dans un bloc «using», un SqlConnection est-il fermé au retour ou à une exception?

Première question:
dis que j'ai

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    string storedProc = "GetData";
    SqlCommand command = new SqlCommand(storedProc, connection);
    command.CommandType = CommandType.StoredProcedure;
    command.Parameters.Add(new SqlParameter("@EmployeeID", employeeID));

    return (byte[])command.ExecuteScalar();
}

La connexion est-elle fermée? Parce que techniquement, nous n'arrivons jamais au dernier }comme returnavant.

Deuxième question:
Cette fois, j'ai:

try
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        int employeeID = findEmployeeID();

        connection.Open();
        SqlCommand command = new SqlCommand("UpdateEmployeeTable", connection);
        command.CommandType = CommandType.StoredProcedure;
        command.Parameters.Add(new SqlParameter("@EmployeeID", employeeID));
        command.CommandTimeout = 5;

        command.ExecuteNonQuery();
    }
}
catch (Exception) { /*Handle error*/ }

Maintenant, disons quelque part dans le trynous obtenons une erreur et elle est interceptée. La connexion est-elle toujours fermée? Car encore une fois, nous sautons le reste du code dans le tryet passons directement à l' catchinstruction.

Est-ce que je pense trop linéairement à la façon dont usingfonctionne? c'est-à-dire est Dispose()simplement appelé lorsque nous quittons la usingportée?

1. Oui
2. Oui.

Dans tous les cas, lorsque le bloc utilisateur est quitté (soit par réussite, soit par erreur), il est fermé.

Bien que je pense qu'il serait préférable de s'organiser comme ça, car il est beaucoup plus facile de voir ce qui va se passer, même pour le nouveau programmeur de maintenance qui le soutiendra plus tard:

using (SqlConnection connection = new SqlConnection(connectionString)) 
{    
    int employeeID = findEmployeeID();    
    try    
    {
        connection.Open();
        SqlCommand command = new SqlCommand("UpdateEmployeeTable", connection);
        command.CommandType = CommandType.StoredProcedure;
        command.Parameters.Add(new SqlParameter("@EmployeeID", employeeID));
        command.CommandTimeout = 5;

        command.ExecuteNonQuery();    
    } 
    catch (Exception) 
    { 
        /*Handle error*/ 
    }
}

Oui aux deux questions. L'instruction using est compilée dans un bloc try / finally

using (SqlConnection connection = new SqlConnection(connectionString))
{
}

est le même que

SqlConnection connection = null;
try
{
    connection = new SqlConnection(connectionString);
}
finally
{
   if(connection != null)
        ((IDisposable)connection).Dispose();
}

Edit: Correction de la distribution en jetable http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Voici mon modèle. Tout ce dont vous avez besoin pour sélectionner des données à partir d'un serveur SQL. La connexion est fermée et supprimée et les erreurs de connexion et d'exécution sont interceptées.

string connString = System.Configuration.ConfigurationManager.ConnectionStrings["CompanyServer"].ConnectionString;
string selectStatement = @"
    SELECT TOP 1 Person
    FROM CorporateOffice
    WHERE HeadUpAss = 1 AND Title LIKE 'C-Level%'
    ORDER BY IntelligenceQuotient DESC
";
using (SqlConnection conn = new SqlConnection(connString))
{
    using (SqlCommand comm = new SqlCommand(selectStatement, conn))
    {
        try
        {
            conn.Open();
            using (SqlDataReader dr = comm.ExecuteReader())
            {
                if (dr.HasRows)
                {
                    while (dr.Read())
                    {
                        Console.WriteLine(dr["Person"].ToString());
                    }
                }
                else Console.WriteLine("No C-Level with Head Up Ass Found!? (Very Odd)");
            }
        }
        catch (Exception e) { Console.WriteLine("Error: " + e.Message); }
        if (conn.State == System.Data.ConnectionState.Open) conn.Close();
    }
}

* Révisé: 2015-11-09 *
Tel que suggéré par NickG; Si trop d'accolades vous ennuient, formatez comme ça ...

using (SqlConnection conn = new SqlConnection(connString))
   using (SqlCommand comm = new SqlCommand(selectStatement, conn))
   {
      try
      {
         conn.Open();
         using (SqlDataReader dr = comm.ExecuteReader())
            if (dr.HasRows)
               while (dr.Read()) Console.WriteLine(dr["Person"].ToString());
            else Console.WriteLine("No C-Level with Head Up Ass Found!? (Very Odd)");
      }
      catch (Exception e) { Console.WriteLine("Error: " + e.Message); }
      if (conn.State == System.Data.ConnectionState.Open) conn.Close();
   }

Là encore, si vous travaillez pour des jeux EA ou DayBreak, vous pouvez également renoncer aux sauts de ligne, car ceux-ci sont réservés aux personnes qui doivent revenir et regarder votre code plus tard et qui s'en soucient vraiment? Ai-je raison? Je veux dire 1 ligne au lieu de 23 signifie que je suis un meilleur programmeur, non?

using (SqlConnection conn = new SqlConnection(connString)) using (SqlCommand comm = new SqlCommand(selectStatement, conn)) { try { conn.Open(); using (SqlDataReader dr = comm.ExecuteReader()) if (dr.HasRows) while (dr.Read()) Console.WriteLine(dr["Person"].ToString()); else Console.WriteLine("No C-Level with Head Up Ass Found!? (Very Odd)"); } catch (Exception e) { Console.WriteLine("Error: " + e.Message); } if (conn.State == System.Data.ConnectionState.Open) conn.Close(); }

Ouf ... OK. J'ai sorti ça de mon système et j'ai fini de m'amuser pendant un moment. Continuer.

Dispose est simplement appelé lorsque vous quittez le champ d'utilisation. L'intention de «l'utilisation» est de donner aux développeurs un moyen garanti de s'assurer que les ressources sont éliminées.

Depuis MSDN :

Une instruction using peut être quittée lorsque la fin de l'instruction using est atteinte ou si une exception est levée et que le contrôle quitte le bloc d'instructions avant la fin de l'instruction.

Usinggénère un essai / enfin autour de l'objet alloué et appelle Dispose()pour vous.

Cela vous évite d'avoir à créer manuellement le bloc try / finally et à appeler Dispose()

Dans votre premier exemple, le compilateur C # traduira en fait l'instruction using en ce qui suit:

SqlConnection connection = new SqlConnection(connectionString));

try
{
    connection.Open();

    string storedProc = "GetData";
    SqlCommand command = new SqlCommand(storedProc, connection);
    command.CommandType = CommandType.StoredProcedure;
    command.Parameters.Add(new SqlParameter("@EmployeeID", employeeID));

    return (byte[])command.ExecuteScalar();
}
finally
{
    connection.Dispose();
}

Enfin, les instructions seront toujours appelées avant le retour d'une fonction et ainsi la connexion sera toujours fermée / supprimée.

Ainsi, dans votre deuxième exemple, le code sera compilé comme suit:

try
{
    try
    {
        connection.Open();

        string storedProc = "GetData";
        SqlCommand command = new SqlCommand(storedProc, connection);
        command.CommandType = CommandType.StoredProcedure;
        command.Parameters.Add(new SqlParameter("@EmployeeID", employeeID));

        return (byte[])command.ExecuteScalar();
    }
    finally
    {
        connection.Dispose();
    }
}
catch (Exception)
{
}

L'exception sera interceptée dans l'instruction finally et la connexion sera fermée. L'exception ne sera pas vue par la clause catch externe.

J'ai écrit deux instructions using dans un bloc try / catch et je pouvais voir que l'exception était interceptée de la même manière si elle était placée dans l' instruction using interne , comme dans l' exemple ShaneLS .

     try
     {
       using (var con = new SqlConnection(@"Data Source=..."))
       {
         var cad = "INSERT INTO table VALUES (@r1,@r2,@r3)";

         using (var insertCommand = new SqlCommand(cad, con))
         {
           insertCommand.Parameters.AddWithValue("@r1", atxt);
           insertCommand.Parameters.AddWithValue("@r2", btxt);
           insertCommand.Parameters.AddWithValue("@r3", ctxt);
           con.Open();
           insertCommand.ExecuteNonQuery();
         }
       }
     }
     catch (Exception ex)
     {
       MessageBox.Show("Error: " + ex.Message, "UsingTest", MessageBoxButtons.OK, MessageBoxIcon.Error);
     }

Peu importe où est placé le try / catch , l'exception sera interceptée sans problème.