Manejando cadenas de conexión en .Net con C#(3/3)

Bien, llegamos a la tercera y última entrega sobre el manejo de conexiones en .net con C#, hemos hablado en el pasado acerca de cómo crear una cadena de  conexión en la parte 1 y acerca de una manera mas eficiente para mejorar nuestro código en la parte 2.

En esta parte, hablaremos acerca de colocar nuestra cadena de conexión en un archivo de configuración, y cómo poder hacer uso de la misma en nuestro código.

Vamos a retomar el mismo proyecto que hemos venido manejando, y lo primero que haremos será agregar un nuevo archivo de configuración:

Lo dejaremos con el nombre por defecto. Ahora, el archivo creado nos mostrará lo siguiente:

¿Para qué servirá esto? Bueno, pues imagina que tienes 10 llamadas a tu base de datos con el código que hemos venido trabajando, si recuerdas, definimos en el código nuestra cadena de conexión; ¿Qué pasaría si de repente debemos cambiar el servidor de la conexión? pues un lío, habría que sustituir de una u otra forma cada una de las connection strings. Para evitarnos esto, creamos el archivo de configuración de nuestra aplicación, donde podremos agregar desde cadenas de conexión, hasta por ejemplo, colores de algún elemento visual. El formato de nuestro App.config está en xml, por lo que deberemos empezar a especificar etiquetas.

Nuestra primera etiqueta que agregaremos quedará:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:     <connectionStrings>        

   4:     </connectionStrings>

   5: </configuration>

Si te das cuenta, cuando empiezas a escribir dentro del app.config, el intellisense de visual studio te indica de hecho, que <connectionStrings> está disponible para autocompletar.

Excelente, ahora, dentro de connectionStrings, podemos definir la cantidad de cadenas de conexión que nosotros queramos, pero solo definiremos una en nuestro ejemplo, agregamos pues, una nueva cadena de conexión de la siguiente manera:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:   <connectionStrings>

   4:       <add name="miCadenaConexion" 

   5:            connectionString="Data Source=.\SQLEXPRESS;

   6:               Initial Catalog=BalloonShop;

   7:               User=balloonshop;

   8:               password=contraseña"/>

   9:   </connectionStrings>

  10: </configuration>

donde:

name = Nombre de tu cadena de conexión, puede ser cualquier nombre que desees;

connectionString = Hemos rescatado la cadena de conexión, que hemos utilizado en los posts anteriores, y la hemos colocado aquí.

Y listo, ya está listo nuestro archivo app.config, nos aseguramos de salvarlo, y ahora, cómo usarlo desde nuestro código?

Lo primero que debemos hacer, es agregar una nueva referencia, al ensamblado System.Configuration

Con un using, especificamos que queremos usar System.Configuration:

   1: using System.Configuration;

Ahora, cuando vayamos a definir nuestra cadena de conexión, debemos poner algo como esto:

   1: string miCadenaConexion = 

   2:                 ConfigurationManager.

   3:                 ConnectionStrings["miCadenaConexion"].

   4:                 ConnectionString;

Lo que hacemos, es llamar al administrador de configuraciones, quien obtiene la parte de connectionStrings de nuestro archivo app.config, ahí le especificamos el nombre de la cadena de conexión que queremos usar, y al final, le decimos que es la parte de connectionString la que nos interesa.

Si probamos nuestro código de ayer con esta modificación:

   1: using System;

   2: using System.Data.SqlClient;

   3: using System.Configuration;

   4:  

   5: namespace Cadenas_conexion_1

   6: {

   7:     class Program

   8:     {

   9:         static void Main(string[] args)

  10:         {

  11:             string miCadenaConexion = 

  12:                 ConfigurationManager.

  13:                 ConnectionStrings["miCadenaConexion"].

  14:                 ConnectionString;

  15:  

  16:             SqlConnection sqlconnection;

  17:  

  18:             using (sqlconnection = 

  19:                 new SqlConnection(miCadenaConexion))

  20:             {

  21:                 sqlconnection.Open();

  22:                 if (sqlconnection.State == 

  23:                     System.Data.ConnectionState.Open)

  24:                 {

  25:                     Console.WriteLine

  26:                         ("Conexión abierta");

  27:                     Console.Read();

  28:                 }

  29:             }

  30:  

  31:             if (sqlconnection.State 

  32:                 == System.Data.ConnectionState.Open)

  33:             {

  34:                 Console.WriteLine

  35:                     ("La conexión sigue abierta!");

  36:                 Console.Read();

  37:  

  38:             }

  39:             else

  40:             {

  41:                 Console.WriteLine

  42:                     ("La conexión se ha cerrado satisfactoriamente! :)");

  43:                 Console.Read();

  44:             }

  45:         }

  46:     }

  47: }

Obtendremos el mismo resultado:

Jeje, hemos pues, descrito en estas 3 partes, las mejores prácticas para manejar de una forma eficiente nuestras cadenas y conexiones a una base de datos, mas adelante, haremos uso de esto ampliamente 🙂

Salu2

Héctor Uriel Pérez Rojas

Manejando cadenas de conexión en .Net con C#(2/3)

En el post anterior, explicábamos acerca los partes que lleva una cadena de conexión, tanto cuando es autentificada por Windows, así como cuando es autentificada por rol SQL Server.

Bien, pues en este post, nos enfocaremos a ver una forma mucho más eficiente de conectarnos a nuestra base de datos.

En primer lugar, si recordamos el código del post anterior, tenía algo como esto:

   1: try

   2: {

   3:   sqlconnection.Open();

   4:   Console.WriteLine("Conexión Abierta Satisfactoriamente!");

   5: }

   6: catch (Exception ex)

   7: {

   8:   Console.WriteLine("Falló al tratarse de conectar a Base de Datos!");

   9: }

  10: finally

  11: {

  12:   sqlconnection.Close();

  13:   Console.ReadLine();

  14: }

Se podría decir, que este código está bien, sin embargo, existe un problema debido a que no se liberan los recursos una vez cerrada la conexión. Esto mismo hubiera pasado si hubiésemos tenido un sqlcommand.

Para arreglar esto, lo que debemos hacer, es poner el código dentro de un bloque a través de un using, el cual nos permitirá liberar de forma automática los recursos.

El using, es usado de la siguiente manera:

   1: using (SqlConnection sqlconnection = 

   2:         new SqlConnection(miCadenaConexion))

   3: {

   4:   sqlconnection.Open();               

   5: } 

como vez, en esta sección lo  estamos usando como un bloque, define un ámbito donde al final, el objeto automáticamente se destruirá, por eso no es necesario ni siquiera cerrar la conexión. A este código se le puede implementar un try – catch para probar capturar excepciones, pero para comprobar, y veas que no te miento, usaré el siguiente código para revisar el estado de nuestra conexión a la base de datos:

   1: SqlConnection sqlconnection;

   2:  

   3: using (sqlconnection = new SqlConnection(miCadenaConexion))

   4: {

   5:   sqlconnection.Open();

   6:   if (sqlconnection.State == System.Data.ConnectionState.Open)

   7:   {

   8:     Console.WriteLine("Conexión abierta");

   9:     Console.Read();

  10:   }

  11: }

  12:  

  13: if (sqlconnection.State == System.Data.ConnectionState.Open)

  14: {

  15:   Console.WriteLine("La conexión sigue abierta!");

  16:   Console.Read();

  17: }

  18: else

  19: {

  20:   Console.WriteLine("La conexión se ha cerrado satisfactoriamente! :)");

  21:   Console.Read();

  22: }

Como vez, lo que hacemos es primero comprobar el estado de la conexión dentro del primer if, y posteriormente lo volvemos a comprobar una vez saliéndonos del bloque using, con lo cual obtenemos:

Es una práctica recomendada, y que mejora mucho la forma de programar 🙂

Salu2

Héctor Uriel Pérez Rojas

Manejando cadenas de conexión en .Net con C#(1/3)

Esta es una duda muy común entre los que inician a trabajar con bases de datos desde .Net, así que aquí trataré de explicar en primer lugar, qué son, y posteriormente, cómo usarlas desde nuestras aplicaciones.

En primer lugar, para esta demo, he creado un proyecto nuevo en Visual Studio, del tipo consola.

Ahora, lo que haremos será abrir el Server Explorer de Visual Studio(Ctrl+Alt+S), y agregaremos una nueva conexión a la base de datos, que queramos conectarnos:

Suponiendo que nuestro proveedor es SQL Server, especificamos el nombre del Servidor de SQL Server, si es una conexión a través de Windows Authetication o SQL Server Authetication, y la base de datos correspondiente, para hacer un poco más práctico esto, agregaré 2 conexiones a la base de datos, una a través de autentificación por Windows, y la otra a través de autentificación SQL Server:

NOTA: En caso de no conocer tu Servidor SQL Server, dirigete a tu aplicación SQL Server Management Studio, donde podrás saber qué servidores tienes disponibles en tu máquina:

Si ahora nos dirigimos a las propiedades en Visual Studio de cada una de las conexiones, veremos diferentes cadenas de conexión:

De la conexión por Autentificación Windows:

De la conexión por SQL Server:

Para poder hacer uso, de las clases que .Net nos proporciona para poder trabajar con Bases de Datos, lo primero que tenemos que hacer es colocar dentro de la sección de nuestros using, el siguiente namespace:

   1: using System.Data.SqlClient;

Teniendo esto, vamos a hacer algo muy sencillo, no haremos consultas ni nada por el estilo, simplemente queremos comprobar que podemos abrir la Base de Datos apropiadamente, para esto, en primer lugar, declararemos una variable del tipo string, donde almacenaremos nuestra cadena de conexión a la base de datos autentificada por medio de Windows:

   1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;

   2:                            Initial Catalog=BalloonShop;

   3:                            Integrated Security=true";

donde:

Data Source = El Servidor de Base de datos;

Initial Catalog = Tu Base de Datos a la que te conectarás;

Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.

Nota: La @, sirve para poder hacer uso del símbolo \ sin que nos tire un error.

Bien, toca el turno a crear un objeto del tipo Connection String, a la cual le pasaremos como parámetro, la cadena de conexión especificada anteriormente:

   1: SqlConnection sqlconnection = new SqlConnection
                                       (miCadenaConexion);

Así de fácil y sencillo quedó listo esto, ahora, para probarla, lo que haremos será tratar de abrirla en un bloque try-catch-finally, para ver si es correctamente abierta:

   1: try

   2: {

   3:     sqlconnection.Open();

   4:     Console.WriteLine
          ("Conexión Abierta Satisfactoriamente!");

   5: }

   6: catch (Exception ex)

   7: {

   8:     Console.WriteLine
          ("Falló al tratarse de conectar a Base de Datos!");

   9: }

  10: finally

  11: {

  12:     sqlconnection.Close();

  13:     Console.ReadLine();

  14: }

Con lo que el código final queda así:

   1: using System;

   2: using System.Data.SqlClient;

   3:  

   4: namespace Cadenas_conexion_1

   5: {

   6:     class Program

   7:     {

   8:         static void Main(string[] args)

   9:         {

  10:             string miCadenaConexion = 
                  @"Data Source=.\SQLEXPRESS;
                  Initial Catalog=BalloonShop;
                  Integrated Security=true";

  11:             SqlConnection sqlconnection = new SqlConnection
                                             (miCadenaConexion);

  12:             try

  13:             {

  14:                 sqlconnection.Open();

  15:                 Console.WriteLine
                      ("Conexión Abierta Satisfactoriamente!");

  16:             }

  17:             catch (Exception ex)

  18:             {

  19:                 Console.WriteLine
                 ("Falló al tratarse de conectar a Base de Datos!");

  20:             }

  21:             finally

  22:             {

  23:                 sqlconnection.Close();

  24:                 Console.ReadLine();

  25:             }

  26:         }

  27:     }

  28: }

Probamos el código y obtenemos lo siguiente:

Si hubiesemos querido usar un LogIn de SQL Server, lo único que tenemos que hacer, es cambiar la cadena de conexión por una de este tipo:

   1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;

   2:                             Initial Catalog=BalloonShop;

   3:                             User=balloonshop;

   4:                             password=contraseña";

Y listo!

Nos vemos en la parte 2! 😉

Héctor Uriel Pérez Rojas