Difference between DBContext and DBSet

 DbContext corresponds to your database (or a collection of tables and views in your database) whereas a DbSet corresponds to a table or view in your database. So it makes perfect sense that you will get a combination of both!

public class MyAppContext : DbContext
{
    public MyAppContext () : ;

    public DbSet<Table1> Table1 { get; set; }
    public DbSet<Table2> Table2 { get; set; }
    public DbSet<Table3> Table3 { get; set; }
    public DbSet<Table4> Table4 { get; set; }
    public DbSet<Table5> Table5 { get; set; }
}

Entity frame work Generic Base controller

 public class BaseController<T,E,R> : ApiController, ICRUD<E> where T : class
        where E:class
        where R : class
   
    {
        #region ExtensionMethod
        public virtual object UpdateAllExtension(RequestDTO objParamData)
        {
            return null;
        }

        public virtual object DeleteAllExtension(object objParamData)
        {
            return null;
        }

        public virtual object CreateAllExtension(RequestDTO objParamData)
        {
            return null;
        }
        #endregion


        #region Protected Methods

        #region ResponseData
        /// <summary>
        /// Transforming result in to the client acceptable DTO format.  
        /// </summary>
        /// <param name="objParamResult">object instance...</param>
        /// <returns>ResponseModel instance...</returns>
        protected object ResponseData(object objParamResult)
        {
            if (null == objParamResult)
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, "NODATA");
            else if (objParamResult is Exception)
            {
                if (objParamResult is UnauthorizedAccessException)
                {
                    return Request.CreateErrorResponse(HttpStatusCode.Unauthorized, ((Exception)objParamResult).Message, (Exception)objParamResult);
                }
                //else if (objParamResult is System.ServiceModel.CommunicationException)
                //{
                //    if (((Exception)objParamResult).InnerException != null && ((Exception)objParamResult).InnerException.Message == "The remote server returned an error: (401) Unauthorized.")
                //        return Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid credentials", (Exception)objParamResult);
                //    else
                //        Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, ((Exception)objParamResult).Message, (Exception)objParamResult);

                //}
                return Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, ((Exception)objParamResult).Message, (Exception)objParamResult);
            }
            ResponseModel objResponseModelDTO = new ResponseModel();
            objResponseModelDTO.data = objParamResult;
            return objResponseModelDTO;
        }
        #endregion

        #endregion

        public Type objEntity = typeof(T);

        #region Create
        /// <summary>
        /// Create new record in the table
        /// </summary>
        /// <param name="objDTO">Table Model Entity</param>
        /// <returns>Response Model</returns>
        [HttpPost]
        public object Create(RequestDTO objRequestDTO)
        {
            Type objBusinessType = typeof(T);
            //GenericRepository<T> objGenericRepository = new GenericRepository<B>();
            object objBusinessInstance = Activator.CreateInstance(objBusinessType);

            E objDTO = (E)DeserializeObject(objRequestDTO.Entity);

            if (objDTO == null)
                return ResponseData("Entity value is null");

            Object objValue = objBusinessType.GetMethod("Insert").Invoke(objBusinessInstance, new object[] { objDTO });
            object obj3 = objBusinessType.GetMethod("SaveChanges").Invoke(objBusinessInstance, null);

            object objNewValue = CreateAllExtension(objRequestDTO);
           
            objValue = objNewValue == null ? objValue : objNewValue;
            return ResponseData(objValue);
        }
        #endregion

        #region Update
        /// <summary>
        /// Update a record in the table
        /// </summary>
        /// <param name="objDTO">Table Model Entity</param>
        /// <returns>Response Model</returns>
        [HttpPost]
        public object Update(RequestDTO objRequestDTO)
        {
            Type objBusinessType = typeof(T);
            // GenericRepository<T> objGenericRepository = new GenericRepository<B>();
            object objBusinessInstance = Activator.CreateInstance(objBusinessType);

            E objDTO = (E)DeserializeObject(objRequestDTO.Entity);

            if (objDTO == null)
                return ResponseData("Entity value is null");
           
            objBusinessType.GetMethod("Update").Invoke(objBusinessInstance, new object[] { objDTO });
            object objValue = objBusinessType.GetMethod("SaveChanges").Invoke(objBusinessInstance, null);

            object objNewValue = UpdateAllExtension(objRequestDTO);
            objValue = objNewValue == null ? objValue : objNewValue;

            return ResponseData(objValue);
        }
        #endregion

        [HttpGet]
        public object Delete(int iValue)
        {
            Type objBusinessType = typeof(T);
            // GenericRepository<T> objGenericRepository = new GenericRepository<B>();
            object objBusinessInstance = Activator.CreateInstance(objBusinessType);

            if (iValue == null)
                return ResponseData("Value is null");

            objBusinessType.GetMethod("Delete").Invoke(objBusinessInstance, new object[] { iValue });
            object objValue = objBusinessType.GetMethod("SaveChanges").Invoke(objBusinessInstance, null);

            object objNewValue = DeleteAllExtension(objValue);

            objValue = objNewValue == null ? objValue : objNewValue;
            return ResponseData(objValue);
        }

        [HttpGet]
        public object FindById(int objId)
         {
             //Type objBusinessType = typeof(T);
              GenericRepository<E> objGenericRepository = new GenericRepository<E>();
           
           //  object objBusinessInstance = Activator.CreateInstance(objBusinessType);

              object objValue = objGenericRepository.GetType().GetMethod("GetByID").Invoke(objGenericRepository, new object[] { objId });
//             object objValue = objBusinessType.GetMethod("GetByID").Invoke(objBusinessInstance, new object[] { objId });
            // objBusinessType.GetMethod("SaveChanges").Invoke(objBusinessInstance, null);
             return ResponseData(objValue);
         }

        [HttpPost]
        [Action1DebugActionWebApiFilter]
        public object FindAll(RequestDTO objRequestDTO)
        {
            Type objBusinessType = typeof(T);
         
            // GenericRepository<T> objGenericRepository = new GenericRepository<B>();
            object objBusinessInstance = Activator.CreateInstance(objBusinessType);

            List<Filter> filter = new List<Filter>
{
    new  Filter  { PropertyName = "Id" , Value = "10" ,Operation = Op .Equals, },
   
};
            if (objRequestDTO == null)
                objRequestDTO = new RequestDTO();
         //   objRequestDTO.Filter = filter;
            Expression<Func<E, bool>> delegFilter = null;
         //   delegFilter = ExpressionBuilder.GetExpression<E>(filter);
           delegFilter= ExpressionBuilder.GetExpression<E>(objRequestDTO.Filter);
           Func<IQueryable<E>, IOrderedQueryable<E>> delegOrder=null;



           //delegOrder = (Func<IQueryable<E>, IOrderedQueryable<E>>)GetOrderBy<UserDTO>("dUserId", "asc");
            if(!string.IsNullOrEmpty(objRequestDTO.strOrderColumn))
           delegOrder = (Func<IQueryable<E>, IOrderedQueryable<E>>)GetOrderBy<E>(objRequestDTO.strOrderColumn,objRequestDTO.strSortBy);

           // Expression<Func<UserDTO, bool>> deleg = ExpressionBuilder.GetOrderExpression<UserDTO>(order);

            object objValue = objBusinessType.GetMethod("Get").Invoke(objBusinessInstance, new object[] { delegFilter, delegOrder, "", objRequestDTO.offset, objRequestDTO.Max});
            // objBusinessType.GetMethod("SaveChanges").Invoke(objBusinessInstance, null);
 

            //List<Type> lst =new List<Type>();
            //lst.Add(typeof(SubTask));
            //lst.Add(typeof(CheckList));
            //lst.Add(typeof(Company));

            //System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(typeof(Task), lst.AsEnumerable());
            //var serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(Task), new System.Runtime.Serialization.DataContractSerializerSettings()
            //{
            //    DataContractResolver = new System.Data.Entity.Core.Objects.ProxyDataContractResolver()
            //});
            //var ms = new System.IO.MemoryStream();

            //serializer.WriteObject(ms, objValue);

            //ms.Seek(0, SeekOrigin.Begin);



            //var sr = new StreamReader(ms);

            //var xml = sr.ReadToEnd();
         
            return  ResponseData(objValue);
        }

        internal static object DeserializeObject(object objEntity)
        {
            string TempJson = Newtonsoft.Json.JsonConvert.SerializeObject(objEntity);
            Type objType = typeof(Newtonsoft.Json.JsonConvert);

            MethodInfo[] arrt = typeof(Newtonsoft.Json.JsonConvert).GetMethods();
            object objValue1 = arrt[40].MakeGenericMethod(typeof(E)).Invoke(null, new object[] { TempJson });
            return objValue1;
        }

        public object FindByOwnder(int objId)
        {
            throw new NotImplementedException();
        }

        public static Func<IQueryable<T>, IOrderedQueryable<T>> GetOrderBy<T>(string orderColumn, string orderType)
        {
            Type typeQueryable = typeof(IQueryable<T>);
            ParameterExpression argQueryable = Expression.Parameter(typeQueryable, "p");
            var outerExpression = Expression.Lambda(argQueryable, argQueryable);
            string[] props = orderColumn.Split('.');
            IQueryable<T> query = new List<T>().AsQueryable<T>();
            Type type = typeof(T);
            ParameterExpression arg = Expression.Parameter(type, "x");

            Expression expr = arg;
            foreach (string prop in props)
            {
                PropertyInfo pi = type.GetProperty(prop, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                expr = Expression.Property(expr, pi);
                type = pi.PropertyType;
            }
            expr = Expression.Property(arg, orderColumn);
            LambdaExpression lambda = Expression.Lambda(expr, arg);
            string methodName = orderType == "asc" ? "OrderBy" : "OrderByDescending";
           
            MethodCallExpression resultExp =
                Expression.Call(typeof(Queryable), methodName, new Type[] { typeof(T),type }, outerExpression.Body, Expression.Quote(lambda));
            var finalLambda = Expression.Lambda(resultExp, argQueryable);
            return (Func<IQueryable<T>, IOrderedQueryable<T>>)finalLambda.Compile();
        }
    }

    #region ExpressionBuilder
    public static class ExpressionBuilder
    {
        private static MethodInfo containsMethod = typeof(string).GetMethod("Contains");
        private static MethodInfo startsWithMethod =
        typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
        private static MethodInfo endsWithMethod =
        typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });


        public static Expression<Func<T,
        bool>> GetExpression<T>(IList<Filter> filters)
        {
            if (filters == null)
                return null;

            if (filters.Count == 0)
                return null;

            ParameterExpression param = Expression.Parameter(typeof(T), "t");
            Expression exp = null;

            if (filters.Count == 1)
                exp = GetExpression<T>(param, filters[0]);
            else if (filters.Count == 2)
                exp = GetExpression<T>(param, filters[0], filters[1]);
            else
            {
                while (filters.Count > 0)
                {
                    var f1 = filters[0];
                    var f2 = filters[1];

                    if (exp == null)
                        exp = GetExpression<T>(param, filters[0], filters[1]);
                    else
                        exp = Expression.AndAlso(exp, GetExpression<T>(param, filters[0], filters[1]));

                    filters.Remove(f1);
                    filters.Remove(f2);

                    if (filters.Count == 1)
                    {
                        exp = Expression.AndAlso(exp, GetExpression<T>(param, filters[0]));
                        filters.RemoveAt(0);
                    }
                }
            }

            return Expression.Lambda<Func<T, bool>>(exp, param);
        }

        private static Expression GetExpression<T>(ParameterExpression param, Filter filter)
        {
            MemberExpression member = Expression.Property(param, filter.PropertyName);
            ConstantExpression constant = null;
            if (member.Type.Name == "Int32")
            {
                Int32 iValue = Convert.ToInt32(filter.Value);
                constant = Expression.Constant(iValue);
            }
            else if (member.Type.Name == "Int64")
            {
                Int64 iValue = Convert.ToInt64(filter.Value);
                constant = Expression.Constant(iValue);
            }
            else
                constant = Expression.Constant(filter.Value);

            switch (filter.Operation)
            {
                case Op.Equals:
                    return Expression.Equal(member, constant);

                case Op.NotEquals:
                    return Expression.NotEqual(member, constant);

                case Op.GreaterThan:
                    return Expression.GreaterThan(member, constant);

                case Op.GreaterThanOrEqual:
                    return Expression.GreaterThanOrEqual(member, constant);

                case Op.LessThan:
                    return Expression.LessThan(member, constant);

                case Op.LessThanOrEqual:
                    return Expression.LessThanOrEqual(member, constant);

                case Op.Contains:
                    return Expression.Call(member, containsMethod, constant);

                case Op.StartsWith:
                    return Expression.Call(member, startsWithMethod, constant);

                case Op.EndsWith:
                    return Expression.Call(member, endsWithMethod, constant);
            }

            return null;
        }

        private static BinaryExpression GetExpression<T>
        (ParameterExpression param, Filter filter1, Filter filter2)
        {
            Expression bin1 = GetExpression<T>(param, filter1);
            Expression bin2 = GetExpression<T>(param, filter2);

            return Expression.AndAlso(bin1, bin2);
        }



    }
    #endregion


    public class Action1DebugActionWebApiFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            List<string> lstHeaderValue = actionContext.Request.Headers.GetValues("Authorization").ToList();
           
            if (lstHeaderValue == null)
                throw new Exception("");

         
        }

    }

Entity framework Generic Repository

public class GenericRepository<TEntity> where TEntity : class

    {

        internal DbContext context;

        internal DbSet<TEntity> dbSet;

        public GenericRepository()

        {

            this.context = new EWEFDTO();

            this.dbSet = context.Set<TEntity>();

        }

        public virtual IEnumerable<TEntity> Get(

            Expression<Func<TEntity, bool>> filter = null,

            // Expression<Func<TEntity, bool>> orderBy = null,

            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,

            string includeProperties = "", int iOffset=0,int iMax=10)

        {

            IQueryable<TEntity> query = dbSet;

            if (filter != null)

            {

               query = query.Where(filter);

                //return query.OrderBy(filter).ToList();

            //    return query.ToList();

            }

            foreach (var includeProperty in includeProperties.Split

                (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))

            {

                query = query.Include(includeProperty);

            }

            if (orderBy != null)

            {

                query= orderBy(query);

            }

            if (iOffset > 0)

                iOffset = iOffset * iMax;

            if (iMax == 0)

                iMax = 10;

            if (orderBy != null)

                return query.Skip(iOffset).Take(iMax).ToList();

            else

                return query.ToList();

           // }

        }

        public virtual TEntity GetByID(object id)

        {

            return dbSet.Find(id);

        }

        public virtual TEntity Insert(TEntity entity)

        {

           return dbSet.Add(entity);

        }

        public virtual void Delete(object id)

        {

            TEntity entityToDelete = dbSet.Find(id);

            DeleteEntity(entityToDelete);

        }

        public virtual void DeleteEntity(TEntity entityToDelete)

        {

            if (context.Entry(entityToDelete).State == EntityState.Detached)

            {

                dbSet.Attach(entityToDelete);

            }

            dbSet.Remove(entityToDelete);

        }

        public virtual void Update(TEntity entityToUpdate)

        {

            //TEntity objTEntity = dbSet.Find(3);

            //TEntity objNewEntity = (TEntity)ReflectionHelper.SetDTOValueFromEntity(objTEntity, entityToUpdate);

            //context.Entry(objNewEntity);

            dbSet.Attach(entityToUpdate);

            context.Entry(entityToUpdate).State = EntityState.Modified;

        }

        public virtual int SaveChanges()

        {

            return context.SaveChanges();

        }

    }