dans une "aide" bloc est une occurrence de SqlConnection fermé sur le retour ou l'exception?

Question

Première question:
Dire 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 se ferment? Parce que, techniquement, nous n'avons jamais arriver au dernier } comme nous l' return avant elle.

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, dire que quelque part dans l' try , on obtient une erreur et il se fait attraper. La connexion encore fermé? Car, encore une fois, nous avons passer le reste du code dans l' try et aller directement à l' catch déclaration.

Suis-je trop penser de façon linéaire dans la façon dont using fonctionne? ie N' Dispose() simplement appelée lorsque nous quittons l' using portée?

Answer 1

1. Oui
2. Oui.

De toute façon, lorsque le bloc using (soit par la réussite ou par erreur), il est fermé.

Bien que je pense qu'il serait mieux d'organiser comme ça parce que c'est beaucoup plus facile de voir ce qui va se passer, même pour la maintenance programmeur qui 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*/ 
   }

}

Answer 2

Oui aux deux questions. L'utilisation de déclaration sera compilé dans un try/finally bloc

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: la Fixation de la fonte à Jetables http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Answer 3

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

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

Answer 4

Jetez simplement qui est appelé lorsque vous quittez le champ d'application de l'aide. L'intention de "l'aide" est pour donner aux développeurs un moyen sûr de s'assurer que les ressources sont disposées.

À partir de MSDN:

À l'aide d'instruction ne peut être quitté, soit lors de la fin de l'utilisation de déclaration est atteint ou si une exception est levée et le contrôle des feuilles de la déclaration bloc avant la fin de l'instruction.

Answer 5

Dans ton premier exemple, le compilateur C# va traduire le à l'aide de l'énoncé suivant:

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 déclarations de toujours obtenir appelée avant que la fonction retourne et donc la connexion sera toujours fermé/cédées.

Donc, dans ton deuxième exemple, le code sera compilé à la suivante:

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 pris dans l'instruction enfin et la fermeture de la connexion. L'exception ne sera pas vu par l'extérieur clause catch.