手把手教你:让EF动态支持新增表、动态支持多数据库

名词解释:此动态非运行时动态,让EF动态支持新增表、动态切换数据库意在不改变项目核心框架,

通过新增或者替换组件的方式达到标题目地。

 

一、先来点简单的,动态支持多数据库

AppDbContext实现:

public class AppDbContext:DbContext
    {
        public AppDbContext(string configKey)
            : base(configKey)
        {
 
        }
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }
    }

在AppDbContext构造函数中添加configKey参数,通过configKey参数指定配置文件中的连接字符串的配置项;

 

创建IDbContextProvider接口,如下:

public interface IDbContextProvider
    {
        AppDbContext Get();
    }

意图很明显了,通过IDbContextProvider来提供AppDbContext,这样我们首先将AppDbContext与业务层解耦;

 

继续创建2个项目:MsSqlProvider、MySqlProvider,分别实现IDbContextProvider接口:

MsSql:

public class MsSqlProvider:IDbContextProvider
    {
        AppDbContext m_AppDbContext = null;
 
        public AppDbContext Get()
        {
            return m_AppDbContext ?? new AppDbContext("MsSql");
        }
    }

MySql:

  public class MySqlProvider:IDbContextProvider
    {
        AppDbContext m_AppDbContext = null;
 
        public AppDbContext Get()
        {
            return m_AppDbContext ?? new AppDbContext("MySql");
        }
    }

下面继续解释动态支持/切换DbContextProvider,没错…聪明的你一开始就应该想到了..依赖注入,这个时候我们就需要使用依赖注入来完成使命了;

我已MEF为例来演示下如何动态获取2种DbContextProvider:

首先为我们的IDbContextProvider添加 [InheritedExport] 标记,然后分别为两种Provider添加 [Export]标记;

 

"MEF的使用还请大家自己去熟悉,我也仅仅是会使用而已,并不精通"

 

接着在Demo中添加App.Config和测试代码;

App.Config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="MsSql" connectionString="Data Source=LIANG-HU-PC;Initial Catalog=appbase;Integrated Security=True;Pooling=False" providerName="System.Data.SqlClient" />
    <add name="MySql" connectionString="server=localhost;User Id=root;password=mysql;Persist Security Info=True;database=appbase" providerName="MySql.Data.MySqlClient" />
  </connectionStrings>
</configuration>

这里要提醒下哦:要使MySql能够支持EF使用的话,需要到MySql官方下载最新的驱动;

测试代码如下:

 class Program
    {
        [ImportMany]
        static IEnumerable<IDbContextProvider> m_Providers = null;
 
        static void Main(string[] args)
        {
            //使用目录方式查找MEF部件
            var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);
 
            //创建Container
            var container = new CompositionContainer(catalog);
 
            //获取Export项,这里直接加载不采用Lazy
            m_Providers = container.GetExportedValues<IDbContextProvider>();
            if (m_Providers != null)
            {
                foreach (var provider in m_Providers)
                {
                    Console.WriteLine(provider.Get().Database.Connection.ConnectionString);
                }
            }
            Console.ReadKey(false);
        }

OK,我们来编译测试下,当应用程序目录下没有任何Provider的时候是没有获取到任何是不会获取到任何Provider的,如果只放置MySqlProvider再执行的话结果如下:

image

放置两项Provider组件的时候自然就会是两个都被获取到,我就不演示了;

 

到这里可能很多人就要嘘声一片了,也许你会提出一些问题:

比如:

1)为什么不做一个Provider的实现,在Get()方法或者构造函数中依赖注入参数呢?

其实这样做的目地是我们在使用UnitOfWork和Repository模式时能够简单方便的获取DbContext;

可参见示例:

    /// <summary>
    /// Entity Framework Repository
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class EFRepository<T>:IRepository<T>
        where T:class
    {
        readonly IDataBaseFactory m_DataBaseFactory = null;
 
        public EFRepository(IDataBaseFactory dataBaseFactory)
        {
            if(dataBaseFactory==null)
            {
                throw new ArgumentNullException("DataBaseFactory");
            }
            m_DataBaseFactory=dataBaseFactory;
        }
 
        DbContext m_DbContext = null;
 
        protected DbContext DbContext
        {
            get
            {
                return m_DbContext ?? m_DataBaseFactory.Get();
            }
        }
对UnitOfWork模式的使用与此类似;
 
 

2)我只需要一个DbContext,但有时候需要切换数据库,那怎么办呢?

这个问题是ico与依赖注入方面的基础内容,需要您自己去学习哦;

 

至此,简单的“动态”支持多数据库示例就完成了~~~ 我们的关键还是动态支持新建表,下面我们就来一步一步实践吧;

 

二、“动态”支持新建表,计划先行

首先我们创建ModelBase类库,存放一些与实体相关的接口和基类,结构如图所示:

image根据项目结构,我需要给大家解释每个文件的存在意义;

 

IEntity接口与AbstractEntityBase类,顾名思义,大家应该猜得到它们是实体基类,为什么要如此定义呢,主要是方便我们写实体的时候直接继承Id属性,(因为我们的所有表主键都是Guid且名为Id)

public interface IEntity
    {
        Guid Id { get; }
    }
public abstract class AbstractEntityBase : IEntity
    {
        public AbstractEntityBase()
        {
            this.Id = Guid.NewGuid();
        }
 
        [Key]
        [Required]
        public Guid Id
        {
            get;
            protected set;
        }
    }

还有一个好处就是我们直接在基类中描述 主键关系,在写实体的时候直接继承后,可以省去很多重复操作哦^_^

 

再来说IMapping和Mapping,为什么要有这2个基类接口呢,出于以下方面考虑:

1)将实体与数据库的映射关系产生Mapping类与DbContext类解耦(这个会在下面具体出现时再说)

2)通过MappingBase基类实现一些公共操作,避免每个实体类的重复操作,具体看代码你就会明白;

 [InheritedExport]
    public interface IMapping
    {
        void RegistTo(ConfigurationRegistrar configurationRegistrar);
    }
public class MappingBase<TEntity> : EntityTypeConfiguration<TEntity>, IMapping
        where TEntity : class,IEntity
    {
        public MappingBase()
        {
            this.Map(m => m.ToTable(typeof(TEntity).Name));
        }
 
        public void RegistTo(ConfigurationRegistrar configurationRegistrar)
        {
            configurationRegistrar.Add(this);
        }
    }

呵呵,有了“动态”支持多数据库,这里很多人应该就能猜到我们如何“动态”支持新增表咯;注意这里的IMapping接口的精妙所在哦,您发现了吗???;

 

三、万事俱备,只欠东风

我们先在ModelA类库中创建一个User实体和Role实体,同时创建UserMapping和RoleMapping,(为什么要创建Mapping类,后面我会讲)

USer 、UserMapping:

 /*
     * 为什么没有通过[Table]来指明表明呢,
     * 并不是因为我们需要EF自己支持的表明方式
     * 而是我们继承自AbstractEntityBase,在其基类已经实现了将类名映射为表名
     */
    public class User : AbstractEntityBase
    {
        [Required]
        public string Username { get; set; }
 
        [Required]
        public string Password { get; set; }
 
        /*
         * 注意这里,我为什么不通过DataAnnotations方式添加外键关联呢
         * 个人认为User实体与Role实体关联,已经拥有Role属性了,
         * 如果在添加一个RoleId来表示外键关系,会让我觉得User类不够清爽
         * 所以我的做法是添加UserMapping类来指定它与Role实体的关系
         * 
         * 但是有一点要注意,如果不指定外键的话,默认数据库外键是为 表名_主键(Role_Id)类型
         */
        public virtual Role Role{get;set;}
    }
 
[Export("UserMapping")]
    public class UserMapping:MappingBase<User>
    {
        public UserMapping()
        {
            this.HasRequired(m => m.Role)
                .WithMany(m => m.Users);
            /*注意这里没有指定HasForeignKey哦*/
        }
    }

Role类和RoleMapping的实现也是同理,结合上面代码中的注释内容,我想大家也能够理解我的良苦用心了吧;如果还不能理解,我们再看下DbContext是如何实现的:

/*
     * 很清爽的DbContext,完全不包含任何DbSet
     * 通过Mapping来加载表结构
     */
    public class AppDbContext:DbContext
    {
        public AppDbContext(string configKey)
            : base(configKey)
        {
            //可以设置通过反向方式创建表哦,但是我们演示的目地不在于此
            //Database.SetInitializer(new DropCreateDatabaseIfModelChanges<AppDbContext>());
 
            //加载目录下所有IMapping实现
            var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);
            var container = new CompositionContainer(catalog);
            m_Mappings = container.GetExportedValues<IMapping>();
        }
 
        [ImportMany]
        IEnumerable<IMapping> m_Mappings = null;
 
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            if (m_Mappings != null)
            {
                //这里是关键
                foreach (var mapping in m_Mappings)
                {
                    mapping.RegistTo(modelBuilder.Configurations);
                }
            }
            base.OnModelCreating(modelBuilder);
        }
    }

 

没错,我们的目地就是让DbContext完全依靠IMapping去加载解释表结构关系,这样即保证DbContext不包含大量的DbSet,又能够非常好的将DbContext与实体解耦,

更重要的是,我们通过 DataAnnotations 和 Fluent API结合使用,让我们的实体也非常清爽;

 

到这里,其实我已经把核心的内容都展现出来了,对于新增表的动态使用也就类似与最前面讲的“动态”支持多数据库,我们只需要依赖注入所有的IMapping的实现,就可以让DbContext自动去解释所有表结构了(所以DbContext的OnModelCreating方法是关键所在)。

 

好,接着我们在新增一个ModelB 作为新增表NewModel实体的载体,来演示是我们的示例是否能够如题所描述的那样,不改变核心框架的前提下动态支持新增的表和实体。

 public class NewModel : AbstractEntityBase
    {
        [Required]
        public string Name { get; set; }
    }

 

我们按照之前做CmdDemo的方式添加一个AppDemo,并添加App.Config文件,同时创建一个DataViewControl的自定义控件用来显示数据;

我们来看下AppDemo的演示:

image

其具体实现为:

    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            IDbContextProvider provider = new MsSqlProvider.MsSqlProvider();
            AppDbContext dbContext = provider.Get();
 
            var users = dbContext.Set<User>();
            if (users != null)
            {
                users.Add(new User()
                {
                    Username = "admin",
                    Password = "admin",
                    Role = new Role() { Name = "administrators" }
                });
                dbContext.SaveChanges();
 
                DataViewControl usersViewControl=new DataViewControl();
                usersViewControl.Binding(users.ToList());
 
                TabItem item = new TabItem();
                item.Header = "User表展示";
                item.Content = usersViewControl;
 
                this.myTabControl.Items.Add(item);
            }
 
            var roles = dbContext.Set<Role>();
            if (roles != null)
            {
                DataViewControl rolesViewControl = new DataViewControl();
                rolesViewControl.Binding(roles.ToList());
 
                TabItem item = new TabItem();
                item.Header = "Role表展示";
                item.Content = rolesViewControl;
                this.myTabControl.Items.Add(item);
            }
 
            /*
             * 请注意此处,我们的NewModel还是和应用耦合在一起了,
             * 并没有像我们标题说的动态加载;
             * 这里主要是为了演示方便,我就不在做实体与业务层的解耦了,
             * 一般我们的应用可能是单独的UI模块和它对应的实体耦合,而不是UI框架耦合
             * 仅在需要的时候加载不同模块的UI组件
             *
             */
            var newModels = dbContext.Set<NewModel>();
            if (newModels != null)
            {
                DataViewControl newModelsViewControl = new DataViewControl();
                newModelsViewControl.Binding(newModels.ToList());
                TabItem item = new TabItem();
                item.Header = "NewModel表展示";
                item.Content = newModelsViewControl;
                this.myTabControl.Items.Add(item);
            }
        }
    }

 

需要解释的是AppDemo中没有很好的演示怎么动态支持新建表,其实我前面解释过ModelB中NewModel就是新增的表,主要是为了给大家展示实现思路,我并没有去把NewModel和AppDemo去解耦,所以没有很好的演示效果,但是实际上是没有问题的,这就跟我们具体的应用息息相关了。

到这里,我们已经完整的解释了整个过程,为此我也是边创建项目边写博客,在最后会附上完整项目源码,有兴趣的可以自行下载学习;如果这篇文章对你有所启发,或者让你学到了一些东西,那是我非常乐见的,同时也希望各位高手不要鄙视。

 

完整源码下载

posted @ 2011-10-28 13:58  lianghugg  阅读(6849)  评论(6编辑  收藏  举报