Visita nuestros cursos en KODOTI. Click para unirte
Estudia con KODOTI. Únete

Alternativa al Entity Framework, ejemplo de NPoco con CSharp

Veremos un par de ejemplos de NPoco como alternativa al Entity Framework en este ejemplo hecho en C#

Rodríguez Patiño, Eduardo
5,133 lecturas
Rodríguez Patiño, Eduardo
Hemos migrado nuestras publicaciones del blog antiguo. Si crees que esta se encuentra incompleta o sin coherencia deja un comentario para darle una pronta solución.

Este micro ORM es una alternativa ideal al Entity Framework debido a su performance y curva de aprendizaje, en el video adjunto explicamos como trabajar con este.

¿Cómo funciona?

Lo primero que debemos hacer es agregar la referencia desde el NuGet, para esto buscamos en el NuGet NPoco y solo faltaría crear instanciar la clase 

using(var db = new Database("NPocoExample")) { .. }

Funcionalidades soportadas

  • Queries inteligentes
  • Expresiones Lambda con Linq (Limitado)
  • Consultas muy rápidas
  • Annotations
  • Fluent Mapping (lo que vendría a ser el Fluent Api del EF)
  • Paginación
  • Transacciones
  • Manejo de relaciones

Select

public static IEnumerable<Empleado> GetAll()
{
    var result = new List<Empleado>();

    try
    {
        using (IDatabase db = DbContext.GetInstance())
        {
            #region Select All
            result = db.Fetch<Empleado>();
            #endregion

            #region Select especificando las columnas
            //result =  db.Fetch<Empleado>("SELECT id, Nombre, Apellido FROM Empleado");
            #endregion

            #region Select con Where
            //result = db.Fetch<Empleado>("SELECT * FROM Empleado WHERE Sexo = @0", 2);
            #endregion

            #region Select con Where directo, omitiendo el SELECT *
            //result = db.Fetch<Empleado>("WHERE Sexo = @0", 2);
            #endregion

            #region Select con Where directo, omitiendo el SELECT *
            //result = db.Fetch<Empleado>("WHERE Sexo = @0", 2);
            #endregion
        }
    }
    catch (Exception e)
    {
        Console.Write(e.Message);
    }

    return result;
}

Los queries retornados son más limpios que Entity Framework

Un SELECT simple

SELECT id, nombre, apellido, profesion__id, profesion__name FROM Empleado

Un SELECT con Includes

exec sp_executesql N'SELECT [E].[id] as [id], [E].[Profesion_id] as [Profesion_id], [E].[Nombre] as [Nombre], [E].[Apellido] as [Apellido], [E].[Correo] as [Correo], [E].[Sexo] as [Sexo], [E].[FechaNacimiento] as [FechaNacimiento], [E].[FechaRegistro] as [FechaRegistro], [E].[Sueldo] as [Sueldo], [P].[id] as [Profesion__id], [P].[Nombre] as [Profesion__Nombre] FROM [Empleado] [E]  
  LEFT JOIN [Profesion] [P] ON [E].[Profesion_id] = [P].[id] 
WHERE ([E].[Profesion_id] = @0) 
ORDER BY [FechaNacimiento] ASC',N'@0 int',@0=2

El EF genera unos queries horribles que disminuyen bastante el performance.

Un solo registro

En este ejemplo tenemos 2 opciones SingleOrDefaultById que encontrará un registro haciendo un WHERE por el PK de nuestra clase o FirstOrDefault que encontrará el primer registro encontrado en base a nuestra condición.

public static Empleado Get(int id = 0)
{
    var result = new Empleado();

    try
    {
        using (IDatabase db = DbContext.GetInstance())
        {
            if (id > 0)
            {
                result = db.SingleOrDefaultById<Empleado>(id);
            }
            else
            {
                result = db.FirstOrDefault<Empleado>("WHERE id IS NOT NULL");
            }

        }
    }
    catch (Exception e)
    {
        Console.Write(e.Message);
    }

    return result;
}

Insert, Update, Delete

public static void Insert(Empleado model)
{
    try
    {
        using (IDatabase db = DbContext.GetInstance())
        {
            db.Insert(model);
        }
    }
    catch (Exception e)
    {
        Console.Write(e.Message);
    }
}

public static void Update(Empleado model)
{
    try
    {
        using (IDatabase db = DbContext.GetInstance())
        {
            var originalModel = db.SingleById<Empleado>(model.id);

            originalModel.Nombre = model.Nombre;
            originalModel.Apellido = model.Apellido;
            originalModel.Correo = model.Correo;

            db.Update(originalModel);
        }
    }
    catch (Exception e)
    {
        Console.Write(e.Message);
    }
}

public static void Delete(int id)
{
    try
    {
        using (IDatabase db = DbContext.GetInstance())
        {
            db.Delete<Empleado>(id);
        }
    }
    catch (Exception e)
    {
        Console.Write(e.Message);
    }
}

Adicionalmente, para un insertOrUpdate tenemos el método Save, lo pueden ver en su wiki.

Conclusiones

  • Para Queries muy difíciles lo mejor y más recomendado es que hagas una vista de SQL, luego crees una clase de C# con los campos de tu vista.
  • Se extraña tener un sistema de migraciones, será cosa de buscar si existe una alternativa.
  • Adiós a ASP.NET Identity, pero existe una forma de usar Owin y un sistema de autenticación sin depender de este, creo que sería lo más óptimo.

PD: adjunto el ejemplo para descargar del GitHub y el video explicativo

¿Te gustó nuestra publicación?
Suscríbete a nuestro boletín