¿en un bloque "using" se cierra una conexión SqlConnection en retorno o excepción?

Sí a ambas preguntas. La instrucción using se compila en un bloque try/finally

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

Es lo mismo que

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

Editar: Fijar la escayola a Desechable http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Aquí está mi Plantilla. Todo lo que necesita para seleccionar datos de un servidor SQL. La conexión se cierra y se elimina y se detectan errores en la conexión y la ejecución.

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

* Revisadas: 2015-11-09 *
Como sugiere NickG; Si demasiados frenos te molestan, formatea así...

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 otra parte, si trabajas para EA o DayBreak games, también puedes renunciar a cualquier salto de línea porque son solo para las personas que tienen que volver y mirar tu código más tarde, ¿y a quién le importa? ¿Tengo razón? Quiero decir 1 línea en lugar de 23 significa que soy un mejor programador, ¿verdad?

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

Uf... OK. Lo saqué de mi sistema y he terminado de divertirme por un tiempo. Continúa.

Dispose simplemente se llama al salir del ámbito de uso. La intención de" usar " es dar a los desarrolladores una forma garantizada de asegurarse de que los recursos se eliminen.

De MSDN :

Una sentencia using puede salir cuando se alcanza el final de la sentencia using o si se lanza una excepción y control abandona el bloque de sentencia antes del final de la sentencia.

Using genera un try / finally alrededor del objeto que se está asignando y llama Dispose() para usted.

Te ahorra la molestia de crear manualmente el bloque try / finally y llamar a Dispose()

En su primer ejemplo, el compilador de C # traducirá la instrucción using a lo siguiente:

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 declaraciones siempre llama antes de que una función devuelve y así, la conexión será siempre cerrado/eliminados.

Por lo tanto, en su segundo ejemplo, el código se compilará de la siguiente manera:

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

La excepción quedará atrapada en la sentencia finally y la conexión se cerrará. La excepción no se verá en la cláusula de captura exterior.

Escribí dos usando instrucciones dentro de un probar / atrapar block y pude ver que la excepción estaba siendo atrapada de la misma manera si se coloca dentro de la interior usando sentencia al igual que ShaneLS ejemplo.

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

No importa dónde está el probar / atrapar colocado, la excepción será capturada sin problemas.