C#使用SqlSugarClient进行数据访问并实现了统一的批量依赖注入(示例代码)

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" });
        }
    }
}