Wird Dispose immer noch aufgerufen, wenn eine Ausnahme in einer using-Anweisung ausgelöst wird?

Wird im folgenden Beispiel die Verbindung geschlossen und getrennt, wenn eine Ausnahme ausgelöst wird, wenn sie sich in einer usingAnweisung befindet?

using (var conn = new SqlConnection("..."))
{
    conn.Open();
    // stuff happens here and exception is thrown...
}

Ich weiß, dass dieser Code unten sicherstellt, dass dies der Fall ist, aber ich bin gespannt, wie die Verwendung der Anweisung dies bewirkt.

var conn;
try
{
    conn = new SqlConnection("...");
    conn.Open();
    // stuff happens here and exception is thrown...
}
// catch it or let it bubble up
finally
{
    conn.Dispose();
}

Verbunden:

Ja, usingverpackt Ihren Code in einen try / finally-Block, in dem der finallyTeil aufgerufen wird, Dispose()falls vorhanden. Es wird jedoch nicht Close()direkt aufgerufen, da nur die IDisposableimplementierte Schnittstelle und damit die Dispose()Methode überprüft wird.

Siehe auch:

• Abfangen einer Ausnahme in IDisposable.Dispose
• Wie kann sichergestellt werden, dass eine SQL-Verbindung geschlossen wird, wenn eine Ausnahme ausgelöst wird?
• C # Syntax "Verwenden"
• Schlüsselwort C # USING - wann und wann nicht?
• 'using' Anweisung vs 'endlich versuchen'
• Was ist der C # Using-Block und warum sollte ich ihn verwenden?
• Einweg mit Muster
• Endet die Verwendung Schließen einer offenen SQL-Verbindung

So decodiert der Reflektor die von Ihrem Code erzeugte IL:

private static void Main (string [] args)
{
    SqlConnection conn = new SqlConnection ("...");
    Versuchen
    {
        conn.Open ();
        Sachen machen();
    }}
    endlich
    {
        if (conn! = null)
        {
            conn.Dispose ();
        }}
    }}
}}

Die Antwort lautet also: Ja, die Verbindung wird geschlossen, wenn

Sachen machen()

Dispose () wird in diesem Code nicht aufgerufen.

class Program {
    static void Main(string[] args) {
        using (SomeClass sc = new SomeClass())
        {
            string str = sc.DoSomething();
            sc.BlowUp();
        }
    }
}

public class SomeClass : IDisposable {
    private System.IO.StreamWriter wtr = null;

    public SomeClass() {
        string path = System.IO.Path.GetTempFileName();
        this.wtr = new System.IO.StreamWriter(path);
        this.wtr.WriteLine("SomeClass()");
    }

    public void BlowUp() {
        this.wtr.WriteLine("BlowUp()");
        throw new Exception("An exception was thrown.");
    }

    public string DoSomething() {
        this.wtr.WriteLine("DoSomething()");
        return "Did something.";
    }

    public void Dispose() {
        this.wtr.WriteLine("Dispose()");
        this.wtr.Dispose();
    }
}