Если я правильно понимаю, время выполнения .net всегда будет очищаться после меня. Поэтому, если я создаю новые объекты и перестаю ссылаться на них в своем коде, среда выполнения очистит эти объекты и освободит память, которую они занимают.
Так как это так, почему тогда некоторые объекты должны иметь деструктор или метод удаления? Не удастся ли запустить среду после них, когда они больше не будут ссылаться?
Финализаторы необходимы, чтобы гарантировать выход ограниченных ресурсов обратно в систему, такие как дескрипторы файлов, сокеты, объекты ядра и т.д. Так как финализатор всегда работает в конце жизни объектов, это назначенное место для выпуска этих ручек.
Шаблон Dispose используется для обеспечения детерминированного уничтожения ресурсов. Поскольку сборщик мусора в режиме времени .net не является детерминированным (это означает, что вы никогда не можете быть уверены, когда среда выполнения будет собирать старые объекты и вызывать их финализатор), необходим метод для обеспечения детерминированного выпуска системных ресурсов. Поэтому, когда вы правильно реализуете шаблон Dispose, вы предоставляете детерминированный выпуск ресурсов, а в тех случаях, когда потребитель неосторожен и не распоряжается объектом, финализатор очистит объект.
Простым примером того, почему требуется Dispose, может быть быстрый и грязный метод журнала:
public void Log(string line)
{
var sw = new StreamWriter(File.Open(
"LogFile.log", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None));
sw.WriteLine(line);
// Since we don't close the stream the FileStream finalizer will do that for
// us but we don't know when that will be and until then the file is locked.
}
В приведенном выше примере файл останется заблокированным до тех пор, пока сборщик мусора не вызовет финализатор на объекте StreamWriter. Это создает проблему, поскольку, тем временем, метод может быть снова вызван для записи журнала, но на этот раз он завершится неудачно, поскольку файл все еще заблокирован.
Правильный способ заключается в том, чтобы уничтожить объект, когда он выполняется с ним:
public void Log(string line)
{
using (var sw = new StreamWriter(File.Open(
"LogFile.log", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None))) {
sw.WriteLine(line);
}
// Since we use the using block (which conveniently calls Dispose() for us)
// the file well be closed at this point.
}
BTW, технически финализаторы и деструкторы означают одно и то же; Я предпочитаю называть финализаторы С# деструкторов, поскольку в противном случае они склонны смешивать людей с деструкторами С++, которые в отличие от С# являются детерминированными.
Предыдущие ответы хороши, но позвольте мне еще раз подчеркнуть важный момент. В частности, вы сказали, что
Если я правильно понимаю, время выполнения .net всегда будет очищаться после меня.
Это лишь отчасти правильно. На самом деле .NET предлагает только автоматическое управление для одного конкретного ресурса: основная память. Все остальные ресурсы нуждаются в ручной очистке. 1)
Как ни странно, основная память получает особый статус почти во всех обсуждениях ресурсов программы. Разумеется, для этого есть веская причина - основная память часто является самым скудным ресурсом. Но стоит помнить, что есть и другие типы ресурсов, которые также нуждаются в управлении.
1) Обычное попытка - связать время жизни других ресурсов со временем жизни мест памяти или идентификаторов в коде - отсюда и наличие финализаторов.
Сборщик мусора будет работать только в том случае, если система не находится под давлением памяти, если только не нужно освобождать память. Это означает, что вы никогда не сможете быть уверены, когда GC будет работать.
Теперь представьте, что вы подключаетесь к базе данных. Если вы позволите очистить GC после вас, вы можете быть подключены к базе данных намного дольше, чем это необходимо, вызывая странную нагрузку. В этом случае вы хотите реализовать IDisposable, чтобы пользователь мог вызвать Dispose() или использовать с помощью(), чтобы действительно убедиться, что соединение закрыто как можно скорее, не полагаясь на GC, который может работать намного позже.
Как правило, IDisposable реализуется в любом классе, который работает с неуправляемыми ресурсами.
Настоящая причина заключается в том, что сборка мусора .net НЕ предназначена для сбора неуправляемых ресурсов, поэтому очистка этих ресурсов по-прежнему лежит в руках разработчика. Кроме того, финализаторы объектов не вызывается автоматически, когда объект выходит из области видимости. Они вызываются GC в какое-то неопределенное время. И когда их вызывают, GC не запускает ее сразу, она ждет следующего раунда, чтобы называть ее, увеличивая время на очистку еще больше, не очень хорошо, когда ваши объекты содержат ограниченные неуправляемые ресурсы (например, файлы или сетевые соединения). Введите шаблон одноразового использования, в котором разработчик может вручную освободить ограниченные ресурсы в определенное время (при вызове функции yourobject.Dispose() или использования (...)). Имейте в виду, что вы должны вызвать GC.SuppressFinalize(this); в вашем методе размещения, чтобы сообщить GC, что объект был вручную удален и не должен быть завершен. Я предлагаю вам взглянуть на книгу "Руководства по разработке каркаса" К. Квалины и Б. Абрамса. Он очень хорошо описывает одноразовый шаблон.
Удачи!
Простейшее объяснение:
Некоторые рекомендации по реализации метода Finalize:
Некоторые рекомендации по реализации метода Dispose:
Объекты, которые нуждаются в дескрипторах и методах удаления, - это использование ресурсов без управления. Поэтому сборщик мусора не может очистить эти ресурсы, и вам нужно сделать это самостоятельно.
Посмотрите документацию MSDN для IDisposable; http://msdn.microsoft.com/en-us/library/system.idisposable.aspx
В примере используется не управляемый обработчик - IntPr.
Некоторым объектам может понадобиться очистка элементов низкого уровня. Например, аппаратное обеспечение, которое необходимо закрыть, и т.д.
В основном для неконтролируемого кода и взаимодействия с не управляемым кодом. Управляемый код "Pure" никогда не нуждается в финализаторе. Одноразовая с другой стороны - это просто удобный шаблон, который заставит что-то освободиться, когда вы закончите с ним.
Сборщик мусора .NET знает, как обрабатывать управляемые объекты в среде выполнения .NET. Но шаблон Dispose (IDisposable) используется в основном для не управляемых объектов, которые использует приложение.
Другими словами, среда выполнения .NET не обязательно знает, как обращаться с каждым типом устройства или обрабатывать там (закрытие сетевых подключений, дескрипторов файлов, графических устройств и т.д.), поэтому использование IDisposable обеспечивает способ сказать "позвольте мне реализовать некоторую очистку моего собственного" в типе. Увидев эту реализацию, сборщик мусора может вызвать Dispose() и обеспечить очистку вещей за пределами управляемой кучи.
Есть несколько (очень немногих) случаев, когда может потребоваться выполнить определенное действие, когда чистый управляемый объект больше не используется, я не могу придумать пример с верхней части головы, но у меня есть на протяжении многих лет видел пару законных целей. Но главная причина - очистить любые неуправляемые ресурсы, которые может использовать объект.
Итак, в общем случае вам не нужно использовать шаблон Dispose/Finalize, если вы не используете неуправляемые ресурсы.
Поскольку сборщик мусора не может собрать то, что не удалось выделить управляемой среде. Поэтому любой вызов неуправляемого API, который приводит к распределению памяти, должен собираться старомодным способом.