Birden fazla kaynakla "kullanmak" bir kaynak sızıntısına neden olabilir mi?

C # şunu yapmama izin veriyor (MSDN'den örnek):

using (Font font3 = new Font("Arial", 10.0f),
            font4 = new Font("Arial", 10.0f))
{
    // Use font3 and font4.
}

font4 = new FontFırlatırsa ne olur ? Anladığım kadarıyla font3 kaynakları sızdıracak ve imha edilmeyecek.

• Bu doğru mu? (font4 atılmayacak)
• Bu using(... , ...), iç içe kullanım lehine tamamen kaçınılması gerektiği anlamına mı geliyor ?

Hayır.

Derleyici, finallyher değişken için ayrı bir blok oluşturacaktır .

Spec (§8.13) der ki:

Bir kaynak edinimi bir yerel değişken bildirimi biçimini aldığında, belirli bir türden birden çok kaynağı elde etmek mümkündür. usingFormun bir açıklaması

using (ResourceType r1 = e1, r2 = e2, ..., rN = eN) statement 

tam olarak iç içe geçmiş ifadeler dizisine eşdeğerdir:

using (ResourceType r1 = e1)
   using (ResourceType r2 = e2)
      ...
         using (ResourceType rN = eN)
            statement

GÜNCELLEME : Ben bulunabilir bir makale için temel olarak bu soruyu kullanılan burada ; bu konuyla ilgili ek tartışma için buna bakın. Güzel soru için teşekkürler!

Schabse'nin cevabı elbette doğru olsa ve sorulan soruyu cevaplasa da, sorunuzda sormadığınız önemli bir varyant var:

Yönetilmeyen kaynak kurucu tarafından tahsis edildikten sonra , ancak ctor geri dönüp referansla doldurmadan öncefont4 = new Font() atışlar ne olur ?font4

Bunu biraz daha netleştireyim. Varsayalım ki:

public sealed class Foo : IDisposable
{
    private int handle = 0;
    private bool disposed = false;
    public Foo()
    {
        Blah1();
        int x = AllocateResource();
        Blah2();
        this.handle = x;
        Blah3();
    }
    ~Foo()
    {
        Dispose(false);
    }
    public void Dispose() 
    { 
        Dispose(true); 
        GC.SuppressFinalize(this);
    }
    private void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (this.handle != 0) 
                DeallocateResource(this.handle);
            this.handle = 0;
            this.disposed = true;
        }
    }
}

Şimdi sahibiz

using(Foo foo = new Foo())
    Whatever(foo);

Bu aynıdır

{
    Foo foo = new Foo();
    try
    {
        Whatever(foo);
    }
    finally
    {
        IDisposable d = foo as IDisposable;
        if (d != null) 
            d.Dispose();
    }
}

TAMAM. Atışları varsayalım Whatever. Daha sonra finallyblok çalışır ve kaynak serbest bırakılır. Sorun değil.

Atışları varsayalım Blah1(). Ardından, kaynak ayrılmadan önce atış gerçekleşir. Nesne tahsis edilmiştir, ancak ctor asla geri dönmez, bu yüzden fooasla doldurulmaz. Asla girmedik, trybu yüzden finallyikisine de girmeyiz. Nesne referansı artık kaldı. Sonunda GC bunu keşfedecek ve onu sonlandırıcı sırasına koyacaktır. handlehala sıfırdır, bu nedenle sonlandırıcı hiçbir şey yapmaz. Sonlandırıcının, kurucusu hiçbir zaman tamamlanmayan, sonuçlandırılan bir nesne karşısında sağlam olması gerektiğine dikkat edin . Sen edilir gerekli bu güçlü finalizers yazmak için. Bu, son yazıyı uzmanlara bırakmanız ve bunu kendiniz yapmaya çalışmamanız için bir başka nedendir.

Atışları varsayalım Blah3(). Kaynak tahsis edildikten sonra atış gerçekleşir. Ama yine, fooasla doldurulmaz, asla girilmez finallyve nesne sonlandırıcı ipliği tarafından temizlenir. Bu sefer tutamaç sıfır değildir ve sonlandırıcı onu temizler. Yine, sonlandırıcı, kurucusu asla başarılı olamayan bir nesne üzerinde çalışıyor, ancak sonlandırıcı yine de çalışıyor. Açıkçası olmalı çünkü bu sefer yapacak işleri vardı.

Şimdi Blah2()atışları varsayalım . Atış, kaynak tahsis edildikten sonra ancak doldurulmadan önce handle gerçekleşir! Yine, sonlandırıcı çalışacak ama şimdi handlehala sıfır ve kolu sızdırıyoruz!

Bu sızıntının olmasını önlemek için son derece akıllı bir kod yazmanız gerekir . Şimdi, Fontkaynağınız söz konusu olduğunda , kimin umurunda? Bir yazı tipi tanıtıcısı sızdırıyoruz, önemli. Ama eğer kesinlikle olumlu gerektiren bu her yönetilmeyen kaynak temizlenecek olursa olsun istisna zamanlaması ne o zaman ellerini çok zor bir sorun var.

CLR bu sorunu kilitlerle çözmelidir. C # 4'ten beri, lockifadeyi kullanan kilitler şu şekilde uygulanmıştır:

bool lockEntered = false;
object lockObject = whatever;
try
{
    Monitor.Enter(lockObject, ref lockEntered);
    lock body here
}
finally
{
    if (lockEntered) Monitor.Exit(lockObject);
}

Enterçok dikkatli bir şekilde yazılmıştır, böylece hangi istisnalar yapılırsa yapılsın , ancak ve ancak kilit gerçekten alınmışsa lockEntereddoğru olarak ayarlanır . Benzer gereksinimleriniz varsa, yapmanız gereken şey aslında yazmaktır:

    public Foo()
    {
        Blah1();
        AllocateResource(ref handle);
        Blah2();
        Blah3();
    }

ve AllocateResourcezekice yazın Monitor.Enterki içeride ne olursa olsun AllocateResource, sadece ve ancak ayrılması gerektiğinde handledoldurulur .

Bunu yapmak için gereken teknikleri açıklamak bu cevabın kapsamı dışındadır. Bu gereksiniminiz varsa bir uzmana danışın.

@SLaks yanıtına bir tamamlayıcı olarak, kodunuz için IL burada:

.method private hidebysig static 
    void Main (
        string[] args
    ) cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 74 (0x4a)
    .maxstack 2
    .entrypoint
    .locals init (
        [0] class [System.Drawing]System.Drawing.Font font3,
        [1] class [System.Drawing]System.Drawing.Font font4,
        [2] bool CS$4$0000
    )

    IL_0000: nop
    IL_0001: ldstr "Arial"
    IL_0006: ldc.r4 10
    IL_000b: newobj instance void [System.Drawing]System.Drawing.Font::.ctor(string, float32)
    IL_0010: stloc.0
    .try
    {
        IL_0011: ldstr "Arial"
        IL_0016: ldc.r4 10
        IL_001b: newobj instance void [System.Drawing]System.Drawing.Font::.ctor(string, float32)
        IL_0020: stloc.1
        .try
        {
            IL_0021: nop
            IL_0022: nop
            IL_0023: leave.s IL_0035
        } // end .try
        finally
        {
            IL_0025: ldloc.1
            IL_0026: ldnull
            IL_0027: ceq
            IL_0029: stloc.2
            IL_002a: ldloc.2
            IL_002b: brtrue.s IL_0034

            IL_002d: ldloc.1
            IL_002e: callvirt instance void [mscorlib]System.IDisposable::Dispose()
            IL_0033: nop

            IL_0034: endfinally
        } // end handler

        IL_0035: nop
        IL_0036: leave.s IL_0048
    } // end .try
    finally
    {
        IL_0038: ldloc.0
        IL_0039: ldnull
        IL_003a: ceq
        IL_003c: stloc.2
        IL_003d: ldloc.2
        IL_003e: brtrue.s IL_0047

        IL_0040: ldloc.0
        IL_0041: callvirt instance void [mscorlib]System.IDisposable::Dispose()
        IL_0046: nop

        IL_0047: endfinally
    } // end handler

    IL_0048: nop
    IL_0049: ret
} // end of method Program::Main

İç içe geçmiş dene / nihayet bloklarına dikkat edin.

Bu kod (orijinal örneğe göre):

using System.Drawing;

public class Class1
{
    public Class1()
    {
        using (Font font3 = new Font("Arial", 10.0f),
                    font4 = new Font("Arial", 10.0f))
        {
            // Use font3 and font4.
        }
    }
}

Aşağıdaki CIL'i üretir ( Visual Studio 2013'te .NET 4.5.1'i hedefler ):

.method public hidebysig specialname rtspecialname
        instance void  .ctor() cil managed
{
    // Code size       82 (0x52)
    .maxstack  2
    .locals init ([0] class [System.Drawing]System.Drawing.Font font3,
                  [1] class [System.Drawing]System.Drawing.Font font4,
                  [2] bool CS$4$0000)
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  nop
    IL_0007:  nop
    IL_0008:  ldstr      "Arial"
    IL_000d:  ldc.r4     10.
    IL_0012:  newobj     instance void [System.Drawing]System.Drawing.Font::.ctor(string,
                                                                                  float32)
    IL_0017:  stloc.0
    .try
    {
        IL_0018:  ldstr      "Arial"
        IL_001d:  ldc.r4     10.
        IL_0022:  newobj     instance void [System.Drawing]System.Drawing.Font::.ctor(string,
                                                                                      float32)
        IL_0027:  stloc.1
        .try
        {
            IL_0028:  nop
            IL_0029:  nop
            IL_002a:  leave.s    IL_003c
        }  // end .try
        finally
        {
            IL_002c:  ldloc.1
            IL_002d:  ldnull
            IL_002e:  ceq
            IL_0030:  stloc.2
            IL_0031:  ldloc.2
            IL_0032:  brtrue.s   IL_003b
            IL_0034:  ldloc.1
            IL_0035:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
            IL_003a:  nop
            IL_003b:  endfinally
        }  // end handler
        IL_003c:  nop
        IL_003d:  leave.s    IL_004f
    }  // end .try
    finally
    {
        IL_003f:  ldloc.0
        IL_0040:  ldnull
        IL_0041:  ceq
        IL_0043:  stloc.2
        IL_0044:  ldloc.2
        IL_0045:  brtrue.s   IL_004e
        IL_0047:  ldloc.0
        IL_0048:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
        IL_004d:  nop
        IL_004e:  endfinally
    }  // end handler
    IL_004f:  nop
    IL_0050:  nop
    IL_0051:  ret
} // end of method Class1::.ctor

Gördüğünüz gibi, try {}blok, 'da gerçekleşen ilk tahsisin sonrasına kadar başlamıyor IL_0012. İlk bakışta bu, korumasız koddaki ilk öğeyi tahsis ediyor gibi görünüyor . Bununla birlikte, sonucun konum 0'da saklandığına dikkat edin. İkinci tahsis başarısız olursa, dış finally {} blok çalışır ve bu, nesneyi 0 konumundan, yani ilk tahsisinden alır font3ve Dispose()yöntemini çağırır .

İlginç bir şekilde, bu derlemeyi dotPeek ile yeniden derlemek , aşağıdaki yeniden oluşturulmuş kaynağı üretir:

using System.Drawing;

public class Class1
{
    public Class1()
    {
        using (new Font("Arial", 10f))
        {
            using (new Font("Arial", 10f))
                ;
        }
    }
}

Derlenmiş kod, her şeyin doğru olduğunu ve usingesasen iç içe geçmiş usinge- postalara genişletildiğini doğrular . CIL koduna bakmak biraz kafa karıştırıcı ve ne olduğunu tam olarak anlamadan önce ona birkaç dakika bakmak zorunda kaldım, bu yüzden bazı 'eski eş hikayelerinin' filizlenmeye başlamasına şaşırmadım. bu. Ancak üretilen kod tartışılmaz bir gerçektir.

İşte @SLaks yanıtını kanıtlamak için örnek bir kod:

void Main()
{
    try
    {
        using (TestUsing t1 = new TestUsing("t1"), t2 = new TestUsing("t2"))
        {
        }
    }
    catch(Exception ex)
    {
        Console.WriteLine("catch");
    }
    finally
    {
        Console.WriteLine("done");
    }

    /* outputs

        Construct: t1
        Construct: t2
        Dispose: t1
        catch
        done

    */
}

public class TestUsing : IDisposable
{
    public string Name {get; set;}

    public TestUsing(string name)
    {
        Name = name;

        Console.WriteLine("Construct: " + Name);

        if (Name == "t2") throw new Exception();
    }

    public void Dispose()
    {
        Console.WriteLine("Dispose: " + Name);
    }
}