Si eres de los que trabajan con sistemas legacy o corporativos, entonces es probable que hayas trabajado con esta tecnología de acceso a datos. Es por eso que en este artículo hablaré de conceptos que debes manejar así como en la práctica de cómo realizar conexiones a base de datos con ADO.net.

Como siempre, este blog es pragmático así que te mostraré ejemplos de código reales para que puedas aplicarlos y así consolidar lo que aprenderás aquí 🧑‍💻👩‍💻

Primero lo primero...

ADO.net es una tecnología de acceso a datos que incluye una serie de clases, estructuras, interfaces y tipos que permiten acceder a los datos almacenados en una base de datos utilizando la plataforna .NET Framework.

Aquí tienes información oficial de Microsoft.

Un conocido profesional en este campo llamado Fernando Berzal Galiano hace tiempo ya, escribió un artículo como parte de un curso de C#, el cual me pareció muy bueno, tiene toda la teoría muy bien complementada con gráficos y además está bien estructurada y rigurosa, así que te lo dejo también por aquí.

ADO.net podría verse como la evolución de ADO (ActiveX Data Objects) sin embargo es más que eso ya que su desarrollo tiene poco o nada que ver y presenta una concepción de ver los datos totalmente distinta

Componentes principales

Sus componentes están agrupados en dos grandes grupos: DataProvider y DataSet

DataProvider

Son una serie de clases muy importantes para poder conectarse a la base de datos o también llamada fuente de datos.

Cada proveedor de datos tiene sus propias clases para poder realizar esta conexión y operaciones hacia la base de datos. Esto quiere decir que existen varios proveedores de datos como SQL Server, MySQL, Oracle, MongoDB, DB2 entre otros y cada uno de ellos tiene sus propias clases que hacen las veces de proveedor de datos.

Las clases que conforman un DataProvider son:

• Connection
• Command
• Parameter
• DataAdapter
• DataReader

DataSet

Mientras que las clases del grupo DataProvider se encargan del trabajo a bajo nivel, por así decirlo, ya que trabajan con la conexión que ocurre por debajo hacia la base de datos, las clases de DataSet se encargan de representar una base de datos relacional en memoria, esto quiere decir emular las tablas, relaciones, restricciones mediante clases destinadas a este fin.

Entre sus clases principales tenemos:

• DataTable
• DataRelation
• Constraint

Cómo utilizar ADO.net: Caso de uso

A continuación te daré los snippets necesarios para poder accesar a los datos en una base de datos SQL Server utilizando la tecnología de ADO.net.

Estos snippets funcionan para aplicaciones de escritorio sin embargo podrías utilizarlos también en aplicaciones web MVC por ejemplo.

Vamos a suponer que estás desarrollando en .NET Framework y utilizando ADO.net como tecnología para accesar a tus datos y tienes una base de datos en SQL Server.

Este caso de uso propone hacer uso de procedimientos almacenados, no detallaré los procedimientos almacenados ya que no son el tema de este artículo, pero fácilmente podrás hacerte una idea de qué procedimiento armar para tu caso particular.

El caso de uso para este ejemplo será: Hacer el CRUD para una tabla Almacén.

Esto quiere decir que en tu base de datos tendrás una tabla llamada ALMACEN y por eso en tu aplicación tendrás una clase entidad llamada: eAlmacen. Yo he considerado que tu tabla tiene 3 campos y por consiguiente tu entidad también tiene 3 propiedades, pero tu le vas a dar la forma que necesites según tu realidad.

	public class eALMACEN 
    {

        public string ALM_codigo { get; set; }
        public string ALM_nombre { get; set; }
        public string ALM_descripcion { get; set; }
	}

Suponiendo que tienes tu cadena de conexión en tu app.config:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <connectionStrings>
    <clear />
    <add name="CadenaPrincipal" connectionString="Data Source=.;Initial Catalog=MyDatabase;User ID=sa;Password=YourPassword"
      providerName="System.Data.SqlClient" />
  </connectionStrings>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
    </startup>
</configuration>

La siguiente sería tu clase de acceso a datos.

La llamaré dalALMACEN ya que dal viene de data access layer.

	public partial class dalALMACEN
	{
		public DataTable ObtenerTodos() {
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "pa_pplt_ALMACEN_poblar";
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.StoredProcedure;
				SqlDataAdapter dad = new SqlDataAdapter(cmd);
				DataTable dt = new DataTable();
				dad.Fill(dt);
				return dt;
			}
		}

		public DataTable obtenerRegistro(eALMACEN oeALMACEN) { //también pude haber simplemente pedido el id
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "pa_crud_ALMACEN_obtenerRegistro";
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.StoredProcedure;
				
				SqlDataAdapter dad = new SqlDataAdapter(cmd);
				dad.SelectCommand.Parameters.Add(new SqlParameter("@ALM_CODIGO", oeALMACEN.ALM_codigo));
				
				DataTable dt = new DataTable();
				dad.Fill(dt);
				
				return dt;
			}
		}

		public bool insertarRegistro(eALMACEN oeALMACEN) {
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "pa_crud_ALMACEN_insertarRegistro";//aquí tienes que poner el nombre de tu query
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.StoredProcedure;
				
				cnn.Open();
				//aquí pon tus propios parámetros del query
				cmd.Parameters.Add(new SqlParameter("@ALM_CODIGO", oeALMACEN.ALM_codigo)); //variable tipo:string
				cmd.Parameters.Add(new SqlParameter("@ALM_NOMBRE", oeALMACEN.ALM_nombre)); //variable tipo:string
				cmd.Parameters.Add(new SqlParameter("@ALM_DESCRIPCION", (object)oeALMACEN.ALM_descripcion ?? DBNull.Value)); //variable tipo:string
				
				return cmd.ExecuteNonQuery() > 0;
			}
		}

		public bool actualizarRegistro(eALMACEN oeALMACEN) {
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "pa_crud_ALMACEN_actualizarRegistro";
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.StoredProcedure;
				
				cnn.Open();
				
				cmd.Parameters.Add(new SqlParameter("@ALM_CODIGO", oeALMACEN.ALM_codigo)); //variable tipo:string
				cmd.Parameters.Add(new SqlParameter("@ALM_NOMBRE", oeALMACEN.ALM_nombre)); //variable tipo:string
				cmd.Parameters.Add(new SqlParameter("@ALM_DESCRIPCION", (object)oeALMACEN.ALM_descripcion ?? DBNull.Value)); //variable tipo:string
				
				return cmd.ExecuteNonQuery() > 0;
			}
		}

		public bool eliminarRegistro(eALMACEN oeALMACEN) {
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "pa_crud_ALMACEN_eliminarRegistro";
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.StoredProcedure;
				
				cnn.Open();
				
				cmd.Parameters.Add(new SqlParameter("@ALM_CODIGO", oeALMACEN.ALM_codigo));
			
				return cmd.ExecuteNonQuery() > 0;
			}
		}
	}

Yo utilizo el objeto de conexión dentro de una sentencia using para manejar adecuadamente la conexión y a la vez estar evitando preocuparme por abrirla, cerrarla y hacerle "dispose", el using lo hace por mi.

Si no haces uso de procedimientos almacenados, entonces también puedes escribir tu consulta directamente desde tu clase de acceso a datos, sólo tendrías que cambiar unas pequeñas cosas, y por ejemplo para obtener todos los registros tendrías algo así:

		public DataTable ObtenerTodos() {
			using ( SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["CadenaPrincipal"].ToString()))
			{
				string sp = "SELECT * FROM ALMACEN";
				SqlCommand cmd = new SqlCommand(sp, cnn);
				cmd.CommandType = CommandType.Text;
				SqlDataAdapter dad = new SqlDataAdapter(cmd);
				DataTable dt = new DataTable();
				dad.Fill(dt);
				return dt;
			}
		}

Si quieres hacer este ejemplo para un método cuya consulta SQL necesite parámetros entonces tendrías que concatenarlo en la variable sp sin embargo esto deja la puerta abierta a que te hagan un ataque llamado SQL Injection, por eso lo mejor siempre será utilizar procedimientos almacenados y parámetros.

Ahora te toca a ti ponerlas a prueba y practicar.

Por supuesto, hay más cosas que aprender de ADO.net pero con esto tienes el 80% o más de los casos abarcados y es lo que realmente importa 😉

Si esta entrada te ha gustado un montón, entonces compártela 😇

Imagen principal: Foto de Shubham Dhage en Unsplash