Como conectar SQL Server con C#?

Conectar nuestras aplicaciones C# a una base de datos en SQL Server es uno de los requerimientos mas
importantes de funcionalidad en nuestros proyectos. Por eso hoy aprenderemos una forma de realizar esta
conexin y veremos ejemplos que nos guen a travs de todo el articulo.
En primera instancia vers como abrir la conexin al servidor, luego aprenders a ejecutar comandos ,
tambin a mostrar los datos de una consulta en un DataGridView y finalmente comprenders la ejecucin de
procedimientos almacenados.
Crear Una Conexin Con SqlConnection
Lo primero es crear una conexin de red entre la aplicacin y el servidor de bases de datos. Para ello
usaremos la clase SqlConnection del namespace SqlClient. Este espacio de nombres es el encargado de
gestionar los datos en SQL Server hacia el Framework .NET. Es solo declarar un nuevo objeto de conexin
similar la siguiente linea de cdigo:
using System.Data.SqlClient;
...
SqlConnection con = new SqlConnection();
Para nuestro objeto con es de vital importancia los datos que abren la conexin, los cuales estarn
almacenados en un atributo llamado ConnectionString de tipo String. Para establecerlo podemos usar
el constructor o asignrselo luego de la inicializacin.
Veamos:
string datosConexion = "Data Source=localhost;"
+"Initial Catalog=facturacion;Integrated Security=true;";

SqlConnection con = new SqlConnection();

con.ConnectionString = datosConexion;
La cadena de conexin indica las caractersticas necesarias para la conexin. Veamos la definicin de
algunas:

Data Source: Se refiere al origen de datos, nombre del servidor o direccin donde se encuentra la base de
datos.

Initial Catalog: Es el nombre de la base de datos a la que deseamos acceder.

Integrated Security: Si usas true el ingreso a la base de datos se autentica con los permisos del usuarios actual
de Windows, si usas false, debes indicar en la cadena el nombre de usuario(UID) y la contrasea(PWD).
Existen mas caractersticas, pero por ahora estn fuera del alcance de este articulo. Puedes consultarlas luego
por tu cuenta.
Luego de establecer la cadena de conexin procedemos a abrir la conexin hacia el servidor con el mtodo
Open():
con.Open();
Al realizar todas las operaciones sobre nuestra base de datos es importante cerrar la conexin con el mtodo
Close():
con.Close();

Otra alternativa para asegurar que la conexin se cierra es usando un bloque using en C#:
using (SqlConnection con = new SqlConnection(datoConexion))
{
con.Open();
//Bloque de instrucciones sobre la base de datos
}
Al finalizar dicho bloque la conexin se cierra inmediatamente, liberndonos de esta responsabilidad.
Ejecutar Un Comando SQL En C#
Buena pregunta!, para ejecutar comandos T-SQL usaremos la clase SqlCommand(hace parte de SqlClient).
Solo debemos crear una instancia de esta clase y asociar una cadena que guarde el comando y el objeto que
esta gestionando la conexin.
El atributo que guarda el texto del comando se llama CommandText y es de tipo String, lo usaremos en el
constructor del objeto comando de la siguiente forma:
SqlCommand cmd = new SqlCommand(textoCmd, con);
El primer parmetro es CommandText y el segundo la conexin asociada. Miremos el siguiente ejemplo:
string textoCmd = "DELETE FROM CLIENTE WHERE IDCLIENTE = 1112;"
SqlCommand cmd = new SqlCommand (textoCmd,con);
Para ejecutarlo usamos el mtodo ExecuteNonQuery(), que ejecuta sentencias que no retornan filas
como INSERT, UPDATE, DELETE SET.
cmd.ExecuteNonQuery();
Como Quedara Todo El Cdigo Completo?
Aadamos cada paso en orden para completar un pequeo ejemplo:
static void Main(string[] args)
{
// Paso 1 - Crear una instancia de la clase SqlConnection
string datosConexion = "Data Source = localhost;"
+ "Initial Catalog = CLIENTE ; Integrated Security = true;";
try
{
using (SqlConnection con = new SqlConnection(datosConexion))
{
//Paso 2 - Abrir la conexin
con.Open();
// Paso 3 - Crear un nuevo comando
string textoCmd = "DELETE FROM CLIENTE WHERE IDCLIENTE = 1112;";

SqlCommand cmd = new SqlCommand(textoCmd, con);

//Paso 4 - Ejecutar el comando
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException e)
{
Console.WriteLine(e.Message);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadKey();
}
Si vas a correr el cdigo recuerda cambiar los datos subrayados en amarillo por los tuyos. Si deseas saber el
nombre del servidor, abre SQL Server Management Studio y copia el contenido del campo Nombre del
Servidor que aparece antes de iniciar sesin.
SENTENCIAS PREPARADAS
Bueno, esta es uno de los requerimientos mas importante en el desarrollo de una aplicacin. Existen varias
formas de realizarlo, pero yo te mostrar solo 4 para que elijas la que mas te convenga.
Primera
Supn que vas a eliminar a travs de un formulario a un proveedor de tu Tienda de Ipodsmediante el cdigo.
Que se te ocurre?
string textoCmd = "DELETE FROM IPOD WHERE ID = " + label_codigo.Text ;
SqlCommand cmd = new SqlCommand(textoCmd,con);
cmd.ExecuteNonQuery();
Muy bien!, esta sencilla forma permite construir por fracciones la cadena de nuestro comando. Concatenando
el atributo Text del control label_codigo para obtener como resultado el String deseado.
Recuerda que si tu atributo es VARCHAR o DATE debes concatenar las comillas simples (). Esto evitar que
se presenten errores SQL en tu aplicacin.
Segunda
Es muy similar a la primera, solo que esta vez usaremos la funcin Format de String. Veamos:
string textoCmd = String.Format("DELETE FROM IPOD WHERE ID = {0}",
label_codigo.Text);

Tercera
Usaremos el atributo Parameters de SqlCommand. Este atributo es una lista de objetos SqlParameter que
permiten especificar el tipo de parmetro y su comportamiento. Introducimos el carcter @ en cada valor que
deseamos reemplazar y luego lo referenciamos con el mtodo Add() del atributo Parameters.
Por ejemplo
string textoCmd = "DELETE FROM IPOD WHERE ID = @idIpod";
SqlCommand cmd = new SqlCommand(textoCmd,con);
cmd.Parameters.Add("@idIpod", SqlDbType.Int);
cmd.Parameters["@idIpod"].Value = Convert.ToInt32(label_codigo.Text);
El cdigo anterior tiene varios conceptos interesantes. @idIpod es el parmetro que declaramos para referirnos
al valor que introduciremos en nuestro comando.
Luego usamos Add() con dos parmetros, el primero es el identificador declarado en el texto del comando y el
segundo es el tipo de dato en SQL Server.
La clase SqlDbType proporciona la mayora de tipos de dato que se presentan, en este caso el cdigo
del Ipod es INT. Y finalmente accedemos al parmetro para indicarle que use Text del Label. Obvio hicimos la
conversin mediante la clase Convert para que todo sea acorde.
Cuarta
Esta ultima forma implementa tambin la clase SqlParameter pero con una construccin previa. Esto permite
dotar de nuevas caractersticas a los parmetros y as conseguir nuevas funcionalidades. En el siguiente cdigo
consultaremos cuantas Tablets tienen un precio mayor a N dolares:
Int32 precio;
string textoCmd = "SELECT @cantidad = COUNT(*) FROM TABLET "
+"WHERE PRECIO >@precio";
SqlCommand cmd = new SqlCommand(textoCmd,con);
SqlParameter p1 = new SqlParameter("@precio", Convert.ToInt32(textBox_precio.Text));
p1.Direction = ParameterDirection.Input;
SqlParameter p2 = new SqlParameter("@cantidad", null);
p2.Direction = ParameterDirection.Output;
p2.SqlDbType = SqlDbType.Int;
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
Esta vez usamos dos parmetros, una variable para guardar la cantidad de filas contadas y otra en la condicin
del WHERE. Para cada parmetro instanciamos un objeto SqlParameter definiendo todos sus atributos.

Esta vez hemos usado el atributo Direction asignndole una bandera del tipo ParameterDirection, el cual tiene
como funcin indicar si el parmetro es de entrada o salida.
Cuando un parmetro es de entrada significa que recibir un valor establecido por el programador, si es de
salida, este recibir un valor producido por la sentencia T-SQL que construimos. En nuestro caso, usamos
@cantidad para obtener la cantidad de Tablets que superan el precio dado por @precio.
Si deseas acceder al valor de @cantidad, entonces accedemos a los elementos del parmetro de forma
vectorial, y as obtener el atributo Value, el cual representa el valor contenido:
cmd.Parameters["@cantidad"].Value
Tu escoges que forma deseas usar. Mas adelante cuando incluyas comandos con mas columnas a consultar,
te dars cuenta que una forma es mas cmoda que la otra. O cuando construyas mtodos para tus formularios,
notars los distintos grados de complejidad y flexibilidad para cada forma. Todo es cuestin de necesidades.
EJECUTAR CONSULTAS SQL
Usaremos el mtodo ExecuteReader() para leer cada fila del resultado de la consulta. Pero necesitamos una
estructura de datos en donde leer dicha informacin. Para ello usaremos la clase SqlDataReader (tambin
contenida en SqlClient) que nos proporciona la forma de lectura ideal.
Veamos como acondicionar el cdigo para recibir el resultado de un SELECT:
textoCmd = "SELECT Nombre,Apellido FROM HUESPED;";
SqlCommand cmd = new SqlCommand(textoCmd,con);
SqlDataReader reader = cmd.ExecuteReader();
Una vez referenciadas las filas de la consulta, procedemos a leer fila a fila mediante el mtodo Read(). Este
mtodo cada vez que es invocado mueve la posicin de lectura a la siguiente fila, por lo cual usaremos un bucle
while para la lectura completa:
try
{
while (reader.Read())
{
Console.WriteLine(String.Format(" {0},{1}",
reader[0], reader[1]));
}
}
catch (SqlException e)
{
Console.WriteLine(e.Message);
}
reader.Close();
Si pones atencin en la linea de impresin de los datos del SqlDataReader, vers que estamos accediendo
como si se tratase de un arreglo que guarda la fila en las posiciones 0 y 1 (debido a que son solo dos columnas).

Si fuesen mas columnas retornadas, entonces vas accediendo en orden secuencial a cada una de ellas de la
misma forma.
Los objetos SqlDataReader deben cerrarse con el mtodo Close() para desbloquear la memoria que estn
referenciando.
VISUALIZAR REGISTROS EN UN DATAGRIDVIEW
Te explicar la forma que mas me gusta y hasta ahora me ha dado buenos resultados. Para ello usaremos la
clase del namespace SqlCliente, llamada SqlDataAdapter, la cual administra nuestras filas como un bloque de
datos en forma de tabla. Este formato este ideal para usar la clase DataTable y comunicar los resultados de la
consulta con el DataGridView.
Analicemos el siguiente ejemplo, donde se consultan todos los registros que contiene una tabla
llamada ESTUDIANTE:
DataTable datos = new DataTable();
string textoCmd = "SELECT * FROM ESTUDIANTE;";
SqlCommand cmd = new SqlCommand(textoCmd,con);
SqlDataAdapter adapter = new SqlDataAdapter(cmd);
adapter.Fill(datos);
dataGridView1.DataSource = datos;
Podemos destacar que hemos creado un objeto DataTable para hacer referencia a la informacin retornada por
al consulta. El objeto adapter ha sido creado con un constructor que recibe como parmetro al comando
asociado.
Y finalmente usamos el mtodo Fill() que deposita de forma ordenada los registros en nuestra tabla, luego de
ello asignamos la tabla al atributo DataSourcedel DataGridView, el cual contiene la informacin que se muestra
en las celdas.
EJECUTAR PROCEDIMIENTOS ALMACENADOS EN C#
En este caso usaremos todas las herramientas que hasta el momento hemos visto. Para ejecutar un
procedimiento debemos cambiar el atributo CommandType a StoredProcedure. En la cadena del comando
usamos solo el nombre del procedimiento y aadimos todos los parmetros que tenga, ya sean
de entrada, salida o entrada-salida.
A continuacin veremos un ejemplo simple. Primero entra a SQL Server Management Studio, selecciona tu
base de datos y ejecuta el siguiente procedimiento:
CREATE PROCEDURE impresion (@entrada INT)
AS
SELECT 'Tu parametro de entrada es:'+CAST(@entrada AS VARCHAR);
Ahora abre tu IDE favorita para C#, crea un nuevo proyecto y ejecuta la siguiente aplicacin de consola:
static void Main(string[] args)
{
string valor;

// Creamos una instancia de la clase SqlConnection

string datosConexion = "Data Source = TuServidor;" +
"Initial Catalog = Ejemplo ; Integrated Security = true;";
using (SqlConnection con = new SqlConnection(datosConexion))
{
//Solicitamos un numero de ejemplo al usuario
Console.Write("Digite su numero:");
valor = Console.ReadLine();
//Creamos el comando de tipo StoredProcedure
SqlCommand cmd = new SqlCommand("impresion", con);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
//Aadimos el parametro @entrada que establecimos en SQL Server
SqlParameter p1 = new SqlParameter("@entrada", valor);
p1.Direction = System.Data.ParameterDirection.Input;
cmd.Parameters.Add(p1);
try
{
//Abrimos la conexin
con.Open();
//Ejecutamos el comando
SqlDataReader reader = cmd.ExecuteReader();
//Retorn filas?, entonces leemos con Read()
if (reader.HasRows)
{
while (reader.Read())
{
//Imprimimos el resultado del procedimiento
Console.WriteLine(reader[0]);
}
}
else
{
Console.WriteLine("El procedimiento no retorno ninguna fila");
}
}
catch (SqlException e)
{
Console.WriteLine("/*--------------------------");
Console.WriteLine(e.Message);
Console.WriteLine("--------------------------*/");
}
System.Console.ReadKey();

}
}
Fjate que en la sentencia trycatch usamos Excepciones tipo SqlException. Esto nos permite obtener
los errores SQL en nuestra aplicacin con todo detalle.
Espero este pequeo ejemplo te ayude a desarrollar requerimientos mas complejos en tu aplicacin. Si tienes
dudas, te in