entity framework winform 依赖注入

 public interface IRepository<TEntity> where TEntity : class
    {
        void Insert(TEntity entity);
        void Update(TEntity entity);
        void Delete(TEntity entity);
        TEntity GetEntityById(object id);
        IList<TEntity> GetAllEntities();
        IList<TEntity> GetEntities(Expression<Func<TEntity, bool>> filter);
        IList<TEntity> GetEntitiesByPage(int page, int pageSize);
        IList<TEntity> GetEntitiesByPage(Expression<Func<TEntity, bool>> filter, int page, int pageSize);
        IDbSet<TEntity> Table { get; }
    }

  public partial class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        private IDbSet<TEntity> table = null;
        public DataAccessDbContext dbContext = null;
        public Repository()
        {
            dbContext = new DataAccessDbContext();
        }


        protected string GetFullErrorText(DbEntityValidationException exc)
        {
            var msg = string.Empty;
            foreach (var validationErrors in exc.EntityValidationErrors)
                foreach (var error in validationErrors.ValidationErrors)
                    msg += string.Format("Property: {0} Error: {1}", error.PropertyName, error.ErrorMessage) + Environment.NewLine;
            return msg;
        }


        public virtual void Insert(TEntity entity)
        {
            try
            {
                Table.Add(entity);
                dbContext.SaveChanges();
            }
            catch (DbEntityValidationException ep)
            {
                throw new Exception(GetFullErrorText(ep));
            }
            catch (Exception ep)
            {
                throw ep;
            }
        }


        public virtual void Update(TEntity entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentNullException("Entity is null...");
                Table.Attach(entity);
                dbContext.Entry(entity).State = EntityState.Modified;
                dbContext.SaveChanges();
            }
            catch (DbEntityValidationException ep)
            {
                throw new Exception(GetFullErrorText(ep));
            }
            catch (Exception ep)
            {
                throw ep;  // You can also choose to handle the exception here...
            }
        }


        public virtual void Delete(TEntity entity)
        {
            if (dbContext.Entry(entity).State == EntityState.Detached)
            {
                Table.Attach(entity);
            }
            Table.Remove(entity);
            dbContext.SaveChanges();
        }


        public virtual void Delete(object id)
        {
            TEntity entity = Table.Find(id);
            Delete(entity);
        }


        public virtual IList<TEntity> GetAllEntities()
        {
            return Table.ToList();
        }


        public virtual TEntity GetEntityById(object id)
        {
            return Table.Find(id);
        }


        public virtual IList<TEntity> GetEntities(Expression<Func<TEntity, bool>> filter)
        {
            return Table.Where<TEntity>(filter).ToList<TEntity>();
        }


        public IList<TEntity> GetEntitiesByPage(int page, int pageSize)
        {
            return Table.Skip((page - 1) * pageSize).Take(pageSize).ToList();
        }


        public IList<TEntity> GetEntitiesByPage(Expression<Func<TEntity, bool>> filter, int page, int pageSize)
        {
            return Table.Where(filter).Skip((page - 1) * pageSize).Take(pageSize).ToList();
        }


        public virtual IDbSet<TEntity> Table
        {
            get
            {
                if (table == null)
                    table = dbContext.Set<TEntity>();
                return table;
            }
        }
    }

public class DataAccessDbContext : DbContext
    {
        public DataAccessDbContext () : base("connectionString")
        {
 
        }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            Assembly ass = Assembly.GetExecutingAssembly();
            Type[] types = ass.GetTypes();
            foreach (var item in types)
            {
                if (item.BaseType.IsGenericType && item.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>))
                {
                    dynamic obj = Activator.CreateInstance(item);
                    modelBuilder.Configurations.Add(obj);
                }
            }
            base.OnModelCreating(modelBuilder);
        }
}

 

 public static class AutoFacContainer
    {
        private static IContainer ic = null;
        private static ContainerBuilder builder = null;
        public static void Regsitry()
        {
            builder = new ContainerBuilder();
            Type[] types = Assembly.GetAssembly(typeof(Asset)).GetTypes().Where(d => d.Namespace == "Super.Core.Models").ToArray();
            builder.RegisterTypes(types);
            builder.RegisterType(typeof(DataAccessDbContext ));
            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));//必须的
            builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(UserCenterBLL))).AsImplementedInterfaces().AsSelf();
            ic = builder.Build(ContainerBuildOptions.None);
        }
 
        public static T Resolve<T>()
        {
            return ic.Resolve<T>();
        }
    }