Uso de Entity Framework Core y Dapper en ASP.NET Core

En este artículo, aprenderemos sobre el uso de Entity Framework Core y Dapper en ASP.NET Core juntos en la misma aplicación. Otro punto importante de discusión será Transacciones. Al final del artículo, tendremos una aplicación que funciona con Entity Framework Core y Dapper uno al lado del otro, pero también lo suficientemente inteligente como para revertir los datos siempre que haya una excepción con el proceso.

¡Empecemos!

Núcleo de Dapper vs Entity Framework

Dapper es literalmente mucho más rápido que Entity Framework Core considerando el hecho de que no hay campanas ni silbatos en Dapper. Es un Micro ORM sencillo que también tiene características mínimas. Siempre depende del desarrollador elegir entre estas 2 impresionantes tecnologías de acceso a datos. Esto no significa que Entity Framework Core sea más lento. Con cada actualización, el rendimiento también parece mejorar. Dapper es el paraíso para aquellos a quienes todavía les gusta trabajar con consultas RAW en lugar de LINQ con EFCore.

Ahora, Entity Framework Core tiene toneladas de funciones incluidas junto con mejoras de rendimiento también. Entonces esa pregunta es: ¿Por qué elegir entre Dapper y Entity Framework Core cuando puede usar ambos y aprovechar al máximo, sí?

Dapper es súper increíble para manejar consultas complejas que tienen uniones múltiples y una lógica comercial realmente larga. Entity Framework Core es excelente para la generación de clases, el seguimiento de objetos, el mapeo de varias clases anidadas y mucho más. Por lo general, se trata de rendimiento y características cuando se habla de estos 2 ORM.

Requisito

Diseñaremos una WebAPI ASP.NET Core simple para una empresa imaginaria. Esta empresa tiene una política que dice que todos los demás empleados deben estar vinculados a un departamento único. Para que quede más claro, cada vez que agrega un nuevo empleado a través del extremo de la API, también debe crear un nuevo Registro de departamento. Un requisito muy imaginario, ¿sí? Junto con esto, tendremos otros 2 puntos finales que devuelven todos los Empleados y Empleado por Id.

Ampliando los detalles, tendremos que asegurarnos de que el Departamento recién agregado no exista ya. Obtendrá una idea de esto una vez que llegue a ver las Entidades de Dominio.

Para demostrar el uso de Dapper, Entity Framework Core y ambos combinados, los implementaremos en los 3 puntos finales. Para GetAll Endpoints, usaremos Dapper. GetById Endpoint usaría Entity Framework Core con Eager Loading para mostrar los detalles del departamento también. Y, por último, POST Endpoint aprovecharía estas increíbles tecnologías de acceso a datos y demostraría limpiamente las transacciones en ASP.NET Core.

En el camino, conoceremos algunas bibliotecas para ASP.NET Core que probablemente también podrían ahorrarle algo de tiempo de desarrollo.

Aspecto Importante a Manejar – Transacciones

Ahora, de acuerdo con nuestros requisitos, necesitamos que tanto Entity Framework Core como Dapper trabajen juntos. Esto es bastante fácil de lograr en realidad. Pero el detalle importante a tener en cuenta es que debemos asegurarnos de que tanto Entity Framework Core como Dapper participen en la misma transacción de base de datos para que el proceso general pueda ser sólido.

Por ejemplo, una operación de escritura en particular puede involucrar varias entidades y tablas. Esto, a su vez, puede tener operaciones que Entity Framework Core puede manejar fácilmente y, digamos, un montón de consultas complejas que Dapper debe ejecutar. En tales casos, debemos asegurarnos de que sea posible revertir la operación de ejecución de SQL cuando falla cualquier operación/consulta. ¿Tiene sentido? Este es el aspecto que puede introducir una pequeña complejidad en el diseño de nuestro sistema.

Si no estamos considerando esto, el proceso general sería muy sencillo. Déjame poner la idea en pasos.
1. Configure Entity Framework Core.
2. Configure Dapper. Puede lograr esto utilizando la misma cadena de conexión que también utiliza EFCore. (Obviamente, desde appsettings.json)
3. Registre los servicios en el Contenedor y comience a usar Context / Dapper según sea necesario.

Pero buscaremos un mecanismo más complejo y preparado para el futuro que manejará realmente todo, incluidas las reversiones y las transacciones. ¿Consíguelo?

Uso de Entity Framework Core y Dapper en ASP.NET Core

Configuración de la solución y los proyectos

Seguiremos una Arquitectura Cebolla como de costumbre para formar una clara separación de preocupaciones. En primer lugar, abra Visual Studio 2019 y cree una nueva solución en blanco. Aquí agregaremos 4 nuevos proyectos, a saber, dominio, persistencia y WebApi. El dominio y los proyectos de persistencia son una biblioteca de clases de .NET Core, mientras que WebApi es una aplicación web ASP.NET Core 3.1 con la plantilla de API seleccionada.

El Proyecto de Dominio consistirá únicamente en las Entidades e Interfaces de Dominio Principales. La Capa de Persistencia debe tener la Implementación de las Interfaces, Servicios y todo lo relacionado con Entity Framework Core y Dapper. Finalmente, el proyecto WebApi tendría los puntos finales de la API.

Tenga en cuenta que esta es una implementación mínima de Onion / Hexagonal Architecture. Para obtener un tutorial mucho más detallado sobre la arquitectura, consulte este artículo: Arquitectura de cebolla en ASP.NET Core con CQRS: detallada

Sobre la base de los detalles que aprendió del artículo mencionado anteriormente, aquí hay una implementación completa de Clean Architecture en ASP.NET Core WebAPI disponible como una plantilla repetitiva para que pueda comenzar en poco tiempo: ASP.NET Core WebAPI – Clean Architecture ( Proyecto de código abierto)

Ahora, comencemos a instalar todos los paquetes necesarios para cada proyecto.

Paquetes para Proyecto de Dominio

Está bastante claro que Domain Project NUNCA debe depender de nada más. Pero dado que estamos combinando la capa de Dominio y Aplicación en una sola entidad, y para simplificar las cosas, instalemos estos 2 paquetes en el Proyecto de Dominio.

Install-Package Microsoft.EntityFrameworkCore

Paquetes para el proyecto de persistencia

Como se mencionó anteriormente, todo lo relacionado con la Infraestructura / Persistencia de la Solución se colocará en este Proyecto. Continúe e instale los siguientes paquetes en el Proyecto Persistencia.

Install-Package Dapper
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Relational
Install-Package System.Data.SqlClient

Paquetes para el Proyecto WebApi

Finalmente, agregue estos paquetes al Proyecto WebAPI.

Install-Package Microsoft.EntityFrameworkCore.Tools

Agregar las entidades de dominio

Navegue al Proyecto de Dominio y cree una nueva Carpeta de Entidades y agregue estas 2 clases, Empleado y Departamento.

namespace Domain.Entities
{
public class Department
{
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
}
}
using AspNetCoreHero.Abstractions;
namespace Domain.Entities
{
public class Employee : BaseEntity
{
public int Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
public int DepartmentId { get; set; }
public Department Department { get; set; }
}
}

Diseño de las interfaces

Nuevamente, dentro del Proyecto de Dominio agregue otra carpeta, Interfaces. Aquí estamos utilizando el concepto de Inversión de Dependencia, de modo que el sistema no se preocupa por la implementación y solo se encarga de proporcionar el Contrato en lo que realmente quiere. Con este enfoque, es más fácil diseñar sistemas limpios y simples que también son ideales para las pruebas. De esta manera, el núcleo de la solución no depende de nada como Entity Framework o Dapper, sino que también nos facilita cambiar a diferentes tecnologías.

Agreguemos nuestra primera interfaz, IApplicationDbContext.cs, que está destinada a implementarse en la capa de persistencia mediante Entity Framework Core.

public interface IApplicationDbContext
{
public IDbConnection Connection { get; }
DatabaseFacade Database { get; }
public DbSet<Employee> Employees { get; set; }
public DbSet<Department> Departments { get; set; }
Task<int> SaveChangesAsync(CancellationToken cancellationToken);
}

Aquí puede ver que estamos usando 2 nuevas propiedades, IDbConnection y DbFacade. Este es solo un acceso directo a la base de datos que Dapper utilizará más adelante. ¿Recuerdas que hablamos sobre hacer que EFCore y Dapper funcionen juntos?

A continuación, agreguemos 2 interfaces más que están diseñadas específicamente para lectura y escritura. La interfaz de lectura tendrá los contratos para ejecutar consultas únicamente en la base de datos. mientras que la interfaz de escritura será un paquete completo.

Tenga en cuenta que también estamos usando IDbTransaction, que será útil cuando comencemos a tratar con transacciones más adelante en este artículo.

public interface IApplicationReadDbConnection
{
Task<IReadOnlyList<T>> QueryAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default);
Task<T> QueryFirstOrDefaultAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default);
Task<T> QuerySingleAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default);
}
public interface IApplicationWriteDbConnection : IApplicationReadDbConnection
{
Task<int> ExecuteAsync(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default);
}

Eso es casi todo lo que necesitamos hacer con el Proyecto de Dominio. Comencemos las implementaciones ahora.

Configuración de EntityFrameworkCore

En el proyecto de persistencia, agreguemos un nuevo contexto de carpeta y agreguemos el archivo ApplicationDbContext.cs.

public class ApplicationDbContext : DbContext, IApplicationDbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
{
}
public DbSet<Employee> Employees { get; set; }
public DbSet<Department> Departments { get; set; }
public IDbConnection Connection => Database.GetDbConnection();
}

Puede ver que, en la Línea 8, estamos extrayendo el objeto Connection de la instancia de Entity Framework Core.

Para obtener más información sobre Entity Framework Core en detalle, consulte el siguiente artículo: Entity Framework Core en ASP.NET Core 3.1: Introducción

Configuración de Dapper

Ahora, en el proyecto Persistencia, agregue otra carpeta y asígnele el nombre Conexiones. Ambas son interfaces de lectura y escritura que se implementarán aquí. Agregue las siguientes clases.

public class ApplicationReadDbConnection : IApplicationReadDbConnection, IDisposable
{
private readonly IDbConnection connection;
public ApplicationReadDbConnection(IConfiguration configuration)
{
connection = new SqlConnection(configuration.GetConnectionString("DefaultConnection"));
}
public async Task<IReadOnlyList<T>> QueryAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return (await connection.QueryAsync<T>(sql, param, transaction)).AsList();
}
public async Task<T> QueryFirstOrDefaultAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return await connection.QueryFirstOrDefaultAsync<T>(sql, param, transaction);
}
public async Task<T> QuerySingleAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return await connection.QuerySingleAsync<T>(sql, param, transaction);
}
public void Dispose()
{
connection.Dispose();
}
}

Asegúrese de implementar también la interfaz IDisposible.

En el constructor, puede ver que estamos inicializando una nueva conexión utilizando la cadena de conexión de nuestro appSettings.json. Tenga en cuenta que en esta implementación, no hay ningún vínculo con ningún objeto DBContext (Entity Framework Core) porque realmente no tiene sentido compartir las conexiones entre Entity Framework Core y Dapper cuando lee los datos.

El caso de uso de compartir la conexión entra en escena cuando hay escritura de datos involucrada. Veamos cómo se implementa.

public class ApplicationWriteDbConnection : IApplicationWriteDbConnection
{
private readonly IApplicationDbContext context;
public ApplicationWriteDbConnection(IApplicationDbContext context)
{
this.context = context;
}
public async Task<int> ExecuteAsync(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return await context.Connection.ExecuteAsync(sql, param, transaction);
}
public async Task<IReadOnlyList<T>> QueryAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return (await context.Connection.QueryAsync<T>(sql, param, transaction)).AsList();
}
public async Task<T> QueryFirstOrDefaultAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return await context.Connection.QueryFirstOrDefaultAsync<T>(sql, param, transaction);
}
public async Task<T> QuerySingleAsync<T>(string sql, object param = null, IDbTransaction transaction = null, CancellationToken cancellationToken = default)
{
return await context.Connection.QuerySingleAsync<T>(sql, param, transaction);
}
}

En la escritura implementada, realmente tenemos una implementación completa de Connection con funcionalidades de lectura y escritura. También podría evitar la funcionalidad de lectura. Pero depende de tu preferencia.

Puede ver que estamos inyectando el IApplicationDbContext que pertenece a Entity Framework en el Constructor. Así es como podemos compartir la conexión y la transacción. Usando la conexión del contexto, realizamos las operaciones de lectura y escritura usando Dapper. Muy bien, ¿sí?

En la implementación de lectura, estábamos trabajando directamente con el objeto IDbConnection que inicializamos en el constructor usando la cadena de conexión. Mientras que, aquí en la implementación de escritura, estamos reutilizando el objeto de contexto para ejecutar consultas y comandos con la ayuda de Dapper.

Para obtener información detallada sobre Dapper, consulte el siguiente artículo: Dapper en ASP.NET Core con patrón de repositorio: detallado

Agregar la cadena de conexión

Abra su appsettings.json y agregue su cadena de conexión.

"ConnectionStrings": {
"DefaultConnection": "Data Source=LAPTOP-7CS9KHVQ;Initial Catalog=demoDb;Integrated Security=True;MultipleActiveResultSets=True"
},

Registro de los Servicios

Finalmente, registremos estas interfaces y clases en el contenedor de servicios de nuestra aplicación web ASP.NET Core. Abra su Startup.cs en el Proyecto WebAPI y modifique sus ConfigureServices de la siguiente manera.

public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options
.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))
);
services.AddScoped<IApplicationDbContext>(provider => provider.GetService<ApplicationDbContext>());
services.AddScoped<IApplicationWriteDbConnection, ApplicationWriteDbConnection>();
services.AddScoped<IApplicationReadDbConnection, ApplicationReadDbConnection>();
services.AddControllers();
}

Agregar migraciones y actualizar la base de datos

Haga clic con el botón derecho en el Proyecto WebAPI y asegúrese de que esté configurado como el Proyecto de inicio de la solución. A continuación, abra la Consola del administrador de paquetes y configure el proyecto predeterminado en Infraestructura en el menú desplegable.

Ingrese lo siguiente para agregar las migraciones y actualizar la base de datos con las tablas de empleados y departamentos.

add-migration initial
update-database

Cableado con el controlador

Como nos hemos ocupado de todo el trabajo pesado, construyamos nuestro controlador con los 3 puntos finales mencionados. Agregue un nuevo controlador en la carpeta Controladores y asígnele el nombre Controlador de empleados.

Inyectemos las 3 interfaces que habíamos creado anteriormente en el Constructor del controlador. Idealmente, usaría una capa de servicio o un patrón CQRS para hacer esto. Pero nuevamente, para simplificar las cosas, declararemos las inyecciones aquí.

Si está interesado en obtener información sobre la implementación de CQRS en ASP.NET Core con la biblioteca MediatR, consulte este artículo detallado: CQRS con MediatR en ASP.NET Core 3.1: guía definitiva

public EmployeeController(IApplicationDbContext dbContext, IApplicationReadDbConnection readDbConnection, IApplicationWriteDbConnection writeDbConnection)
{
_dbContext = dbContext;
_readDbConnection = readDbConnection;
_writeDbConnection = writeDbConnection;
}
public IApplicationDbContext _dbContext { get; }
public IApplicationReadDbConnection _readDbConnection { get; }
public IApplicationWriteDbConnection _writeDbConnection { get; }

Comencemos con los puntos finales según nuestros requisitos.

Obtener todos los empleados

El primero es un punto final simple que devolverá todos los empleados disponibles de la base de datos. Usaremos Dapper para esto, por lo tanto, haremos uso de _readDbConnection, ¿tiene sentido?

[HttpGet]
public async Task<IActionResult> GetAllEmployees()
{
var query = $"SELECT * FROM Employees";
var employees = await _readDbConnection.QueryAsync<Employee>(query);
return Ok(employees);
}

Antes de ejecutar, permítanme agregar algunos datos ficticios a nuestras tablas.

Una vez que se agreguen los datos, ejecutemos nuestra aplicación y abra POSTMAN . Envíe una solicitud GET al extremo de API/empleado. Esto devolvería la lista de empleados disponibles de la base de datos. Recuerda que esto es de Dapper. El tiempo de ejecución de la consulta siempre pretende ser mucho mejor que otros ORM. Pero el punto principal a tener en cuenta es que dapper idealmente devuelve los datos a un nivel plano. No es lo suficientemente potente como para llenar los objetos anidados secundarios. Puede ver que el Departamento es NULL.

Dicho esto, aún puede lograr esto con Dapper pero agregando mucho más código del que idealmente haría, probablemente mediante múltiples consultas. Este es el margen donde debe elegir entre Dapper y Entity Framework Core. EFCore, por otro lado, puede lograr esto sin ningún código adicional. Lo veremos en el próximo Endpoint.

dapper getAll Usando Entity Framework Core y Dapper en ASP.NET Core - Transacciones seguras

Obtener empleado por ID

Agreguemos un punto final que pueda devolver un empleado en función de la identificación. Haremos uso del objeto _dbContext para este punto final. También presentamos Eager Loading by Entity Framework Core que puede completar el objeto secundario anidado con facilidad.

[HttpGet("{id}")]
public async Task<IActionResult> GetAllEmployeesById(int id)
{
var employees = await _dbContext.Employees.Include(a => a.Department).Where(a => a.Id == id).ToListAsync();
return Ok(employees);
}

efcore getById usando Entity Framework Core y Dapper en ASP.NET Core - Transacciones seguras

Ahora puede ver que también estamos obteniendo los detalles del Departamento.

Crear empleado y departamento de una sola vez

Finalmente, trabajemos en un punto final un poco más complejo. Aquí está el algoritmo formulado según el requisito.

  1. Aceptar una Clase DTO que contenga datos del Nuevo Empleado y el Nuevo Departamento como parámetros
  2. Asegúrese de estar utilizando la misma transacción y Dapper/Entity Framework Core
  3. Compruebe si el nombre del Departamento ya existe. Lanzar una excepción si el departamento existe.
  4. Inserte los detalles del departamento en la tabla de departamentos.
  5. Devolver el ID del Departamento
  6. Inserte los detalles del empleado en la tabla Empleados junto con la identificación del departamento generado.
  7. Devuelva la identificación del empleado y confirme la transacción
  8. Si alguna de las operaciones anteriores falla o arroja excepciones, revierta la transacción y asegúrese de que la base de datos no se vea afectada.

Así que ese es el requisito en detalle. Agreguemos las clases DTO. En el proyecto WebAPI, agregue una nueva carpeta, DTO y agregue las siguientes clases.

public class DepartmentDto
{
[Required]
public string Name { get; set; }
public string Description { get; set; }
}
public class EmployeeDto
{
[Required]
public string Name { get; set; }
[Required]
public string Email { get; set; }
[Required]
public DepartmentDto Department { get; set; }
}
Next, in the Employee Controller add in the following.
[HttpPost]
public async Task<IActionResult> AddNewEmployeeWithDepartment(EmployeeDto employeeDto)
{
_dbContext.Connection.Open();
using (var transaction = _dbContext.Connection.BeginTransaction())
{
try
{
_dbContext.Database.UseTransaction(transaction as DbTransaction);
//Check if Department Exists (By Name)
bool DepartmentExists = await _dbContext.Departments.AnyAsync(a => a.Name == employeeDto.Department.Name);
if(DepartmentExists)
{
throw new Exception("Department Already Exists");
}
//Add Department
var addDepartmentQuery = $"INSERT INTO Departments(Name,Description) VALUES('{employeeDto.Department.Name}','{employeeDto.Department.Description}');SELECT CAST(SCOPE_IDENTITY() as int)";
var departmentId = await _writeDbConnection.QuerySingleAsync<int>(addDepartmentQuery, transaction: transaction);
//Check if Department Id is not Zero.
if(departmentId == 0)
{
throw new Exception("Department Id");
}
//Add Employee
var employee = new Employee
{
DepartmentId = departmentId,
Name = employeeDto.Name,
Email = employeeDto.Email
};
await _dbContext.Employees.AddAsync(employee);
await _dbContext.SaveChangesAsync(default);
//Commmit
transaction.Commit();
//Return EmployeeId
return Ok(employee.Id);
}
catch (Exception)
{
transaction.Rollback();
throw;
}
finally
{
_dbContext.Connection.Close();
}
}
}

Así que la idea es simple. Abra una conexión, cree un objeto de transacción. Use esta transacción en Entity framework core and dapper. Si alguna operación falla, revierta las transacciones para asegurarse de que no haya datos defectuosos. Si no hay excepciones, confirme la transacción y finalmente cierre la conexión.

Línea 4: abre la conexión.
Línea 5: crea / inicia la transacción a través del objeto _dbContext.
Línea 9: asigne este objeto de transacción a la base de datos.
Línea 11: compruebe si existe el departamento ingresado.

Línea 18: ejecute una consulta de inserción utilizando _writeDbConnection (Dapper) y devuelva la identificación agregada. Tenga en cuenta que aquí también estamos usando el objeto de transacción.

Línea 25: ahora que tenemos una identificación de departamento válida, creemos un objeto Empleado y complételo con los datos requeridos.
Línea 31: agrega el objeto a la instancia de dbContext.
Línea 32 – Finalmente guarda los cambios.
Línea 34 – Confirmar la transacción. Una vez que el control llega a esta línea, significa que no se encontraron excepciones y es seguro realizar la transacción.
Línea 36- Devuelve el ID de empleado recién generado.

Línea 40: si hubiera una excepción, todos los cambios en la base de datos se revertirían para mantener los datos limpios. Este es el uso real de las transacciones.
Línea 45 – Finalmente cierra las conexiones.

Con la explicación clara, veamos el código en acción. La siguiente será mi solicitud en POSTMAN al punto final POST del controlador de empleados.

{
"name": "Mukesh Murugan",
"email": "mukesh@google.es",
"department": {
"name" : "Development",
"description" : "Development department"
}
}

Ahora, ya sabemos que el Departamento con el Nombre Desarrollo no existe en la base de datos. Enviemos la solicitud.

transacciones POST usando Entity Framework Core y Dapper en ASP.NET Core - Transacciones seguras

Puede ver que la operación se completó y devuelve la identificación del empleado recién agregado. Verifiquemos nuestro punto final GetById usando esta ID.

transacción agregada Usando Entity Framework Core y Dapper en ASP.NET Core - Transacciones seguras

Puede ver que el registro se crea tanto en la tabla de Empleado como en la de Departamento, según lo necesitábamos. Así de fácil es usar Entity Framework Core y Dapper en la misma aplicación ASP.NET Core dentro de la misma transacción.

Ahora, ¿qué sucede cuando enviamos la solicitud POST nuevamente con el mismo cuerpo de solicitud?

Transacciones Error al usar Entity Framework Core y Dapper en ASP.NET Core - Transacciones seguras

PD: es posible que vea un mensaje diferente en POSTMAN, ya que estaba usando un paquete diferente mientras desarrollaba.

Eso es un final para este artículo. Espero que haya aclarado muchas dudas y abierto un enfoque poderoso para el uso de Entity Framework Core y Dapper en ASP.NET Core que se ocupa de las transacciones.

Resumen

En este artículo detallado, aprendimos sobre un enfoque realmente simple y poderoso para aprovechar los dos ORM más poderosos para ASP.NET Core, que son Entity Framework Core y Dapper. Además, hablamos sobre Transacciones y creamos una aplicación que puede hacer uso de ambos ORM teniendo en cuenta las transacciones. Como resultado, tenemos una aplicación que es lo suficientemente inteligente como para deshacer los cambios si ocurre alguna excepción en el proceso.

Puede encontrar el código fuente completo de la implementación aquí.

Deje sus valiosas consultas y sugerencias en la sección de comentarios a continuación. Además, si crees que aprendiste algo nuevo de este artículo, no olvides compartirlo con tu comunidad de desarrolladores. ¡Feliz codificación!

Fuente: https://codewithmukesh.com/blog/using-entity-framework-core-and-dapper/

   #entityframework 

What is GEEK

Buddha Community

Uso de Entity Framework Core y Dapper en ASP.NET Core
Einar  Hintz

Einar Hintz

1602560783

jQuery Ajax CRUD in ASP.NET Core MVC with Modal Popup

In this article, we’ll discuss how to use jQuery Ajax for ASP.NET Core MVC CRUD Operations using Bootstrap Modal. With jQuery Ajax, we can make HTTP request to controller action methods without reloading the entire page, like a single page application.

To demonstrate CRUD operations – insert, update, delete and retrieve, the project will be dealing with details of a normal bank transaction. GitHub repository for this demo project : https://bit.ly/33KTJAu.

Sub-topics discussed :

  • Form design for insert and update operation.
  • Display forms in modal popup dialog.
  • Form post using jQuery Ajax.
  • Implement MVC CRUD operations with jQuery Ajax.
  • Loading spinner in .NET Core MVC.
  • Prevent direct access to MVC action method.

Create ASP.NET Core MVC Project

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N).

From new project window, Select Asp.Net Core Web Application_._

Image showing how to create ASP.NET Core Web API project in Visual Studio.

Once you provide the project name and location. Select Web Application(Model-View-Controller) and uncheck HTTPS Configuration. Above steps will create a brand new ASP.NET Core MVC project.

Showing project template selection for .NET Core MVC.

Setup a Database

Let’s create a database for this application using Entity Framework Core. For that we’ve to install corresponding NuGet Packages. Right click on project from solution explorer, select Manage NuGet Packages_,_ From browse tab, install following 3 packages.

Showing list of NuGet Packages for Entity Framework Core

Now let’s define DB model class file – /Models/TransactionModel.cs.

public class TransactionModel
{
    [Key]
    public int TransactionId { get; set; }

    [Column(TypeName ="nvarchar(12)")]
    [DisplayName("Account Number")]
    [Required(ErrorMessage ="This Field is required.")]
    [MaxLength(12,ErrorMessage ="Maximum 12 characters only")]
    public string AccountNumber { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Beneficiary Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BeneficiaryName { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Bank Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BankName { get; set; }

    [Column(TypeName ="nvarchar(11)")]
    [DisplayName("SWIFT Code")]
    [Required(ErrorMessage = "This Field is required.")]
    [MaxLength(11)]
    public string SWIFTCode { get; set; }

    [DisplayName("Amount")]
    [Required(ErrorMessage = "This Field is required.")]
    public int Amount { get; set; }

    [DisplayFormat(DataFormatString = "{0:MM/dd/yyyy}")]
    public DateTime Date { get; set; }
}

C#Copy

Here we’ve defined model properties for the transaction with proper validation. Now let’s define  DbContextclass for EF Core.

#asp.net core article #asp.net core #add loading spinner in asp.net core #asp.net core crud without reloading #asp.net core jquery ajax form #asp.net core modal dialog #asp.net core mvc crud using jquery ajax #asp.net core mvc with jquery and ajax #asp.net core popup window #bootstrap modal popup in asp.net core mvc. bootstrap modal popup in asp.net core #delete and viewall in asp.net core #jquery ajax - insert #jquery ajax form post #modal popup dialog in asp.net core #no direct access action method #update #validation in modal popup

Hertha  Mayer

Hertha Mayer

1602668764

Announcing Entity Framework Core (EF Core) 5 RC2

Today, the Entity Framework Core team announces the second release candidate (RC2) of EF Core 5.0. This is a feature complete release candidate of EF Core 5.0 and ships with a “go live” license. You are supported using it in production. This is a great opportunity to start using EF Core 5.0 early while there is still time to fix remaining issues. We’re looking for reports of any remaining critical bugs that should be fixed before the final release.

Prerequisites

EF Core 5.0 will not run on .NET Standard 2.0 platforms, including .NET Framework.

How to get EF Core 5.0 Release Candidate 2

EF Core is distributed exclusively as a set of NuGet packages. For example, to add the SQL Server provider to your project, you can use the following command using the dotnet tool:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 5.0.0-rc.2.20475.6

#.net #.net core #.net framework #asp.net #c# #entity framework #announcement #asp.net core #entity framework core

Einar  Hintz

Einar Hintz

1602564619

MVC User Registration & Login with ASP.NET Core Identity

User registration and authentication are mandatory in any application when you have little concern about privacy. Hence all most all application development starts with an authentication module. In this article, we will discuss the quickest way to use **ASP.NET Core Identity for User Login and Registration **in a new or existing MVC application.

Sub-topics discussed :

  • How to add ASP.NET Core Identity to MVC application.
  • Customize ASP.NET Core Identity.
  • Identity.UI Design Customization.
  • Next step.

Background

ASP.NET Core Identity is an API, which provides both user interface(UI) and functions for user authentication, registration, authorization, etc. Modules/ APIs like this will really be helpful and fasten the development process. It comes with ASP.NET Core Framework and used in many applications before. Which makes the API more dependable and trustworthy.

ASP.NET Core MVC with user authentication can easily be accomplished using Identity.UI. While creating the MVC project, you just need to select Authentication as Individual User Accounts.

Showing how to create an MVC application with ASP.NET Core Identity API

The rest will be handled by ASP.NET Core Identity UI. It already contains razor view pages and backend codes for an authentication system. But that’s not what we want in most of the cases. we want to customize ASP.NET Core Identity as per our requirement. That’s what we do here.

Create an ASP.NET Core MVC Project

First of all, I will create a brand new ASP.NET Core MVC application without any authentication selected. We could add ASP.NET Core Identity later into the project.

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N). From new project window, select ASP.NET Core Web Application.

Create an ASP.NET Core Web application

Once you provide the project name and location. A new window will be opened as follows, Select _Web Application(Model-View-Controller), _uncheck _HTTPS Configuration _and DO NOT select any authentication method. Above steps will create a brand new ASP.NET Core MVC project.

Select Model View Controller templet under .NET Core

#asp.net core article #asp.net core #add asp.net core identity to existing project #asp.net core identity in mvc #asp.net core mvc login and registration #login and logout in asp.net core

Delete role in asp net core identity framework

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework

AllowAnonymous in asp.net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework