如何使用ISqlSugarClient進行資料訪問，並實現了統一的批次依賴注入

倉儲層當前有介面 IRepository<T> 抽象類 BaseRepository<T> 業務邏輯層有抽象類 BaseBusiness<M, E> 介面 IBusiness<M, E>，其中使用ISqlSugarClient，其中還有E表示 BaseEntity，M為 BaseDto 請用C# 給出一個案例，支援不同表對應不同的業務邏輯層，然後不同倉儲例項，不同表的業務，都實現統一的批次依賴注入。

以下是一個更新後的C#示例，演示瞭如何使用ISqlSugarClient進行資料訪問，並實現了統一的批次依賴注入：

using System;
using System.Collections.Generic;
using SqlSugar;

// 實體類
public class BaseEntity
{
    [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
    public int Id { get; set; }
    // 其他實體屬性...
}

public class ProductEntity : BaseEntity
{
    public string Name { get; set; }
    // 其他產品實體屬性...
}

public class CustomerEntity : BaseEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    // 其他客戶實體屬性...
}

// 資料傳輸物件（DTO）
public class BaseDto
{
    // 公共DTO屬性...
}

public class ProductDto : BaseDto
{
    public string Name { get; set; }
    // 其他產品DTO屬性...
}

public class CustomerDto : BaseDto
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    // 其他客戶DTO屬性...
}

// 倉儲層
public interface IRepository<T>
{
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
    T GetById(int id);
    // 其他倉儲操作方法...
}

public abstract class BaseRepository<T> : IRepository<T> where T : BaseEntity
{
    protected readonly ISqlSugarClient _db;

    public BaseRepository(ISqlSugarClient db)
    {
        _db = db;
    }

    public void Add(T entity)
    {
        _db.Insertable(entity).ExecuteCommand();
    }

    public void Update(T entity)
    {
        _db.Updateable(entity).ExecuteCommand();
    }

    public void Delete(T entity)
    {
        _db.Deleteable<T>().In(entity.Id).ExecuteCommand();
    }

    public T GetById(int id)
    {
        return _db.Queryable<T>().InSingle(id);
    }

    // 其他倉儲操作方法的實現...
}

// 業務邏輯層
public interface IBusiness<M, E> where M : BaseDto where E : BaseEntity
{
    void Process(M model);
    // 其他業務邏輯方法...
}

public abstract class BaseBusiness<M, E> : IBusiness<M, E> where M : BaseDto where E : BaseEntity
{
    protected readonly IRepository<E> _repository;

    public BaseBusiness(IRepository<E> repository)
    {
        _repository = repository;
    }

    public abstract void Process(M model);
    // 其他業務邏輯方法...
}

// 具體業務邏輯類
public class ProductBusiness : BaseBusiness<ProductDto, ProductEntity>
{
    public ProductBusiness(IRepository<ProductEntity> repository) : base(repository)
    {
    }

    public override void Process(ProductDto model)
    {
        // 實現產品業務邏輯
        Console.WriteLine("Processing product: " + model.Name);
    }
}

public class CustomerBusiness : BaseBusiness<CustomerDto, CustomerEntity>
{
    public CustomerBusiness(IRepository<CustomerEntity> repository) : base(repository)
    {
    }

    public override void Process(CustomerDto model)
    {
        // 實現客戶業務邏輯
        Console.WriteLine("Processing customer: " + model.FirstName + " " + model.LastName);
    }
}

// 批次依賴注入容器
public class DependencyInjector
{
    private readonly ISqlSugarClient _db;

    public DependencyInjector(ISqlSugarClient db)
    {
        _db = db;
    }

    public IEnumerable<BaseBusiness<M, E>> ResolveBusinesses<M, E>() where M : BaseDto where E : BaseEntity
    {
        var repositoryType = typeof(IRepository<E>);
        var businessType = typeof(IBusiness<M, E>);

        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
        var businessTypes = new List<Type>();

        foreach (var assembly in assemblies)
        {
            var types = assembly.GetTypes();
            foreach (var type in types)
            {
                if (type.BaseType != null && type.BaseType.IsGenericType)
                {
                    var baseType = type.BaseType.GetGenericTypeDefinition();
                    if (baseType == businessType)
                    {
                        businessTypes.Add(type);
                    }
                }
            }
        }

        foreach (var businessTypeItem in businessTypes)
        {
            var repositoryGenericType = repositoryType.MakeGenericType(businessTypeItem.GetGenericArguments());
            var repository = Activator.CreateInstance(repositoryGenericType, _db);
            var business = Activator.CreateInstance(businessTypeItem, repository);

            yield return (BaseBusiness<M, E>)business;
        }
    }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        // 模擬ISqlSugarClient的例項
        var db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "YourConnectionString",
            DbType = DbType.SqlServer,
            IsAutoCloseConnection = true,
        });

        // 例項化依賴注入容器
        var injector = new DependencyInjector(db);

        // 解析並例項化業務邏輯類
        var businesses = injector.ResolveBusinesses<BaseDto, BaseEntity>();

        // 使用業務邏輯類進行操作
        foreach (var business in businesses)
        {
            // 處理業務邏輯
            business.Process(new ProductDto { Name = "Sample Product" });
            business.Process(new CustomerDto { FirstName = "John", LastName = "Doe" });
        }
    }
}

原創，轉載請說明出處。