Acceso a Bases de Datos con C#

El acceso a bases de datos desempeña un papel fundamental en el desarrollo de aplicaciones C# y es esencial en numerosos aspectos. Aquí tienes una presentación de la importancia del acceso a bases de datos en aplicaciones C#:

Persistencia de Datos: Una de las razones más evidentes para acceder a bases de datos en aplicaciones C# es la persistencia de datos. Las aplicaciones necesitan almacenar información de manera permanente para que los datos sobrevivan más allá de la ejecución de la aplicación. Las bases de datos proporcionan un medio seguro y eficiente para lograrlo.
Gestión de Datos Complejos: En aplicaciones empresariales o de nivel empresarial, a menudo se deben gestionar conjuntos de datos complejos con múltiples tablas y relaciones. Las bases de datos relacionales como SQL Server, MySQL o PostgreSQL permiten modelar y gestionar estos datos de manera eficaz.
Búsqueda y Consulta Eficiente: Las bases de datos están diseñadas para realizar búsquedas y consultas de datos de manera eficiente, lo que es esencial cuando se manejan grandes volúmenes de información. Esto permite a las aplicaciones C# recuperar rápidamente los datos que necesitan, reduciendo la latencia y mejorando la experiencia del usuario.
Integridad de Datos: Las bases de datos proporcionan mecanismos para garantizar la integridad de los datos. Las restricciones, claves primarias y secundarias, así como las transacciones, permiten mantener los datos coherentes y precisos, lo que es crucial en aplicaciones donde la integridad de los datos es primordial.
Escalabilidad: Las bases de datos escalables permiten que las aplicaciones crezcan a medida que aumenta la demanda. Esto es esencial en aplicaciones que esperan un alto tráfico o que necesitan manejar grandes conjuntos de datos.
Seguridad de Datos: Las bases de datos ofrecen medidas de seguridad robustas para proteger los datos confidenciales. Esto incluye autenticación, autorización y cifrado, entre otros mecanismos de seguridad. Para aplicaciones que manejan información sensible, la seguridad es una preocupación principal.
Historial y Auditoría: En muchas aplicaciones, es importante llevar un registro de los cambios en los datos. Las bases de datos permiten el seguimiento del historial de datos y la auditoría, lo que es valioso para el cumplimiento de normativas y la resolución de problemas.
Acceso Concurrente: Las bases de datos están diseñadas para manejar múltiples accesos concurrentes de manera eficiente. Esto es esencial en aplicaciones que tienen múltiples usuarios que acceden y actualizan datos al mismo tiempo.
Portabilidad: El acceso a bases de datos a través de tecnologías como ADO.NET en C# proporciona portabilidad. Puedes diseñar tu aplicación para funcionar con diferentes motores de bases de datos sin tener que reescribir todo el código.

En resumen, el acceso a bases de datos es un componente crítico en el desarrollo de aplicaciones C#. Proporciona un medio para almacenar y gestionar datos, garantiza la integridad de los datos, mejora la eficiencia de las operaciones de búsqueda y consulta, y proporciona una base sólida para la escalabilidad y la seguridad de datos. Dominar las técnicas de acceso a bases de datos es esencial para crear aplicaciones robustas y efectivas en C#.

Enfoque en la conexión a bases de datos SQL utilizando ADO.NET y el uso de Entity Framework Core.

En este capítulo, nos centraremos en el acceso a bases de datos SQL utilizando dos enfoques principales en C#: ADO.NET y Entity Framework Core.

ADO.NET (ActiveX Data Objects para .NET) es un conjunto de clases en el framework .NET que proporciona una forma de conectarse a bases de datos, recuperar, insertar, actualizar y eliminar datos. ADO.NET es versátil y se puede utilizar con una variedad de motores de bases de datos. Utiliza una arquitectura basada en conexiones, comandos y conjuntos de resultados para interactuar con la base de datos.

Entity Framework Core (EF Core) es un marco de mapeo objeto-relacional (ORM) que simplifica el acceso a bases de datos relacionales. Permite a los desarrolladores trabajar con objetos en lugar de escribir consultas SQL directamente. EF Core genera consultas SQL automáticamente en función del modelo de datos de la aplicación. Además, admite múltiples proveedores de bases de datos, lo que facilita la migración entre sistemas de gestión de bases de datos.

A continuación, te proporcionaré ejemplos de cómo usar ADO.NET y Entity Framework Core para acceder a bases de datos SQL en C#:

Ejemplo de Uso de ADO.NET para Conectar y Consultar una Base de Datos SQL:

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "Data Source=MiServidor;Initial Catalog=MiBaseDeDatos;User ID=MiUsuario;Password=MiContraseña";
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            string query = "SELECT Nombre, Apellido FROM Empleados";
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                using (SqlDataReader reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        string nombre = reader["Nombre"].ToString();
                        string apellido = reader["Apellido"].ToString();
                        Console.WriteLine($"Nombre: {nombre}, Apellido: {apellido}");
                    }
                }
            }
        }
    }
}

Ejemplo de Uso de Entity Framework Core para Conectar y Consultar una Base de Datos SQL:

using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;

// Definición de una clase de modelo
public class Empleado
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Apellido { get; set; }
}

// Contexto de base de datos
public class ApplicationDbContext : DbContext
{
    public DbSet<Empleado> Empleados { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Data Source=MiServidor;Initial Catalog=MiBaseDeDatos;User ID=MiUsuario;Password=MiContraseña");
    }
}

class Program
{
    static void Main()
    {
        using (var context = new ApplicationDbContext())
        {
            var empleados = context.Empleados.ToList();
            foreach (var empleado in empleados)
            {
                Console.WriteLine($"Nombre: {empleado.Nombre}, Apellido: {empleado.Apellido}");
            }
        }
    }
}

Ambos enfoques tienen sus ventajas y desventajas, y la elección entre ADO.NET y Entity Framework Core depende de los requisitos específicos de tu proyecto y de tu preferencia personal. ADO.NET proporciona un control más granular sobre las consultas SQL, mientras que Entity Framework Core simplifica muchas tareas comunes de acceso a datos mediante el mapeo de objetos a tablas de bases de datos.

Conexión a Bases de Datos SQL utilizando ADO.NET:

ADO.NET (ActiveX Data Objects para .NET) es una tecnología de acceso a datos en C# que permite a los desarrolladores interactuar con bases de datos relacionales, como SQL Server, Oracle, MySQL y otros. ADO.NET proporciona un conjunto de clases y componentes que permiten establecer conexiones, ejecutar consultas SQL y comandos, y trabajar con conjuntos de resultados.

Aquí tienes una explicación de los pasos para establecer una conexión a una base de datos SQL utilizando ADO.NET y ejecutar consultas SQL:

Paso 1: Importar Espacios de Nombres

using System;
using System.Data;
using System.Data.SqlClient;

Paso 2: Establecer una Cadena de Conexión

string connectionString = "Data Source=MiServidor;Initial Catalog=MiBaseDeDatos;User ID=MiUsuario;Password=MiContraseña";

Reemplaza «MiServidor», «MiBaseDeDatos», «MiUsuario» y «MiContraseña» con los detalles de tu servidor y base de datos SQL.

Paso 3: Crear una Conexión

using (SqlConnection connection = new SqlConnection(connectionString))
{
    // Abre la conexión
    connection.Open();
    
    // Aquí se pueden realizar operaciones de base de datos
    
    // Cierra automáticamente la conexión al salir del bloque "using"
}

Paso 4: Ejecutar Consultas SQL

string query = "SELECT Nombre, Apellido FROM Empleados";
using (SqlCommand command = new SqlCommand(query, connection))
{
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            string nombre = reader["Nombre"].ToString();
            string apellido = reader["Apellido"].ToString();
            Console.WriteLine($"Nombre: {nombre}, Apellido: {apellido}");
        }
    }
}

En este ejemplo, hemos realizado una conexión a la base de datos SQL, ejecutado una consulta SQL para seleccionar datos de la tabla «Empleados» y leído los resultados utilizando un SqlDataReader. Puedes adaptar este código para realizar otras operaciones de lectura y escritura según tus necesidades.

Recuerda manejar adecuadamente las excepciones y asegurarte de cerrar la conexión después de su uso, lo cual hemos hecho en el ejemplo utilizando un bloque using. Esto garantiza la liberación de recursos de manera adecuada y evita problemas de memoria y conexiones no cerradas.

Consulta SQL para Seleccionar Datos:

string selectQuery = "SELECT Nombre, Apellido FROM Empleados";
using (SqlCommand command = new SqlCommand(selectQuery, connection))
{
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            string nombre = reader["Nombre"].ToString();
            string apellido = reader["Apellido"].ToString();
            Console.WriteLine($"Nombre: {nombre}, Apellido: {apellido}");
        }
    }
}

Este código ejecuta una consulta SQL que selecciona los campos «Nombre» y «Apellido» de la tabla «Empleados» y muestra los resultados.

Consulta SQL para Insertar Datos:

string insertQuery = "INSERT INTO Empleados (Nombre, Apellido) VALUES ('Juan', 'Pérez')";
using (SqlCommand command = new SqlCommand(insertQuery, connection))
{
    int rowsAffected = command.ExecuteNonQuery();
    Console.WriteLine($"Se insertaron {rowsAffected} registros.");
}

Este código ejecuta un comando SQL para insertar un nuevo registro en la tabla «Empleados» con los valores «Juan» y «Pérez» en los campos «Nombre» y «Apellido», respectivamente.

Consulta SQL para Actualizar Datos:

string updateQuery = "UPDATE Empleados SET Apellido = 'Gómez' WHERE Nombre = 'Juan'";
using (SqlCommand command = new SqlCommand(updateQuery, connection))
{
    int rowsAffected = command.ExecuteNonQuery();
    Console.WriteLine($"Se actualizaron {rowsAffected} registros.");
}

Este código ejecuta un comando SQL que actualiza registros en la tabla «Empleados» estableciendo el apellido como «Gómez» donde el nombre es «Juan».

Consulta SQL para Eliminar Datos:

string deleteQuery = "DELETE FROM Empleados WHERE Nombre = 'Juan'";
using (SqlCommand command = new SqlCommand(deleteQuery, connection))
{
    int rowsAffected = command.ExecuteNonQuery();
    Console.WriteLine($"Se eliminaron {rowsAffected} registros.");
}

Este código ejecuta un comando SQL que elimina registros de la tabla «Empleados» donde el nombre es «Juan».

Asegúrate de adaptar estos ejemplos a tu esquema de base de datos y necesidades específicas. También, ten en cuenta que es importante manejar las excepciones que puedan surgir durante la ejecución de estas consultas y comandos SQL.

Uso de Entity Framework Core para el Acceso a Datos:

A continuación, te mostraré ejemplos de cómo utilizar Entity Framework Core para el acceso a datos en una aplicación C#.

1. Configuración de Entity Framework Core:

Para comenzar, debes configurar Entity Framework Core en tu proyecto. Esto implica agregar las dependencias necesarias y definir un contexto de base de datos. A continuación, se muestra un ejemplo de cómo configurar Entity Framework Core en una aplicación ASP.NET Core:

// Instala las dependencias necesarias:
// Microsoft.EntityFrameworkCore
// Microsoft.EntityFrameworkCore.Design
// Microsoft.EntityFrameworkCore.SqlServer (o el proveedor de base de datos de tu elección)

using Microsoft.EntityFrameworkCore;
using System;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    public DbSet<Empleado> Empleados { get; set; }
}

2. Definición de un Modelo:

Luego, define una clase de modelo que represente una tabla en tu base de datos. Por ejemplo, aquí hay una clase de modelo «Empleado»:

public class Empleado
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Apellido { get; set; }
}

3. Consultas LINQ con Entity Framework Core:

Una vez que tengas configurado Entity Framework Core y definidos tus modelos, puedes realizar consultas utilizando LINQ. Aquí hay algunos ejemplos:

Consulta para Obtener Todos los Empleados:

var empleados = dbContext.Empleados.ToList();

Consulta para Filtrar Empleados por Apellido:

var empleadosConApellidoGomez = dbContext.Empleados
    .Where(e => e.Apellido == "Gómez")
    .ToList();

Consulta para Agregar un Nuevo Empleado:

var nuevoEmpleado = new Empleado { Nombre = "Juan", Apellido = "Pérez" };
dbContext.Empleados.Add(nuevoEmpleado);
dbContext.SaveChanges();

Consulta para Actualizar un Empleado:

var empleadoAActualizar = dbContext.Empleados.FirstOrDefault(e => e.Id == 1);
if (empleadoAActualizar != null)
{
    empleadoAActualizar.Apellido = "Gómez";
    dbContext.SaveChanges();
}

Consulta para Eliminar un Empleado:

var empleadoAEliminar = dbContext.Empleados.FirstOrDefault(e => e.Id == 2);
if (empleadoAEliminar != null)
{
    dbContext.Empleados.Remove(empleadoAEliminar);
    dbContext.SaveChanges();
}

Recuerda que en estos ejemplos, dbContext representa una instancia de tu contexto de base de datos (ApplicationDbContext) que se ha inyectado en tu aplicación.

Este es solo un vistazo rápido a cómo utilizar Entity Framework Core para el acceso a datos en C#. La configuración y las consultas pueden variar según las necesidades específicas de tu proyecto y la base de datos que estés utilizando.

Ejemplo: Conexión y Consulta de Datos con ADO.NET:

Establecimiento de una conexión a una base de datos SQL utilizando ADO.NET.
Ejemplo de consulta SQL para recuperar datos y mostrarlos en una aplicación C#.

Aquí tienes un ejemplo de cómo establecer una conexión a una base de datos SQL utilizando ADO.NET y realizar una consulta SQL para recuperar datos en una aplicación C#:

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "Data Source=TuServidor;Initial Catalog=TuBaseDeDatos;User ID=TUUsuario;Password=TuContraseña";

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            try
            {
                connection.Open();
                // Consulta SQL para seleccionar todos los empleados de una tabla
                string query = "SELECT * FROM Empleados";
                
                using (SqlCommand command = new SqlCommand(query, connection))
                {
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        Console.WriteLine("Lista de Empleados:\n");

                        while (reader.Read())
                        {
                            int empleadoId = reader.GetInt32(0);
                            string nombre = reader.GetString(1);
                            string apellido = reader.GetString(2);

                            Console.WriteLine($"ID: {empleadoId}, Nombre: {nombre}, Apellido: {apellido}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            finally
            {
                connection.Close();
            }
        }
    }
}

Asegúrate de reemplazar los valores en la cadena de conexión (connectionString) con los correspondientes a tu servidor SQL, base de datos, usuario y contraseña.

Este código establece una conexión a la base de datos, ejecuta una consulta SQL para seleccionar todos los empleados de la tabla «Empleados», recupera los datos y los muestra en la consola.

Ten en cuenta que este es solo un ejemplo básico de cómo usar ADO.NET para conectarse a una base de datos SQL y realizar una consulta. En una aplicación real, es importante manejar las excepciones adecuadamente y seguir las mejores prácticas de seguridad, como el uso de parámetros en las consultas SQL para prevenir la inyección SQL.

Ejemplo: Uso de Entity Framework Core en una Aplicación C#:

Configuración de Entity Framework Core en una aplicación C#.
Realización de consultas utilizando LINQ y Entity Framework Core para acceder y manipular datos.

Aquí tienes un ejemplo de cómo configurar Entity Framework Core en una aplicación C# y realizar consultas utilizando LINQ y Entity Framework Core para acceder y manipular datos en una base de datos SQL:

Supongamos que tienes una clase Empleado y una base de datos SQL llamada EmpresaDB con una tabla llamada Empleados.

using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;

// Definición de la clase Empleado que se mapeará a la tabla Empleados en la base de datos
public class Empleado
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public string Apellido { get; set; }
}

// Contexto de Entity Framework Core
public class ApplicationDbContext : DbContext
{
    public DbSet<Empleado> Empleados { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Data Source=TuServidor;Initial Catalog=EmpresaDB;User ID=TUUsuario;Password=TuContraseña");
    }
}

class Program
{
    static void Main()
    {
        using (var context = new ApplicationDbContext())
        {
            // Consulta LINQ para seleccionar todos los empleados
            var empleados = context.Empleados.ToList();

            Console.WriteLine("Lista de Empleados:\n");

            foreach (var empleado in empleados)
            {
                Console.WriteLine($"ID: {empleado.Id}, Nombre: {empleado.Nombre}, Apellido: {empleado.Apellido}");
            }
        }
    }
}

Asegúrate de reemplazar los valores en la cadena de conexión en OnConfiguring con los correspondientes a tu servidor SQL, base de datos, usuario y contraseña.

Este código configura Entity Framework Core para acceder a la base de datos, define una clase Empleado que se mapeará a la tabla Empleados y realiza una consulta utilizando LINQ para seleccionar todos los empleados de la tabla. Luego, muestra los datos en la consola.

Entity Framework Core simplifica el acceso a la base de datos y la manipulación de datos en comparación con ADO.NET, ya que utiliza consultas LINQ en lugar de consultas SQL directas.

Resumen:

En este capítulo aprendimos sobre las siguientes áreas clave:

Conexión a Bases de Datos SQL utilizando ADO.NET: Aprendimos cómo establecer una conexión a una base de datos SQL utilizando ADO.NET. Exploramos la ejecución de consultas SQL y comandos para realizar operaciones de lectura y escritura en la base de datos.
Consultas SQL y Ejecución de Comandos: Comprendimos cómo usar SQL para realizar consultas a bases de datos y seleccionar datos específicos. Vimos ejemplos de consultas SQL simples y complejas, así como la ejecución de comandos para insertar, actualizar y eliminar registros en la base de datos.
Uso de Entity Framework Core para el Acceso a Datos: Introdujimos Entity Framework Core como un ORM (Mapeo Objeto-Relacional) en C#. Configuramos Entity Framework Core en una aplicación C#. Aprendimos a realizar consultas utilizando LINQ y Entity Framework Core para acceder y manipular datos en una base de datos SQL.

El resumen clave de este capítulo es que existen varias formas de acceder a datos en aplicaciones C#, y la elección de la tecnología adecuada depende de las necesidades y requerimientos del proyecto. Tanto ADO.NET como Entity Framework Core son herramientas poderosas para interactuar con bases de datos, y la elección entre ellas dependerá de factores como la complejidad del proyecto, la preferencia personal y los objetivos de desarrollo. En general, este capítulo subraya la importancia de seleccionar la tecnología de acceso a datos adecuada y cómo trabajar con bases de datos SQL en aplicaciones C#, ya que el acceso eficiente y seguro a los datos es fundamental en el desarrollo de software moderno.