.Net core 搭建倉儲模式+SqlsugarORM+AutoFac(轉)

本文轉載自查看原文 2020-07-22 10:12 601 .net core

一、為什么使用倉儲模式

個人覺得倉儲模式就是升級版的三層架構，里面多了接口之間的調用，就好像倉庫管理員，只是負責把倉庫里面的東西交給客戶，也無需知道客戶要做什么，反之客戶也無需知道東西在哪里，怎么存放的，需要的時候就跟管理員索要就可以了，這樣就是低耦合，就算管理員換人了，客戶的流程也無需做出改變，反之亦然。

實際做一遍就一目了然了。

第一步：先把類庫創建好

Common類庫，公共類庫，放一些公共的類和方法，比如，Helper類字符串轉換，編碼格式這些。

IRepositry、Repository倉儲層，負責處理數據就是ADO。net那套東西。

IService、Service 業務服務層，三層架構的BLL。

Model 存放實體類

倉儲層，創建ITestRepository和TestRepository，這里我們先不連接數據庫，下面講到ORM的時候在連庫。

然后在服務層，創建ITestService和TestService類

代碼如下，最好不要復制粘貼，自己一個一個創建，這樣能更好的了解，哪個類庫是做什么的，要怎么做

using System;

namespace WebApi.Core.IRepository
{
    public interface ITestRepository
    {
        /// <summary>
        /// 求和，這里就是定義一下具體實現在 TestRepository
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        int Sum(int i, int j);
    }
}



using System;
using WebApi.Core.IRepository;

namespace WebApi.Core.Repository
{
    /// <summary>
    /// 倉儲具體實現類，繼承倉儲接口類
    /// </summary>
    public class TestRepository:ITestRepository
    {
        /// <summary>
        /// 求和，倉儲實現，這個過程就是訪問數據庫得到數據，並且返回
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public int Sum(int i, int j)
        {
            return i + j;
        }
    }
}



using System;

namespace WebApi.Core.IService
{
    /// <summary>
    /// 業務服務接口層
    /// </summary>
    public interface ITestService
    {
        /// <summary>
        /// 求和聲明
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        int SumService(int i, int j);
    }
}


using System;
using WebApi.Core.IRepository;
using WebApi.Core.IService;
using WebApi.Core.Repository;

namespace WebApi.Core.Service
{
    public class TestService:ITestService
    {
        //這里如果要用到倉儲，需要先創建對象，就好像要知道管理員是誰，這個先這么寫，后期改成AutoFac的
        ITestRepository test = new TestRepository();
        /// <summary>
        /// 求和，調用倉儲的求和方法，把參數傳遞給倉儲
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public int SumService(int i, int j)
        {
            return test.Sum(i,j);
        }
    }
}

好了一個簡單的倉儲模式算是搭建完成了，接下來我們測試一下，創建一個Controller名字隨便取，在里面添加如下代碼

 /// <summary>
        /// 測試倉儲模式，求和表示層
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        [HttpPost]
        public int SumService(int i, int j)
        {
            //引用service層
            ITestService testService = new TestService();
            return testService.SumService(i,j);
        }

F5啟動一下，我們測試一下，從測試結果看，是沒有任何問題的

接下來，我們在倉儲模式下增加IOC，上面寫的時候會發現一些new 實體的代碼，這樣的耦合性就很強了，所以需要使用IOC模式來處理這種耦合，這里我們用.net架構比較常用的Autofac

Nuget包引入兩個 Autofac.Extras.DynamicProxy、Autofac.Extensions.DependencyInjection

新建一個類來存放Autofac注冊Module，如下代碼

using Autofac;
using Autofac.Extras.DynamicProxy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

namespace WebApi.Core.Api.SetUpService
{
    /// <summary>
    /// Autofac注冊服務類
    /// </summary>
    public class AutofacModuleRegister:Autofac.Module
    {
        /// <summary>
        /// 重寫Load函數
        /// </summary>
        /// <param name="builder"></param>
        protected override void Load(ContainerBuilder builder)
        {
            //注冊Service
            var assemblysServices = Assembly.Load("Webapi.Core.Service");
            builder.RegisterAssemblyTypes(assemblysServices) 
                .InstancePerDependency()//默認模式，每次調用，都會重新實例化對象；每次請求都創建一個新的對象
               .AsImplementedInterfaces()//是以接口方式進行注入,注入這些類的所有的公共接口作為服務（除了釋放資源）
               .EnableInterfaceInterceptors(); //引用Autofac.Extras.DynamicProxy;應用攔截器

            //注冊Repository
            var assemblysRepository = Assembly.Load("Webapi.Core.Repository");
            builder.RegisterAssemblyTypes(assemblysRepository)
                .InstancePerDependency()//默認模式，每次調用，都會重新實例化對象；每次請求都創建一個新的對象
               .AsImplementedInterfaces()//是以接口方式進行注入,注入這些類的所有的公共接口作為服務（除了釋放資源）
               .EnableInterfaceInterceptors(); //引用Autofac.Extras.DynamicProxy;應用攔截器
        }
    }
}

在startup.cs文件中，增加一個方法，用來配置Autofac服務容器，在Configure方法下面，新建如下代碼

/// <summary>
        /// 注冊Autofac容器
        /// </summary>
        /// <param name="builder"></param>
        public void ConfigureContainer(ContainerBuilder builder)
        {
            builder.RegisterModule(new AutofacModuleRegister());
        }

在program.cs 文件中初始化一下實例代碼如下

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseServiceProviderFactory(new AutofacServiceProviderFactory()) //這里是替換容器的，微軟默認的注入方式是DI，替換成autofac實例
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

到此我們的注冊就算完成了，接下來我們使用一下，如下圖，我們上面練習倉儲的時候，new 了一個倉儲的實例，現在我們來改變一下

改成如下代碼

 public class TestService:ITestService
    {
        //這里如果要用到倉儲，需要先創建對象，就好像要知道管理員是誰，這個先這么寫，后期改成AutoFac的
        //ITestRepository test = new TestRepository();
        //改造成Autofac注入方式，聲明一個倉儲常量
        private readonly ITestRepository test;
        //構造函數注入
        public TestService(ITestRepository testRepository)
        {
            test = testRepository;
        }

        /// <summary>
        /// 求和，調用倉儲的求和方法，把參數傳遞給倉儲
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        public int SumService(int i, int j)
        {
            return test.Sum(i,j);
        }
    }

testController這里也有一個new 也需要變化一下

改成如下代碼

 /// <summary>
    /// 測試倉儲模式控件
    /// </summary>
    public class TestRepositoryController : BaseController
    {
        //聲明一個常量
        private readonly ITestService testService;
        //構造函數注入 service
        public TestRepositoryController(ITestService testS)
        {
            testService = testS;
        }

        /// <summary>
        /// 測試倉儲模式，求和表示層
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        [HttpPost]
        public int SumService(int i, int j)
        {
            return testService.SumService(i,j);
        }
    }

接下來我們F5啟動項目，測試一下，注入是否已完成，是否會報錯。從結果上看木有問題啊，哎真希望報錯，踩踩坑啊。這也太順利了

還有一個問題，就是如果一個接口被好多服務繼承了，依賴注入會怎么處理，會注入哪個服務呢？我們來測試一下

首先在ITestService 里面在添加一個方法

/// <summary>
        /// 返回支付類型
        /// </summary>
        /// <returns></returns>
        string payType();

然后在創建一個服務來繼承ITestService接口

using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IService;

namespace WebApi.Core.Service
{
    public class TestPayService:ITestService
    {

　　　　/// <summary>
　　　　/// 測試一個接口多個實例下的依賴注入
　　　　/// </summary>
　　　　/// <returns></returns>

public string payType()

        {
            return "微信";
        }

        public int SumService(int i, int j)
        {
            return 1;
        }
    }
}

在TestService也要加一個方法

/// <summary>
        /// 測試一個接口多個實例下的依賴注入
        /// </summary>
        /// <returns></returns>
        public string payType()
        {
            return "支付寶";
        }

在TestRepositoryController 下添加一個接口

/// <summary>
        /// 測試一個接口多個實例下的依賴注入
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string payType()
        {
            return testService.payType();
        }

按F5我們看一下結果，可以看到返回的始終是支付寶，不管調用多少次，如果我想要微信怎么辦呢，或者兩個都顯示。

其實很簡單的，需要在startup.cs 的ConfigureServices 加一段代碼

public void ConfigureServices(IServiceCollection services)
        {
            //注冊AppSettings讀取類
            services.AddSingleton(new AppSettings(Configuration));

            //注冊Swagger服務
            services.AddSwaggerSetup();

            //jwt授權驗證
            services.AddAuthorizationJwtSetUp();

            services.AddControllers();
            //同一個接口兩個實現，依賴注入
            services.AddTransient<ITestService, TestPayService>();
            services.AddTransient<ITestService, TestService>();
        }

然后在TestRepositoryController的構造函數修改一下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using WebApi.Core.IService;
using WebApi.Core.Service;

namespace WebApi.Core.Api.Controllers
{
    /// <summary>
    /// 測試倉儲模式控件
    /// </summary>
    public class TestRepositoryController : BaseController
    {
        //聲明一個常量
        private readonly ITestService testService;
        private readonly ITestService testPayService;
        //構造函數注入 service 這里使用的就是一對多注入
        public TestRepositoryController(IEnumerable<ITestService> testS)
        {
            testService = testS.FirstOrDefault(x => x.GetType().Name == "TestService");
            testPayService = testS.FirstOrDefault(x=>x.GetType().Name == "TestPayService");
        }

        /// <summary>
        /// 測試倉儲模式，求和表示層
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        /// <returns></returns>
        [HttpPost]
        public int SumService(int i, int j)
        {
            return testService.SumService(i,j);
        }
        /// <summary>
        /// 測試一個接口多個實例下的依賴注入
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string payType()
        {
            return testService.payType()+";"+testPayService.payType();
        }
    }
}

然后我們運行F5看一下結果，是沒問題的，當然這種寫法，會根據業務需求來定，我個人覺得不會經常出現，如果遇到了會用就行。

還有一個屬性注入，但是.NET如果需要用屬性注入的話，屬性就需要public暴露出去，所以推薦使用構造函數注入。

下面我們繼續 Sqlsugar + 改造一下倉儲，變成異步的。我們這邊用的數據是oracle，首先創建一個表名字隨便起一個

我們在Repository 和 model層中引入 Nuget包 sqlSugarCore

然后修改一下UserModel 代碼如下

using SqlSugar;
using System;

namespace WebApi.Core.Model
{
    /// <summary>
    /// 用戶實體類 注意這個SugarTable要改成你自己的表名字不然會報錯哦
    /// </summary>
    [SugarTable("testcoreuser")]
    public class UsersModel
    {
        /// <summary>
        /// id
        /// </summary>
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
        public int UserId { get; set; }
        /// <summary>
        /// 姓名
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 年齡
        /// </summary>
        public int? Age { get; set; }
    }
}

我們在Repository層中新建一個DbContext類，和BaseDBConfig 類

代碼如下

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using WebApi.Core.Model;

namespace WebApi.Core.Repository.SqlSugar
{

public class DbContext<T> where T : class, new()
{
    public DbContext()
    {
        Db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = BaseDBConfig.ConnectionString,
            DbType = DbType.SqlServer,
            InitKeyType = InitKeyType.Attribute,//從特性讀取主鍵和自增列信息
            IsAutoCloseConnection = true,//開啟自動釋放模式

        });
        //調式代碼 用來打印SQL 
        Db.Aop.OnLogExecuting = (sql, pars) =>
        {
            Console.WriteLine(sql + "\r\n" +
                Db.Utilities.SerializeObject(pars.ToDictionary(it => it.ParameterName, it => it.Value)));
            Console.WriteLine();
        };

    }
    //注意：不能寫成靜態的
    public SqlSugarClient Db;//用來處理事務多表查詢和復雜的操作
    public SimpleClient<T> CurrentDb { get { return new SimpleClient<T>(Db); } }//用來操作當前表的數據

    public SimpleClient<UsersModel> UserDb { get { return new SimpleClient<UsersModel>(Db); } }//用來處理User表的常用操作

}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace WebApi.Core.Repository.SqlSugar
{
    public class BaseDBConfig
    {
        /// <summary>
        /// 數據庫連接字符串oracle
        /// </summary>
        public static string ConnectionString { get; set; }
    }
}

然后在 startup.cs 的ConfigureServices() 方法中讀取 appsettings.json 配置的數據

接下來我們優化一下倉儲模式，先創建一個倉儲基類 IBaseRepository.cs

代碼如下

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

namespace WebApi.Core.IRepository.Base
{
    /// <summary>
    /// 基類接口,其他接口繼承該接口
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IBaseRepository<TEntity> where TEntity : class
    {
        /// <summary>
        /// 根據ID查詢
        /// </summary>
        /// <param name="objId"></param>
        /// <returns></returns>
        Task<TEntity> QueryByID(object objId);

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<bool> Add(TEntity model);

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<bool> Update(TEntity model);

        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        Task<bool> DeleteByIds(object[] ids);

    }
}

在創建IUserRepository 然后繼承IBaseRepository 代碼如下

using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IRepository.Base;
using WebApi.Core.Model;

namespace WebApi.Core.IRepository
{
    public interface IUserRepository:IBaseRepository<UsersModel>
    {
    }
}

同樣的操作，需要在Repository做一遍

創建一個BaseRepository和UserRepository代碼如下，異步的不要隨便加Task.Run（）會有意想不到的問題。會有一些人不知道where 后面是做什么的，其實就是對泛型的約束

class 是表示傳過來的必須是類，new（）表示類型參數必須有一個公有的,無參數的構造方法.當和別的約束一起使用的時候,new()約束必須放在最后

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using WebApi.Core.IRepository.Base;
using WebApi.Core.Repository.SqlSugar;

namespace WebApi.Core.Repository.Base
{
    /// <summary>
    /// 基類實現
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class BaseRepository<TEntity> : DbContext<TEntity>, IBaseRepository<TEntity> where TEntity : class, new()
    {
        /// <summary>
        /// 寫入實體數據
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> Add(TEntity model)
        {
            //這里需要注意的是，如果使用了Task.Run()就會導致 sql語句日志無法記錄改成下面的
            //var i = await Task.Run(() => Db.Insertable(model).ExecuteCommand());
            var i = await Db.Insertable(model).ExecuteCommandAsync();
            return i>0;
        }

        /// <summary>
        /// 根據ID刪除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task<bool> DeleteByIds(object[] ids)
        {
            var i = await Db.Deleteable<TEntity>().In(ids).ExecuteCommandAsync();
            return i > 0;
        }

        /// <summary>
        /// 根據ID查詢一條數據
        /// </summary>
        /// <param name="objId"></param>
        /// <returns></returns>
        public async Task<TEntity> QueryByID(object objId)
        {
            return await Db.Queryable<TEntity>().InSingleAsync(objId);
        }

        /// <summary>
        /// 更新實體數據
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity model)
        {
            //這種方式會以主鍵為條件
            var i = await Db.Updateable(model).ExecuteCommandAsync();
            return i > 0;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IRepository;
using WebApi.Core.Model;
using WebApi.Core.Repository.Base;

namespace WebApi.Core.Repository
{
    public class UserRepository:BaseRepository<UsersModel>,IUserRepository
    {

    }
}

倉儲層都有了基類，那么service怎么可以沒有呢，跟倉儲差不多

4個類的代碼就全部放在一個里面了，如果要復制，別全部復制，要分批，還是不建議復制粘貼

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

namespace WebApi.Core.IService.Base
{
    public interface IBaseService<TEntity> where TEntity:class
    {
        /// <summary>
        /// 根據ID列表刪除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        Task<bool> DeleteByIds(object[] ids);

        /// <summary>
        /// 根據ID查詢
        /// </summary>
        /// <param name="objId"></param>
        /// <returns></returns>
        Task<TEntity> QueryByID(object objId);

        /// <summary>
        /// 添加實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<bool> Add(TEntity model);

        /// <summary>
        /// 更新實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>

        Task<bool> Update(TEntity model);
    }
}



using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using WebApi.Core.IRepository.Base;
using WebApi.Core.IService.Base;
using WebApi.Core.Repository.Base;

namespace WebApi.Core.Service.Base
{
    /// <summary>
    /// 服務基類
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class BaseService<TEntity> : IBaseService<TEntity> where TEntity : class, new()
    {

　　　　　　private readonly IBaseRepository<TEntity> baseDal;

　　　　　　//這里使用依賴注入

　　　　　　public BaseService(IBaseRepository<TEntity> baseRepository)
　　　　　　{
　　　　　　　　baseDal = baseRepository;
　　　　　　}

/// <summary>
        /// 寫入實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> Add(TEntity model)
        {
            return await baseDal.Add(model);
        }

        /// <summary>
        /// 根據ID刪除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>

        public async Task<bool> DeleteByIds(object[] ids)
        {
            return await baseDal.DeleteByIds(ids);
        }

        /// <summary>
        /// 根據ID查詢
        /// </summary>
        /// <param name="objId"></param>
        /// <returns></returns>
        public async Task<TEntity> QueryByID(object objId)
        {
            return await baseDal.QueryByID(objId);
        }

        /// <summary>
        /// 更新實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity model)
        {
            return await baseDal.Update(model);
        }
    }
}



using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IService.Base;
using WebApi.Core.Model;

namespace WebApi.Core.IService
{
    public interface IUserService:IBaseService<UsersModel>
    {

    }
}




using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IService;
using WebApi.Core.Model;
using WebApi.Core.Service.Base;

namespace WebApi.Core.Service
{
    public class UserService:BaseService<UsersModel>,IUserService
    {
　　　　　//這里我們要把實參傳到baseService 不然會報錯

　　　　　　public UserService(IBaseRepository<UsersModel> baseRepository):base(baseRepository)
　　　　　　{

　　　　　　}

}
}

接下來我們測試一下，新增一個UserTest控制器代碼如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WebApi.Core.IService;
using WebApi.Core.Model;

namespace WebApi.Core.Api.Controllers
{
    /// <summary>
    /// 用戶表測試ORMSqlSuggr
    /// </summary>
    public class UserORMController : BaseController
    {
        //聲明一個常量
        private readonly IUserService userService;
        /// <summary>
        /// 通過構造函數依賴注入
        /// </summary>
        /// <param></param>
        public UserORMController(IUserService userSer)
        {
            userService = userSer;
        }

        /// <summary>
        /// 根據id獲取數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> GetUser(int id)
        {
            UsersModel user = await userService.QueryByID(id);
            return Ok(user);
        }


        /// <summary>
        /// 添加數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Add(UsersModel user)
        {
            var count = await userService.Add(user);
            return Ok(count);
        }

        /// <summary>
        /// 更新數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Update(UsersModel user)
        {
            var sucess = await userService.Update(user);
            return Ok(sucess);
        }

        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Delete(object[] ids)
        {
            var sucess = await userService.DeleteByIds(ids);
            return Ok(sucess);
        }
    }
}

終於完工了，我們來F5運行看一下，數據已經有了，剩下的各位可以試一下，建議可以自己試着改一下看看各種效果

刪除可以批量傳入ID

可以看到 sql語句也打印出來了，是在DBContext 里面使用 Db.Aop.OnLogExecuting 這句話是 sql執行同時記錄

接下來我們把SqlSugar下的常用查詢方法試一下（有太多了，需要用到的在去搜索一下就可以，萬變不離其宗，就是lambda表達式和一些內置函數的支持，跳轉到源碼估計也就是ADO.net那些東西）

在倉儲層增加一個方法，IUserRepository和UserRepository ，服務層 IUserService 和UserService 也需要添加，然后在Controller中添加一個接口調用

這里也是把東西放在一起了，其中UserRepository重點看一下

using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IRepository.Base;
using WebApi.Core.Model;

namespace WebApi.Core.IRepository
{
    public interface IUserRepository:IBaseRepository<UsersModel>
    {
        /// <summary>
        /// 測試sqlSugar 常用語句
        /// </summary>
        void testSqlSugar();
    }
}


using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IRepository;
using WebApi.Core.Model;
using WebApi.Core.Repository.Base;

namespace WebApi.Core.Repository
{
    public class UserRepository:BaseRepository<UsersModel>,IUserRepository
    {
        /// <summary>
        /// 測試sqlSugar 常用語句
        /// </summary>
        public void testSqlSugar()
        {
            //查詢一個集合
            List<UsersModel> list = Db.Queryable<UsersModel>().ToList();
            //把list轉換成json串打印輸出
            Console.WriteLine(JsonConvert.SerializeObject(list));
            //打印集合的數量
            Console.WriteLine(list.Count);
            //直接查詢並轉換成json 跟上面的輸出結果一樣，沒有任何區別
            var testJson = Db.Queryable<UsersModel>().ToJson();
            Console.WriteLine(testJson);
            //根據條件查詢單條數據
            UsersModel usermodel = Db.Queryable<UsersModel>().Single(t=>t.Age==30);
            //判斷不為空，打印其中一個字段值
            Console.WriteLine(usermodel?.UserName +"----------");
            //根據主鍵查詢單條數據
            usermodel = Db.Queryable<UsersModel>().InSingle(1);
            //判斷不為空，打印其中一個字段值
            Console.WriteLine(usermodel?.UserName + "----------");
            //查詢姓名為張三的第一條記錄
            usermodel = Db.Queryable<UsersModel>().Where(t => t.UserName == "張三").First();
            Console.WriteLine(usermodel?.UserName + "----------");
            //判斷數據是否存在
            bool exists = Db.Queryable<UsersModel>().Any(t=>t.UserName=="小蘭");
            Console.WriteLine(exists.ToString());
            //模糊查詢
            testJson = Db.Queryable<UsersModel>().Where(t => t.UserName.Contains("李")).ToJson();
            Console.WriteLine(testJson);
            //以xx結尾 或開始
            testJson = Db.Queryable<UsersModel>().Where(t => t.UserName.EndsWith("三") || t.UserName.StartsWith("李")).ToJson();
            Console.WriteLine(testJson);
        }
    }
}



using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IService.Base;
using WebApi.Core.Model;

namespace WebApi.Core.IService
{
    public interface IUserService:IBaseService<UsersModel>
    {
        /// <summary>
        /// 測試sqlSugar 常用語句
        /// </summary>
        void testSqlSugar();
    }
}



using System;
using System.Collections.Generic;
using System.Text;
using WebApi.Core.IRepository;
using WebApi.Core.IRepository.Base;
using WebApi.Core.IService;
using WebApi.Core.Model;
using WebApi.Core.Service.Base;

namespace WebApi.Core.Service
{
    public class UserService:BaseService<UsersModel>,IUserService
    {
        //聲明常量
        private readonly IUserRepository userService;
        public UserService(IBaseRepository<UsersModel> baseRepository, IUserRepository usersSer):base(baseRepository)
        {
            userService = usersSer;
        }
        /// <summary>
        /// 測試sqlSugar 常用語句
        /// </summary>
        public void testSqlSugar()
        {
            userService.testSqlSugar();
        }
    }
}




using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WebApi.Core.IService;
using WebApi.Core.Model;

namespace WebApi.Core.Api.Controllers
{
    /// <summary>
    /// 用戶表測試ORMSqlSuggr
    /// </summary>
    public class UserORMController : BaseController
    {
        //聲明一個常量
        private readonly IUserService userService;
        /// <summary>
        /// 通過構造函數依賴注入
        /// </summary>
        /// <param></param>
        public UserORMController(IUserService userSer)
        {
            userService = userSer;
        }

        /// <summary>
        /// 根據id獲取數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> GetUser(int id)
        {
            UsersModel user = await userService.QueryByID(id);
            return Ok(user);
        }


        /// <summary>
        /// 添加數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Add(UsersModel user)
        {
            var count = await userService.Add(user);
            return Ok(count);
        }

        /// <summary>
        /// 更新數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Update(UsersModel user)
        {
            var sucess = await userService.Update(user);
            return Ok(sucess);
        }

        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <param>參數id</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IActionResult> Delete(object[] ids)
        {
            var sucess = await userService.DeleteByIds(ids);
            return Ok(sucess);
        }
        /// <summary>
        /// 測試sqlSugar 常用語句
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult testSqlSugar()
        {
            userService.testSqlSugar();
            return Ok("true");
        }
    }
}

這里代碼問題解決后，F5啟動看看結果

運行沒問題，沒有報錯，然后我們看一下控制台輸出，可以看到輸出的sql語句和打印出的結果，這里可以跟代碼比對一下。也可以自己搜索一些分頁啊等等的，可以看一下結果

原文地址：https://www.cnblogs.com/xiaojinFat/p/13346380.html

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 .Net core 搭建倉儲模式+SqlsugarORM+AutoFac .Net Core3.0 WebApi 項目框架搭建五:倉儲模式 .Net Core之倉儲（Repository）模式（上） Asp.Net Core倉儲模式+工作單元 ASP.NET Core Autofac 泛型接口注入，實現自動化倉儲設計。 ASP.NET Core 2.2 WebApi 系列【三】AutoFac 倉儲接口的依賴注入【.Net Core從零開始前后端分離】（四）——倉儲+服務+抽象接口模式（五）React Ant Design Pro + .Net5 WebApi：后端環境搭建-Autofac注入+ 泛型倉儲 ASP.NET Core 2.2 WebApi 系列【六】泛型倉儲模式【從零開始搭建自己的.NET Core Api框架】（六）泛型倉儲的作用