EFcore与动态模型

　　在开发商城系统的时候，大家会遇到这样的需求，商城系统里支持多种商品类型，比如衣服，手机，首饰等，每一种产品类型都有自己独有的参数信息，比如衣服有颜色，首饰有材质等，大家可以上淘宝看一下就明白了。现在的问题是，如果我程序发布后，要想增加一种新的商品类型怎么办，如果不在程序设计时考虑这个问题的话，可能每增加一个商品类型，就要增加对应商品类型的管理程序，并重新发布上线，对于维护来说成本会很高。有没有简单的方式可以快速增加新类型的支持？下面介绍的方案是这样的，首先把模型以配置的方式保存到配置文件中，在程序启动时解析模型信息编译成具体的类，然后通过ef实现动态编译类的数据库操作，如果新增类型，首先改下配置文件，然后在数据库中创建对应的数据库表，重启应用程序即可。

　　要实现这样的功能，需要解决以下几个问题：

　　1，如何实现动态模型的配置管理

　　2，如何根据模型配置在运行时动态生成类型

　　3，如何让ef识别动态类型

　　4，如何结合ef对动态类型信息进行操作，比如查询，增加等

　　一、如何实现动态模型的配置管理

　　这个问题解决的方案是，把模型的信息作为系统的一个配置文件，在系统运行时可以获取到模型配置信息。

　　首先定义一个类表示一个动态模型，代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public  class  RuntimeModelMeta     {         public  int  ModelId {  get ;  set ; }         public  string  ModelName {  get ;  set ; } //模型名称         public  string  ClassName {  get ;  set ; } //类名称         public  ModelPropertyMeta[] ModelProperties {  get ;  set ; }                  public  class  ModelPropertyMeta         {             public  string  Name {  get ;  set ; } //对应的中文名称             public  string  PropertyName {  get ;  set ; }  //类属性名称  　　　　　　 public  int  Length {  get ;  set ; } //数据长度，主要用于string类型   　　　　　   public  bool  IsRequired {  get ;  set ; } //是否必须输入，用于数据验证 　　　　　   public  string  ValueType {  get ;  set ; } //数据类型，可以是字符串，日期，bool等         }     }

　　

　　然后定义个配置类：

1 2 3 4

public  class  RuntimeModelMetaConfig    {        public  RuntimeModelMeta[] Metas {  get ;  set ; }    }

　　增加配置文件，文件名称为runtimemodelconfig.json，结构如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

{    "RuntimeModelMetaConfig" : {      "Metas" : [        {          "ModelId" : 1,          "ModelName" :  "衣服" ,          "ClassName" :  "BareDiamond" ,                   "ModelProperties" : [            {              "Name" :  "尺寸" ,              "PropertyName" :  "Size" ,            },            {              "Name" :  "颜色" ,              "PropertyName" :  "Color" ,            }          ]        }      ]    } }

　　下一步再asp.net core mvc的Startup类的构造方法中加入配置文件

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public  Startup(IHostingEnvironment env)      {          var  builder =  new  ConfigurationBuilder()              .SetBasePath(env.ContentRootPath)              .AddJsonFile( "appsettings.json" , optional:  true , reloadOnChange:  true )              .AddJsonFile( "runtimemodelconfig.json" , optional: true ,reloadOnChange: true )              .AddEnvironmentVariables();            if  (env.IsDevelopment())          {              builder.AddApplicationInsightsSettings(developerMode:  true );          }          Configuration = builder.Build();      }

　　然后再public void ConfigureServices(IServiceCollection services)方法中，获取到配置信息，代码如下：

1 2 3 4 5 6

public  void  ConfigureServices(IServiceCollection services)     {         。。。。。。         services.Configure<RuntimeModelMetaConfig>(Configuration.GetSection( "RuntimeModelMetaConfig" ));    　　  。。。。。。     }

　　到此就完成了配置信息的管理，在后续代码中可以通过依赖注入方式获取到IOptions<RuntimeModelMetaConfig>对象，然后通过IOptions<RuntimeModelMetaConfig>.Value.Metas获取到所有模型的信息。为了方便模型信息的管理，我这里定义了一个IRuntimeModelProvider接口，结构如下：

1 2 3 4 5

public  interface  IRuntimeModelProvider      {          Type GetType( int  modelId); 　　　　 Type[] GetTypes();      }

　　　IRuntimeModelProvider.GetType方法可以通过modelId获取到对应的动态类型Type信息，GetTypes方法返回所有的动态类型信息。这个接口实现请看下面介绍。

　　二、如何根据模型配置在运行时动态生成类型

　　我们有了上面的配置后，需要针对模型动态编译成对应的类。C#提供了多种运行时动态生成类型的方式，下面我们介绍通过Emit来生成类，上面的配置信息比较适合模型配置信息的管理，对于生成类的话我们又定义了一个方便另外一个类，代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

public  class  TypeMeta    {        public  TypeMeta()        {            PropertyMetas =  new  List<TypePropertyMeta>();            AttributeMetas =  new  List<AttributeMeta>();        }        public  Type BaseType {  get ;  set ; }        public  string  TypeName {  get ;  set ; }        public  List<TypePropertyMeta> PropertyMetas {  get ;  set ; }        public  List<AttributeMeta> AttributeMetas {  get ;  set ; }          public  class  TypePropertyMeta        {            public  TypePropertyMeta()            {                AttributeMetas =  new  List<AttributeMeta>();            }            public  Type PropertyType {  get ;  set ; }            public  string  PropertyName {  get ;  set ; }            public  List<AttributeMeta> AttributeMetas {  get ;  set ; }        }          public  class  AttributeMeta        {            public  Type AttributeType {  get ;  set ; }            public  Type[] ConstructorArgTypes {  get ;  set ; }            public  object [] ConstructorArgValues {  get ;  set ; }            public  string [] Properties {  get ;  set ; }            public  object [] PropertyValues {  get ;  set ; }        }    }

　　上面的类信息更接近一个类的定义，我们可以把一个RuntimeModelMeta转换成一个TypeMeta，我们把这个转换过程放到IRuntimeModelProvider实现类中，实现代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

public  class  DefaultRuntimeModelProvider : IRuntimeModelProvider      {          private  Dictionary< int , Type> _resultMap;          private  readonly  IOptions<RuntimeModelMetaConfig> _config;          private  object  _lock =  new  object ();          public  DefaultRuntimeModelProvider(IOptions<RuntimeModelMetaConfig> config)          {              //通过依赖注入方式获取到模型配置信息              _config = config;          } 　　     //动态编译结果的缓存，这样在获取动态类型时不用每次都编译一次          public  Dictionary< int , Type> Map          {              get              {                  if  (_resultMap ==  null )                  {                      lock  (_lock)                      {                          _resultMap =  new  Dictionary< int , Type>();                                            foreach  ( var  item  in  _config.Value.Metas)                          {                              //根据RuntimeModelMeta编译成类，具体实现看后面内容                              var  result = RuntimeTypeBuilder.Build(GetTypeMetaFromModelMeta(item));                             //编译结果放到缓存中，方便下次使用                              _resultMap.Add(item.ModelId, result);                          }                      }                  }                  return  _resultMap;              }          }            public  Type GetType( int  modelId)          {              Dictionary< int , Type> map = Map;              Type result =  null ;              if  (!map.TryGetValue(modelId,  out  result))              {                  throw  new  NotSupportedException( "dynamic model not supported:"  + modelId);              }              return  result;          }            public  Type[] GetTypes()          {              int [] modelIds = _config.Value.Metas.Select(m => m.ModelId).ToArray();              return  Map.Where(m => modelIds.Contains(m.Key)).Select(m => m.Value).ToArray();                     }          //这个方法就是把一个RuntimeModelMeta转换成更接近类结构的TypeMeta对象          private  TypeMeta GetTypeMetaFromModelMeta(RuntimeModelMeta meta)          {              TypeMeta typeMeta =  new  TypeMeta();              //我们让所有的动态类型都继承自DynamicEntity类，这个类主要是为了方便属性数据的读取，具体代码看后面              typeMeta.BaseType =  typeof (DynamicEntity);              typeMeta.TypeName = meta.ClassName;                           foreach  ( var  item  in  meta.ModelProperties)              {                  TypeMeta.TypePropertyMeta pmeta =  new  TypeMeta.TypePropertyMeta();                  pmeta.PropertyName = item.PropertyName;                  //如果必须输入数据，我们在属性上增加RequireAttribute特性，这样方便我们进行数据验证                  if  (item.IsRequired)                  {                      TypeMeta.AttributeMeta am =  new  TypeMeta.AttributeMeta();                      am.AttributeType =  typeof (RequiredAttribute);                      am.Properties =  new  string [] {  "ErrorMessage"  };                      am.PropertyValues =  new  object [] {  "请输入"  + item.Name };                      pmeta.AttributeMetas.Add(am);                  }                                    if  (item.ValueType ==  "string" )                  {                      pmeta.PropertyType =  typeof ( string );                      TypeMeta.AttributeMeta am =  new  TypeMeta.AttributeMeta();                      //增加长度验证特性                       am.AttributeType =  typeof (StringLengthAttribute);                       am.ConstructorArgTypes =  new  Type[] {  typeof ( int ) };                       am.ConstructorArgValues =  new  object [] { item.Length };                       am.Properties =  new  string [] {  "ErrorMessage"  };                       am.PropertyValues =  new  object [] { item.Name +  "长度不能超过"  + item.Length.ToString() +  "个字符"  };                                                pmeta.AttributeMetas.Add(am);                  }                  else  if (item.ValueType== "int" )                  {                      if  (!item.IsRequired)                      {                          pmeta.PropertyType =  typeof ( int ?);                      }                      else                      {                          pmeta.PropertyType =  typeof ( int );                      }                  }                  else  if  (item.ValueType== "datetime" )                  {                      if  (!item.IsRequired)                      {                          pmeta.PropertyType =  typeof (DateTime?);                      }                      else                      {                          pmeta.PropertyType =  typeof (DateTime);                      }                  }                  else  if  (item.ValueType ==  "bool" )                  {                      if  (!item.IsRequired)                      {                          pmeta.PropertyType =  typeof ( bool ?);                      }                      else                      {                          pmeta.PropertyType =  typeof ( bool );                      }                  }                  typeMeta.PropertyMetas.Add(pmeta);              }              return  typeMeta;          }      }

　　

　　DynamicEntity是所有动态类型的基类，主要是方便属性的操作，具体代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102

public  class  DynamicEntity: IExtensible      {          private  Dictionary< object ,  object > _attrs;          public  DynamicEntity()          {              _attrs =  new  Dictionary< object ,  object >();          }          public  DynamicEntity(Dictionary< object , object > dic)          {              _attrs = dic;          }          public  static  DynamicEntity Parse( object  obj)          {              DynamicEntity model =  new  DynamicEntity();              foreach  (PropertyInfo info  in  obj.GetType().GetProperties())              {                  model._attrs.Add(info.Name, info.GetValue(obj,  null ));              }              return  model;          }          public  T GetValue<T>( string  field)          {              object  obj2 =  null ;              if (!_attrs.TryGetValue(field,  out  obj2))              {                  _attrs.Add(field,  default (T));              }              if  (obj2 ==  null )              {                  return  default (T);              }              return  (T)obj2;          }            public  void  SetValue<T>( string  field, T value)          {              if  (_attrs.ContainsKey(field))              {                  _attrs[field] = value;              }              else              {                  _attrs.Add(field, value);              }          }            [JsonIgnore]          public  Dictionary< object ,  object > Attrs          {              get              {                  return  _attrs;              }          } 　　　　 //提供索引方式操作属性值          public  object  this [ string  key]          {              get              {                  object  obj2 =  null ;                  if  (_attrs.TryGetValue(key,  out  obj2))                  {                      return  obj2;                  }                  return  null ;              }              set              {                  if  (_attrs.Any(m =>  string .Compare(m.Key.ToString(), key,  true ) != -1))                  {                      _attrs[key] = value;                  }                  else                  {                      _attrs.Add(key, value);                  }              }          }          [JsonIgnore]          public  string [] Keys          {              get              {                  return  _attrs.Keys.Select(m=>m.ToString()).ToArray();              }          }            public  int  Id          {              get              {                  return  GetValue< int >( "Id" );              }              set              {                  SetValue( "Id" , value);              }          }          [Timestamp]          [JsonIgnore]          public  byte [] Version {  get ;  set ; }      }

　　

　　另外在上面编译类的时候用到了RuntimeTypeBuilder类，我们来看下这个类的实现，代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

public  static  class  RuntimeTypeBuilder      {          private  static  ModuleBuilder moduleBuilder;          static  RuntimeTypeBuilder()          {              AssemblyName an =  new  AssemblyName( "__RuntimeType" );              moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run).DefineDynamicModule( "__RuntimeType" );          }          public  static  Type Build(TypeMeta meta)          {              TypeBuilder builder = moduleBuilder.DefineType(meta.TypeName, TypeAttributes.Public);              CustomAttributeBuilder tableAttributeBuilder =  new  CustomAttributeBuilder( typeof (TableAttribute).GetConstructor( new  Type[1] {  typeof ( string )}),  new  object [] {  "RuntimeModel_"  + meta.TypeName });              builder.SetParent(meta.BaseType);              builder.SetCustomAttribute(tableAttributeBuilder);                            foreach  ( var  item  in  meta.PropertyMetas)              {                  AddProperty(item, builder, meta.BaseType);              }              return  builder.CreateTypeInfo().UnderlyingSystemType;          }                   private  static  void  AddProperty(TypeMeta.TypePropertyMeta property, TypeBuilder builder,Type baseType)          {              PropertyBuilder propertyBuilder = builder.DefineProperty(property.PropertyName, PropertyAttributes.None, property.PropertyType,  null );                foreach  ( var  item  in  property.AttributeMetas)              {                  if  (item.ConstructorArgTypes== null )                  {                      item.ConstructorArgTypes =  new  Type[0];                      item.ConstructorArgValues =  new  object [0];                  }                  ConstructorInfo cInfo = item.AttributeType.GetConstructor(item.ConstructorArgTypes);                  PropertyInfo[] pInfos = item.Properties.Select(m => item.AttributeType.GetProperty(m)).ToArray();                  CustomAttributeBuilder aBuilder =  new  CustomAttributeBuilder(cInfo, item.ConstructorArgValues, pInfos, item.PropertyValues);                  propertyBuilder.SetCustomAttribute(aBuilder);              }                MethodAttributes attributes = MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public;              MethodBuilder getMethodBuilder = builder.DefineMethod( "get_"  + property.PropertyName, attributes, property.PropertyType, Type.EmptyTypes);              ILGenerator iLGenerator = getMethodBuilder.GetILGenerator();              MethodInfo getMethod = baseType.GetMethod( "GetValue" ).MakeGenericMethod( new  Type[] { property.PropertyType });              iLGenerator.DeclareLocal(property.PropertyType);              iLGenerator.Emit(OpCodes.Nop);              iLGenerator.Emit(OpCodes.Ldarg_0);              iLGenerator.Emit(OpCodes.Ldstr, property.PropertyName);              iLGenerator.EmitCall(OpCodes.Call, getMethod,  null );              iLGenerator.Emit(OpCodes.Stloc_0);              iLGenerator.Emit(OpCodes.Ldloc_0);              iLGenerator.Emit(OpCodes.Ret);              MethodInfo setMethod = baseType.GetMethod( "SetValue" ).MakeGenericMethod( new  Type[] { property.PropertyType });              MethodBuilder setMethodBuilder = builder.DefineMethod( "set_"  + property.PropertyName, attributes,  null ,  new  Type[] { property.PropertyType });              ILGenerator generator2 = setMethodBuilder.GetILGenerator();              generator2.Emit(OpCodes.Nop);              generator2.Emit(OpCodes.Ldarg_0);              generator2.Emit(OpCodes.Ldstr, property.PropertyName);              generator2.Emit(OpCodes.Ldarg_1);              generator2.EmitCall(OpCodes.Call, setMethod,  null );              generator2.Emit(OpCodes.Nop);              generator2.Emit(OpCodes.Ret);              propertyBuilder.SetGetMethod(getMethodBuilder);              propertyBuilder.SetSetMethod(setMethodBuilder);            }          }

　　主要部分是ILGenerator的使用，具体使用方式大家可以查阅相关资料，这里不再详细介绍。

　　三、如何让ef识别动态类型

　　在ef中操作对象需要借助DbContext，如果静态的类型，那我们就可以在定义DbContext的时候，增加DbSet<TEntity>类型的属性即可，但是我们现在的类型是在运行时生成的，那怎么样才能让DbContext能够认识这个类型，答案是OnModelCreating方法，在这个方法中，我们把动态模型加入到DbContext中，具体方式如下：

1 2 3 4 5 6 7 8 9 10 11

protected  override  void  OnModelCreating(ModelBuilder modelBuilder)        { 　　　　　 //_modelProvider就是我们上面定义的IRuntimeModelProvider,通过依赖注入方式获取到实例            Type[] runtimeModels = _modelProvider.GetTypes( "product" );            foreach  ( var  item  in  runtimeModels)            {                modelBuilder.Model.AddEntityType(item);            }              base .OnModelCreating(modelBuilder);        }

　　

　　这样在我们DbContext就能够识别动态类型了。注册到DbContext很简单，关键是如何进行信息的操作。

　　四、如何结合ef对动态信息进行操作

　　我们先把上面的DbContext类补充完整，

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public  class  ShopDbContext : DbContext    {        private  readonly  IRuntimeModelProvider _modelProvider;        public  ShopDbContext(DbContextOptions<ShopDbContext> options, IRuntimeModelProvider modelProvider)            :  base (options)        {            _modelProvider = modelProvider;        }          protected  override  void  OnModelCreating(ModelBuilder modelBuilder)        {            Type[] runtimeModels = _modelProvider.GetTypes( "product" );            foreach  ( var  item  in  runtimeModels)            {                modelBuilder.Model.AddEntityType(item);            }              base .OnModelCreating(modelBuilder);        }<br>}

　　

　　在efcore中对象的增加，删除，更新可以直接使用DbContext就可以完成，比如增加代码，

1 2	ShopDbContext.Add(entity); ShopDbContext.SaveChanges();

　　更新操作比较简单，比较难解决的是查询，包括查询条件设置等等。国外有大牛写了一个LinqDynamic，我又对它进行了修改，并增加了一些异步方法，代码我就不粘贴到文章里了，大家可以直接下载源码：下载linqdynamic

　　LinqDynamic中是对IQueryable的扩展，提供了动态linq的查询支持，具体使用方法大家可以百度。efcore中DbSet泛型定义如下：

　　

　　public abstract partial class DbSet<TEntity>: IQueryable<TEntity>, IAsyncEnumerableAccessor<TEntity>, IInfrastructure<IServiceProvider>

　　不难发现，它就是一个IQueryable<TEntity>，而IQueryable<TEntity>又是一个IQueryable，正好是LinqDynamic需要的类型，所以我们现在需要解决的是根据动态模型信息，获取到一个IQueryable，我采用反射方式获取：

　　　ShopDbContext.GetType().GetTypeInfo().GetMethod("Set").MakeGenericMethod(type).Invoke(context, null) as IQueryable;

　　有了IQueryable，就可以使用LinqDynamic增加的扩展方式，实现动态查询了。查询到的结果是一个动态类型，但是我们前面提到，我们所有的动态类型都是一个DynamicEntity类型，所以我们要想访问某个属性的值的时候，我们可以直接采用索引的方式读取，比如obj["属性"]，然后结合RuntimeModelMeta配置信息，就可以动态的把数据呈现到页面上了。

　　上面的方案还可以继续改进，可以把配置信息保存到数据库中，在程序中增加模型配置管理的功能，实现在线的模型配置，配置改动可以同步操作数据库表结构，这种方案后续补充上，敬请期待。