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

阿新 • • 發佈：2020-07-22

一、為什麼使用倉儲模式

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

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

第一步：先把類庫建立好

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

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

一、為什麼使用倉儲模式

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

Autofac-.net core控制檯使用依賴注入【轉】

.Net Core WebApi檔案配置內容（轉）

.Net Core之選項模式Options使用

ASP.NET Core 6.0 中使用 Autofac

【.Net Core從零開始前後端分離】（四）——倉儲+服務+抽象介面模式

.Net Core 倉儲模式建立Vue 走馬燈

abp(net core)+easyui+efcore實現倉儲管理系統——ABP WebAPI與EasyUI結合增刪改查之九(三十五)

C# Net Core 使用 itextsharp.lgplv2.core 把Html轉PDF

詳解如何在C#/.NET Core中使用責任鏈模式

1個檔案如何輕鬆搞定Asp.net core 3.1動態頁面轉靜態頁面

NET CORE WebAPI 搭建--基礎搭建

如何使用.NET Core 選項模式【Options】

搭建一套ASP.NET Core+Nacos+Spring Cloud Gateway專案

ASP.Net Core 3.1 With Autofac ConfigureServices returning an System.IServiceProvider isn't supported.

.NET Core 使用RabbitMQ(轉)

在虛擬機器安裝Linux+Linux環境搭建Redis+.net core 3.1 使用Redis

.NET Core + K8S + Loki 玩轉日誌聚合

使用 autofac 實現 asp .net core 的屬性注入

.net core 中的經典設計模式的應用

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

一、為什麼使用倉儲模式

相關推薦

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