public interface IGenericRepository<TEntity> where TEntity : class

    {

        IQueryable<TEntity> GetAll();

        IQueryable<TEntity> FindBy(Expression<Func<TEntity , bool>> predicate);

        void Add(TEntity entity);

        void Delete(TEntity  entity);

        void Edit(TEntity  entity);

        void Save();

    }

    public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : class

    {

        private readonly DbContext _context;

        private readonly IDbSet<TEntity> _entities;

        public GenericRepository(DbContext context)

        {

            this._context = context;

            _entities = _context.Set<TEntity>();

        }

        public virtual IQueryable<TEntity> GetAll()

        {

            IQueryable<TEntity> query = _entities;

            return query;

        }

        public IQueryable<TEntity> FindBy(Expression<Func<TEntity, bool>> predicate)

        {

            IQueryable<TEntity> query = _entities.Where(predicate);

            return query;

        }

        public virtual void Add(TEntity entity)

        {

            _entities.Add(entity);

        }

        public virtual void Delete(TEntity entity)

        {

            _entities.Remove(entity);

        }

        public virtual void Edit(TEntity entity)

        {

           // entity.State = EntityState.Modified;

        }

        public virtual void Save()

        {

            //_entities.SaveChanges();

        }

    }

    public class MyContext : DbContext

    {

        public MyContext(){}

        public MyContext(string nameOrConnectionString)

            : base(nameOrConnectionString)

        {

        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)

        {

            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();   //取消级联删除设置

            modelBuilder.Entity<Area>().ToTable("Area");

            base.OnModelCreating(modelBuilder);

        }

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

    }

    public class AreaRepository : IAreaRepository

    {

        private GenericRepository<Area> internalGenericRepository;

        public AreaRepository(GenericRepository<Area> internalGenericRepository)

        {

            this.internalGenericRepository = internalGenericRepository;

        }

        public List<Area> GetAllProvince()

        {

            var query = from o in this.internalGenericRepository.GetAll()

                        //where o.AreaTypeID == AreaTypeEnum.Province

                   select o;

            return query.ToList();

        }

    }

public class AreaService : IAreaService

    {

        private readonly IAreaRepository _AreaRepository;

        public AreaService(IAreaRepository areaRepository)

        {

            this._AreaRepository = areaRepository;

        }

        public List<DictionaryEntry> ProvinceList {

            get {

                var query = from o in this._AreaRepository.GetAllProvince()

                            select new DictionaryEntry(o.Name, o.Id);

                return query.ToList();

            }

        }

    }

IUnityContainer  container = new UnityContainer();

container.RegisterInstance<DbContext>(new MyContext("ConnectionString"));　//注册实例

container.RegisterType<IAreaService, AreaService>();

container.RegisterType<IAreaRepository, AreaRepository>();

container.RegisterType(typeof(IGenericRepository<>), typeof(GenericRepository<>));

var IAreaService = container.Resolve<IAreaService>();    //实例化接口

Console.WriteLine(IAreaService.ProvinceList.Count());