顾 静

顾 静

1659364200

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper

在本文中,我们将了解如何在同一个应用程序中同时使用 ASP.NET Core 中的 Entity Framework Core 和 Dapper。另一个主要的讨论点是交易。在本文的最后,我们将拥有一个应用程序,它可以同时与 Entity Framework Core 和 Dapper 一起工作,而且还足够智能,可以在进程出现异常时回滚数据。

让我们开始吧!

Dapper 与实体框架核心

考虑到 Dapper 没有花里胡哨的事实,Dapper 实际上比 Entity Framework Core 快得多。它是一个简单的微型 ORM,也具有最少的功能。开发人员始终可以在这两种出色的数据访问技术之间进行选择。这并不意味着 Entity Framework Core 更慢。随着每次更新,性能似乎也在提高。对于那些仍然喜欢使用 RAW 查询而不是使用 EFCore 的 LINQ 的人来说,Dapper 是天堂。

现在,Entity Framework Core 包含大量功能以及性能改进。所以这个问题是,为什么在 Dapper 和 Entity Framework Core 之间进行选择,当你可以同时使用两者并充分利用时,是吗?

Dapper 在处理包含多个连接和一些真正长业务逻辑的复杂查询方面非常棒。Entity Framework Core 非常适合类生成、对象跟踪、映射到多个嵌套类等等。因此,在谈论这两个 ORM 时,通常是性能和功能。

要求

我们将为一家虚构公司设计一个简单的 ASP.NET Core WebAPI。这家公司的政策规定,所有其他员工都必须与一个独特的部门相关联。更清楚地说,每次通过 API 端点添加新员工时,您还必须创建新的部门记录。一个非常虚构的要求,是吗?除此之外,我们还有 2 个其他端点,它们按 ID 返回所有员工和员工。

扩展细节,我们必须确保新添加的部门不存在。一旦您看到域实体,您就会掌握这一点。

为了演示 Dapper、Entity Framework Core 以及两者结合的用法,我们将在 3 个端点中分别实现它们。对于 GetAll Endpoints,我们将使用 Dapper。GetById 端点也将使用带有 Eager Loading 的 Entity Framework Core 来显示部门详细信息。最后,POST 端点将利用这些出色的数据访问技术和 ASP.NET Core 中的清晰演示事务。

在此过程中,我们将介绍一些用于 ASP.NET Core 的库,它们可能也可以为您节省一些开发时间。

需要处理的重要方面——交易

现在,根据我们的要求,我们需要 Entity Framework Core 和 Dapper 一起工作。这实际上很容易实现。但是需要注意的重要细节是,我们需要确保 Entity Framework Core 和 Dapper 都应该参与同一个 DB Transaction,以便整个过程能够健壮。

例如,特定的写入操作可能涉及多个实体和表。反过来,这可以具有易于由 Entity Framework Core 处理的操作,比方说一堆复杂的查询,这些查询旨在由 Dapper 执行。在这种情况下,我们必须确保当任何操作/查询失败时应该可以回滚 SQL Execute 操作。说得通?这是可以给我们的系统设计带来一点复杂性的方面。

如果我们不考虑这一点,整个过程将如此简单。让我把这个想法分成几个步骤。
1. 配置实体框架核心。
2. 配置小巧玲珑。您也可以使用 EFCore 使用的相同连接字符串来实现此目的。(显然,来自 appsettings.json)
3. 将服务注册到 Container 中,并根据需要开始使用 Context / Dapper。

但我们将寻求一种更复杂且面向未来的机制,该机制将处理包括回滚和事务在内的所有事情。得到它?

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper

设置解决方案和项目

我们将像往常一样遵循洋葱架构以形成清晰的关注点分离。首先,打开 Visual Studio 2019 并创建一个新的空白解决方案。在这里,我们将添加 4 个新项目,即 Domain、Persistence 和 WebApi。域和持久性项目是 .NET Core 类库,而 WebApi 是选择了 API 模板的 ASP.NET Core 3.1 Web 应用程序。

域项目将仅包含核心域实体和接口。持久层应该具有接口、服务以及与 Entity Framework Core 和 Dapper 相关的所有内容的实现。最后,WebApi 项目将具有 API 端点。

请注意,这是洋葱/六边形架构的一个非常小的实现。有关架构的更详细教程,请参阅这篇文章 - ASP.NET Core 中的洋葱架构与 CQRS - 详细

基于您从上述文章中了解到的详细信息,这里是 ASP.NET Core WebAPI 中 Clean Architecture 的完整实现,可作为样板模板提供,让您立即开始 - ASP.NET Core WebAPI - Clean Architecture (开源项目)

现在,让我们开始为每个项目安装所有必需的包。

领域项目包

很明显,域项目永远不应该依赖其他任何东西。但是由于我们将域和应用层合并为一个实体,并且为了简单起见,让我们将这两个包安装到域项目中。

Install-Package Microsoft.EntityFrameworkCore

持久性项目包

如前所述,与解决方案的基础架构/持久性相关的所有内容都将放在此项目中。继续并将以下软件包安装到持久性项目中。

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

WebApi 项目的包

最后,将这些包添加到 WebAPI 项目中。

Install-Package Microsoft.EntityFrameworkCore.Tools

添加域实体

导航到域项目并创建一个新的文件夹实体并将这两个类添加到它,员工和部门。

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; }
}
}

设计接口

同样,在域项目中添加另一个文件夹 Interfaces。这里使用了依赖倒置的概念,这样系统不关心实现,只负责提供它真正想要的合约。使用这种方法,可以更轻松地设计出非常适合测试的干净简单的系统。通过这种方式,解决方案的核心不依赖于实体框架或 Dapper 之类的任何东西,而是让我们也可以轻松切换到不同的技术。

让我们添加我们的第一个接口 IApplicationDbContext.cs,它旨在使用 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);
}

在这里,您可以看到我们使用了 2 个新属性 IDbConnection 和 DbFacade 。这只是对 Dapper 稍后将使用的数据库的直接访问。还记得,我们说过要让 EFCore 和 Dapper 一起工作吗?

接下来,让我们再添加 2 个专门用于读取和写入的接口。读取接口将具有仅对数据库运行查询的合同。而写接口将是完整的封装。

请注意,我们还使用了 IDbTransaction,当我们在本文后面开始处理事务时,它会派上用场。

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);
}

这几乎就是我们需要对域项目做的所有事情。让我们现在开始实施。

设置 EntityFrameworkCore

在 Persistence Project 中,让我们添加一个新的文件夹上下文,并添加到 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();
}

您可以看到,在第 8 行,我们正在从 Entity Framework Core 实例中提取 Connection 对象。

详细了解Entity Framework Core,请参考以下文章——ASP.NET Core 3.1 中的Entity Framework Core——入门

设置 Dapper

现在,在 Persistence 项目中添加另一个文件夹并将其命名为 Connections。两者都是 Read 和 Write 接口将在此处实现。添加以下类。

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();
}
}

确保您也实现了 IDisposible 接口。

在构造函数中,您可以看到我们正在使用 appSettings.json 中的连接字符串初始化一个新连接。请注意,在此实现中,没有与任何 DBContext 对象(Entity Framework Core)的链接,因为在读取数据时共享 Entity Framework Core 和 Dapper 之间的连接确实没有意义。

当涉及数据写入时,共享连接的用例就出现了。让我们看看它是如何实现的。

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);
}
}

在实现的写入中,我们确实有一个完整的连接实现,具有读取和写入功能。您也可以避免读取功能。但这取决于您的喜好。

您可以看到我们正在将属于实体框架的 IApplicationDbContext 注入到构造函数中。这就是我们可以共享连接和事务的方式。使用上下文的连接,我们使用 Dapper 执行读写操作。很酷,是吗?

在 Read 实现中,我们直接使用我们在构造函数中使用连接字符串初始化的 IDbConnection 对象。同时,在 Write 实现中,我们在 Dapper 的帮助下重新使用上下文对象来执行查询和命令。

详细了解Dapper,请参考以下文章- ASP.NET Core 中的Dapper with Repository Pattern - 详解

添加连接字符串

打开你的 appsettings.json 并添加你的连接字符串。

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

注册服务

最后,让我们将这些接口和类注册到我们的 ASP.NET Core Web 应用程序的服务容器中。在 WebAPI 项目中打开您的 Startup.cs 并按如下方式修改您的 ConfigureServices。

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();
}

添加迁移和更新数据库

右键单击 WebAPI 项目并确保将其设置为解决方案的启动项目。接下来打开包管理器控制台并从下拉菜单中将默认项目设置为基础设施。

输入以下内容以添加迁移并使用员工和部门表更新数据库。

add-migration initial
update-database

与控制器接线

由于我们已经处理了所有繁重的工作,让我们使用提到的 3 个端点构建我们的控制器。在 Controllers 文件夹下添加一个新的 Controller 并将其命名为 Employee Controller。

让我们将之前创建的所有 3 个接口注入到 Controller 的构造函数中。理想情况下,您将使用服务层或 CQRS 模式来执行此操作。但同样,为了简单起见,我们将在这里声明注入。

如果您有兴趣了解使用 MediatR 库在 ASP.NET Core 中实现 CQRS,请参阅这篇详细的文章 – CQRS with MediatR in ASP.NET Core 3.1 – Ultimate Guide

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; }

让我们根据我们的要求开始使用端点。

获取所有员工

首先是一个简单的端点,它将从数据库中返回所有可用的 Employee。我们将为此使用 Dapper,因此我们将使用 _readDbConnection,有意义吗?

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

在执行之前,让我在我们的表中添加一些虚拟数据。

添加数据后,让我们运行我们的应用程序并打开POSTMAN。向 api/employee 端点发送 GET 请求。这将从数据库中返回可用员工的列表。请记住,这是由 Dapper 编写的。查询执行时间总是比其他 ORM 好得多。但要注意的主要一点是,dapper 理想地以平坦的水平返回数据。它不足以填充子嵌套对象。可以看到 Department 为 NULL。

话虽这么说,你仍然可以通过 Dapper 来实现这一点,但是通过添加比理想情况更多的代码,可能是通过多个查询。这是您必须在 Dapper 和 Entity Framework Core 之间进行选择的边距。另一方面,EFCore 可以在没有额外代码的情况下实现这一目标。我们将在下一个 Endpoint 中看到它。

dapper getAll 在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper - 安全事务

按 ID 获取员工

让我们添加一个可以根据 Id 返回 Employee 的端点。我们将为此端点使用 _dbContext 对象。我们还引入了 Entity Framework Core 的 Eager Loading,它可以轻松填充嵌套的子对象。

[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 在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper - 安全事务

现在您可以看到我们也在获取部门详细信息。

一次性创建员工和部门

最后,让我们处理一个更复杂的端点。这是根据要求制定的算法。

  1. 接受包含新员工和新部门数据作为参数的 DTO 类
  2. 确保您使用的是相同的事务和 Dapper / Entity Framework Core
  3. 检查部门名称是否已存在。如果部门存在则抛出异常。
  4. 将部门详细信息插入部门表。
  5. 返回部门 ID
  6. 将员工详细信息与生成的部门 ID 一起插入到员工表中。
  7. 返回员工 ID 并提交交易
  8. 如果上述任何操作失败或抛出异常,则回滚事务并确保数据库不受影响。

所以这就是详细的要求。让我们添加 DTO 类。在 WebAPI 项目中添加一个新文件夹 DTO 并添加以下类。

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();
}
}
}

所以这个想法很简单。打开一个连接,创建一个事务对象。跨实体框架核心和 dapper 使用此事务。如果任何操作失败,则回滚事务以确保没有错误数据。如果没有异常,提交事务,最后关闭连接。

第 4 行 – 打开连接
第 5 行 – 通过 _dbContext 对象创建/启动事务。
第 9 行 – 将此事务对象分配给数据库。
第 11 行 - 检查输入的部门是否存在。

第 18 行 – 使用 _writeDbConnection (Dapper) 执行插入查询并返回添加的 Id。请注意,我们也在此处使用事务对象。

第 25 行——现在我们有了一个有效的部门 ID,让我们创建一个 Employee 对象并用所需的数据填充它。
第 31 行 - 将对象添加到 dbContext 实例。
第 32 行 - 最后保存更改。
第 34 行——提交事务。一旦控件到达这一行,就意味着我们没有遇到异常并且可以安全地提交事务。
第 36 行 - 返回新生成的员工 ID。

第 40 行——如果出现异常,所有数据库更改都将回滚以保持数据干净。这是事务的实际使用。
第 45 行——最后关闭连接。

解释清楚后,让我们实际看看代码在运行中。以下将是我对 POSTMAN 对员工控制器 POST 端点的请求。

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

现在,我们已经知道数据库中不存在名称为Development 的Department。让我们发送请求。

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper 进行事务 POST - 安全事务

可以看到操作完成,返回新添加员工的ID。让我们使用这个 ID 检查我们的 GetById 端点。

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper 添加事务 - 安全事务

您可以看到记录是根据我们的需要在 Employee 和 Department 表中创建的。这就是在同一个事务中的同一个 ASP.NET Core 应用程序中使用 Entity Framework Core 和 Dapper 是多么容易。

现在,当我们使用相同的请求正文再次发送 POST 请求时会发生什么?

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper 时出现事务错误 - 安全事务

PS,您可能会在 POSTMAN 中看到不同的消息,因为我在开发时使用了不同的包。

这是本文的总结。我希望它消除了很多疑虑,并开辟了一种在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper 来处理事务的强大方法。

概括

在这篇详细的文章中,我们了解了一种非常简单而强大的方法来利用 ASP.NET Core 的两个最强大的 ORM,即 Entity Framework Core 和 Dapper。此外,我们讨论了事务并构建了一个应用程序,该应用程序可以利用两个 ORM 来记住事务。因此,我们有一个足够智能的应用程序,可以在过程中发生任何异常时回滚更改。

您可以在此处找到实现的完整源代码。

在下面的评论部分留下您宝贵的疑问和建议。此外,如果您认为您从本文中学到了一些新东西,请不要忘记在您的开发人员社区中分享。快乐编码!

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

   #entityframework 

What is GEEK

Buddha Community

在 ASP.NET Core 中使用 Entity Framework Core 和 Dapper
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