Repository

Переваги та недоліки

Переваги

Недоліки

Опис мовою C#

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public interface IRepository<TEntity> where TEntity : class
{
    int Count();
    int Count(Expression<Func<TEntity, bool>> predicate);

    IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null,
                                Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
                                string includeProperties = "",
                                int? page = null, int? amount = null);
    TEntity Get(int id);

    void Insert(TEntity entity);

    void Delete(object id);
    void Delete(TEntity entityToDelete);
    void Delete(Expression<Func<TEntity, bool>> predicate);
}

public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
    // FIELDS
    // узагальнений контекст
    protected DbContext dbContext;
    protected DbSet<TEntity> dbSet;

    // CONSTRUCTORS
    public GenericRepository(DbContext dbContext)
    {
        this.dbContext = dbContext;
        this.dbSet = dbContext.Set<TEntity>();
    }

    // METHODS
    public virtual int Count()
    {
        return dbSet.Count();
    }
    public virtual int Count(Expression<Func<TEntity, bool>> predicate)
    {
        return dbSet.Count(predicate);
    }

    public virtual IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null,
                                            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
                                            string includeProperties = "",
                                            int? page = null, int? amount = null)
    {
        // filter
        IQueryable<TEntity> query = dbSet;
        if (filter != null)
        {
            query = query.Where(filter);
        }

        // include properties
        foreach (string includeProperty in includeProperties.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        // ordering
        if (orderBy != null) query = orderBy(query);

        // paging
        if (page.HasValue && amount.HasValue) query = query.Skip((page.Value - 1) * amount.Value).Take(amount.Value);

        return query;
    }
    public virtual TEntity Get(int id)
    {
        return dbSet.Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        dbSet.Add(entity);
    }

    public virtual void Delete(object id)
    {
        // find
        if (id == null) throw new ArgumentNullException(nameof(id));
        TEntity entityToDelete = dbSet.Find(id);

        // delete finded
        if (entityToDelete == null) throw new InvalidOperationException("There is no records with such id");
        Delete(entityToDelete);
    }
    public virtual void Delete(TEntity entityToDelete)
    {
        if (entityToDelete == null) throw new ArgumentNullException(nameof(entityToDelete));

        if (dbContext.Entry(entityToDelete).State == EntityState.Detached)
        {
            dbSet.Attach(entityToDelete);
        }
        dbSet.Remove(entityToDelete);
    }
    public virtual void Delete(Expression<Func<TEntity, bool>> predicate)
    {
        if (predicate != null) dbSet.RemoveRange(dbSet.Where(predicate));
        else dbSet.RemoveRange(dbSet);
    }
}

public interface IUserRepository: IRepository<User>
{
    User GetByName(string name);
}

public class UserRepository : GenericRepository<User>, IUserRepository
{
    public UserRepository(DbContext dbContext) 
        : base(dbContext) { }

    public User GetByName(string name)
    {
        return dbSet.First(u => u.Name == name);
    }
}

public interface IRepository<TEntity, TKey> where TEntity : class, IEntity<TKey>
{
   . . .
}

Зв'язок з іншими патернами

Реалізація

Див. також

Джерела