اجرای الگوی مخزن با چارچوب Entity و Dapper در یک برنامه C#

public interface IRepository<T> where T : class  
{  
    Task AddAsync(T entity);  
    Task UpdateAsync(T entity);  
    Task DeleteAsync(T entity);  
    Task<T?> GetByIdAsync(int id);  
}  

public interface IReadRepository<T> where T : class  
{  
    Task<IEnumerable<T>> QueryAsync(string sql, object? parameters = null);  
}  

public class EfRepository<T> : IRepository<T> where T : class  
{  
    private readonly AppDbContext _context;  

    public EfRepository(AppDbContext context)  
    {  
        _context = context;  
    }  

    public async Task AddAsync(T entity) =>  
        await _context.Set<T>().AddAsync(entity);  

    public async Task UpdateAsync(T entity) =>  
        _context.Set<T>().Update(entity);  

    // Other methods (GetById, Delete) use _context  
}  

public class DapperRepository<T> : IReadRepository<T> where T : class  
{  
    private readonly IDbConnection _connection;  

    public DapperRepository(IDbConnection connection)  
    {  
        _connection = connection;  
    }  

    public async Task<IEnumerable<T>> QueryAsync(string sql, object? parameters = null)  
    {  
        return await _connection.QueryAsync<T>(sql, parameters);  
    }  
}  

// For Entity Framework  
builder.Services.AddDbContext<AppDbContext>(options =>  
    options.UseSqlServer(configuration.GetConnectionString("Default")));  

builder.Services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));  

// For Dapper  
builder.Services.AddScoped(typeof(IReadRepository<>), typeof(DapperRepository<>));  
builder.Services.AddScoped<IDbConnection>(_ =>  
    new SqlConnection(configuration.GetConnectionString("Default")));  

public class ProductService  
{  
    private readonly IRepository<Product> _efRepository;  
    private readonly IReadRepository<Product> _dapperRepository;  

    public ProductService(  
        IRepository<Product> efRepository,  
        IReadRepository<Product> dapperRepository)  
    {  
        _efRepository = efRepository;  
        _dapperRepository = dapperRepository;  
    }  

    public async Task AddProduct(Product product) =>  
        await _efRepository.AddAsync(product);  

    public async Task<List<Product>> GetExpensiveProducts()  
    {  
        string sql = "SELECT * FROM Products WHERE Price > 100";  
        return (await _dapperRepository.QueryAsync(sql)).ToList();  
    }  
}