от
Вы должны установить все объекты
null
(
Nothing
в VB.NET) после того как вы закончили с ними? Я понимаю, что в .Нетто важно, чтобы утилизировать все экземпляры объектов, которые реализуют
IDisposable
интерфейс, чтобы освободить некоторые ресурсы, хотя объект еще может быть что-то после того, как он расположен (отсюда
isDisposed
собственность в формы), поэтому я предполагаю, что он все еще может находиться в памяти или по крайней мере частично? Я также знаю, что когда объект выходит из области видимости, затем он помечен для сборки готов к следующем проходе сборщика мусора (хотя это может занять некоторое время). Так что с учетом этого будет установка
null
ускорения работы системы, высвобождая память, как она не должны работать, что его больше нет в объем и они какие-то плохие побочные эффекты? Статьи MSDN никогда не делайте этого в примерах и в настоящее время я делаю это, как я не могу вижу в этом вреда. Однако я наткнулся на смесь мнений, так что любые комментарии будут полезны.

Ваш ответ

Отображаемое имя (по желанию):
Конфиденциальность: Ваш электронный адрес будет использоваться только для отправки уведомлений.

15 Ответы

0 голосов
от
Вы должны установить все объекты
null
(
Nothing
в VB.NET) после того как вы закончили с ними? Я понимаю, что в .Нетто важно, чтобы утилизировать все экземпляры объектов, которые реализуют
IDisposable
интерфейс, чтобы освободить некоторые ресурсы, хотя объект еще может быть что-то после того, как он расположен (отсюда
isDisposed
собственность в формы), поэтому я предполагаю, что он все еще может находиться в памяти или по крайней мере частично? Я также знаю, что когда объект выходит из области видимости, затем он помечен для сборки готов к следующем проходе сборщика мусора (хотя это может занять некоторое время). Так что с учетом этого будет установка
null
ускорения работы системы, высвобождая память, как она не должны работать, что его больше нет в объем и они какие-то плохие побочные эффекты? Статьи MSDN никогда не делайте этого в примерах и в настоящее время я делаю это, как я не могу вижу в этом вреда. Однако я наткнулся на смесь мнений, так что любые комментарии будут полезны.
0 голосов
от
Карл-это абсолютно правильно, нет необходимости, чтобы установить объекты в null после использования. Если объект реализует
IDisposable
, просто убедитесь, что вы называете
IDisposable.Dispose()
, когда вы закончите с этим объектом (завернутый в
try
..
finally
, или
using()
блока). Но даже если вы не забудьте позвонить
Dispose()
, метод finaliser на объекте должно быть призвание
Dispose()
для вас. Я подумал, что это хорошее лечение: Покопавшись в интерфейс IDisposable и это Понимания Интерфейс IDisposable Нет никакого смысла пытаться угадать ГК и его стратегии управления, потому что это самонастраивающиеся и непрозрачные. Там была хорошая дискуссия о внутренней работе с Джеффри Рихтером на сети многоточия скалы здесь: Джеффри Рихтер на модель памяти Windows и Рихтерс забронировать среды CLR через C Глава# 20 имеет большое лечение:
0 голосов
от
Еще одна причина, чтобы избегать создания объектов в null, когда вы сделали с ними то, что она может держать их дольше. например
void foo()
{
    var someType = new SomeType();
    someType.DoSomething();
    // someType is now eligible for garbage collection         

    // ... rest of method not using 'someType' ...
}
позволит объектом, на который ссылается someType для ГХ, что после вызова "сделать", но
void foo()
{
    var someType = new SomeType();
    someType.DoSomething();
    // someType is NOT eligible for garbage collection yet
    // because that variable is used at the end of the method         

    // ... rest of method not using 'someType' ...
    someType = null;
}
иногда может держать объект в живых до конца метода. В JIT, как правило, будет оптимизирован до назначения в null, так как биты кода закончится тем же.
0 голосов
от
Нет не нулевые объекты. Вы можете проверить http://codebetter.com/blogs/karlseguin/archive/2008/04/27/foundations-of-programming-pt-7-back-to-basics-memory.aspx для получения более подробной информации, но все в null ничего не делает, кроме грязного кода.
0 голосов
от
Также:
using(SomeObject object = new SomeObject()) 
{
  // do stuff with the object
}
// the object will be disposed of
0 голосов
от
В общем, не нужно нуль объекты после использования, но в некоторых случаях я считаю это хорошей практикой. Если объект реализует IDisposable и хранится в поле, я думаю, что это хорошее значение null, чтобы избежать с помощью удаленного объекта. Ошибки следующего рода может быть болезненным:
this.myField.Dispose();
// ... at some later time
this.myField.DoSomething();
Это хорошо, чтобы нуль-поле после утилизации, и получить право NullPtrEx в строке, где поле используется снова. В противном случае, вы можете столкнуться с некоторыми загадочными Буг по линии (в зависимости от того, что сделать ничего).
0 голосов
от
Вероятность того, что ваш код не достаточно жестко структурирован, если вы чувствуете необходимость переменные
null
. Есть несколько способов, чтобы ограничить область действия переменной: Как отметил Стив Транби
using(SomeObject object = new SomeObject()) 
{
  // do stuff with the object
}
// the object will be disposed of
Аналогичным образом, вы можете просто использовать фигурные скобки:
{
    // Declare the variable and use it
    SomeObject object = new SomeObject()
}
// The variable is no longer available
Я считаю, что с помощью фигурных скобках без каких-либо "заголовок", чтобы действительно вычистить код и сделать его более понятным.
0 голосов
от
Единственный раз, когда вы должны присвоить переменной значение NULL, если переменная не выйдут из области видимости и вам больше не нужны данные, связанные с ним. В противном случае нет необходимости.
0 голосов
от
В целом нет необходимости устанавливать в null. Но, предположим, у вас есть функция сброса в свой класс. Затем вы могли бы сделать, потому что вы не хотите звонить дважды распоряжаться, поскольку некоторые избавиться не могут быть корректно реализованы и бросить системы.ObjectDisposed исключение.
private void Reset()
{
    if(_dataset != null)
    {
       _dataset.Dispose();
       _dataset = null;
    }
    //..More such member variables like oracle connection etc. _oraConnection
 }
0 голосов
от
такого рода "нет необходимости, чтобы установить объекты в null после использования" не совсем точно. Там несколько раз нужно обнулить переменную после удаления. Да, вы всегда должны позвонить
.Dispose()
или
.Close()
на все, что есть, когда вы сделали. Будь то файловые дескрипторы, подключения к базам данных или одноразовыми предметами. Отдельно от того, что это очень практичная модель LazyLoad. Говорят, что у меня и создается
ObjA
из
class A
.
Class A
есть общественная собственность называется
PropB
из
class B
. Внутренне,
PropB
использует частная переменная
_B
и по умолчанию null. При использовании
PropB.Get()
, он проверяет, чтобы увидеть, если
_PropB
является нулем, и если это так, открывает ресурсы, необходимые для создания
B
в
_PropB
. Затем он возвращает
_PropB
. По моему опыту, это очень полезный трюк. Где нужно нуль приходит в если вы сбросить или изменить каким-то образом, что содержание
_PropB
были ребенку прежнего значения
A
, вам нужно будет распоряжаться и обнулить
_PropB
так LazyLoad можете сбросить, чтобы получить правильное значение, если код требует. Если вы только делаете
_PropB.Dispose()
и вскоре после того, как ожидать, нулевой чек на LazyLoad, чтобы добиться успеха, он не будет null, и вы будете смотреть на устаревшие данные. В силу, необходимо null это после
Dispose()
просто чтобы быть уверенным. Если бы это было иначе, но я получил код сейчас показывать такое поведение после
Dispose()
на
_PropB
и вне вызова функции, которая сделала распоряжаться (и, следовательно, почти вне области), частный проп еще не нуль, и устаревшие данные все же есть. В конце концов, утилизировать собственность будет нуль, но это был недетерминированным с моей точки зрения. Основной причиной, как dbkk намекает, что родительский контейнер (
ObjA
с
PropB
) держит экземпляр
_PropB
в области, несмотря на
Dispose()
.
...