В чем разница между использованием IDisposable и деструктора в C #?

Когда я могу реализовать IDispose в классе, а не деструктор? Я прочитал эту статью , но все еще не понимаю сути.

Я предполагаю, что если я использую IDispose для объекта, я могу явно «разрушить» его, а не ждать, пока сборщик мусора сделает это. Это верно?

Означает ли это, что я всегда должен явно вызывать Dispose для объекта? Каковы некоторые общие примеры этого?

Финализатор (он же деструктор) является частью сборки мусора (GC) - не определено, когда (или даже если) это произойдет, поскольку GC в основном происходит в результате нехватки памяти (т.е. требуется больше места). Финализаторы обычно используются только для очистки неуправляемых ресурсов, поскольку для управляемых ресурсов будет свой собственный сбор / удаление.

Следовательно IDisposable, используется для детерминированной очистки объектов, то есть сейчас. Он не собирает память объекта (которая все еще принадлежит GC), но используется, например, для закрытия файлов, подключений к базе данных и т. Д.

По этому поводу много предыдущих тем:

• детерминированное завершение
• утилизация предметов
• используя блок
• Ресурсы

Наконец, обратите внимание, что IDisposableобъект нередко также имеет финализатор; в этом случае Dispose()обычно вызывает GC.SuppressFinalize(this), что означает, что GC не запускает финализатор - он просто выбрасывает память (намного дешевле). Финализатор все равно работает, если вы забыли Dispose()объект.

Роль Finalize()метода состоит в том, чтобы гарантировать, что объект .NET может очищать неуправляемые ресурсы при сборке мусора . Однако такие объекты, как соединения с базой данных или обработчики файлов, должны быть освобождены как можно скорее, вместо того, чтобы полагаться на сборку мусора. Для этого вы должны реализовать IDisposableинтерфейс и освободить ресурсы в Dispose()методе.

В MSDN есть очень хорошее описание :

Основное использование этого интерфейса - высвобождение неуправляемых ресурсов . Сборщик мусора автоматически освобождает память, выделенную управляемому объекту, когда этот объект больше не используется. Однако невозможно предсказать, когда произойдет сборка мусора . Кроме того, сборщик мусора не знает о неуправляемых ресурсах, таких как дескрипторы окон или открытые файлы и потоки.

Используйте метод Dispose этого интерфейса, чтобы явно освободить неуправляемые ресурсы вместе со сборщиком мусора. Потребитель объекта может вызвать этот метод , когда объект больше не нужен.

Единственное, что должно быть в деструкторе C #, - это такая строка:

Dispose(False);

Вот и все. В этом методе никогда не должно быть ничего другого.

Ваш вопрос о том, всегда ли вам звонить Dispose, обычно вызывает жаркие споры. В этом блоге вы найдете интересную точку зрения уважаемых людей в сообществе .NET.

Лично я считаю, что позиция Джеффри Рихтера о том, что колл Disposeне является обязательным, невероятно слабая. В обоснование своего мнения он приводит два примера.

В первом примере он говорит, что вызов Disposeэлементов управления Windows Forms утомителен и не нужен в обычных сценариях. Однако он не упоминает, что Disposeфактически вызывается автоматически контейнерами управления в этих основных сценариях.

Во втором примере он заявляет, что разработчик может ошибочно предположить, что экземпляр from IAsyncResult.WaitHandleдолжен быть агрессивно удален, не осознавая, что свойство лениво инициализирует дескриптор ожидания, что приводит к ненужному снижению производительности. Но проблема с этим примером заключается в том, что IAsyncResultсам по себе не соответствует собственным опубликованным рекомендациям Microsoft по работе с IDisposableобъектами. То есть, если класс содержит ссылку на IDisposableтип, тогда должен быть реализован сам класс IDisposable. Если IAsyncResultследовать этому правилу, то его собственный Disposeметод мог бы принять решение относительно того, какие из составляющих его членов необходимо избавиться.

Так что, если у кого-то не будет более веских аргументов, я буду придерживаться принципа «всегда вызывать Dispose» с пониманием того, что будут некоторые второстепенные случаи, которые возникают в основном из-за неправильного выбора дизайна.

На самом деле это довольно просто. Я знаю, что на него ответили, но я попробую еще раз, но постараюсь сделать его как можно проще.

Деструктор вообще не следует использовать. Это только запуск. Net хочет, чтобы он работал. Он будет запускаться только после цикла сборки мусора. Он может никогда не запуститься в течение жизненного цикла вашего приложения. По этой причине вы никогда не должны помещать в деструктор код, который «должен» быть запущен. Вы также не можете полагаться на то, что какие-либо существующие объекты в классе будут существовать при его запуске (возможно, они уже были очищены, поскольку порядок, в котором выполняются деструкторы, не гарантируется).

IDisposible следует использовать всякий раз, когда у вас есть объект, который создает ресурсы, требующие очистки (например, дескрипторы файлов и графики). Фактически, многие утверждают, что все, что вы помещаете в деструктор, должно быть помещено в IDisposable по причинам, перечисленным выше.

Большинство классов вызывают dispose при выполнении финализатора, но это просто надежная защита, и на него никогда нельзя полагаться. Вы должны явно удалить все, что реализует IDisposable, когда вы закончите с этим. Если вы действительно реализуете IDisposable, вам следует вызвать dispose в финализаторе. См. Пример на http://msdn.microsoft.com/en-us/library/system.idisposable.aspx .

Вот еще одна прекрасная статья, которая проясняет туман вокруг IDisposable, GC и dispose.

Крис Лайонс: WebLog проясняет утилизацию