Dispose est-il toujours appelé lorsqu'une exception est levée à l'intérieur d'une instruction using?

Dans l'exemple ci-dessous, la connexion va-t-elle se fermer et être supprimée lorsqu'une exception est levée si elle se trouve dans une usinginstruction?

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

Je sais que ce code ci-dessous s'assurera que c'est le cas, mais je suis curieux de savoir comment utiliser l'instruction le fait.

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

En relation:

Oui, usingencapsule votre code dans un bloc try / finally où la finallypartie sera appelée Dispose()si elle existe. Cependant, il n'appellera pas Close()directement car il ne vérifie que l' IDisposableinterface implémentée et donc la Dispose()méthode.

Voir également:

• Intercepter une exception dans IDisposable.
• Quelle est la bonne façon de garantir qu'une connexion SQL est fermée lorsqu'une exception est levée?
• C # "Utilisation" de la syntaxe
• Mot-clé C # USING - quand et quand ne pas l'utiliser?
• 'en utilisant' instruction vs 'essayer enfin'
• Qu'est-ce que le bloc C # Using et pourquoi devrais-je l'utiliser?
• Modèle d'utilisation jetable
• Termine-t-il par fermer une connexion SQL ouverte

Voici comment réflecteur décode l'IL généré par votre code:

private static void Main (string [] args)
{
    SqlConnection conn = new SqlConnection ("...");
    essayer
    {
        conn.Open ();
        Faire des trucs();
    }
    enfin
    {
        si (conn! = null)
        {
            conn.Dispose ();
        }
    }
}

Donc la réponse est oui, cela fermera la connexion si

Faire des trucs()

Dispose () n'est pas appelé dans ce code.

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