.NEXT FRAMEWORK
Programación
1julio 21, 2025

Base de datos MySQL con C#

En C#, el acceso y la gestión de bases de datos se facilitan mediante el uso de bibliotecas especializadas disponibles a través de NuGet, el gestor de paquetes de Microsoft. Estas bibliotecas proporcionan las herramientas necesarias para interactuar con diversas bases de datos de manera eficiente y segura

1. Instalación

Install-Package MySql.Data

MySQL Connector/NET: Este es el controlador ADO.NET oficial para MySQL. Puedes instalarlo a través del Administrador de Paquetes NuGet en Visual Studio:Install-Package MySql.Data<br>O, si usas .NET CLI:dotnet add package MySql.Data

dotnet add package MySql.Data

2. Estableciendo una Conexión

Para conectarte a una base de datos MySQL, necesitas una cadena de conexión que especifique la dirección del servidor, el nombre de la base de datos, el ID de usuario y la contraseña. La clase MySqlConnection se utiliza para gestionar la conexión.

using MySql.Data.MySqlClient;
using System;

public class MySQLConnector
{
    private string connectionString;

    public MySQLConnector(string server, string database, 
      string uid, string password)
    {
        connectionString = $@"Server={server};Database={database};Uid={uid};
         Pwd={password};";
    }

    public MySqlConnection GetConnection()
    {
        MySqlConnection connection = new MySqlConnection(connectionString);
        try
        {
            connection.Open();
            Console.WriteLine("¡Conexión exitosa!");
            return connection;
        }
        catch (MySqlException ex)
        {
            Console.WriteLine("Conexión fallida: " + ex.Message);
            return null;
        }
    }

    public void CloseConnection(MySqlConnection connection)
    {
        if (connection != null && 
           connection.State == System.Data.ConnectionState.Open)
        {
            connection.Close();
            Console.WriteLine("Conexión cerrada.");
        }
    }
}

// Ejemplo de Uso:
/*
public class Program
{
    public static void Main(string[] args)
    {
        MySQLConnector connector = new MySQLConnector("localhost",
        "nombre_de_tu_base_de_datos", "tu_nombre_de_usuario", "tu_contraseña");
        MySqlConnection connection = connector.GetConnection();

        if (connection != null)
        {
            // Realizar operaciones de base de datos aquí
            connector.CloseConnection(connection);
        }
    }
}
*/

Explicación:

  • MySql.Data.MySqlClient: Este espacio de nombres contiene todas las clases necesarias para la conectividad MySQL.
  • connectionString: Define los parámetros para conectarse a tu base de datos.
  • GetConnection(): Intenta abrir una conexión. Imprime un mensaje de éxito o fracaso y devuelve el objeto MySqlConnection.
  • CloseConnection(): Cierra la conexión si está abierta. Es crucial cerrar las conexiones para liberar recursos.

3. Leyendo Datos (SELECT)

Para recuperar datos de una tabla, usarás MySqlCommand para ejecutar una consulta SELECT y MySqlDataReader para leer los resultados fila por fila.

using MySql.Data.MySqlClient;
using System;
using System.Data; // Requerido para ConnectionState

public class DataReader
{
    public void ReadData(MySqlConnection connection)
    {
        if (connection == null || connection.State != ConnectionState.Open)
        {
            Console.WriteLine("La conexión a la base de datos no está abierta.");
            return;
        }

        string query = "SELECT id, name, email FROM users"; 
        // Consulta de ejemplo

        MySqlCommand command = new MySqlCommand(query, connection);
        MySqlDataReader reader = null;

        try
        {
            reader = command.ExecuteReader();

            Console.WriteLine("\n--- Datos de Usuario ---");
            while (reader.Read())
            {
                // Acceder a los datos por nombre de columna o índice
                int id = reader.GetInt32("id");
                string name = reader.GetString("name");
                string email = reader.GetString("email");

                Console.WriteLine($"ID: {id}, Nombre: {name}, Correo: {email}");
            }
            Console.WriteLine("-----------------\n");
        }
        catch (MySqlException ex)
        {
            Console.WriteLine("Error al leer datos: " + ex.Message);
        }
        finally
        {
            if (reader != null)
            {
                reader.Close(); // Siempre cierra el lector
            }
        }
    }
}

// Ejemplo de Uso (añadir al método Main del ejemplo anterior):
/*
public class Program
{
    public static void Main(string[] args)
    {
        MySQLConnector connector = new MySQLConnector("localhost",
        "nombre_de_tu_base_de_datos", "tu_nombre_de_usuario", "tu_contraseña");
        MySqlConnection connection = connector.GetConnection();

        if (connection != null)
        {
            DataReader dataReader = new DataReader();
            dataReader.ReadData(connection);
            connector.CloseConnection(connection);
        }
    }
}
*/

Explicación:

  • MySqlCommand: Representa una declaración SQL o un procedimiento almacenado para ejecutar contra una base de datos MySQL.
  • ExecuteReader(): Ejecuta la consulta SELECT y devuelve un objeto MySqlDataReader.
  • MySqlDataReader: Proporciona una forma de leer un flujo de filas de solo avance desde una fuente de datos MySQL.
  • reader.Read(): Avanza el lector al siguiente registro. Devuelve true si hay más filas, false en caso contrario.
  • reader.GetInt32(), reader.GetString(): Métodos para recuperar datos de columnas específicas por nombre o índice, convertidos al tipo C# apropiado.

4. Insertando Datos (INSERT)

Para añadir nuevos registros a una tabla, usarás una consulta INSERT. Se recomienda encarecidamente usar consultas parametrizadas para prevenir vulnerabilidades de inyección SQL.

using MySql.Data.MySqlClient;
using System;
using System.Data;

public class DataInserter
{
    public void InsertData(MySqlConnection connection, string name, 
    string email)
    {
        if (connection == null || connection.State != ConnectionState.Open)
        {
            Console.WriteLine("La conexión a la base de datos no está abierta.");
            return;
        }

        string query = "INSERT INTO users (name, email) VALUES (@name, @email)";

        MySqlCommand command = new MySqlCommand(query, connection);
        // Añadir parámetros para prevenir la inyección SQL
        command.Parameters.AddWithValue("@name", name);
        command.Parameters.AddWithValue("@email", email);

        try
        {
            int rowsAffected = command.ExecuteNonQuery();
            Console.WriteLine($@"\n{rowsAffected} fila(s) 
            insertada(s) exitosamente.");
        }
        catch (MySqlException ex)
        {
            Console.WriteLine("Error al insertar datos: " + ex.Message);
        }
    }
}

// Ejemplo de Uso (añadir al método Main):
/*
public class Program
{
    public static void Main(string[] args)
    {
        MySQLConnector connector = new MySQLConnector("localhost", 
        "nombre_de_tu_base_de_datos", "tu_nombre_de_usuario", "tu_contraseña");
        MySqlConnection connection = connector.GetConnection();

        if (connection != null)
        {
            DataInserter inserter = new DataInserter();
            inserter.InsertData(connection, "Alice Smith", "alice@example.com");
            inserter.InsertData(connection, "Bob Johnson", "bob@example.com");

            DataReader dataReader = new DataReader();
            dataReader.ReadData(connection); 
// Leer datos de nuevo para ver las nuevas entradas

            connector.CloseConnection(connection);
        }
    }
}
*/

Explicación:

  • ExecuteNonQuery(): Ejecuta declaraciones SQL que no devuelven datos (como INSERT, UPDATE, DELETE). Devuelve el número de filas afectadas.
  • command.Parameters.AddWithValue(): Esto es crucial para la seguridad. Añade parámetros a la consulta SQL, que luego son reemplazados por los valores reales en tiempo de ejecución, evitando que se inyecte código malicioso en tu consulta.

5. Modificando Datos (UPDATE)

La actualización de registros existentes también utiliza ExecuteNonQuery() con una consulta UPDATE y valores parametrizados.

using MySql.Data.MySqlClient;
using System;
using System.Data;

public class DataModifier
{
    public void UpdateData(MySqlConnection connection, int id, string newEmail)
    {
        if (connection == null || connection.State != ConnectionState.Open)
        {
            Console.WriteLine("La conexión a la base de datos no está abierta.");
            return;
        }

        string query = "UPDATE users SET email = @newEmail WHERE id = @id";

        MySqlCommand command = new MySqlCommand(query, connection);
        command.Parameters.AddWithValue("@newEmail", newEmail);
        command.Parameters.AddWithValue("@id", id);

        try
        {
            int rowsAffected = command.ExecuteNonQuery();
            Console.WriteLine($@"\n{rowsAffected} fila(s) 
            actualizada(s) exitosamente.");
        }
        catch (MySqlException ex)
        {
            Console.WriteLine("Error al actualizar datos: " + ex.Message);
        }
    }
}

// Ejemplo de Uso (añadir al método Main):
/*
public class Program
{
    public static void Main(string[] args)
    {
        MySQLConnector connector = new MySQLConnector("localhost", 
        "nombre_de_tu_base_de_datos", "tu_nombre_de_usuario", "tu_contraseña");
        MySqlConnection connection = connector.GetConnection();

        if (connection != null)
        {
            DataInserter inserter = new DataInserter();
            inserter.InsertData(connection, "Charlie Brown", 
            "charlie@example.com");

            DataReader dataReader = new DataReader();
            dataReader.ReadData(connection);

            DataModifier modifier = new DataModifier();
            modifier.UpdateData(connection, 1, "charlie.new@example.com"); 
            // Suponiendo que el ID 1 existe

            dataReader.ReadData(connection); 
            // Leer datos de nuevo para ver la actualización

            connector.CloseConnection(connection);
        }
    }
}

Explicación:

  • La consulta UPDATE apunta a filas específicas usando una cláusula WHERE.
  • Los parámetros se utilizan tanto para el nuevo valor (@newEmail) como para la condición (@id).

6. Eliminando Datos (DELETE)

La eliminación de registros también utiliza ExecuteNonQuery() con una consulta DELETE, típicamente con una cláusula WHERE para especificar qué registros eliminar.

using MySql.Data.MySqlClient;
using System;
using System.Data;

public class DataDeleter
{
    public void DeleteData(MySqlConnection connection, int id)
    {
        if (connection == null || connection.State != ConnectionState.Open)
        {
            Console.WriteLine("La conexión a la base de datos no está abierta.");
            return;
        }

        string query = "DELETE FROM users WHERE id = @id";

        MySqlCommand command = new MySqlCommand(query, connection);
        command.Parameters.AddWithValue("@id", id);

        try
        {
            int rowsAffected = command.ExecuteNonQuery();
            Console.WriteLine($@"\n{rowsAffected} fila(s) 
            eliminada(s) exitosamente.");
        }
        catch (MySqlException ex)
        {
            Console.WriteLine("Error al eliminar datos: " + ex.Message);
        }
    }
}

// Ejemplo de Uso (añadir al método Main):
/*
public class Program
{
    public static void Main(string[] args)
    {
        MySQLConnector connector = new MySQLConnector("localhost", 
        "nombre_de_tu_base_de_datos", "tu_nombre_de_usuario", 
        "tu_contraseña");
        MySqlConnection connection = connector.GetConnection();

        if (connection != null)
        {
            DataInserter inserter = new DataInserter();
            inserter.InsertData(connection, "David Lee", 
            "david@example.com");

            DataReader dataReader = new DataReader();
            dataReader.ReadData(connection);

            DataDeleter deleter = new DataDeleter();
            deleter.DeleteData(connection, 2); 
            // Suponiendo que el ID 2 existe

            dataReader.ReadData(connection); 
            // Leer datos de nuevo para ver la eliminación

            connector.CloseConnection(connection);
        }
    }
}
*/

Explicación:

  • La consulta DELETE elimina las filas que coinciden con la cláusula WHERE.
  • Siempre usa una cláusula WHERE con DELETE a menos que tengas la intención de eliminar todos los registros de una tabla.

Buenas Prácticas

  • Manejo de Errores: Siempre envuelve tus operaciones de base de datos en bloques try-catch para manejar las excepciones de manera elegante (por ejemplo, problemas de red, SQL no válido, base de datos caída).
  • Gestión de Recursos: Usa declaraciones using para MySqlConnection, MySqlCommand y MySqlDataReader para asegurarte de que se eliminen correctamente, incluso si ocurren errores. Esta es la forma preferida sobre las llamadas explícitas a Close() y Dispose() en los bloques finally.
  • Consultas Parametrizadas: Siempre usa consultas parametrizadas para INSERT, UPDATE y DELETE (e incluso SELECT con cláusulas WHERE) para prevenir ataques de inyección SQL.
  • Agrupación de Conexiones (Connection Pooling): MySqlConnection maneja automáticamente la agrupación de conexiones. Esto significa que cuando cierras una conexión, a menudo se devuelve a un grupo para su reutilización en lugar de desconectarse físicamente, lo que mejora el rendimiento.
  • Configuración: Almacena tu cadena de conexión en un archivo de configuración (por ejemplo, appsettings.json en .NET Core o App.config en .NET Framework) en lugar de codificarla directamente en tu aplicación.

Comment

Post a Comment