EF6&EFCore 注册/使用实体类的正确姿势

首先回顾下EF中常规使用流程

1.新建实体类以及实体配置(data annotation或fluent api)

    [Table("Users")]
    public class Users
    {
        [Key]
        public Guid Id { get; set; }

        [StringLength(10)]
        public string Name { get; set; }
    }

2.新建数据库上下文类MyDbContext

    public class MyDbContext : DbContext
    {
        public MyDbContext() { }

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

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer("connectionString");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }
    }

3.开始欢乐的操作Users

            using (MyDbContext context = new MyDbContext())
            {
                context.Users.FirstOrDefaultAsync(r => r.Name == "老王");
            }

一切看起来都是很美好的,但假如有一天你面对上千个实体的时候,你可能会开始想用代码生成器.EF6中你还可以用modelBuilder.RegisterEntityType(type);那么现在又有一个新的要求,需要能同时使用data annotation和fluent api进行实体配置.自动根据约定注册实体,自动注册fluent api配置类.EF中注册实体的本质就是注册DbSet,方法非常多.

ok,直接贴代码,EF6:

       /// <summary>
        /// 注册某个程序集中所有<typeparamref name="TEntityBase"/>的非抽象实体子类
        /// </summary>
        /// <typeparam name="TEntityBase">实体基类</typeparam>
        /// <param name="modelBuilder"></param>
        /// <param name="assembly">注册程序集</param>
        public static void RegisterEntitiesFromAssembly<TEntityBase>(this DbModelBuilder modelBuilder, Assembly assembly)
            where TEntityBase : class
        {
            modelBuilder.RegisterEntitiesFromAssembly(assembly, r => !r.IsAbstract && r.IsClass && r.IsChildTypeOf<TEntityBase>());
        }

        /// <summary>
        /// 注册某个程序集中所有<typeparamref name="TEntityBase"/>的非抽象实体子类
        /// </summary>
        /// <typeparam name="TEntityBase">实体基类</typeparam>
        /// <param name="modelBuilder"></param>
        /// <param name="assembly">注册程序集</param>
        /// <param name="assembly">注册程序集</param>
        public static void RegisterEntitiesFromAssembly(this DbModelBuilder modelBuilder, Assembly assembly, Func<Type, bool> entityTypePredicate)
        {
            if (assembly == null)
                throw new ArgumentNullException(nameof(assembly));

            //反射得到DbModelBuilder的Entity方法
            var entityMethod = modelBuilder.GetType().GetMethod("Entity");

            //反射得到ConfigurationRegistrar的Add<TEntityType>方法
            var addMethod = typeof(ConfigurationRegistrar)
                   .GetMethods()
                   .Single(m =>
                     m.Name == "Add"
                     && m.GetGenericArguments().Any(a => a.Name == "TEntityType"));
            //扫描所有fluent api配置类,要求父类型必须是EntityTypeConfiguration<TEntityType>
            var configTypes = assembly
                               .GetTypesSafely()
                               .Where(t =>
                                     !t.IsAbstract && t.BaseType != null && t.IsClass
                                     && t.BaseType.IsGenericType
                                     && t.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>)
                                     )
                               .ToList();

            HashSet<Type> registedTypes = new HashSet<Type>();

            //存在fluent api配置的类,必须在Entity方法之前调用
            configTypes.ForEach(mappingType =>
            {
                var entityType = mappingType.BaseType.GetGenericArguments().Single();
                if (!entityTypePredicate(entityType))
                    return;
                var map = Activator.CreateInstance(mappingType);
                //反射调用ConfigurationRegistrar的Add方法注册fluent api配置,该方法会同时注册实体
                addMethod.MakeGenericMethod(entityType)
                     .Invoke(modelBuilder.Configurations, new object[] { map });

                registedTypes.Add(entityType);
            });

            //反射调用Entity方法 注册实体
            assembly
                .GetTypesSafely()
                .Where(entityTypePredicate)
                .ForEach_(r =>
                {
                    entityMethod.MakeGenericMethod(r).Invoke(modelBuilder, new object[0]);
                });
        }

EFCore:

 /// <summary>
        /// 注册某个程序集中所有<typeparamref name="TEntityBase"/>的非抽象子类为实体
        /// </summary>
        /// <typeparam name="TEntityBase">实体基类</typeparam>
        /// <param name="modelBuilder"></param>
        /// <param name="assembly">注册程序集</param>
        public static void RegisterEntitiesFromAssembly<TEntityBase>(this ModelBuilder modelBuilder, Assembly assembly)
            where TEntityBase : class
        {
            modelBuilder.RegisterEntitiesFromAssembly(assembly, r => !r.IsAbstract && r.IsClass && r.IsChildTypeOf<TEntityBase>());
        }

        /// <summary>
        /// 注册某个程序集中所有<typeparamref name="TEntityBase"/>的非抽象子类为实体
        /// </summary>
        /// <typeparam name="TEntityBase">实体基类</typeparam>
        /// <param name="modelBuilder"></param>
        /// <param name="assembly">注册程序集</param>
        /// <param name="assembly">注册程序集</param>
        public static void RegisterEntitiesFromAssembly(this ModelBuilder modelBuilder, Assembly assembly, Func<Type, bool> entityTypePredicate)
        {
            if (assembly == null)
                throw new ArgumentNullException(nameof(assembly));

            //反射得到ModelBuilder的ApplyConfiguration<TEntity>(...)方法
            var applyConfigurationMethod = modelBuilder.GetType().GetMethod("ApplyConfiguration");

            //所有fluent api配置类
            var configTypes = assembly
                               .GetTypesSafely()
                               .Where(t =>
                                 !t.IsAbstract && t.BaseType != null && t.IsClass
                                 && t.IsChildTypeOfGenericType(typeof(IEntityTypeConfiguration<>))).ToList();

            HashSet<Type> registedTypes = new HashSet<Type>();
            //存在fluent api配置的类,必须在Entity方法之前调用
            configTypes.ForEach(mappingType =>
            {
                var entityType = mappingType.GetTypeInfo().ImplementedInterfaces.First().GetGenericArguments().Single();

                //如果不满足条件的实体,不注册
                if (!entityTypePredicate(entityType))
                    return;

                var map = Activator.CreateInstance(mappingType);
                applyConfigurationMethod.MakeGenericMethod(entityType)
                     .Invoke(modelBuilder, new object[] { map });

                registedTypes.Add(entityType);
            });

            assembly
                .GetTypesSafely()
                .Where(r => !registedTypes.Contains(r))
                .Where(entityTypePredicate)
                .ForEach_(r =>
                {
                    //直接调用Entity方法注册实体
                    modelBuilder.Entity(r);
                });
        }

如何使用(EFCore,EF6类似)

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.RegisterEntitiesFromAssembly<IEntity>(this.GetType().Assembly);
        }



            using (MyDbContext context = new MyDbContext())
            {
                context.Set<Users>().FirstOrDefaultAsync(r => r.Name == "老王");
            }

data annotation和fluent api同时使用怎么用?,其中data annotation与fluent api冲突时,以fluent api为准,如Users的表名称最终会映射为"Users___",见代码

    [Table("Users")]
    public class Users
    {
        [Key]
        public Guid Id { get; set; }

        [StringLength(10)]
        public string Name { get; set; }
    }

    public class UsersMapping : IEntityTypeConfiguration<Users>
    {
        public void Configure(EntityTypeBuilder<Users> builder)
        {
            builder.ToTable("Users___");            
        }
    }

不用你写 public DbSet<Users> Users{get;set;},也不用你写一大堆的,modelBuilder.ApplyConfiguration<Users>(new UserMpping());

一句代码modelBuilder.RegisterEntitiesFromAssembly<IEntity>(this.GetType().Assembly);搞定所有的实体与实体配置

代码:https://github.com/280780363/Lazy