w bloku „using” jest SqlConnection zamykane po powrocie lub wyjątku?

Pierwsze pytanie:
powiedz, że tak

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

Czy połączenie zostaje zamknięte? Ponieważ technicznie nigdy nie dotarliśmy do końca, }tak jak returnprzedtem.

Drugie pytanie:
tym razem mam:

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*/ }

Teraz powiedzmy, że gdzieś w trypliku pojawia się błąd i zostaje on przechwycony. Czy połączenie nadal jest zamykane? Ponownie, pomijamy resztę kodu w instrukcji tryi przechodzimy bezpośrednio do catchinstrukcji.

Czy myślę zbyt liniowo, jak to usingdziała? ie Czy Dispose()po prostu zostaje wywołany, gdy opuszczamy usingzakres?

1. tak
2. Tak.

Tak czy inaczej, gdy blok using zostanie zakończony (przez pomyślne zakończenie lub przez błąd), jest zamykany.

Chociaż myślę, że lepiej byłoby to zorganizować w ten sposób, ponieważ znacznie łatwiej jest zobaczyć, co się stanie, nawet dla nowego programisty utrzymania ruchu, który wesprze to później:

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*/ 
    }
}

Tak na oba pytania. Instrukcja using zostaje skompilowana do bloku try / final

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

jest taki sam jak

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

Edycja: Naprawianie rzutowania na jednorazowe http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Oto mój szablon. Wszystko, czego potrzebujesz, aby wybrać dane z serwera SQL. Połączenie jest zamykane i usuwane, a błędy w połączeniu i wykonywaniu są wychwytywane.

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

* Poprawiono: 2015-11-09 *
Zgodnie z sugestią NickG; Jeśli denerwuje Cię zbyt wiele aparatów ortodontycznych, sformatuj w ten sposób ...

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

Z drugiej strony, jeśli pracujesz dla gier EA lub DayBreak, możesz po prostu zrezygnować z przerw między wierszami, ponieważ są one przeznaczone tylko dla osób, które muszą później wrócić i spojrzeć na Twój kod, a kogo to naprawdę obchodzi? Czy mam rację? To znaczy 1 linia zamiast 23 oznacza, że ​​jestem lepszym programistą, prawda?

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

Uff ... OK. Wyciągnąłem to z mojego systemu i przez chwilę się bawię. Kontynuować.

Dispose zostaje po prostu wywołane, gdy opuścisz zakres using. Celem „używania” jest zapewnienie programistom zagwarantowanego sposobu na pozbycie się zasobów.

Z MSDN :

Instrukcja using może zostać zakończona, gdy zostanie osiągnięty koniec instrukcji using lub jeśli zostanie zgłoszony wyjątek, a sterowanie pozostawi blok instrukcji przed końcem instrukcji.

Usinggeneruje próbę / w końcu wokół przydzielanego obiektu i woła Dispose()do Ciebie.

Oszczędza to kłopotów związanych z ręcznym tworzeniem bloku try / last i dzwonieniem Dispose()

W pierwszym przykładzie kompilator C # faktycznie przetłumaczy instrukcję using na następującą:

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

Instrukcje Final zawsze będą wywoływane przed powrotem funkcji, więc połączenie będzie zawsze zamykane / usuwane.

Tak więc w drugim przykładzie kod zostanie skompilowany w następujący sposób:

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)
{
}

Wyjątek zostanie przechwycony w instrukcji last i połączenie zostanie zamknięte. Wyjątek nie będzie widoczny w klauzuli zewnętrznej catch.

Napisałem dwie instrukcje using wewnątrz bloku try / catch i mogłem zobaczyć, że wyjątek jest przechwytywany w ten sam sposób, jeśli jest umieszczony w wewnętrznej instrukcji using , tak jak w przykładzie 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);
     }

Bez względu na to, gdzie jest umieszczony tryb try / catch , wyjątek zostanie przechwycony bez problemów.