.net Core EF 3.1 仓储模式架构搭建

什么是依赖注入，为什么要使用呢?简单通俗说就是一个类需要另一个类来协助工作，就产生了依赖，所以需要的依赖项就要【注入】过来一起来协同完成工作。

引入依赖注入的目的是为了解耦。说白了就是面向接口编程，通过调用接口的方法，而不直接实例化对象去调用。

一：创建一个 Asp.net Core Web ApI项目

添加领域层和实体层

在实体层配置数据库连接，反向工程，上结中有介绍

这个时候会报很多错误，是因为没有找到命名空间，在这里我们在实体层依赖

添加好之后，用实体层依赖领域模型

修改模板，修改成我们需要的模板

修改好后，重新编译一遍反向工程。

现在看着就精简很多了

配置连接数据库

"ConnectionStrings": {
  "DefaultConnection": "Data Source=.;Initial Catalog=Dispatch;Integrated Security=True"
}

            services.AddDbContext<DispatchContext>(budr =>
            budr.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

现在其实已经可以在接口中写构造函数，来处理数据了。

我们要搭建的是仓储模式，所有我们还需要包一层

在实体层添加BaseRepository 上下文

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
 
namespace SW163.EntityFrameworkCore
{
    public class BaseRepository<T> where T : class, new()
    {
        public DispatchContext db;
 
        /// <summary>
        /// 增(异步)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual async Task<T> AddAsync(T entity)
        {
            db.Set<T>().Add(entity);
            await db.SaveChangesAsync();
            return entity;
        }
 
        /// <summary>
        /// 增
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual T Add(T entity)
        {
            db.Set<T>().Add(entity);
            db.SaveChanges();
            return entity;
        }
 
        /// <summary>
        ///删除一条实体数据（异步）
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual async Task<bool> DelAsync(T entity)
        {
            db.Entry(entity).State = EntityState.Deleted;
            int i = await db.SaveChangesAsync();
            return i > 0;
        }
 
        /// <summary>
        /// 删除一条实体数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual bool Del(T entity)
        {
            db.Entry(entity).State = EntityState.Deleted;
            int i = db.SaveChanges();
            return i > 0;
        }
 
        /// <summary>
        /// 删除多条数据，根据传进来的id数据删除(异步)
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public virtual async Task<bool> DelByIdsAsync(params int[] ids)
        {
            foreach (int id in ids)
            {
                var entity = db.Set<T>().Find(id);//如果实体已经在内存中则直接从内存中拿，否则才查询数据库
                db.Set<T>().Remove(entity);
            }
            int i = await db.SaveChangesAsync();
            return i > 0;
        }
 
        /// <summary>
        /// 删除多条数据，根据传进来的id数据删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public virtual bool DelByIds(params int[] ids)
        {
            foreach (int id in ids)
            {
                var entity = db.Set<T>().Find(id);//如果实体已经在内存中则直接从内存中拿，否则才查询数据库
                db.Set<T>().Remove(entity);
            }
            int i = db.SaveChanges();
            return i > 0;
        }
 
        /// <summary>
        /// 改(异步)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual async Task<bool> EditAsync(T entity)
        {
            db.Entry(entity).State = EntityState.Modified;
            int i = await db.SaveChangesAsync();
            return i > 0;
        }
 
        /// <summary>
        /// 改
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual bool Edit(T entity)
        {
            db.Entry(entity).State = EntityState.Modified;
            int i = db.SaveChanges();
            return i > 0;
        }
 
 
 
 
 
 
 
        /// <summary>
        /// 查-获取单条数据(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public virtual async Task<T> GetEntityAsync(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda)
        {
            return await db.Set<T>().Where(whereLambda).FirstOrDefaultAsync();
        }
 
        /// <summary>
        /// 查-获取单条数据
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public virtual T GetEntity(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda)
        {
            return db.Set<T>().Where(whereLambda).FirstOrDefault();
        }
 
        /// <summary>
        /// 查-获取多条数据，返回list集合(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public virtual async Task<List<T>> GetListEntitiesAsync(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda)
        {
            return await db.Set<T>().Where(whereLambda).ToListAsync();
        }
 
 
 
 
        /// <summary>
        /// 查-获取多条数据，返回list集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public virtual List<T> GetListEntities(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda)
        {
            return db.Set<T>().Where(whereLambda).ToList();
        }
 
        /// <summary>
        /// 查询-分页(异步)
        /// </summary>
        /// <typeparam name="s"></typeparam>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageSize">每页多少条</param>
        /// <param name="whereLambda">过滤数据的Lambda表达式</param>
        /// <param name="orderbyLambda">按照哪个排序</param>
        /// <param name="isAsc">是否升序排序：true升序、false降序</param>
        /// <returns></returns>
        public async Task<List<T>> GetPageListAsync<s>(int pageIndex, int pageSize,
            System.Linq.Expressions.Expression<Func<T, bool>> whereLambda,
            System.Linq.Expressions.Expression<Func<T, s>> orderbyLambda, bool isAsc)
        {
            List<T> list = null;
            if (isAsc)//升序
            {
                list = await db.Set<T>().Where(whereLambda).OrderBy(orderbyLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
            }
            else//降序
            {
                list = await db.Set<T>().Where(whereLambda).OrderByDescending(orderbyLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
            }
            return list;
        }
 
        /// <summary>
        /// 查询-分页
        /// </summary>
        /// <typeparam name="s"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="whereLambda"></param>
        /// <param name="orderbyLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public List<T> GetPageList<s>(int pageIndex, int pageSize,
            System.Linq.Expressions.Expression<Func<T, bool>> whereLambda,
            System.Linq.Expressions.Expression<Func<T, s>> orderbyLambda, bool isAsc, out int totalCount)
        {
            List<T> list = null;
            totalCount = db.Set<T>().Where(whereLambda).Count();
            if (isAsc)//升序
            {
                list = db.Set<T>().Where(whereLambda).OrderBy(orderbyLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            else//降序
            {
                list = db.Set<T>().Where(whereLambda).OrderByDescending(orderbyLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            return list;
        }
 
        /// <summary>
        /// 获取总条数(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public async Task<int> GetTotalCountAsync(Expression<Func<T, bool>> whereLambda)
        {
            return await db.Set<T>().Where(whereLambda).CountAsync();
        }
 
 
 
    }
}

　　添加基础设施层：Infrastructure

领域层引用

在基础设施层添加基接口

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace SW163.Infrastructure
{
    /// <summary>
    /// 基接口，操作数据库常用方法：增 删 改 查 分页
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IRepository<T> where T : class, new()
    {
        /// <summary>
        /// 增(异步)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<T> AddAsync(T entity);

        /// <summary>
        /// 增
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        T Add(T entity);


        /// <summary>
        /// 删除一条数据(异步)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> DelAsync(T entity);

        /// <summary>
        /// 删
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        bool Del(T entity);

        /// <summary>
        /// 删除多条数据(异步)-根据传进来的id数据删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        Task<bool> DelByIdsAsync(params int[] ids);

        /// <summary>
        /// 删除多条数据-根据传进来的id数据删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        bool DelByIds(params int[] ids);

        /// <summary>
        /// 改(异步)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> EditAsync(T entity);

        /// <summary>
        /// 改
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        bool Edit(T entity);

        /// <summary>
        /// 查-获取单条数据(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        Task<T> GetEntityAsync(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda);

        /// <summary>
        /// 查-获取单条数据
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        T GetEntity(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda);

        /// <summary>
        /// 查-获取多条数据，返回list集合(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        Task<List<T>> GetListEntitiesAsync(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda);

        /// <summary>
        /// 查-获取多条数据，返回list集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        List<T> GetListEntities(System.Linq.Expressions.Expression<Func<T, bool>> whereLambda);

        /// <summary>
        /// 查询-分页(异步)
        /// </summary>
        /// <typeparam name="s">排序字段的类型</typeparam>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageSize">每页显示多少条</param>
        /// <param name="whereLambda">过滤条件lambda</param>
        /// <param name="orderbyLambda">排序字段</param>
        /// <param name="isAsc">是否升序 true升序 false降序</param>
        /// <returns></returns>
        Task<List<T>> GetPageListAsync<s>(int pageIndex, int pageSize, System.Linq.Expressions.Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, s>> orderbyLambda, bool isAsc);

        /// <summary>
        /// 查询-分页
        /// </summary>
        /// <typeparam name="s">排序字段的类型</typeparam>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageSize">每页显示多少条</param>
        /// <param name="whereLambda">过滤条件lambda</param>
        /// <param name="orderbyLambda">排序字段</param>
        /// <param name="isAsc">是否升序 true升序 false降序</param>
        /// <param name="totalCount">返回的总记录数</param>
        /// <returns>返回实体集合</returns>
        List<T> GetPageList<s>(int pageIndex, int pageSize, System.Linq.Expressions.Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, s>> orderbyLambda, bool isAsc, out int totalCount);

        /// <summary>
        /// 获取总记录数(异步)
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        Task<int> GetTotalCountAsync(Expression<Func<T, bool>> whereLambda);
    }
}

添加仓储和实现文件夹

using SW163.Infrastructure;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace SW163.Domain.IRepository
{
    public interface IAdministratorRepository : IRepository<Administrator>
    {
    }
}

using SW163.Domain;
using SW163.Domain.IRepository;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace SW163.EntityFrameworkCore.Repository
{
    public class AdministratorRepository : BaseRepository<Administrator>, IAdministratorRepository
    {
        /// <summary>
        /// 构造函数注入DispatchContext上下文
        /// </summary>
        /// <param name="dispatchContext"></param>
        public AdministratorRepository(DispatchContext dispatchContext)
        {
            db = dispatchContext;
        }
 
    }
}

　　如果每个仓储都需要注入services.AddScoped<IAdministratorRepository, AdministratorRepository>(); 那就太繁琐了，我们这使用批量注入 Autofac.Extensions.DependencyInjection

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using SW163.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace SW163.Web
{
    public class Program
    {
        public static void Main(string[] args) => CreateHostBuilder(args).Build().Run();

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(budr => budr.UseStartup<Startup>())
                .UseServiceProviderFactory(cntx => new AutofacServiceProviderFactory(budr => budr
                    .RegisterAssemblyTypes(typeof(DispatchContext).Assembly)
                    .AsImplementedInterfaces()
                    .InstancePerLifetimeScope()));
    }
}

添加一个接口，看看配置OK没

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using SW163.Domain.IRepository;
using SW163.EntityFrameworkCore;
using System.Threading.Tasks;

namespace SW163.Web.Controllers
{
    public class HomeController : ControllerBase
    {
        //ctor
        public HomeController(IAdministratorRepository administratorRepository)
        {
            AdministratorRepository = administratorRepository;
        }

        public IAdministratorRepository AdministratorRepository { get; }


        [HttpGet,Route("api/GetListEntity")]
        public async Task<ActionResult> GetListEntity() {
            var entity =await AdministratorRepository.GetListEntitiesAsync(it=>true);

            return Ok(entity);
        }
    }
}

数据是展示出来了，但接口不是特别美观，我们配置swwager中间件 Swashbuckle.AspNetCore

ConfigureServices：

services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My Repository API", Version = "v1" });
    #region 
    var basePath = PlatformServices.Default.Application.ApplicationBasePath;
    var xmlPath = Path.Combine(basePath, "WebApi.xml");
    c.IncludeXmlComments(xmlPath, true);
    #endregion
});

　　Configure：

app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My Repository API V1");
});

修改启动项：

运行效果

加油

posted @ 2023-03-23 16:42 蟾宝阅读(776) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 入坑.net core（三）.net core api 3.1 反向工程增删改查

· .net core 3.1仓储模式升.net core 6

· 乘风破浪，遇见最佳跨平台跨终端框架.Net Core/.Net生态 - 贯穿ASP.NET Core整个架构的依赖注入框架(Dependency Injection)

· NetCore+Dapper WebApi架构搭建（四）：仓储的依赖注入

· 全面理解 ASP.NET Core 依赖注入 (转载)

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称：蟾宝
园龄： 7年7个月
粉丝： 3
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

蟾宝

静心，悟心，用心，开心。

.net Core EF 3.1 仓储模式架构搭建

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论