Entity Framework 实体框架的形成之旅--Code First模式中使用 Fluent API 配置（6）

时间：2015-03-27 21:34:25 阅读：325 评论：0 收藏：0 [点我收藏+]

在前面的随笔《Entity Framework 实体框架的形成之旅--Code First的框架设计（5）》里介绍了基于Code First模式的实体框架的经验，这种方式自动处理出来的模式是通过在实体类（POCO类）里面添加相应的特性说明来实现的，但是有时候我们可能需要考虑基于多种数据库的方式，那这种方式可能就不合适。本篇主要介绍使用 Fluent API 配置实现Code First模式的实体框架构造方式。

使用实体框架 Code First 时，默认行为是使用一组 EF 中内嵌的约定将 POCO 类映射到表。但是，有时您无法或不想遵守这些约定，需要将实体映射到约定指示外的其他对象。特别是这些内嵌的约定可能和数据库相关的，对不同的数据库可能有不同的表示方式，或者我们可能不同数据库的表名、字段名有所不同；还有就是我们希望尽可能保持POCO类的纯洁度，不希望弄得太过乌烟瘴气的，那么我们这时候引入Fluent API 配置就很及时和必要了。

1、Code First模式的代码回顾

上篇随笔里面我构造了几个代表性的表结构，具体关系如下所示。

技术分享

这些表包含了几个经典的关系，一个是自引用关系的Role表，一个是User和Role表的多对多关系，一个是User和UserDetail之间的引用关系。

我们看到，默认使用EF工具自动生成的实体类代码如下所示。

    [Table("Role")]
    public partial class Role
    {
        public Role()
        {
            Children = new HashSet<Role>();
            Users = new HashSet<User>();
        }

        [StringLength(50)]
        public string ID { get; set; }

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

        [StringLength(50)]
        public string ParentID { get; set; }

        public virtual ICollection<Role> Children { get; set; }

        public virtual Role Parent { get; set; }

        public virtual ICollection<User> Users { get; set; }
    }

而其生成的数据库操作上下文类的代码如下所示。

    public partial class DbEntities : DbContext
    {
        public DbEntities() : base("name=Model1")
        {
        }
        public virtual DbSet<Role> Roles { get; set; }
        public virtual DbSet<User> Users { get; set; }
        public virtual DbSet<UserDetail> UserDetails { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Role>()
                .HasMany(e => e.Children)
                .WithOptional(e => e.Parent)
                .HasForeignKey(e => e.ParentID);

            modelBuilder.Entity<Role>()
                .HasMany(e => e.Users)
                .WithMany(e => e.Roles)
                .Map(m => m.ToTable("UserRole"));

            modelBuilder.Entity<User>()
                .HasMany(e => e.UserDetails)
                .WithOptional(e => e.User)
                .HasForeignKey(e => e.User_ID);

            modelBuilder.Entity<UserDetail>()
                .Property(e => e.Height)
                .HasPrecision(18, 0);
        }
    }

2、使用Fluent API 配置的Code First模式代码结构

不管是Code First模式中使用 Fluent API 配置，还是使用了前面的Attribute特性标记的说明，都是为了从代码层面上构建实体类和表之间的信息，或者多个表之间一些关系，不过如果我们把这些实体类Attribute特性标记去掉的话，那么我们就可以通过Fluent API 配置进行属性和关系的指定了。

其实前面的OnModelCreating函数里面，已经使用了这种方式来配置表之间的关系了，为了纯粹使用Fluent API 配置，我们还需要把实体类进行简化，最终我们可以获得真正的实体类信息如下所示。

    public partial class User
    {
        public User()
        {
            UserDetails = new HashSet<UserDetail>();
            Roles = new HashSet<Role>();
        }

        public string ID { get; set; }

        public string Account { get; set; }

        public string Password { get; set; }

        public virtual ICollection<UserDetail> UserDetails { get; set; }

        public virtual ICollection<Role> Roles { get; set; }
    }

这个实体类和我们以往的表现几乎一样，没有多余的信息，唯一多的就是完全是实体对象化了，包括了一些额外的关联对象信息。

前面说了，Oracle的生成实体类字段全部为大写字母，不过我们实体类还是需要保持它的Pascal模式书写格式，那么就可以在Fluent API 配置进行指定它的字段名为大写（注意，Oracle一定要指定字段名为大写，因为它是大小写敏感的）。

最终我们定义了Oracle数据库USERS表对应映射关系如下所示。

    /// <summary>
    /// 用户表USERS的映射信息（Fluent API 配置）
    /// </summary>
    public class UserMap : EntityTypeConfiguration<User>  
    {
        public UserMap()
        {
            HasMany(e => e.UserDetails).WithOptional(e => e.User).HasForeignKey(e => e.User_ID);
            
            Property(t => t.ID).HasColumnName("ID");
            Property(t => t.Account).HasColumnName("ACCOUNT");
            Property(t => t.Password).HasColumnName("PASSWORD");

            ToTable("WHC.USERS");
        }
    }

我们为每一个字段进行了字段名称的映射，而且Oracle要大写，我们还通过 ToTable("WHC.USERS") 把它映射到了WHC.USERS表里面了。

如果对于有多对多中间表关系的Role来说，我们看看它的关系代码如下所示。

    /// <summary>
    /// 用户表 ROLE 的映射信息（Fluent API 配置）
    /// </summary>
    public class RoleMap : EntityTypeConfiguration<Role>  
    {
        public RoleMap()
        {
            Property(t => t.ID).HasColumnName("ID");
            Property(t => t.Name).HasColumnName("NAME");
            Property(t => t.ParentID).HasColumnName("PARENTID");
            ToTable("WHC.ROLE");
            
            HasMany(e => e.Children).WithOptional(e => e.Parent).HasForeignKey(e => e.ParentID);
            HasMany(e => e.Users).WithMany(e => e.Roles).Map(m=>
                {
                    m.MapLeftKey("ROLE_ID");
                    m.MapRightKey("USER_ID");
                    m.ToTable("USERROLE", "WHC");
                });
        }
    }

这里注意的是MapLeftKey和MapRightKey一定的对应好了，否则会有错误的问题，一般情况下，开始可能很难理解那个是Left，那个是Right，不过经过测试，可以发现Left的肯定是指向当前的这个映射实体的键（如上面的为ROLE_ID这个是Left一样，因为当前的实体映射是Role对象）。

通过这些映射代码的建立，我们为每个表都建立了一一的对应关系，剩下来的就是把这映射关系加载到数据库上下文对象里面了，还记得刚才说到的OnModelCreating吗，就是那里，一般我们加载的方式如下所示。

            //手工加载
            modelBuilder.Configurations.Add(new UserMap());
            modelBuilder.Configurations.Add(new RoleMap());
            modelBuilder.Configurations.Add(new UserDetailMap());

这种做法代替了原来的臃肿代码方式。

            modelBuilder.Entity<Role>()
                .HasMany(e => e.Children)
                .WithOptional(e => e.Parent)
                .HasForeignKey(e => e.ParentID);

            modelBuilder.Entity<Role>()
                .HasMany(e => e.Users)
                .WithMany(e => e.Roles)
                .Map(m => m.ToTable("UserRole"));

            modelBuilder.Entity<User>()
                .HasMany(e => e.UserDetails)
                .WithOptional(e => e.User)
                .HasForeignKey(e => e.User_ID);

            modelBuilder.Entity<UserDetail>()
                .Property(e => e.Height)
                .HasPrecision(18, 0);

一般情况下，到这里我认为基本上把整个思路已经介绍完毕了，不过精益求精一贯是个好事，对于上面的代码我还是觉得不够好，因为我每次在加载 Fluent API 配置的时候，都需要指定具体的映射类，非常不好，如果能够把它们动态加载进去，岂不妙哉。

对类似下面的关系硬编码可不是一件好事。

modelBuilder.Configurations.Add(new UserMap());
modelBuilder.Configurations.Add(new RoleMap());
modelBuilder.Configurations.Add(new UserDetailMap());

我们可以通过反射方式，把它们进行动态的加载即可。这样OnModelCreating函数处理的时候，就是很灵活的了，而且OnModelCreating函数只是在程序启动的时候映射一次而已，即使重复构建数据库操作上下文对象DbEntities的时候，也是不会重复触发这个OnModelCreating函数的，因此我们利用反射不会有后顾之忧，性能只是第一次慢一点而已，后面都不会重复触发了。

最终我们看看一步步下来的代码如下所示（注释的代码是不再使用的代码）。

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            #region MyRegion
            //modelBuilder.Entity<Role>()
            //    .HasMany(e => e.Children)
            //    .WithOptional(e => e.Parent)
            //    .HasForeignKey(e => e.ParentID);

            //modelBuilder.Entity<Role>()
            //    .HasMany(e => e.Users)
            //    .WithMany(e => e.Roles)
            //    .Map(m => m.ToTable("UserRole"));

            //modelBuilder.Entity<User>()
            //    .HasMany(e => e.UserDetails)
            //    .WithOptional(e => e.User)
            //    .HasForeignKey(e => e.User_ID);

            //modelBuilder.Entity<UserDetail>()
            //    .Property(e => e.Height)
            //    .HasPrecision(18, 0);

            //手工加载
            //modelBuilder.Configurations.Add(new UserMap());
            //modelBuilder.Configurations.Add(new RoleMap());
            //modelBuilder.Configurations.Add(new UserDetailMap()); 
            #endregion

            //使用数据库后缀命名，确保加载指定的数据库映射内容
            //string mapSuffix = ".Oracle";//.SqlServer/.Oracle/.MySql/.SQLite
            string mapSuffix = ConvertProviderNameToSuffix(defaultConnectStr.ProviderName);
            
            var typesToRegister = Assembly.GetExecutingAssembly().GetTypes()
                .Where(type => type.Namespace.EndsWith(mapSuffix, StringComparison.OrdinalIgnoreCase))
                .Where(type => !String.IsNullOrEmpty(type.Namespace))
                .Where(type => type.BaseType != null && type.BaseType.IsGenericType
                    && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>));

            foreach (var type in typesToRegister)
            {
                dynamic configurationInstance = Activator.CreateInstance(type);
                modelBuilder.Configurations.Add(configurationInstance);
            }
            base.OnModelCreating(modelBuilder); 
        }

这样我们运行程序运行正常，不在受约束于实体类的字段必须是大写的忧虑了。而且动态加载，对于我们使用其他数据库，依旧是个好事，因为其他数据库也只需要修改一下映射就可以了，真正远离了复杂的XML和实体类臃肿的Attribute书写内容，实现了非常弹性化的映射处理了。

最后我贴出一下测试的代码例子，和前面的随笔使用没有太大的差异。

        private void button1_Click(object sender, EventArgs e)
        {
            DbEntities db = new DbEntities();

            User user = new User();
            user.Account = "TestName" + DateTime.Now.ToShortTimeString();
            user.ID = Guid.NewGuid().ToString();
            user.Password = "Test";

            UserDetail detail = new UserDetail() { ID = Guid.NewGuid().ToString(), Name = "userName33", Sex = 1, Note = "测试内容33", Height = 175 };
            user.UserDetails.Add(detail);
            db.Users.Add(user);

            Role role = new Role();
            role.ID = Guid.NewGuid().ToString();
            role.Name = "TestRole";
            //role.Users.Add(user);

            user.Roles.Add(role);
            db.Users.Add(user);
            //db.Roles.Add(role);
            db.SaveChanges();

            Role roleInfo = db.Roles.FirstOrDefault();
            if (roleInfo != null)
            {
                Console.WriteLine(roleInfo.Name);
                if (roleInfo.Users.Count > 0)
                {
                    Console.WriteLine(roleInfo.Users.ToList()[0].Account);
                }
                MessageBox.Show("OK");
            }
        }