Dispose viene comunque chiamato quando viene generata un'eccezione all'interno di un'istruzione using?

Nell'esempio seguente, la connessione verrà chiusa e eliminata quando viene generata un'eccezione se si trova all'interno di usingun'istruzione?

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

So che questo codice qui sotto farà in modo che lo faccia, ma sono curioso di sapere come lo fa l'istruzione using.

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

Relazionato:

Sì, usingracchiude il codice in un blocco try / latest dove la finallyparte chiamerà Dispose()se esiste. Tuttavia, non chiamerà Close()direttamente poiché verifica solo l' IDisposableinterfaccia implementata e quindi il Dispose()metodo.

Guarda anche:

• Intercettazione di un'eccezione all'interno di IDisposable.Dispose
• Qual è il modo corretto per garantire che una connessione SQL venga chiusa quando viene generata un'eccezione?
• Sintassi "Utilizzo" di C #
• Parola chiave C # USING: quando e quando non usarla?
• istruzione "using" vs "try finally"
• Cos'è il blocco C # Using e perché dovrei usarlo?
• Usa e getta utilizzando il modello
• Fine di utilizzo chiude una connessione SQL aperta

Ecco come il riflettore decodifica l'IL generato dal tuo codice:

private static void Main (string [] args)
{
    SqlConnection conn = new SqlConnection ("...");
    provare
    {
        conn.Open ();
        Fare cose();
    }
    finalmente
    {
        if (conn! = null)
        {
            conn.Dispose ();
        }
    }
}

Quindi la risposta è sì, chiuderà la connessione se

Fare cose()

Dispose () non viene chiamato in questo codice.

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