Angular JS sample application

CustomerRepository

namespace projectFirst.Repository
{
    public class CustomerRepository : Repository<Customer> , ICustomerRepository
    {
        public CustomerRepository(ProjectFirstDBEntities cotext)
            : base(cotext) { }
    }
}

ICustomerRepository
namespace projecrFirst.Infastructure
{
    public interface ICustomerRepository : IRepository<Customer>
    {

    }
}


Common/Repository

namespace projectFirst.Repository.Common
{
    public class Repository<IEntity> : IRepository<IEntity> where IEntity : class
    {

        protected readonly DbContext _Context;

        public Repository(DbContext context)
        {
            _Context = context;
        }

        public IEntity Get(int id)
        {
            return _Context.Set<IEntity>().Find(id);
        }

        public IEnumerable<IEntity> GetAll()
        {
            return _Context.Set<IEntity>().ToList();
        }

        public IEnumerable<IEntity> Find(System.Linq.Expressions.Expression<Func<IEntity, bool>> predicate)
        {
            return _Context.Set<IEntity>().Where(predicate);
        }

        public void Add(IEntity entity)
        {
            _Context.Set<IEntity>().Add(entity);
        }

        public void AddRange(IEnumerable<IEntity> entities)
        {
            _Context.Set<IEntity>().AddRange(entities);
        }

        public void Remove(IEntity entity)
        {
            _Context.Set<IEntity>().Remove(entity);
        }

        public void RemoveRange(IEnumerable<IEntity> entities)
        {
            _Context.Set<IEntity>().RemoveRange(entities);
        }

        public IEnumerable<X> ExcecuteStoredProcedure<X>(string storedProcedure, params System.Data.SqlClient.SqlParameter[] parameters)
        {
            throw new NotImplementedException();
        }

        public void Update(IEntity entity)
        {
            DbEntityEntry dbEntityEntry = _Context.Entry(entity);

            if (dbEntityEntry.State != EntityState.Detached)
            {
                _Context.Set<IEntity>().Attach(entity);
            }
            dbEntityEntry.State = EntityState.Modified;
        }

        public IEnumerable<X> ExecuteStoredProcedure<X>(string storedProcedureName, params System.Data.SqlClient.SqlParameter[] parameters)
        {
            try
            {
                var spSignature = new StringBuilder();
                object[] spParameters;

                spSignature.AppendFormat("EXECUTE {0}", storedProcedureName);
                var length = parameters.Count() - 1;

                for (int i = 0; i < parameters.Count(); i++)
                {
                    spSignature.AppendFormat(" @{0}", parameters[i].ParameterName);
                    if (i != length) spSignature.Append(",");
                }
                spParameters = parameters.Cast<object>().ToArray();
                var query = _Context.Database.SqlQuery<X>(spSignature.ToString(), spParameters).ToList();

                spSignature.Clear();

                return query;
            }
            catch (Exception ex)
            {

                return null;
            }
        }
    }
}

Common/IRepository
namespace projecrFirst.Infastructure.Common
{
    public interface IRepository<TEntity> where TEntity : class
    {
        TEntity Get(int id);
        IEnumerable<TEntity> GetAll();
        IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
        void Add(TEntity entity);
        void AddRange(IEnumerable<TEntity> entities);
        void Remove(TEntity entity);
        void RemoveRange(IEnumerable<TEntity> entities);

        IEnumerable<X> ExcecuteStoredProcedure<X>(string storedProcedure, params SqlParameter[] parameters);
        void Update(TEntity entity);

    }
}

Common/ UnitOfWork

namespace projectFirst.Repository.Common
{
    public partial class UnitOfWork : IUnitOfWork
    {
        public readonly ProjectFirstDBEntities _CustomerContext;

        public UnitOfWork(ProjectFirstDBEntities context)
        {
            _CustomerContext = context;
        }

        public void Complete()
        {
            _CustomerContext.SaveChanges();
        }

        public void DisPos()
        {
            _CustomerContext.Dispose();
        }

     
    }

}

Common/ IUnitOfWork
namespace projecrFirst.Infastructure.Common
{
    public interface IUnitOfWork
    {
        ICustomerRepository CustomerRepository { get; }
        void Complete();
        void DisPos();
    }
}

Common/ UnitOfWorkPartial

namespace projectFirst.Repository.Common
{
    public partial class UnitOfWork : IUnitOfWork
    {
        public ICustomerRepository CustomerRepository
        {
            get { return new CustomerRepository(_CustomerContext);}
        }
    }
}