Pourquoi utiliser une instruction using avec une SqlTransaction ?

Question

J'ai rencontré quelques problèmes concernant une SqlTransaction que j'utilise dans mon code. En cherchant sur Google, j'ai vu que de nombreuses personnes utilisaient une instruction using avec une SqlTransaction.

Quel est l'avantage et/ou la différence d'utiliser ce type d'instruction avec une SqlTransaction ?

using (SqlConnection cn = new SqlConnection())
{
     using (SqlTransaction tr = cn.BeginTransaction())
     {
      //some code
      tr.Commit();
     }
}

Actuellement, mon code ressemble à ceci :

SqlConnection cn = new SqlConnection(ConfigurationManager.AppSettings["T3"]);
cn.Open();
SqlTransaction tr = cn.BeginTransaction();

try
{
     //some code
     tr.Commit();
     cn.Close();
}
catch(Exception ex)
{
      tr.Rollback();
      cn.Close();
      throw ex;
}

Quel est l'avantage d'une méthode sur l'autre ?

Answer 1

A using devrait être utilisée chaque fois que vous créez une instance d'une classe qui implémente IDisposable dans le cadre d'un bloc . Il garantit que le Dispose() sera appelée sur cette instance, qu'une exception soit levée ou non.

En particulier, votre code n'attrape que les exceptions gérées, puis détruit le cadre de la pile en lançant une nouvelle exception au lieu de relancer celle qui existe.

La façon correcte de procéder est la suivante :

using (SqlConnection cn = new SqlConnection(ConfigurationManager.AppSettings["T3"])) {
    cn.Open();
    using (SqlTransaction tr = cn.BeginTransaction()) {
        //some code
        tr.Commit();
    }
}

Notez que si votre classe possède des membres d'instance de types qui mettent en œuvre l'option IDisposable alors votre classe doit implémenter IDisposable lui-même, et dispose de ces membres pendant sa propre période d'activité. Dispose() appeler.

Answer 2

La raison en est que l'objet SqlTransaction revient en arrière dans sa méthode Dispose() s'il n'a pas été explicitement validé (par exemple, si une exception est levée). En d'autres termes, cela a le même effet que votre code, juste un peu plus propre.

Answer 3

L'utilisation fait essentiellement la même chose que vous, à l'exception d'un bloc final au lieu d'attraper toutes les exceptions :

using (SqlConnection cn = new SqlConnection())
{
     using (SqlTransaction tr = cn.BeginTransaction())
     {
      //some code
      tr.Commit();
     }
}

est la même chose que, juste beaucoup moins de code :)

{
    SqlConnection cn = null;
    try
    {
       cn = new SqlConnection();
       {
           SqlTransaction tr = null;
           try
           {
               tr = cn.BeginTransaction())

               //some code
               tr.Commit();
            }
            finally
            {
                if(tr != null && tr is IDisposable)
                {
                    tr.Dispose();
                }
            }
        }
    }
    finally
    {
        if(cn != null && cn is IDisposable)
        {
            cn.Dispose();
        }
    }
}

Answer 4

En fin de compte, using est juste un raccourci pour un motif. Mais c'est un très utile et un raccourci utile, car il permet de s'assurer que vous implémentez le modèle correctement et de le faire avec moins de code.

Dans ce cas, vous n'avez pas mis en œuvre le modèle correctement. Que se passe-t-il dans votre code si l'appel à tr.RollBack() lance également une exception ?

Answer 5

Le site en utilisant l'énoncé ferme et dispose de votre connexion et de votre transaction pour vous. C'est l'équivalent d'avoir un bloc final sur votre try/catch qui fait la disposition.

Vous pourriez aussi condenser les blocs d'utilisation un peu comme ceci...

using (SqlConnection cn = new SqlConnection())
using (SqlTransaction tr = cn.BeginTransaction())     
{
      //some code
      tr.Commit();
}

ce qui revient à peu près au même que :

SqlConnection cn = null;
SqlTransaction tr = null;
try
{
    cn = new SqlConnection());
    tr = cn.BeginTransaction());

    //some code
    tr.Commit();
}
finally
{
    if (cn != null)
        cn.Dispose();
    if (tr != null)    
        tr.Dispose();
}