ef 通用类

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using System.Text;
using System.Threading.Tasks;

namespace Domain.Infrastructure
{
    public class BaseRepository<T> where T : class
    {
        protected CCDbContext Context = CCDbContext.Current;

        public virtual IQueryable<T> GetAll()
        {
            var ls = Context.Set<T>();
            return ls;
        }
        public virtual IQueryable<T> GetAll(string includes)
        {
            if (!string.IsNullOrWhiteSpace(includes))
            {
                string[] ins = includes.Split(',');
                DbQuery<T> query = Context.Set<T>();
                foreach (string s in ins)
                {
                    query = query.Include(s);
                }
                return query;
            }
            return Context.Set<T>();
        }

        public void Add(T entity)
        {
            Context.Set<T>().Add(entity);
            Context.SaveChanges();
        }

        public virtual void Update(T entity)
        {
            var entry = Context.Entry(entity);
            Context.Set<T>().Attach(entity);
            entry.State = EntityState.Modified;
            Context.SaveChanges();
        }

        public virtual T Get(int id)
        {
            return Context.Set<T>().Find(new object[] { id });
        }

        public T Get(object[] ids)
        {
            return Context.Set<T>().Find(ids);
        }

        public virtual bool Del(int id)
        {
            var entity = Context.Set<T>().Find(new object[] { id });

            if (entity == null)
                return false;

            Context.Set<T>().Remove(entity);
            Context.SaveChanges();
            return true;
        }

        public virtual bool Del(int[] ids)
        {
            if (ids == null || ids.Length <= )
            {
                return false;
            }
            var changed = false;
            foreach (var id in ids)
            {
                var entity = Get(id);
                if (entity != null)
                {
                    Context.Set<T>().Remove(entity);
                    changed = true;
                }
            }
            if (changed)
                Context.SaveChanges();

            return changed;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using Domain.Course.Entry;
using Domain.User.Entry;

namespace Domain.Infrastructure
{
    public class CCDbContext : DbContext
    {
        public CCDbContext()
            : base("name=conn")
        {
        }

        private static ThreadLocal<CCDbContext> _threadLocal;
        private static CCDbContext _current;
        public static CCDbContext Current
        {
            get
            {
                if (HttpContext.Current == null)
                {
                    // 非 web 环境
                    if (_threadLocal == null)
                    {
                        _threadLocal = new ThreadLocal<CCDbContext>(() => new CCDbContext());
                    }
                    _current = _threadLocal.Value;
                    return _threadLocal.Value;
                }
                else
                {
                    var cached = HttpContext.Current.Items["_CCDbContext"];
                    if (cached != null && cached is CCDbContext)
                    {
                        _current = cached as CCDbContext;
                        return _current;
                    }
                    else
                    {
                        var context = new CCDbContext();
                        HttpContext.Current.Items["_CCDbContext"] = context;
                        _current = context;
                        return context;
                    }
                }
            }
        }

        public static void DisposeCurrent()
        {
            if (_current != null)
                _current.Dispose();
        }

        #region 所有实例
        public DbSet<Word> Words { get; set; }

        public DbSet<WordTranslation> WordTranslations { get; set; }

        public DbSet<Language> Languages { get; set; }

        public DbSet<Catalog> Catalogs { get; set; }

        public DbSet<CatalogName> CatalogNames { get; set; }

        public DbSet<Term> Terms { get; set; }

        public DbSet<TermTranslation> TermTranslations { get; set; }

        public DbSet<Lesson> Lessons { get; set; }

        public DbSet<LessonWord> LessonWords { get; set; }

        public DbSet<RelevantTerm> RelevantTerms { get; set; }

        public DbSet<Domain.User.Entry.User> Users { get; set; }

        public DbSet<Group> Groups { get; set; }

        public DbSet<GroupTranslation> GroupTranslation { get; set; }

        public DbSet<TermGroup> TermGroup { get; set; }

        public DbSet<RelevantGroup> RelevantGroups { get; set; }

        public DbSet<Derivations> Derivations { get; set; }

        public DbSet<RelatedWord> RelatedWord { get; set; }
        public DbSet<Role> Role { get; set; }

        public DbSet<wordsh> wordsh { get; set; }
        public DbSet<shinfo> shinfo { get; set; }

        public DbSet<Part> Part { get; set; }
        public DbSet<Radical> Radical { get; set; }
        public DbSet<WordPart> WordPart { get; set; }
        #endregion
    }
}