En este artículo les voy a explicar los principales clases que se utilizan para acceder a una base de datos SQL server.
Antes de comenzar a utilizar las clases, debemos importar en nuestro proyecto el espacio de nombres System.Data.SqlClient para tener acceso a dichas clases.
using System.Data.SqlClient;
SqlConnection
La clase SqlConnection permite establecer una conexión con una base de datos SQL server.
La propiedad mas importante es ConnectionString que representa la cadena de conexión hacia la base de datos.
Pueden ingresar a esta web, en la cual, van a encontrar las distintas cadenas que corresponden a SQL server.
Veremos dos ejemplos acerca de la clase SqlConnection
using (SqlConnection cnn = new SqlConnection("Data Source=.;Initial Catalog=AdventureWorks2012;Integrated Security=True"))
{
cnn.Open();
}
Utilizando el bloque Using podemos crear la conexión cuando necesitemos. Debemos ejecutar el método Open() del objeto cnn para abrir la conexión. Como notaran, no es necesario llamar al método Close() de dicho objeto ya que el bloque Using se encarga y además garantiza que va a llamar Dispose() para dicho objeto.
Este es el mejor camino, pero también podríamos utilizar:
SqlConnection cnn = new SqlConnection("Data Source=.;Initial Catalog=AdventureWorks2012;Integrated Security=True");
cnn.Open();
cnn.Close();
En este caso, debemos utilizar el método Close() para cerrar la conexión.
En vez de pasar como parámetro la cadena podríamos hacer uso de la propiedad ConnectionString
SqlConnection cnn = new SqlConnection();
cnn.ConnectionString = "Data Source=.;Initial Catalog=AdventureWorks2012;Integrated Security=True";
cnn.Open();
cnn.Close();
O también
using (SqlConnection cnn = new SqlConnection())
{
cnn.ConnectionString = "Data Source=.;Initial Catalog=AdventureWorks2012;Integrated Security=True";
cnn.Open();
cnn.Close();
}
SqlCommand
Esta clase ejecuta una consulta o un procedimiento almacenado en la base de datos.
Podemos crear el objeto de esta forma:
Para una consulta:
string ConsultaX = "SELECT * FROM TABLA";
SqlCommand cmd = new SqlCommand(ConsultaX,cnn);
cnn corresponde al objeto SqlConnection creado anteriormente.
Para un procedimiento almacenado:
string ProcAlmacenado = "EjecutarAccion_SP";
SqlCommand cmd = new SqlCommand(ProcAlmacenado,cnn);
cmd.CommandType = CommandType.StoredProcedure;
En este caso, el string debe ser el nombre del procedimiento almacenado y debemos especificarle al objeto SqlCommand que va ser un comando de tipo StoreProcedure (Procedimiento almacenado).
Llego el momento de ejecutar la instrucción en la base de datos
Por un lado vamos a tener las típicas instrucciones de alta, baja o modificación de un registro de una tabla.
Para estas instrucciones vamos a utilizar el método ExecuteNonQuery()
cmd.ExecuteNonQuery()
Por lo general en este tipo de instrucciones debemos pasar como parámetro los datos que se van a dar de alta y modificar o pasar como parámetro el código del registro que se va a eliminar.
Se puede especificar el parámetro en la consulta al objeto SqlCommand a través de su propiedad Parameters en el cual vamos a utilizar el método AddWithValue donde le pasamos el nombre del parámetro y su valor como argumentos.
Ejemplo de Alta:
using(SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
cnn.Open();
string ConsultaAlta = "INSERT INTO Persona VALUES(@Nombre,@Apellido)";
SqlCommand cmd = new SqlCommand(ConsultaAlta,cnn);
cmd.Parameters.AddWithValue("@Nombre", VariableNombre);
cmd.Parameters.AddWithValue("@Apellido", VariableApellido);
cmd.ExecuteNonQuery();
}
Ejemplo de Modificar
using(SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
cnn.Open();
string ConsultaModificar = "UPDATE Persona SET Nombre=@Nombre,Apellido@Apellido WHERE CodPersona=@CodPersona";
SqlCommand cmd = new SqlCommand(ConsultaModificar,cnn);
cmd.Parameters.AddWithValue("@Nombre", VariableNombre);
cmd.Parameters.AddWithValue("@Apellido", VariableApellido);
cmd.Parameters.AddWithValue("@CodPersona", VariableCodigoPersona);
cmd.ExecuteNonQuery();
}
Ejemplo de Baja
using(SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
cnn.Open();
string ConsultaEliminar = "DELETE FROM Persona WHERE CodPersona=@CodPersona";
SqlCommand cmd = new SqlCommand(ConsultaEliminar, cnn);
cmd.Parameters.AddWithValue("@CodPersona", VariableCodigoPersona);
cmd.ExecuteNonQuery();
}
Ahora vamos a ver el otro tipo de consulta, que es para devolver resultados.
Estas consultas comienzan con la clausula SELECT.
Vamos a ver dos ejemplos, uno utilizando el objeto SqlDataReader y el método ExecuteReader() y por otro lado utilizando el objeto SqlDataAdapter.
SqlDataReader
Este objeto lee las filas solo hacia delante en una base de datos. Pueden revistar este link para mas documentación.
Ejemplo
Vamos a crear una clase llamada Persona (para seguir con el ejemplo de los ABM) que va a contener la siguiente estructura.
class Persona
{
public int CodPersona { get; set; }
public string Nombre { get; set; }
public string Apellido { get; set; }
}
Vamos a crear una método que devuelva una lista del tipo Persona
private List<Persona> CargarPersonas()
{
List<Persona> ListaPersonas = new List<Persona>();
using (SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
cnn.Open();
string Consulta = "SELECT CodPersona,Nombre,Apellido FROM Persona";
SqlCommand cmd = new SqlCommand(Consulta, cnn);
SqlDataReader lector = cmd.ExecuteReader();
while (lector.Read())
{
Persona UnaPersona = new Persona();
UnaPersona.CodPersona = lector.GetInt32(0);
UnaPersona.Nombre = lector[1].ToString();
UnaPersona.Apellido = lector[2].ToString();
ListaPersonas.Add(UnaPersona);
}
}
return ListaPersonas;
}
El ciclo while lector.Read() lo que hace es leer el siguiente registro y así sucesivamente e ir agregándolo a la lista de personas. Como pueden ver, no podemos tener control acerca de lo que traemos desde la tabla afectada.
SqlDataAdapter
Este objeto nos permite rellenar un datatable o un dataset con los datos de una base de datos. Podes consultar este link para obtener mas información.
Ejemplo
private DataTable CargarPersonas()
{
DataTable dtPersonas = new DataTable();
using (SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
string Consulta = "SELECT CodPersona,Nombre,Apellido FROM Persona";
SqlCommand cmd = new SqlCommand(Consulta, cnn);
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(dtPersonas);
}
return dtPersonas;
}
En este ejemplo, le pasemos el objeto SqlCommand como argumento al objeto SqlDataAdapter. También se lo puede especificar de la siguiente manera:
da.SelectCommand = cmd;
El método mas importante en este objeto es Fill, el cual nos permite rellenar con los datos el datatable o el dataset que le pasemos como argumento. Ademas con el método Fill no es necesario abrir la conexión como lo hacíamos anteriormente, ya que dicho método se encarga de abrir una conexión, si nosotros abrimos una conexión con cnn.open() estaríamos abriendo dos conexiones.
Fin
Me gusta el ejemplo pero solo como opinión por que no usar un metodo que resiva un objeto cualquiera para no hacer esto
ResponderBorrarusing(SqlConnection cnn = new SqlConnection("NUESTRA-CADENA"))
{
cnn.Open();
string ConsultaEliminar = "DELETE FROM Persona WHERE CodPersona=@CodPersona";
SqlCommand cmd = new SqlCommand(ConsultaEliminar, cnn);
cmd.Parameters.AddWithValue("@CodPersona", VariableCodigoPersona);
cmd.ExecuteNonQuery();
}
y para mejorar que el metodo fuera bool para saber si se realizo la acción
o no