ASP.Net Core基于EF6、Unitwork、Autofac实现Repository模式

下面是关于“ASP.Net Core基于EF6、Unitwork、Autofac实现Repository模式”的完整攻略，包含两个示例说明。

简介

Repository模式是一种常见的设计模式，用于将数据访问逻辑与业务逻辑分离。在本攻略中，我们将介绍如何在ASP.Net Core应用程序中使用EF6、Unitwork和Autofac实现Repository模式。

实现步骤

以下是在ASP.Net Core应用程序中使用EF6、Unitwork和Autofac实现Repository模式的步骤：

1. 安装NuGet包：

我们需要安装以下NuGet包：

• EntityFramework
• Autofac
• Autofac.Extensions.DependencyInjection

我们可以使用以下命令安装这些NuGet包：

dotnet add package EntityFramework
dotnet add package Autofac
dotnet add package Autofac.Extensions.DependencyInjection

1. 添加数据库上下文：

我们需要添加一个数据库上下文来处理数据访问。例如，我们可以创建一个名为MyDbContext的数据库上下文，并添加以下代码：

using System.Data.Entity;

namespace MyProject.Data
{
    public class MyDbContext : DbContext
    {
        public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
        {
        }

        public DbSet<User> Users { get; set; }
    }
}

在上面的代码中，我们创建了一个名为MyDbContext的数据库上下文，并定义了一个名为Users的DbSet属性。

1. 添加实体：

我们需要添加一个或多个实体来表示数据库中的表。例如，我们可以创建一个名为User的实体，并添加以下代码：

namespace MyProject.Data.Entities
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

在上面的代码中，我们创建了一个名为User的实体，并定义了Id、Name和Age属性。

1. 添加仓储接口：

我们需要添加一个仓储接口来定义数据访问方法。例如，我们可以创建一个名为IUserRepository的仓储接口，并添加以下代码：

using System.Collections.Generic;
using MyProject.Data.Entities;

namespace MyProject.Data.Repositories
{
    public interface IUserRepository
    {
        IEnumerable<User> GetAll();
        User GetById(int id);
        void Add(User user);
        void Update(User user);
        void Delete(User user);
    }
}

在上面的代码中，我们创建了一个名为IUserRepository的仓储接口，并定义了GetAll、GetById、Add、Update和Delete方法。

1. 添加仓储实现：

我们需要添加一个仓储实现来实现仓储接口中定义的方法。例如，我们可以创建一个名为UserRepository的仓储实现，并添加以下代码：

using System.Collections.Generic;
using System.Linq;
using MyProject.Data.Entities;

namespace MyProject.Data.Repositories
{
    public class UserRepository : IUserRepository
    {
        private readonly MyDbContext _dbContext;

        public UserRepository(MyDbContext dbContext)
        {
            _dbContext = dbContext;
        }

        public IEnumerable<User> GetAll()
        {
            return _dbContext.Users.ToList();
        }

        public User GetById(int id)
        {
            return _dbContext.Users.FirstOrDefault(u => u.Id == id);
        }

        public void Add(User user)
        {
            _dbContext.Users.Add(user);
            _dbContext.SaveChanges();
        }

        public void Update(User user)
        {
            _dbContext.Entry(user).State = EntityState.Modified;
            _dbContext.SaveChanges();
        }

        public void Delete(User user)
        {
            _dbContext.Users.Remove(user);
            _dbContext.SaveChanges();
        }
    }
}

在上面的代码中，我们创建了一个名为UserRepository的仓储实现，并实现了IUserRepository接口中定义的方法。

1. 添加Unitwork：

我们需要添加一个Unitwork来处理事务。例如，我们可以创建一个名为MyUnitwork的Unitwork，并添加以下代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MyProject.Data.Repositories;

namespace MyProject.Data.UnitOfWork
{
    public class MyUnitwork : IMyUnitwork
    {
        private readonly MyDbContext _dbContext;
        private readonly Dictionary<Type, object> _repositories = new Dictionary<Type, object>();

        public MyUnitwork(MyDbContext dbContext)
        {
            _dbContext = dbContext;
        }

        public IUserRepository UserRepository => GetRepository<IUserRepository>();

        public void SaveChanges()
        {
            _dbContext.SaveChanges();
        }

        public async Task SaveChangesAsync()
        {
            await _dbContext.SaveChangesAsync();
        }

        private TRepository GetRepository<TRepository>() where TRepository : class
        {
            if (_repositories.TryGetValue(typeof(TRepository), out var repository))
            {
                return (TRepository)repository;
            }

            var newRepository = Activator.CreateInstance(typeof(TRepository), _dbContext);

            _repositories.Add(typeof(TRepository), newRepository);

            return (TRepository)newRepository;
        }
    }
}

在上面的代码中，我们创建了一个名为MyUnitwork的Unitwork，并实现了IMyUnitwork接口中定义的方法。

1. 添加Autofac容器：

我们需要添加一个Autofac容器来管理依赖项。例如，我们可以创建一个名为MyContainer的Autofac容器，并添加以下代码：

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using MyProject.Data.Repositories;
using MyProject.Data.UnitOfWork;

namespace MyProject
{
    public class MyContainer
    {
        public static IContainer Build(IServiceCollection services)
        {
            var builder = new ContainerBuilder();

            builder.Populate(services);

            builder.RegisterType<UserRepository>().As<IUserRepository>();
            builder.RegisterType<MyUnitwork>().As<IMyUnitwork>();

            return builder.Build();
        }
    }
}

在上面的代码中，我们创建了一个名为MyContainer的Autofac容器，并注册了UserRepository和MyUnitwork。

1. 配置Autofac容器：

我们需要配置Autofac容器来替换默认的依赖项注入容器。例如，我们可以在Startup.cs文件中添加以下代码：

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using MyProject.Data;
using MyProject.Data.Repositories;
using MyProject.Data.UnitOfWork;

namespace MyProject
{
    public class Startup
    {
        private readonly IConfiguration _configuration;

        public Startup(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<MyDbContext>(options =>
            {
                options.UseSqlServer(_configuration.GetConnectionString("DefaultConnection"));
            });

            services.AddScoped<IUserRepository, UserRepository>();
            services.AddScoped<IMyUnitwork, MyUnitwork>();

            services.AddControllers();
        }

        public void ConfigureContainer(ContainerBuilder builder)
        {
            builder.RegisterModule(new AutofacModule());
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

在上面的代码中，我们配置了Autofac容器来替换默认的依赖项注入容器，并注册了UserRepository和MyUnitwork。

示例

示例1：使用仓储模式查询用户

在本示例中，我们将演示如何使用仓储模式查询用户。我们可以按照以下步骤来实现：

1. 注入仓储：

我们需要注入IUserRepository仓储。例如，我们可以在控制器的构造函数中注入IUserRepository仓储，并添加以下代码：

using Microsoft.AspNetCore.Mvc;
using MyProject.Data.Repositories;

namespace MyProject.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class UserController : ControllerBase
    {
        private readonly IUserRepository _userRepository;

        public UserController(IUserRepository userRepository)
        {
            _userRepository = userRepository;
        }

        [HttpGet("{id}")]
        public IActionResult GetById(int id)
        {
            var user = _userRepository.GetById(id);

            if (user == null)
            {
                return NotFound();
            }

            return Ok(user);
        }
    }
}

在上面的代码中，我们注入了IUserRepository仓储，并实现了GetById方法来查询用户。

1. 测试查询：

我们可以使用HTTP GET请求测试查询。例如，我们可以使用以下命令发送HTTP GET请求：

curl -X GET https://localhost:5001/user/1

在上面的命令中，我们发送了一个HTTP GET请求来查询ID为1的用户。

示例2：使用Unitwork模式添加用户

在本示例中，我们将演示如何使用Unitwork模式添加用户。我们可以按照以下步骤来实现：

1. 注入Unitwork：

我们需要注入IMyUnitwork Unitwork。例如，我们可以在控制器的构造函数中注入IMyUnitwork Unitwork，并添加以下代码：

using Microsoft.AspNetCore.Mvc;
using MyProject.Data.Entities;
using MyProject.Data.UnitOfWork;

namespace MyProject.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class UserController : ControllerBase
    {
        private readonly IMyUnitwork _unitwork;

        public UserController(IMyUnitwork unitwork)
        {
            _unitwork = unitwork;
        }

        [HttpPost]
        public IActionResult AddUser(User user)
        {
            _unitwork.UserRepository.Add(user);
            _unitwork.SaveChanges();

            return Ok();
        }
    }
}

在上面的代码中，我们注入了IMyUnitwork Unitwork，并实现了AddUser方法来添加用户。

1. 测试添加：

我们可以使用HTTP POST请求测试添加。例如，我们可以使用以下命令发送HTTP POST请求：

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","age":30}' https://localhost:5001/user

在上面的命令中，我们发送了一个HTTP POST请求来添加一个名为John Doe、年龄为30的用户。

在上面的示例中，我们演示了如何使用仓储模式和Unitwork模式来查询和添加用户。