C# – ADO.NET – Parte 3 – Actualización Información Sql Server

 

Introducción

En esta oportunidad avanzaremos un poco mas allá en el uso de ADO.NET para el trabajo con la información, es por eso que no solo recuperaremos datos, sino que también agregaremos nuevos registros, actualizaremos los existentes y eliminaremos aquellos que ya no sean necesarios

Este post es la continuación de un post anterior:

C# – ADO.NET - Parte 1 - Recuperar Información Sql Server

es por ello que ciertos aspectos serán pasados por alto, pues fueron explicados con mas detalle en la primer parte.

1 – Creación nueva entidad (Insert)

Para esta operación se ha creando en la clase ContactosDAL, varias funciones que encapsulan la funcionalidad.

Encontraran un método de nombre Save(), el cual es el único visibilidad publica en la clase que permite la actualziacion de la entidad, y es por este que se decide si la operación a llevar a cabo será en definitiva un Update() o un Insert()

public static ContactoEntity Save(ContactoEntity contacto)
{

    if (string.IsNullOrEmpty(contacto.Nombre))
        throw new BusinessException(Messages.MSG1002);

    if (string.IsNullOrEmpty(contacto.Apellido))
        throw new BusinessException(Messages.MSG1003);

    if (Exists(contacto))
        return Update(contacto);
    else
        return Insert(contacto);
}

 

El método Save() es bastante simple, hace uso de una función interna de nombre Exists(), para decidir si el contacto como entidad enviado desde la presentación es uno nuevo, o si existe y hay que actualizarlo

private static bool Exists(ContactoEntity contacto)
{
    if (contacto == null)
        throw new BusinessException(Messages.ERR1001); 

    return Exists(contacto.IdContacto);
}

private static bool Exists(int Id)
{
    string sql = @"SELECT COUNT(*)
                      FROM Contacto
                      WHERE IdContacto = @Id";


    using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
    {

        SqlCommand command = new SqlCommand(sql, conn);
        command.Parameters.AddWithValue("Id", Id);

        conn.Open();

        int count = Convert.ToInt32(command.ExecuteScalar());

        if (count == 0)
            return false;
        else
            return true;
        
    }
}

La estructura de conexión y creación de objetos se respeta al igual que se comento en el primer articulo escrito, la diferencia en este es que se hace uso del  ExecuteScalar del objeto SqlCommand.

Como se observara este método ideal para estos casos, ya que es utilizado cuando se necesita recuperar un solo valor de la base de datos.

El método ExecuteScalar:

- Ejecuta la consulta y devuelve la primera columna de la primera fila del conjunto de resultados que devuelve la consulta. Se omiten todas las demás columnas y filas.
- Utilice el método ExecuteScalar para recuperar un único valor (por ejemplo, un valor agregado) de una base de datos.

En este caso se esta preguntando cuantos registro hay con el id de contacto que le pasamos como parámetro, si devuelve cero quiere decir que no existe el contacto, en cambio un valor de uno indica que existe por lo tanto debe proceder con la actualización.

Como se notara el método Exists() esta sobrecargado, o sea tiene dos definiciones del mismo pero con distintos parámetros, uno recibe la instancia de un contacto, mientras que al segundo solo el id, es mas el primero termina haciendo uso de siguiente para reutilizar la funcionalidad, y solo codificarla en uno de ellos.

Una vez determinado si existe o no el registro se proceder con las operaciones, por ejemplo el Insert()

private static ContactoEntity Insert(ContactoEntity contacto)
{
    string sql = @"INSERT INTO Contacto ([IdContacto]
                          ,[Nombre]
                          ,[Apellido]
                          ,[FechaNacimiento]
                          ,[Localidad]
                          ,[Calle]
                          ,[Numero])
                      VALUES (@Id, 
                            @Nombre, 
                            @Apellido, 
                            @FechaNacimiento, 
                            @Localidad, 
                            @Calle, 
                            @Numero)";


    using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
    {
        int NextId = MaxId() + 1;

        SqlCommand command = new SqlCommand(sql, conn);
        command.Parameters.AddWithValue("Id", NextId);
        command.Parameters.AddWithValue("Nombre", contacto.Nombre);
        command.Parameters.AddWithValue("Apellido", contacto.Apellido);
        command.Parameters.AddWithValue("FechaNacimiento", contacto.FechaNacimiento);
        command.Parameters.AddWithValue("Localidad", string.IsNullOrEmpty(contacto.Localidad) ? (object)DBNull.Value : contacto.Localidad);
        command.Parameters.AddWithValue("Calle", string.IsNullOrEmpty(contacto.Calle) ? (object)DBNull.Value : contacto.Calle);
        command.Parameters.AddWithValue("Numero", contacto.Numero.HasValue ? contacto.Numero : (object)DBNull.Value );

        conn.Open();

        command.ExecuteNonQuery();

        contacto.IdContacto = NextId;

        return contacto;

    }
}

Durante la creación del registro hay una operación previa que debe realizarse, y esta consiste en obtener el id siguiente de la clave de la entidad a insertar.

Es por ello que se creo el método MaxId()

private static int MaxId()
{
    string sql = @"SELECT MAX(IdContacto)
                      FROM Contacto";


    using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
    {

        SqlCommand command = new SqlCommand(sql, conn);

        conn.Open();

        return Convert.ToInt32(command.ExecuteScalar());

    }
}

Este es un método muy simple que también hace uso del ExecuteScalar() para obtener el único valor devuelto para la función de agregación que se ejecuta en la consulta sql, en este caso se utiliza la función Max, para recuperar el ultimo id de la tabla utilizada en la consulta.

Además de obtener el próximo id, durante el proceso de insertar se validan ciertos campos, para verificar si estos contiene información asignada, pero en caso de no tenerla se envía a la db el valor DBNull.Value, esto se puede hacer ya que los campos donde se realiza la operación permiten valores nulos como contenido.

Como este es un proceso de insert y la clave es generada de forma interna a la aplicación, es por esta razón que el final se actualiza la entidad pasada por parámetro y es devuelta para que el sistema pueda informarlo al usuario, ya sea en un mensaje de texto, o para registrar la operación en algún sistema de log, si fuera necesario.

2 – Actualización de la entidad (Update)

El proceso de actualización es bastante similar al de creación de la entidad, solo varia en que este requiere que la entidad exista, se tenga el identificador o código para poder identificarlo

private static ContactoEntity Update(ContactoEntity contacto)
{

    string sql = @"UPDATE Contacto SET 
                          [Nombre] = @Nombre
                          ,[Apellido] = @Apellido
                          ,[FechaNacimiento] = @FechaNacimiento
                          ,[Localidad] =  @Localidad
                          ,[Calle] =  @Calle
                          ,[Numero] = @Numero
                    WHERE [IdContacto] = @Id";


    using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
    {

        SqlCommand command = new SqlCommand(sql, conn);
        command.Parameters.AddWithValue("Id", contacto.IdContacto);
        command.Parameters.AddWithValue("Nombre", contacto.Nombre);
        command.Parameters.AddWithValue("Apellido", contacto.Apellido);
        command.Parameters.AddWithValue("FechaNacimiento", contacto.FechaNacimiento);
        command.Parameters.AddWithValue("Localidad", string.IsNullOrEmpty(contacto.Localidad) ? (object)DBNull.Value : contacto.Localidad);
        command.Parameters.AddWithValue("Calle", string.IsNullOrEmpty(contacto.Calle) ? (object)DBNull.Value : contacto.Calle);
        command.Parameters.AddWithValue("Numero", contacto.Numero.HasValue ? contacto.Numero : (object)DBNull.Value);

        conn.Open();

        command.ExecuteNonQuery();

        return contacto;

    }
}

A diferencia del proceso de creación de la entidad en esta oportunidad no es creado un nuevo Id, sino que este debe enviarse para que la actualización pueda realizarse correctamente. Es mas esta Id es utilizado en la sección WHERE de la consulta para poder identificar el registro que se quiere actualizar.

3 – Eliminación de la entidad (Delete)

Para este proceso una vez que se tiene la entidad simplemente se envía el id y eso es todo.

public static void Delete(ContactoEntity contacto)
{
    if (contacto == null)
        throw new BusinessException(Messages.ERR1001); 

    Delete(contacto.IdContacto);
}

public static void Delete(int Id)
{
    string sql = @"DELETE FROM Contacto 
                   WHERE [IdContacto] = @Id";


    using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
    {

        SqlCommand command = new SqlCommand(sql, conn);
        command.Parameters.AddWithValue("Id", Id);

        conn.Open();

        command.ExecuteNonQuery();

    }
}

Consideración sobre el ejemplo

Algo que se notara cuando se analice la aplicación es que fue eliminado el DataSet del ejemplo previo en el post anterior, dejando únicamente  el uso de la entidad como clase, esto se debió a que era necesario uniformizar la aplicación para tratar con solo un tipo de entidad, y poder así conservar esta cuando se esta en modo edición.

Se vera a nivel de presentación una propiedad que representa la entidad seleccionada, el tener o no un objeto que representa al contacto marca el modo en que se encuentra la aplicación, ya que al hacer dobleclick en una entidad de la grilla esta carga el contenido y asigna un valor en este propiedad interna del formulario

Los ejemplos requieren al menos Sql Server 2008 Express instalado localmente

[C#]

[VB.NET]