.NET'te bir MemoryStream kapatılmadıysa bellek sızıntısı oluşur mu?

Takip koduna sahibim:

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

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

Ayırdığım MemoryStream'in bir şekilde daha sonra atılmaması ihtimali var mı?

Bunu manuel olarak kapatmam konusunda ısrar eden bir meslektaş incelemem var ve geçerli bir noktası olup olmadığını söyleyecek bilgiyi bulamıyorum.

Tek kullanımlık bir şey varsa, onu her zaman atmalısınız. Disposed aldığınızdan emin olmak usingiçin bar()yönteminizde bir ifade kullanmalısınız ms2.

Sonunda çöp toplayıcı tarafından temizlenecektir, ancak Dispose'u çağırmak her zaman iyi bir uygulamadır. FxCop'u kodunuzda çalıştırırsanız, onu bir uyarı olarak işaretler.

En azından mevcut uygulamada hiçbir şey sızdırmayacaksınız.

Dispose çağırmak, MemoryStream tarafından kullanılan belleği daha hızlı temizlemeyecektir. Bu olacak ya sizin için yararlı olabilir veya olmayabilir çağrı, sonra okuma / yazma aramalar için geçerli olmaktan akışınızı durdurun.

Kesinlikle emin bunu iseniz asla akışının başka türlü bir MemoryStream gelen taşımak istiyor, size Dispose çağırmaz için herhangi bir zarar vermeyecek. Ancak, şimdiye kadar eğer kısmen genellikle iyi bir uygulamadır yapmak farklı bir Stream kullanmak için değişiklik, size erken kolay yolu seçti çünkü zor find böcek tarafından ısırıldı istemiyoruz. (Öte yandan, YAGNI argümanı var ...)

Zaten bunu yapmak için başka bir nedenle yeni bir uygulama olmasıdır olabilir Dispose üzerinde muaf tutuluyordu kaynaklarını tanıtmak.

Evet bir sızıntı var , KAÇAK'ı nasıl tanımladığınıza ve ne kadar DAHA SONRA demek istediğinize bağlı olarak ...

Sızıntı ile "bellek tahsis edilmiş durumda kalır, kullanımınız bitmiş olsa bile kullanım için kullanılamaz" demektir ve ikincisi ile dispose'ı çağırdıktan sonra herhangi bir zamanda kastediyorsanız, o zaman evet kalıcı olmasa da bir sızıntı olabilir (örn. uygulamalarınızın çalışma süresi).

MemoryStream tarafından kullanılan yönetilen belleği boşaltmak için, referansı kaldırmanız gerekir geçersiz kılarak başvuruyu kaldırmanız gerekir, böylece hemen çöp toplamaya uygun hale gelir. Bunu yapmazsanız, onu kullanmayı bitirdiğiniz andan referansınız kapsam dışına çıkana kadar geçici bir sızıntı oluşturursunuz, çünkü bu arada bellek tahsis için uygun olmayacaktır.

Using ifadesinin faydası (sadece dispose çağırmaktan ziyade), using ifadesinde referansınızı BEYAN EDEBİLECEĞİNİZdir. Using ifadesi bittiğinde, yalnızca dispose çağrılır, aynı zamanda referansınız kapsam dışına çıkarak referansı etkin bir şekilde geçersiz kılar ve "reference = null" kodunu yazmanızı hatırlamanıza gerek kalmadan nesnenizi hemen çöp toplama için uygun hale getirir.

Bir şeye anında gönderme yapmamak klasik bir "kalıcı" bellek sızıntısı olmasa da, kesinlikle aynı etkiye sahiptir. Örneğin, MemoryStream referansınızı (dispose çağırdıktan sonra bile) tutarsanız ve yönteminizin biraz daha aşağısında daha fazla bellek ayırmaya çalışırsanız ... hala referans verilen bellek akışınız tarafından kullanılan bellek kullanılamayacaktır. Siz referansı iptal edene kadar veya kapsam dışına çıkana kadar, dispose'u çağırmış olsanız ve onu kullanmayı bitirmiş olsanız bile size.

Telefon etmek .Dispose()(veya sarmak Using) gerekli değildir.

Aradığınızda nedeni .Dispose()etmektir mümkün olduğunca çabuk kaynağı serbest .

Sınırlı bir bellek setimiz ve gelen binlerce isteğimizin olduğu Stack Overflow sunucusunu düşünün. Planlanmış çöp toplama için beklemek istemiyoruz, bu belleği en kısa sürede serbest bırakmak istiyoruz, böylece kullanılabilir yeni gelen istekler için.

Bu zaten cevaplandı, ancak ekleyeceğim eski moda bilgi gizleme ilkesi, gelecekte bir noktada yeniden düzenleme yapmak isteyebileceğiniz anlamına geliyor:

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

için:

Stream foo()
{    
   ...
}

Bu, arayanların ne tür bir Akışın iade edildiğini umursamaması gerektiğini vurgular ve dahili uygulamayı değiştirmeyi mümkün kılar (örneğin, birim testi için alay ederken).

Bar uygulamanızda Dispose kullanmadıysanız, başınızın belaya girmesi gerekecektir:

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

Tüm akışlar IDisposable uygular. Bellek akışınızı bir kullanım ifadesine sarın ve iyi ve şık olacaksınız. Kullanım bloğu, ne olursa olsun akışınızın kapatılmasını ve atılmasını sağlar.

Foo'yu nerede ararsanız arayın, (MemoryStream ms = foo ()) kullanarak yapabilirsiniz ve bence hala iyi olmalısınız.

Bellek sızdırmazsınız, ancak kod incelemeciniz akışınızı kapatmanız gerektiğini belirtmekte haklıdır. Bunu yapmak kibarlık.

Hafızayı sızdırabileceğiniz tek durum, yanlışlıkla akışa bir referans bırakıp onu asla kapatmadığınız zamandır. Hala gerçekten bellek sızıntısı değil, ancak edilir bunu kullanıyor iddia gereksiz süreyi uzatma.

MemoryStream'i esas olarak tutarlılık için bar()bir usingifadeye sarmanızı tavsiye ederim :

• Şu anda MemoryStream, .Dispose() , ancak gelecekte bir noktada sizin veya sizin (veya şirketinizdeki başka birinin) onu kendi özel MemoryStream'inizle değiştirmesi, vb. Mümkündür.
• Tüm Akışların elden çıkarılmasını sağlamak için projenizde bir model oluşturmanıza yardımcı olur - "Bazı Akışlar elden çıkarılmalıdır, ancak bazı akışlar zorunlu değildir" yerine "tüm Akışlar atılmalıdır" diyerek çizgi daha sıkı bir şekilde çizilir ...
• Kodu, diğer Akış türlerinin iade edilmesine izin verecek şekilde değiştirirseniz, yine de imha etmek için değiştirmeniz gerekir.

Bir foo()IDisposable oluştururken ve döndürürken olduğu gibi genellikle yaptığım başka bir şey , nesneyi oluşturmakla nesne arasındaki herhangi bir başarısızlığın returnbir istisna tarafından yakalanmasını, nesneyi elden çıkarmasını ve istisnayı yeniden atmasını sağlamaktır:

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;
}

Bir nesne IDisposable uygularsa, işiniz bittiğinde .Dispose yöntemini çağırmanız gerekir.

Bazı nesnelerde Dispose, Kapat ile aynı anlama gelir ve tersi de geçerlidir, bu durumda her ikisi de iyidir.

Şimdi, özel sorunuz için, hayır, hafıza sızdırmayacaksınız.

.Net uzmanı değilim, ancak belki de buradaki sorun kaynaklar, yani dosya tanıtıcısı ve bellek değil. Sanırım çöp toplayıcı sonunda akışı serbest bırakacak ve tutamacı kapatacak, ancak içeriği diske attığınızdan emin olmak için açık bir şekilde kapatmanın her zaman en iyi uygulama olacağını düşünüyorum.

Yönetilmeyen kaynakların imhası, çöp toplama dillerinde belirleyici değildir. Dispose'u açıkça çağırsanız bile, yedekleme belleğinin gerçekte ne zaman serbest bırakılacağı konusunda kesinlikle hiçbir kontrolünüz yoktur. Dispose, bir nesne kapsam dışına çıktığında, bir using deyiminden çıkarak veya bir alt yöntemden çağrı yığınını açarak, dolaylı olarak çağrılır. Bütün bunlar söyleniyor, bazen nesne aslında yönetilen bir kaynak için (örneğin dosya) bir sarmalayıcı olabilir. Bu nedenle nihayet ifadelerini açıkça kapatmak veya using ifadesini kullanmak iyi bir uygulamadır. Şerefe

MemorySteram, yönetilen nesne olan bayt dizisinden başka bir şey değildir. Atmayı veya kapatmayı unutun, bunun nihai sonuçlandırma dışında hiçbir yan etkisi yoktur.
Yansıtıcıdaki MemoryStream'in yapılandırıcı veya boşaltma yöntemini kontrol etmeniz yeterlidir ve iyi uygulamayı takip etmek dışında neden onu kapatmak veya elden çıkarmak konusunda endişelenmenize gerek olmadığı anlaşılacaktır.