"abrir/cerrar" SqlConnection o mantener abierto?

Question

Tengo mi lógica de negocio implementada en clases estáticas simples con métodos estáticos. Cada uno de estos métodos se abre/cierra la conexión de SQL cuando se le llama:

public static void AddSomething(string something) 
{ 
    using (SqlConnection connection = new SqlConnection("...")) 
    { 
     connection.Open(); 

     // ... 

     connection.Close(); 
    } 
} 

pero creo evitando la apertura y el cierre de una conexión ahorra rendimiento. Hice algunas pruebas muuuucho tiempo atrás con OleDbConnection clase (no estoy seguro sobre el SqlConnection), y que sin duda ayudó a trabajar así (por lo que yo recuerdo):

//pass the connection object into the method 
public static void AddSomething(string something, SqlConnection connection) 
{ 
    bool openConn = (connection.State == ConnectionState.Open); 
    if (!openConn) 
    { 
     connection.Open(); 
    } 

    // .... 

    if (openConn) 
    { 
     connection.Close(); 
    } 
} 

Así que la pregunta es - debería elegir el método (a) o el método (b)? Leí en otra pregunta stackoverflow que la conexión agrupa el rendimiento guardado para mí, no tengo que molestar en absoluto ...

PS. Es una aplicación ASP.NET: las conexiones existen solo durante una solicitud web. No es una aplicación o servicio win.

Answer 1

Se adhiere a la opción a.

El grupo de conexiones es tu amigo.

Answer 2

Siempre cierre las conexiones tan pronto como haya terminado con ellas, para que la conexión de la base de datos subyacente pueda volver al grupo y esté disponible para otras personas que llaman. La agrupación de conexiones está bastante optimizada, por lo que no hay una penalización notable por hacerlo. El consejo es básicamente el mismo que para las transacciones: manténgalas cortas y cerradas cuando haya terminado.

Se vuelve más complicado si se encuentra con problemas MSDTC al usar una sola transacción alrededor del código que usa conexiones múltiples, en cuyo caso tiene que compartir el objeto de conexión y solo cerrarlo una vez que la transacción finaliza .

Sin embargo, usted está haciendo las cosas a mano aquí, por lo que es posible que desee investigar las herramientas que gestionan las conexiones para usted, como DataSets, Linq a SQL, Entity Framework o NHibernate.

Answer 3

Utilice el método (a), cada vez. Cuando comiences a escalar tu aplicación, la lógica que trata con el estado se convertirá en un verdadero dolor si no lo haces.

La agrupación de conexiones hace lo que dice en la lata. Solo piense en lo que sucede cuando la aplicación escala, y qué tan difícil sería administrar manualmente el estado de apertura/cierre de la conexión. El grupo de conexiones hace un buen trabajo al manejar esto automáticamente. Si le preocupa el rendimiento, piense en algún tipo de mecanismo de memoria caché para que nada se bloquee.

Answer 4

Existen distinciones entre las conexiones físicas y lógicas. DbConnection es un tipo de conexión lógica y utiliza una conexión física subyacente a Oracle. Cerrar/abrir DbConnection no afecta su rendimiento, pero hace que su código esté limpio y estable; las fugas de conexión son imposibles en este caso.

También debe recordar los casos en que existen limitaciones para las conexiones en paralelo en el servidor de base de datos, teniendo en cuenta que es necesario hacer sus conexiones muy breves.

El grupo de conexiones lo libera de la comprobación del estado de la conexión: simplemente ábralo, úselo y ciérrelo inmediatamente.

Answer 5

Descargo de responsabilidad: Sé que esto es viejo, pero encontré una manera fácil de demostrar este hecho, por lo que estoy poniendo en mi valor de dos centavos.

Si usted está teniendo problemas para creer que la puesta en común es realmente va a ser más rápido, a continuación, dar a este un intento:

Añadir la siguiente parte:

using System.Diagnostics; 
public static class TestExtensions 
{ 
    public static void TimedOpen(this SqlConnection conn) 
    { 
     Stopwatch sw = Stopwatch.StartNew(); 
     conn.Open(); 
     Console.WriteLine(sw.Elapsed); 
    } 
} 

Ahora reemplace todas las llamadas a Open() con TimedOpen() y ejecuta su programa. Ahora, para cada cadena de conexión distinta que tenga, la ventana de la consola (salida) tendrá una única ejecución larga abierta, y se abrirá rápidamente un grupo de muy.

Si desea etiquetarlos puede agregar new StackTrace(true).GetFrame(1) + a la llamada al WriteLine.