Чи створюється витік пам'яті, якщо MemoryStream в .NET не закритий?

У мене є такий код:

MemoryStream foo(){
    MemoryStream ms = new MemoryStream();
    // write stuff to ms
    return ms;
}

void bar(){
    MemoryStream ms2 = foo();
    // do stuff with ms2
    return;
}

Чи є ймовірність, що виділений я MemoryStream якось не вдасться позбавитись згодом?

Я маю експертну оцінку, наполягаючи на тому, що я закриваю це вручну, і я не можу знайти інформацію, щоб сказати, чи має він дійсну точку чи ні.

Якщо щось є одноразовим, завжди слід розпоряджатися цим. Ви повинні використовувати usingоператор у своєму bar()методі, щоб переконатися, що ви ms2отримаєте розпорядження.

Врешті-решт очищення сміттєзбірника буде очищене, але завжди добре називати утилізацію. Якщо ви запустите FxCop на своєму коді, він позначить його як попередження.

Ви нічого не просочите - принаймні в поточній реалізації.

Calling Dispose швидше не очистить пам'ять, яку використовує MemoryStream. Це не зупинить ваш потік від життєздатності для читання / запису дзвінків після дзвінка, що може вам бути корисним.

Якщо ви абсолютно впевнені, що ніколи не хочете переходити з MemoryStream до іншого виду потоку, це не принесе вам шкоди, щоб не викликати Dispose. Тим НЕ менше, це взагалі хороша практика почасти тому , що якщо ви коли - небудь зробити зміни , щоб використовувати інший потік, ви не хочете , щоб отримати вкусили помилкою важкодоступній знахідки , тому що ви вибрали легкий шлях рано. (З іншого боку, є аргумент YAGNI ...)

Інша причина зробити це все-таки полягає в тому, що нова реалізація може впровадити ресурси, які були б звільнені на Dispose.

Так, є витік , залежно від того, як ви визначаєте ЛІК та скільки ПОСЛІД маєте на увазі ...

Якщо під протіканням ви маєте на увазі "пам’ять залишається виділеною, недоступною для використання, навіть якщо ви її використовуєте", а під останнім ви маєте на увазі в будь-який час після виклику розпоряджатися, то так, може виникнути витік, хоча він не є постійним (тобто для термін служби ваших програм).

Щоб звільнити керовану пам'ять, яку використовує MemoryStream, потрібно скасувати її , скасувавши свою посилання на неї, щоб вона одразу стала придатною для збору сміття. Якщо цього не зробити, тоді ви створюєте тимчасовий витік з часу, коли ви закінчите його використання, поки ваша посилання не вийде за межі, оскільки тим часом пам'ять буде недоступною для розподілу.

Перевага використовуючого оператора (над просто викликом розпоряджається) полягає в тому, що ви можете ДЕКЛАРИРУВАТИ свою посилання в використовуваному операторі. Після завершення використання оператора не тільки вилучається, але і ваша посилання виходить за межі, фактично зводить нанівець посилання та робить ваш об'єкт придатним для збору сміття негайно, не вимагаючи від вас пам’ятати про написання коду «reference = null».

Хоча відмова від невиконання чогось відразу не є класичним "постійним" витоком пам'яті, це, безумовно, має той же ефект. Наприклад, якщо ви зберігаєте посилання на MemoryStream (навіть після виклику розпорядження) і трохи далі в своєму способі, ви намагаєтеся виділити більше пам'яті ... пам'ять, якою використовується ваш все ще посилається потік пам'яті, не буде доступною для вас, поки ви не зведете нанівець посилання або воно не вийде за межі, навіть якщо ви зателефонували утилізувати і виконаєте його використання.

Зателефонувати .Dispose()(або завершити з ним Using) не потрібно.

Причина, яку ви телефонуєте, .Dispose()- звільнити ресурс якомога швидше .

Подумайте з точки зору, наприклад, сервера переповнення стека, де у нас обмежений набір пам'яті та тисячі запитів, що надходять. для нових вхідних запитів.

На це вже відповіли, але я просто додам, що хороший старомодний принцип приховування інформації означає, що ви можете в якийсь майбутній момент захотіти переробити:

MemoryStream foo()
{    
    MemoryStream ms = new MemoryStream();    
    // write stuff to ms    
    return ms;
}

до:

Stream foo()
{    
   ...
}

Це підкреслює, що абонентам не слід дбати про те, який тип потоку повертається, і дає можливість змінити внутрішню реалізацію (наприклад, під час знущання щодо тестування одиниць).

Тоді у вас виникнуть проблеми, якщо ви не використовували Dispose у своїй барі:

void bar()
{    
    using (Stream s = foo())
    {
        // do stuff with s
        return;
    }
}

Усі потоки реалізують IDisposable. Оберніть свій потік пам’яті в використовуваному операторі, і ви будете чудовий і веселий. Блок, що використовує, забезпечить, щоб ваш потік був закритий і розміщений незалежно від того.

де б ви не зателефонували до Foo, ви можете зробити це за допомогою (MemoryStream ms = foo ()), і я думаю, вам все одно все в порядку.

Ви не будете просочувати пам'ять, але ваш переглядач кодів правильно вказав, що слід закрити потік. Ввічливо це зробити.

Єдина ситуація, в якій ви можете просочити пам'ять - це випадково залишити посилання на потік і ніколи не закрити його. Ви все ще не дійсно витоку пам'яті, але які без необхідності розширення кількості часу , яке ви стверджуєте використовувати його.

Я б рекомендував обгортання MemoryStream в bar()в usingзаяві , головним чином , для послідовності:

• Зараз MemoryStream не звільняє пам'ять .Dispose() , але можливо, в якийсь момент в майбутньому це може виникнути, або ви (або хтось інший у вашій компанії) може замінити його на ваш власний користувальницький MemoryStream, який працює тощо.
• Це допомагає встановити схему у вашому проекті, щоб забезпечити утилізацію всіх потоків - лінія більш чітко намальована, кажучи "всі потоки повинні бути утилізовані", а не "деякі потоки повинні бути утилізовані, але певні не повинні". ...
• Якщо ви коли-небудь змінюєте код, щоб дозволити повернення інших типів потоків, вам потрібно буде змінити його, щоб все-таки розпоряджатися.

Інша річ, яку я зазвичай роблю у таких випадках, як foo()при створенні та поверненні ідентифікатора, - це переконатися, що будь-який збій між побудовою returnоб'єкта та вилученим винятком викидає об'єкт та повторно виключає виняток:

MemoryStream x = new MemoryStream();
try
{
    // ... other code goes here ...
    return x;
}
catch
{
    // "other code" failed, dispose the stream before throwing out the Exception
    x.Dispose();
    throw;
}

Якщо об’єкт реалізує IDisposable, ви повинні зателефонувати до методу .Dispose, коли закінчите.

У деяких об'єктах "Утилізація" означає те саме, що "Закрити", і навпаки, у цьому випадку або добре.

Тепер, для вашого конкретного питання, ні, ви не просочите пам'ять.

Я не експерт .net, але, мабуть, проблема тут - ресурси, а саме обробка файлів, а не пам'ять. Я думаю, що збирач сміття врешті-решт звільнить потік і закриє ручку, але я думаю, що завжди було б найкращим способом закрити це явно, щоб переконатись, що ви вимили вміст на диск.

Утилізація некерованих ресурсів є недетермінованою на зібраних сміттям мовах. Навіть якщо ви чітко зателефонуєте у розпорядження, ви не маєте абсолютно ніякого контролю над тим, коли резервна пам'ять фактично звільнена. Dispose неявно називається, коли об’єкт виходить із сфери застосування, будь то шляхом виходу із використовуючого оператора чи спливаючої позиції callsta з підпорядкованого методу. Все це говориться, іноді об'єкт може бути фактично обгорткою керованого ресурсу (наприклад, файлу). Ось чому є хорошою практикою явно закривати остаточні висловлювання або використовувати оператор, що використовує. Ура

MemorySteram - це не що інше, як масив байтів, яким керує об'єкт. Забудьте розпоряджатися або закривати це не має жодного побічного ефекту, ніж над головою доопрацювання.
Просто перевірте конвектор або метод промивання MemoryStream у рефлекторі, і буде зрозуміло, чому вам не потрібно турбуватися про його закриття чи утилізацію, окрім як лише для того, щоб дотримуватися належної практики.