Implementing a Generic Repository for my web application, is hard to achive

Question

I am reading the following tutorial about creating Generic Repository Link in asp.net mvc & EF, to perform CRUD operations, as follow:-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Data.Entity;
using ContosoUniversity.Models;
using System.Linq.Expressions;

namespace ContosoUniversity.DAL
{
    public class GenericRepository<TEntity> where TEntity : class
    {
        internal SchoolContext context;
        internal DbSet<TEntity> dbSet;

        public GenericRepository(SchoolContext context)
        {
            this.context = context;
            this.dbSet = context.Set<TEntity>();
        }

        public virtual IEnumerable<TEntity> Get(
            Expression<Func<TEntity, bool>> filter = null,
            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
            string includeProperties = "")
        {
            IQueryable<TEntity> query = dbSet;

            if (filter != null)
            {
                query = query.Where(filter);
            }

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

            if (orderBy != null)
            {
                return orderBy(query).ToList();
            }
            else
            {
                return query.ToList();
            }
        }

        public virtual TEntity GetByID(object id)
        {
            return dbSet.Find(id);
        }

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


    }
}

but in real web project Add/Edit/Delete/Find operations might not be very simple and standard, as different entities might require different operations inside these methods.

Currently inside my Asset Management asp.net mvc web application, for example I have a repository method to add a new Server entity , where I do the following main operations:-

• Create a general Technology object and automatically generates a Tag number.
• Create a new audit record.
• Create a new Server.
• etc

so i find it hard to create Generic repository for almost all my current repository methods, because each entity have different requirements when performing CRUD operations.

so my questions is basically , when developing web applications that have different and complex requirements is having a Generic Repository a tasks that can be achieved ? , from my point of view having a Generic Repository will work only if the requirements are simple and standard.

OR i should style my Repository and action method to work with Generic repository , and failing to do so might be a problem ?

Can anyone advice on this please ?

Thanks

Answer 1

Why would we use a generic repository? Because we have common requirements that we want to implement with less code duplication. What if we have a repository with requirements that don't fit into this common pattern? Then we don't try to force this repository into a pattern that it doesn't fit.

The purpose of design patterns is to provide some possible common solutions, in cases where the requirements fit the pattern. The purpose is not to stop thinking about design and not to try to force everything into a pattern.

Answer 2

I used a generic repository pattern in my application. It let me implement filtering on organisation dependent entities, a soft delete and undo - all without code duplication. If I need to add auditing then I will add it to my generic repository with the confidence that all entities will be audited. As far as I am concerned, creating the generic repository let me add quite complex behaviour that isn't present in the DbSet<T> implementation.

When I have additional or different requirements for an entity, I inherit the generic repository and add or override the behaviour in the sub-class. That lets me add quite complex requirements too.

The DbContext/DbSet<T> is a simple implementation of the unit of work / repository pattern but wrapping it in my own has helped me add complex requirements with minimal code.