¿Cuál es la forma correcta de garantizar que se cierra una conexión SQL cuando se lanza una excepción?

Question

Uso un patrón que se ve así más a menudo. Me pregunto si esto está bien o si hay una mejor práctica que no estoy aplicando aquí.

En concreto, me pregunto; en el caso de que se genere una excepción, ¿el código que tengo en el bloque finally es suficiente para garantizar que la conexión se cierra adecuadamente?

public class SomeDataClass : IDisposable 
{ 
    private SqlConnection _conn; 

    //constructors and methods 

    private DoSomethingWithTheSqlConnection() 
    { 
     //some code excluded for brevity 

     try 
     { 
      using (SqlCommand cmd = new SqlCommand(SqlQuery.CountSomething, _SqlConnection)) 
      { 
       _SqlConnection.Open(); 
       countOfSomething = Convert.ToInt32(cmd.ExecuteScalar()); 
      } 
     } 
     finally 
     { 
      //is this the best way? 
      if (_SqlConnection.State == ConnectionState.Closed) 
       _SqlConnection.Close(); 
     } 

     //some code excluded for brevity 
    } 

    public Dispose() 
    { 
     _conn.Dispose(); 
    } 
} 

Answer 1

envolver su código de gestión de base de datos dentro de un "uso"

using (SqlConnection conn = new SqlConnection (...)) 
{ 
    // Whatever happens in here, the connection is 
    // disposed of (closed) at the end. 
} 

Answer 2

Dado que está utilizando IDisposables de todos modos. Puede usar la palabra clave 'using', que es básicamente equivalente a llamar a disponer en un bloque finally, pero se ve mejor.

Answer 3

Supongo que por "_SqlConnection.State == ConnectionState.Closed" significó! =.

Esto sin duda funcionará. Creo que es más habitual contener el objeto de conexión dentro de una sentencia using, pero lo que tienes es bueno si quieres reutilizar el mismo objeto de conexión por alguna razón.

Sin embargo, una cosa que definitivamente debería cambiar es el método Dispose(). No debe hacer referencia al objeto de conexión en disposición, ya que puede que ya se haya finalizado en ese punto. En su lugar, debe seguir el patrón de Disposición recomendado.

Answer 4

podría sugerir esto:

    class SqlOpener : IDisposable 
    { 
     SqlConnection _connection; 

     public SqlOpener(SqlConnection connection) 
     { 
      _connection = connection; 
      _connection.Open(); 

     } 

     void IDisposable.Dispose() 
     { 
      _connection.Close(); 
     } 
    } 

    public class SomeDataClass : IDisposable 
    { 
     private SqlConnection _conn; 

     //constructors and methods 

     private void DoSomethingWithTheSqlConnection() 
     { 
      //some code excluded for brevity 
      using (SqlCommand cmd = new SqlCommand("some sql query", _conn)) 
      using(new SqlOpener(_conn)) 
      { 
       int countOfSomething = Convert.ToInt32(cmd.ExecuteScalar()); 
      } 
      //some code excluded for brevity 
     } 

     public void Dispose() 
     { 
      _conn.Dispose(); 
     } 
    } 

Espero que ayude :)

Answer 5

poner el código estrecha relación dentro de un bloque "Finalmente", como se muestra. Finalmente, los bloques se ejecutan antes de lanzar la excepción. Usar un bloque "usar" funciona igual de bien, pero el método explícito "Finalmente" me parece más claro.

Las declaraciones de uso son anticuadas para muchos desarrolladores, pero los desarrolladores más jóvenes pueden no saberlo.

Answer 6

.Net Framework mantiene un grupo de conexiones por un motivo. ¡Confía en ello! :) No tiene que escribir tanto código solo para conectarse a la base de datos y liberar la conexión.

Puede simplemente usar la instrucción 'using' y tener la seguridad de que 'IDBConnection.Release()' cerrará la conexión por usted.

Las 'soluciones' altamente elaboradas tienden a dar como resultado un código defectuoso. Simple es mejor.

Answer 7

MSDN Docs hacer esta bastante claro ...

• El método Close deshace las transacciones pendientes. A continuación, libera la conexión al grupo de conexiones o cierra la conexión si la agrupación de conexiones está deshabilitada.

Probablemente no haya (y no desee) deshabilitar la agrupación de conexiones, por lo que la agrupación finalmente gestiona el estado de la conexión después de llamar a "Cerrar". Esto podría ser importante ya que puede confundirse mirando desde el lado del servidor de la base de datos en todas las conexiones abiertas.

---

• Una aplicación puede llamar a cerrar más de una vez. No se genera ninguna excepción.

¿Por qué molestarse en la prueba de Cerrado? Simplemente llame a Close().

---

• Cerrar y botar son funcionalmente equivalentes.

Es por esto que un utilizando el bloque da como resultado una conexión cerrada. usando llamadas Eliminar para usted.

---

• No llamar Cerrar o disponer de una conexión, un DataReader, o cualquier otro objeto administrado en el método Finalize de la clase.

Sugerencia importante de seguridad. Gracias, Egon.

Answer 8

Ver esta pregunta para la respuesta:

Close and Dispose - which to call?

Si su vida es una sola conexión de llamada a un método, utilice la función using de la lengua para asegurar la limpieza adecuada de la conexión. Mientras que un bloque try/finally es funcionalmente el mismo, requiere más código y el IMO es menos legible. No es necesario verificar el estado de la conexión, puede llamar al Dispose independientemente y se encargará de limpiar la conexión.

Si la vida útil de su conexión corresponde a la vida útil de una clase contenedora, implemente IDisposable y limpie la conexión en Dispose.

Answer 9

hay necesidad de un try..finally en torno a un "uso", el uso de ES un try..finally