¿Mejores prácticas para conexiones de datos de C#? [cerrado]
Bien, este es uno de esos tipos de temas obstinados, pero según su conocimiento, opinión y práctica actual, ¿cuál es la mejor manera de configurar el siguiente escenario?
Estoy creando una aplicación de ingreso de datos extensa, y por extensa quiero decir que solo tengo la configuración básica que incorpora alrededor del 15 al 25 % del programa general y tengo alrededor de 15 formularios que están parcialmente configurados. (Todavía necesitan trabajo) Estoy usando SQL Compact 4.0 como mi base de datos backend, realmente no necesito una base de datos más amplia ya que no estoy almacenando datos de un MMO y por el momento esto es solo una aplicación local. .
Me encantaría poder configurarlo para que se muestre como una ventana única que simplemente cambie a varias páginas diferentes según un sistema de menú, pero parece que no puedo encontrar un buen tutorial sobre cómo se lograría eso, así que si Alguien sabe de alguno, por favor ilumíneme.
Sin embargo, el escenario en cuestión es cómo conectarse a las bases de datos. Estoy usando 2 bases de datos SQLCE, una que almacena datos constantes que se basan en los servicios y el personal, y una segunda que almacena los datos que cambian constantemente o los datos nuevos que se ingresan en función de la primera base de datos. He visto muchos métodos diferentes sobre cómo configurar esto y actualmente estoy usando uno en el que tengo un BaseForm del que heredan todos los demás formularios. Dentro de BaseForm tengo métodos y variables que son comunes a muchos formularios, minimizando así la cantidad de código que se repite.
Esto incluye las cadenas de conexión a ambas bases de datos y 2 métodos que abren una conexión a cualquiera de ellas. Al igual que:
internal SqlCeConnection dataConn = new SqlCeConnection(@"Data Source = |DataDirectory|\opi_data.sdf");
internal SqlCeConnection logConn = new SqlCeConnection(@"Data Source = |DataDirectory|\opi_logs.sdf");
internal SqlCeCommand command;
internal void openDataConnection() // Opens a connection to the data tables
{
try
{
if(dataConn.State == ConnectionState.Closed)
dataConn.Open();
}
catch(SqlCeException ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
internal void openLogConnection() // Opens a connection to the log tables
{
try
{
if(logConn.State == ConnectionState.Closed)
logConn.Open();
}
catch (SqlCeException ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Luego, cada vez que necesito una conexión abierta, simplemente llamo al método de conexión abierta que corresponde a la base de datos a la que necesito acceder y luego la cierro en una declaración finalmente. De esta manera, una conexión nunca permanece abierta por mucho tiempo, sólo cuando es necesaria. Por supuesto, esto significa que hay muchas llamadas a los métodos de conexión abiertos. Entonces, ¿es esta la mejor manera de implementar este tipo de escenario o existen mejores formas?
¿Es mejor simplemente abrir una conexión tan pronto como se carga un formulario y luego cerrarla cuando se cierra el formulario? Tengo casos en los que hay varios formularios abiertos a la vez y cada uno probablemente necesitaría una conexión abierta a las bases de datos, por lo que si uno lo cierra, los demás estarían jodidos, ¿verdad? ¿O debería abrir una conexión a ambas bases de datos al iniciar la aplicación? Cualquier aportación será apreciada. Gracias.
Las conexiones se agrupan mediante .NET, por lo que recrearlas generalmente no es una operación costosa. Sin embargo, mantener las conexiones abiertas durante largos períodos de tiempo puede causar problemas.
La mayoría de las "mejores prácticas" nos dicen que abramos las conexiones lo más tarde posible (justo antes de ejecutar cualquier SQL) y las cerremos lo antes posible (justo después de que se haya extraído el último bit de datos).
Una forma eficaz de hacerlo automáticamente es con usingdeclaraciones:
using (SqlConnection conn = new SqlConnection(...))
{
using(SqlCommand cmd = new SqlCommand(..., conn))
{
conn.Open();
using(DataReader dr = cmd.ExecuteReader()) // or load a DataTable, ExecuteScalar, etc.
{
...
{
}
}
De esa manera, los recursos se cierran y eliminan incluso si se produce una excepción.
En resumen, abrir una conexión cuando se abre la aplicación o cuando se abre cada formulario probablemente no sea el mejor enfoque.
