em um bloco "using" um SqlConnection é fechado no retorno ou exceção?

Primeira pergunta:
diga que eu tenho

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

A conexão é fechada? Porque tecnicamente nunca chegamos ao último }como returnantes.

Segunda pergunta:
Desta vez eu tenho:

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

Agora, digamos que, em algum lugar try, recebemos um erro e ele seja capturado. A conexão ainda está fechada? Porque, novamente, pulamos o restante do código no trye vamos diretamente para a catchinstrução

Estou pensando linearmente demais em como usingfunciona? ou seja, Dispose()simplesmente é chamado quando deixamos o usingescopo?

1. sim
2. Sim.

De qualquer forma, quando o bloco de uso é encerrado (por conclusão bem-sucedida ou por erro), ele é fechado.

Embora eu ache que seria melhor organizar assim, porque é muito mais fácil ver o que vai acontecer, mesmo para o novo programador de manutenção que o apoiará mais tarde:

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

Sim para ambas as perguntas. A instrução using é compilada em um bloco try / finalmente

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

é o mesmo que

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

Edit: Fixing the cast to Disposable http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Aqui está o meu modelo. Tudo o que você precisa para selecionar dados de um servidor SQL. A conexão é fechada e descartada e erros na conexão e execução são detectados.

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

* Revisado: 09-11-2015 *
Conforme sugerido por NickG; Se muitas chaves lhe incomodam, formate assim ...

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

Por outro lado, se você trabalha para jogos da EA ou do DayBreak, pode simplesmente renunciar a qualquer quebra de linha, porque são apenas para pessoas que precisam voltar e olhar seu código mais tarde e quem realmente se importa? Estou certo? Quero dizer, 1 linha em vez de 23 significa que sou um programador melhor, certo?

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

Ufa ... OK. Tirei isso do meu sistema e acabei me divertindo por um tempo. Continue.

Dispose simplesmente é chamado quando você sai do escopo de uso. A intenção de "usar" é oferecer aos desenvolvedores uma maneira garantida de garantir que os recursos sejam descartados.

Do MSDN :

Uma instrução using pode ser encerrada quando o final da instrução using for atingido ou se uma exceção for lançada e o controle deixar o bloco de instruções antes do final da instrução.

Usinggera uma tentativa / finalmente ao redor do objeto que está sendo alocado e chama Dispose()por você.

Isso evita o incômodo de criar manualmente o bloco try / finalmente e chamar Dispose()

No seu primeiro exemplo, o compilador C # realmente converterá a instrução using para o seguinte:

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

Finalmente, as instruções sempre serão chamadas antes do retorno de uma função e, portanto, a conexão será sempre fechada / descartada.

Portanto, no seu segundo exemplo, o código será compilado da seguinte maneira:

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

A exceção será capturada na instrução finalmente e a conexão será fechada. A exceção não será vista pela cláusula de captura externa.

Escrevi duas instruções using dentro de um bloco try / catch e pude ver que a exceção estava sendo capturada da mesma maneira, se colocada dentro da instrução inner using , como no exemplo do 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);
     }

Não importa onde a tentativa / captura seja feita, a exceção será capturada sem problemas.