SDCores.Repository 1.0.0

SDCores.Repository in .Net core

Repository Base

public interface IRepository<T> where T : class
{
    Task<T> FindById(object id);

    IQueryable<T> FindAll(bool? noTracking = false);

    IQueryable<T> FindAll(Expression<Func<T, bool>> predicate, bool? noTracking = false);

    void Add(T entity);

    void AddMultiple(List<T> entities);

    void Update(T entity);

    void UpdateMultiple(List<T> entities);

    void Remove(T entity);

    void Remove(object id);

    void RemoveMultiple(List<T> entities);

    bool All(Expression<Func<T, bool>> predicate);

    Task<bool> AllAsync(Expression<Func<T, bool>> predicate);

    bool Any();

    bool Any(Expression<Func<T, bool>> predicate);

    Task<bool> AnyAsync();

    Task<bool> AnyAsync(Expression<Func<T, bool>> predicate);

    T FirstOrDefault(bool? noTracking = false);

    T FirstOrDefault(Expression<Func<T, bool>> predicate, bool? noTracking = false);

    Task<T> FirstOrDefaultAsync(bool? noTracking = false);

    Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate, bool? noTracking = false);

    ...
}

Dynamic Repository DBContext

public class Repository<T, DBContext> : IRepository<T> where T : class where DBContext : DbContext
{
    private readonly DBContext _context;

    public Repository(DBContext context)
    {
        _context = context;
    }
    ... 
}

And then, I create Accessor class

...
using Microsoft.EntityFrameworkCore.Storage;
using SDCores;

namespace API._Repositories
{
    [DependencyInjection(ServiceLifetime.Scoped)]
    public interface IRepositoryAccessor
    {
        IRepository<ModelA> ModelA{get;}
        ...
        Task<bool> Save();
        Task<IDbContextTransaction> BeginTransactionAsync();
    }
}

...
using Microsoft.EntityFrameworkCore.Storage;
using SDCores;

namespace API._Repositories
{
    public class RepositoryAccessor : IRepositoryAccessor
    {
        private DBContext _dbContext;
        public RepositoryAccessor(DBContext dbContext)
        {
            _dbContext = dbContext;
            ModelA = new Repository<ModelA, DBContext>(_dbContext);
            ...
        }

        public IRepository<ModelA> ModelA { get; set; }
        ...

        public async Task<bool> Save()
        {
            return await _dbContext.SaveChangesAsync() > 0;
        }

        public async Task<IDbContextTransaction> BeginTransactionAsync()
        {
            return await _dbContext.Database.BeginTransactionAsync();
        }
    }
}

And in Service, you use Accessor as follows

public interface IServiceA
{
    void Do();
}

----------------------------------------------------------------------------------------------------
using SDCores;

public class ServiceA : IServiceA
{
    private readonly IRepositoryAccessor _repoAccessor;

    public ServiceA(IRepositoryAccessor repoAccessor) {
        _repoAccessor = repoAccessor;
    }

    void Do()
    {
        var demo = _repoAccessor.ModelA.FirstOrDefaultAsync(x => ...);
        ...
    }
}