EDN Admin
Well-known member
well excuse me for my english
so i have a class which make connection to sql server 2008, because when a make a query very big (more than 150000 rows) i need a command.timeout = 0, because if is not this way, c# tell me that de i have a error of timeouts
so i make a using(command) instruction for destroy de Command but is the same error ocurre
my error es because i need restore a lot of DB and with my program read de info in eache of BD for copy to a server some info
that wy i like to manteint open my program and can restore BD in the same DATABASE, but i cant restore BD because my program left a lot of process with status sleeping - awaiting command
so i have to close the program restore the DB and then open my program again
this is the code, is in spanish the comment but is comprensible, if you can see i have a process of nameCerrarConexion the which is for close the Connection but that dont make nothing with the process with status sleeping - awaiting command
i use only the process named EjecutarComando and EjecutarLectura in the first i used USING(COMMAND) in the second not, because i wanna know if that make a diference.
when i finished my process i call CerrarConexion for all the conection i make
i hope i can articulate the idea and sorry for me english
using System;
using System.Data;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.IO;
public class ConexionSQL
{
// Definimos las variables publicas que se utilizaran en el sistema
public SqlConnection conexion;
public SqlDataAdapter daSQL;
public SqlCommandBuilder cbSQL;
public SqlCommand comando;
public SqlDataReader consulta = null;
/// <summary>
/// Procedimiento que abre y verifica la conexion al servidor de datos
/// </summary>
/// <param name="Base_de_Datos Servidor de BD al cual conectar</param>
/// <returns>Devolvera el numero de error si este existiera, 0 si no hay error</returns>
public int AbrirConexionServidor(int Servidor)
{
// Creamos una variable de cadena en blanco para guardar la instruccion de conexion al servidor
string Cadena_Conexion = "";
string Base_de_Datos = "";
string Server = "";
/*string Pass = "";
// Definimos a que servidor se esta conectando
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase).Remove(0, 6) + "/";
string cargador = path + "\servidor.txt";
string strConsulta;
string parametros = "";
try
{
//Pass the file path and file name to the StreamReader constructor
StreamReader sr = new StreamReader(cargador);
parametros = sr.ReadToEnd();
parametros = parametros.Trim();
string [] rj = parametros.Split(|);
Server=rj[0];
Pass=rj[1];
sr.Close();
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine("Excepcion: " + ex.Message);
}
finally
{
Console.WriteLine("Ejecutando Ultimo Bloque");
}*/
switch (Servidor)
{
case 1:
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
"COMDALSA01",
"CONCAPERSASAE",
"xxxxx",
//"xxxxxx");
"xxxxxxx");
Base_de_Datos = "CONCAPERSA";
Server = "COMDALSA01";
break;
case 2:
// Cadena de conexion con base de datos
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
"COMDALSA06",
"FACTELECT",
"xxxxxx",
"xxxxxx");
Base_de_Datos = "SISTEMAS";
Server = "COMDALSA06";
break;
default:
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
".\SQLEXPRESS",
"DBFREST07",
"xxxxxxx",
"xxxxxxx");
break;
}
// Inicializamos la variable para la conexion
conexion = new SqlConnection(Cadena_Conexion);
// Bloque para verificar si existira error en la conexion
try
{
conexion.Open(); // Se abre la conexion
}
catch(SqlException ex) // Si hay error se ejecutaran las instrucciones siguientes
{
// Cerramos la conexion al servidor
conexion.Close();
string mensaje = ""; // Cadena para guardar el mensaje que se mostrara en el error
string mostrar_mensaje = "S"; // Definimos si se mostrara el mensaje de error
// Verificamos los diferentes errores que pueden suceder
switch (ex.Number)
{
case 1045:
{
mensaje = "El usuario ingresado no existe o la contraseña es incorrecta";
break;
}
case 1049: // No existe la Base de Datos
{
mensaje = "No se encuentra la base de datos [" + Base_de_Datos + "]";
mostrar_mensaje = "N";
break;
}
case 0:
{
mensaje = "No se puede encontrar el servidor especifico [" + Server + "]";
break;
}
default:
{
mensaje = String.Concat(ex.Message, " - ", ex.Number.ToString());
break;
}
}
// Si la variable contiene el valor "S" se mostrara el mensaje de error
if (mostrar_mensaje == "S")
MessageBox.Show(mensaje, "Error de conexión", MessageBoxButtons.OK, MessageBoxIcon.Error);
// No existe numero de error cuando no existe el servidor, por eso se regresa un -1
if (ex.Number == 0)
return -1;
else
return ex.Number; // Regresamos el numero de error
}
return 0; // Regresamos 0 si no existe error
}
/// <summary>
/// Procedimiento para ejecurtar consultas e instrucciones SQL
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (ej. INSERT, DELETE, UPDATE)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <returns>Devolvera un valor Falso si no existio error en al ejecucion de la sentencia, en caso contrario Verdadero</returns>
public bool EjecutarCommando(string sentenciaSQL, int Server)
{
// Abrimos la conexion y capturamos el error
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutarmos la consulta
if (numero_error == 0)
{
// Instruccion para capturar si existe error en el comando que se ejecutara
try
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
using(comando = new SqlCommand(sentenciaSQL, conexion))
{
comando.CommandTimeout = 0;
// Ejecutamos el comando
comando.ExecuteNonQuery();
}
// Cerramos la conexion al servidor
CerrarConexion();
// Devolvemos un valor falso para informar que no existe error
return false;
}
// Capturamos el error y lo controlamos para mostrar el mensaje especifico del error
catch (SqlException ex)
{
// Mostramos el mensaje de error
MessageBox.Show(ex.Message.Substring(6), "Error No. " + ex.Number.ToString());
// Mostramos un mensaje con la sentencia ingresada
MessageBox.Show(sentenciaSQL, "Información...");
// Cerramos la conexion al servidor
CerrarConexion();
// Devolvemos un valor para indicar que existio un error
return true;
}
}
else
{
// Devolvemos un valor para indicar que existio un error
return true;
}
}
/// <summary>
/// Procedimiento para ejecutar comandos e instrucciones SQL
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (ej. INSERT, DELETE, UPDATE)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <param name="AbrirConexion Verdadero si la funcion abrira la conexion, en otro caso Falso</param>
/// <returns>Devolvera un valor Falso si no existio error en al ejecucion de la sentencia, en caso contrario Verdadero</returns>
public bool EjecutarCommando(string sentenciaSQL, int Server, bool AbrirConexion)
{
// Declaramos una variable para almacenar el numero de error en la conexion SQL
int numero_error = 0;
// Verificamos si hay que abrir la conexion
if (AbrirConexion == true)
{
// Abrimos la conexion y capturamos el error
numero_error = AbrirConexionServidor(Server);
}
// Si no hay error ejecutarmos la consulta
if (numero_error == 0)
{
// Instruccion para capturar si existe error en el comando que se ejecutara
try
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
using(comando = new SqlCommand(sentenciaSQL, conexion))
{
comando.CommandTimeout = 0;
// Ejecutamos el comando
comando.ExecuteNonQuery();
}
// Devolvemos un valor falso para informar que no existe error
return false;
}
// Capturamos el error y lo controlamos para mostrar el mensaje especifico del error
catch (SqlException ex)
{
// Mostramos el mensaje de error
MessageBox.Show(ex.Message.Substring(6), "Error No. " + ex.Number.ToString());
// Mostramos un mensaje con la sentencia ingresada
MessageBox.Show(sentenciaSQL, "Información...");
// Devolvemos un valor para indicar que existio un error
return true;
}
}
else
{
// Devolvemos un valor para indicar que existio un error
return true;
}
}
/// <summary>
/// Procedimiento para ejecutar lecturas de datos
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (SELECT)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void EjecutarLectura(string sentenciaSQL, int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
comando = new SqlCommand(sentenciaSQL, conexion);
comando.CommandTimeout = 0;
// Ejecutamos el comando
consulta = comando.ExecuteReader();
}
}
/// <summary>
/// Procedimiento para indicar que las sentencias SQL se ejecutaran en modo batch
/// </summary>
/// <param name="DB </param>
public void IniciarTransaccion(int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
comando = new SqlCommand("BEGIN", conexion);
comando.ExecuteNonQuery();
}
}
/// <summary>
/// Procedimiento para llenar un objeto DataTable especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataTable en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void LlenarTabla(string sentenciaSQL, DataTable Tabla_para_Datos, int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Eliminamos la informacion de la tabla
Tabla_para_Datos.Clear();
// Llenamos la base de datos
daSQL.Fill(Tabla_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para llenar un objeto DataSet especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataSet en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void LlenarDataSet(string sentenciaSQL, DataTable Data_para_Datos , int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Eliminamos la informacion de la tabla
Data_para_Datos.Clear();
// Llenamos la base de datos
daSQL.Fill(Data_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para llenar un objeto DataTable especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataTable en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <param name="LimpiarTabla Verdadero si se limpiara el objeto DataTable, en otro caso Falso</param>
public void LlenarTabla(string sentenciaSQL, DataTable Tabla_para_Datos, int Server, bool LimpiarTabla)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Verificamos si se eliminara la informacion contenida en el objeto DataTable
if (LimpiarTabla == true)
{
// Eliminamos la informacion de la tabla
Tabla_para_Datos.Clear();
}
// Llenamos la base de datos
daSQL.Fill(Tabla_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para cerrar la conexion al servidor
/// </summary>
public void CerrarConexion()
{
// Se cierra la conexion
if (conexion.State == System.Data.ConnectionState.Open)
{
conexion.Close();
conexion.Dispose();
if (conexion.State == System.Data.ConnectionState.Open)
{
conexion.Close();
conexion.Dispose();
}
}
else
{
Console.WriteLine("La conexión se ha cerrado satisfactoriamente!
");
}
}
}
View the full article
so i have a class which make connection to sql server 2008, because when a make a query very big (more than 150000 rows) i need a command.timeout = 0, because if is not this way, c# tell me that de i have a error of timeouts
so i make a using(command) instruction for destroy de Command but is the same error ocurre
my error es because i need restore a lot of DB and with my program read de info in eache of BD for copy to a server some info
that wy i like to manteint open my program and can restore BD in the same DATABASE, but i cant restore BD because my program left a lot of process with status sleeping - awaiting command
so i have to close the program restore the DB and then open my program again
this is the code, is in spanish the comment but is comprensible, if you can see i have a process of nameCerrarConexion the which is for close the Connection but that dont make nothing with the process with status sleeping - awaiting command
i use only the process named EjecutarComando and EjecutarLectura in the first i used USING(COMMAND) in the second not, because i wanna know if that make a diference.
when i finished my process i call CerrarConexion for all the conection i make
i hope i can articulate the idea and sorry for me english
using System;
using System.Data;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.IO;
public class ConexionSQL
{
// Definimos las variables publicas que se utilizaran en el sistema
public SqlConnection conexion;
public SqlDataAdapter daSQL;
public SqlCommandBuilder cbSQL;
public SqlCommand comando;
public SqlDataReader consulta = null;
/// <summary>
/// Procedimiento que abre y verifica la conexion al servidor de datos
/// </summary>
/// <param name="Base_de_Datos Servidor de BD al cual conectar</param>
/// <returns>Devolvera el numero de error si este existiera, 0 si no hay error</returns>
public int AbrirConexionServidor(int Servidor)
{
// Creamos una variable de cadena en blanco para guardar la instruccion de conexion al servidor
string Cadena_Conexion = "";
string Base_de_Datos = "";
string Server = "";
/*string Pass = "";
// Definimos a que servidor se esta conectando
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase).Remove(0, 6) + "/";
string cargador = path + "\servidor.txt";
string strConsulta;
string parametros = "";
try
{
//Pass the file path and file name to the StreamReader constructor
StreamReader sr = new StreamReader(cargador);
parametros = sr.ReadToEnd();
parametros = parametros.Trim();
string [] rj = parametros.Split(|);
Server=rj[0];
Pass=rj[1];
sr.Close();
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine("Excepcion: " + ex.Message);
}
finally
{
Console.WriteLine("Ejecutando Ultimo Bloque");
}*/
switch (Servidor)
{
case 1:
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
"COMDALSA01",
"CONCAPERSASAE",
"xxxxx",
//"xxxxxx");
"xxxxxxx");
Base_de_Datos = "CONCAPERSA";
Server = "COMDALSA01";
break;
case 2:
// Cadena de conexion con base de datos
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
"COMDALSA06",
"FACTELECT",
"xxxxxx",
"xxxxxx");
Base_de_Datos = "SISTEMAS";
Server = "COMDALSA06";
break;
default:
Cadena_Conexion = string.Format("Data Source={0}; Initial Catalog= {1}; User ID={2}; Password={3}",
".\SQLEXPRESS",
"DBFREST07",
"xxxxxxx",
"xxxxxxx");
break;
}
// Inicializamos la variable para la conexion
conexion = new SqlConnection(Cadena_Conexion);
// Bloque para verificar si existira error en la conexion
try
{
conexion.Open(); // Se abre la conexion
}
catch(SqlException ex) // Si hay error se ejecutaran las instrucciones siguientes
{
// Cerramos la conexion al servidor
conexion.Close();
string mensaje = ""; // Cadena para guardar el mensaje que se mostrara en el error
string mostrar_mensaje = "S"; // Definimos si se mostrara el mensaje de error
// Verificamos los diferentes errores que pueden suceder
switch (ex.Number)
{
case 1045:
{
mensaje = "El usuario ingresado no existe o la contraseña es incorrecta";
break;
}
case 1049: // No existe la Base de Datos
{
mensaje = "No se encuentra la base de datos [" + Base_de_Datos + "]";
mostrar_mensaje = "N";
break;
}
case 0:
{
mensaje = "No se puede encontrar el servidor especifico [" + Server + "]";
break;
}
default:
{
mensaje = String.Concat(ex.Message, " - ", ex.Number.ToString());
break;
}
}
// Si la variable contiene el valor "S" se mostrara el mensaje de error
if (mostrar_mensaje == "S")
MessageBox.Show(mensaje, "Error de conexión", MessageBoxButtons.OK, MessageBoxIcon.Error);
// No existe numero de error cuando no existe el servidor, por eso se regresa un -1
if (ex.Number == 0)
return -1;
else
return ex.Number; // Regresamos el numero de error
}
return 0; // Regresamos 0 si no existe error
}
/// <summary>
/// Procedimiento para ejecurtar consultas e instrucciones SQL
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (ej. INSERT, DELETE, UPDATE)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <returns>Devolvera un valor Falso si no existio error en al ejecucion de la sentencia, en caso contrario Verdadero</returns>
public bool EjecutarCommando(string sentenciaSQL, int Server)
{
// Abrimos la conexion y capturamos el error
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutarmos la consulta
if (numero_error == 0)
{
// Instruccion para capturar si existe error en el comando que se ejecutara
try
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
using(comando = new SqlCommand(sentenciaSQL, conexion))
{
comando.CommandTimeout = 0;
// Ejecutamos el comando
comando.ExecuteNonQuery();
}
// Cerramos la conexion al servidor
CerrarConexion();
// Devolvemos un valor falso para informar que no existe error
return false;
}
// Capturamos el error y lo controlamos para mostrar el mensaje especifico del error
catch (SqlException ex)
{
// Mostramos el mensaje de error
MessageBox.Show(ex.Message.Substring(6), "Error No. " + ex.Number.ToString());
// Mostramos un mensaje con la sentencia ingresada
MessageBox.Show(sentenciaSQL, "Información...");
// Cerramos la conexion al servidor
CerrarConexion();
// Devolvemos un valor para indicar que existio un error
return true;
}
}
else
{
// Devolvemos un valor para indicar que existio un error
return true;
}
}
/// <summary>
/// Procedimiento para ejecutar comandos e instrucciones SQL
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (ej. INSERT, DELETE, UPDATE)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <param name="AbrirConexion Verdadero si la funcion abrira la conexion, en otro caso Falso</param>
/// <returns>Devolvera un valor Falso si no existio error en al ejecucion de la sentencia, en caso contrario Verdadero</returns>
public bool EjecutarCommando(string sentenciaSQL, int Server, bool AbrirConexion)
{
// Declaramos una variable para almacenar el numero de error en la conexion SQL
int numero_error = 0;
// Verificamos si hay que abrir la conexion
if (AbrirConexion == true)
{
// Abrimos la conexion y capturamos el error
numero_error = AbrirConexionServidor(Server);
}
// Si no hay error ejecutarmos la consulta
if (numero_error == 0)
{
// Instruccion para capturar si existe error en el comando que se ejecutara
try
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
using(comando = new SqlCommand(sentenciaSQL, conexion))
{
comando.CommandTimeout = 0;
// Ejecutamos el comando
comando.ExecuteNonQuery();
}
// Devolvemos un valor falso para informar que no existe error
return false;
}
// Capturamos el error y lo controlamos para mostrar el mensaje especifico del error
catch (SqlException ex)
{
// Mostramos el mensaje de error
MessageBox.Show(ex.Message.Substring(6), "Error No. " + ex.Number.ToString());
// Mostramos un mensaje con la sentencia ingresada
MessageBox.Show(sentenciaSQL, "Información...");
// Devolvemos un valor para indicar que existio un error
return true;
}
}
else
{
// Devolvemos un valor para indicar que existio un error
return true;
}
}
/// <summary>
/// Procedimiento para ejecutar lecturas de datos
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara (SELECT)</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void EjecutarLectura(string sentenciaSQL, int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Creamos el comando con la instruccion SQL y la conexion al servidor de datos
comando = new SqlCommand(sentenciaSQL, conexion);
comando.CommandTimeout = 0;
// Ejecutamos el comando
consulta = comando.ExecuteReader();
}
}
/// <summary>
/// Procedimiento para indicar que las sentencias SQL se ejecutaran en modo batch
/// </summary>
/// <param name="DB </param>
public void IniciarTransaccion(int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
comando = new SqlCommand("BEGIN", conexion);
comando.ExecuteNonQuery();
}
}
/// <summary>
/// Procedimiento para llenar un objeto DataTable especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataTable en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void LlenarTabla(string sentenciaSQL, DataTable Tabla_para_Datos, int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Eliminamos la informacion de la tabla
Tabla_para_Datos.Clear();
// Llenamos la base de datos
daSQL.Fill(Tabla_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para llenar un objeto DataSet especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataSet en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
public void LlenarDataSet(string sentenciaSQL, DataTable Data_para_Datos , int Server)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Eliminamos la informacion de la tabla
Data_para_Datos.Clear();
// Llenamos la base de datos
daSQL.Fill(Data_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para llenar un objeto DataTable especifico
/// </summary>
/// <param name="sentenciaSQL Sentencia SQL que se ejecutara para buscar datos</param>
/// <param name="Tabla_para_Datos Objeto DataTable en el cual se insertaran los datos</param>
/// <param name="DB Nombre de la base de datos en que se ejecutara la sentencia</param>
/// <param name="LimpiarTabla Verdadero si se limpiara el objeto DataTable, en otro caso Falso</param>
public void LlenarTabla(string sentenciaSQL, DataTable Tabla_para_Datos, int Server, bool LimpiarTabla)
{
// Abrimos la conexion
int numero_error = AbrirConexionServidor(Server);
// Si no hay error ejecutamos la lectura de datos
if (numero_error == 0)
{
// Asignamos los parametros necesarios al adaptador de datos
daSQL = new SqlDataAdapter(sentenciaSQL, conexion);
// Ejecutamos el comando del adaptador de datos
cbSQL = new SqlCommandBuilder(daSQL);
// Verificamos si se eliminara la informacion contenida en el objeto DataTable
if (LimpiarTabla == true)
{
// Eliminamos la informacion de la tabla
Tabla_para_Datos.Clear();
}
// Llenamos la base de datos
daSQL.Fill(Tabla_para_Datos);
}
// Cerramos la conexion
CerrarConexion();
}
/// <summary>
/// Procedimiento para cerrar la conexion al servidor
/// </summary>
public void CerrarConexion()
{
// Se cierra la conexion
if (conexion.State == System.Data.ConnectionState.Open)
{
conexion.Close();
conexion.Dispose();
if (conexion.State == System.Data.ConnectionState.Open)
{
conexion.Close();
conexion.Dispose();
}
}
else
{
Console.WriteLine("La conexión se ha cerrado satisfactoriamente!
");}
}
}
View the full article