动态生成类、接口及其成员

1.永春博客里提供的将string动态编译类的方式(以下摘自其博客)

动态生成类
我们可以在程序运行过程中调用.NET中提供的编译类，动态的将一段string编译成一个类，然后再通过反射来调用它
需要使用的命名空间：

using System.CodeDom 
using System.CodeDom.Compiler 
using Microsoft.CSharp 
using System.Reflection 

 动态创建、编译类的代码如下：

public static Assembly NewAssembly() 
{ 
//创建编译器实例。   
       provider = new CSharpCodeProvider(); 
//设置编译参数。   
       paras = new CompilerParameters(); 
       paras.GenerateExecutable = false; 
       paras.GenerateInMemory = true; 

//创建动态代码。   
       StringBuilder classSource = new StringBuilder(); 
       classSource.Append("public   class   DynamicClass \n"); 
       classSource.Append("{\n"); 

//创建属性。   
       classSource.Append(propertyString("aaa")); 
       classSource.Append(propertyString("bbb")); 
       classSource.Append(propertyString("ccc")); 

       classSource.Append("}"); 

       System.Diagnostics.Debug.WriteLine(classSource.ToString()); 

//编译代码。   
CompilerResults result = provider.CompileAssemblyFromSource(paras, classSource.ToString()); 

//获取编译后的程序集。   
Assembly assembly = result.CompiledAssembly; 

return assembly; 
   } 

private static string propertyString(string propertyName) 
{ 
       StringBuilder sbProperty = new StringBuilder(); 
       sbProperty.Append(" private   int   _" + propertyName + "   =   0;\n"); 
       sbProperty.Append(" public   int   " + "" + propertyName + "\n"); 
       sbProperty.Append(" {\n"); 
       sbProperty.Append(" get{   return   _" + propertyName + ";}   \n"); 
       sbProperty.Append(" set{   _" + propertyName + "   =   value;   }\n"); 
       sbProperty.Append(" }"); 
return sbProperty.ToString(); 
} 

propertyString方法就是用来拼写字符串的
整个代码比较简单，主要步骤就是：1、拼写类的字符串  2、调用CSharpCodeProvider类进行编译得到程序集(assembly)
接下来就可以利用之前反射的方法来动态调用这个类中的属性了：

object Class1 = assembly.CreateInstance("DynamicClass"); 
ReflectionSetProperty(Class1, "aaa", 10); 
ReflectionGetProperty(Class1, "aaa"); 

object Class2 = assembly.CreateInstance("DynamicClass"); 
ReflectionSetProperty(Class1, "bbb", 20); 
ReflectionGetProperty(Class1, "bbb"); 

DynamicClass是我动态类的类名，aaa和bbb是其中的属性
ReflectionSetProperty和ReflectionGetProperty代码如下：

给属性赋值

private static void ReflectionSetProperty(object objClass, string propertyName, int value) 
{ 
    PropertyInfo _Property = objClass.GetType().GetProperty(propertyName); 
if (_Property != null && _Property.CanRead) 
    { 
        _Property.SetValue(objClass, value, null); 
    } 
} 

取得属性的值

private static void ReflectionGetProperty(object objClass, string propertyName) 
{ 
     PropertyInfo _Property = objClass.GetType().GetProperty(propertyName); 
if (_Property != null && _Property.CanWrite) 
     { 
         _Property.GetValue(objClass, null); 
     } 
} 

2.使用Emit动态创建类，并添加实例成员，属性，方法等（以下内容摘自FrogTan的博客）

下面接着说说如何为动态创建的类添加实例成员，属性，方法等。

准备工作     这次来创建一个Student类。首先准备好大致框架：

AssemblyName assemName = new AssemblyName(); 
assemName.Name = "EmitStudy2"; 
AssemblyBuilder asmBuilder = 
AppDomain.CurrentDomain.DefineDynamicAssembly(assemName, 
AssemblyBuilderAccess.RunAndSave); 
var mdlBldr = asmBuilder.DefineDynamicModule("EmitStudy2", "EmitStudy2.dll"); 
var typeBldr = mdlBldr.DefineType("Sdudent", TypeAttributes.Public); 
//TODO:添加成员 
typeBldr.CreateType(); 
asmBuilder.Save("EmitStudy2.dll"); 

一、定义实例变量

Student包含以下实例成员：id(int),name(string)。下面就来一一创建它们。

创建实例成员要通过TypeBuilder的DefineField方法来完成。该方法有以下形式：

• DefineField(String, Type, FieldAttributes) :用给定的名称、属性和字段类型，向类型中添加新字段。
• DefineField(String, Type, Type[], Type[], FieldAttributes):用给定的名称、属性、字段类型和自定义修饰符，向类型中添加新字段。

     一般情形下，前者使用的比较多。首先创建id:

var fldId = typeBldr.DefineField("id", typeof (int), FieldAttributes.Private); 

     接着是name:

var fldName = typeBldr.DefineField("name", typeof(string), FieldAttributes.Private); 

这时您用reflector打开EmitStudy2.dll会发现Student已经拥有了我们想要的id,name,scores实例变量。

  二、定义属性

Student类相应的也包含了三个简单属性：Id,Name。大家都知道，C#中的属性会被编译为相应的get_XXX或set_XXX的方法组。因此创建属性实质就是在创建方法。

创建方法通过TypeBuilder.DefineMethod完成。该方法重载形式较多，这里就不一一列出，感兴趣的请看这里。还是以Id为例，我们为之创建GetId和SetId方法:

var methodGetId = typeBldr.DefineMethod("GetId", MethodAttributes.Public, typeof (int), null); 
var methodSetId = typeBldr.DefineMethod("SetId", MethodAttributes.Public, null, new Type[] {typeof (int)}); 
var ilGetId = methodGetId.GetILGenerator(); 
ilGetId.Emit(OpCodes.Ldarg_0); 
ilGetId.Emit(OpCodes.Ldfld, fldId); 
ilGetId.Emit(OpCodes.Ret); 
var ilSetId = methodSetId.GetILGenerator(); 
ilSetId.Emit(OpCodes.Ldarg_0); 
ilSetId.Emit(OpCodes.Ldarg_1); 
ilSetId.Emit(OpCodes.Stfld,  fldId); 

这段代码定义了两个方法：GetId和SetId,但是这两个方法还没有真正和属性关联起来。首先，我们需要创建属性Id:

var prptId = typeBldr.DefineProperty("Id", PropertyAttributes.None, typeof (int), null); 

（在这里要说明的一点是，在很多DefineXXX方法中都包含返回类型和参数类型这两个属性，如果无返回值或者无参数直接传递null就可以了）

创建了名称为Id的属性后，我们再将属性和get/set方法关联起来：

prptId.SetGetMethod(methodGetId); 
prptId.SetSetMethod(methodSetId); 

另外两个属性类似。在上面创建get/set方法时提到了几个新的OpCodes:

OpCodes.Ldarg_0:Ldarg是加载方法参数的意思。这里arg_0事实上是对当前对象的引用即this。因为类的实例方法（非静态方法）在调用时，this是会作为第一个参数传入的。

OpCodes.Ldarg_1:当然就是参数列表的第一个参数了。

OpCodes.Stfld:用新值替换在对象引用或指针的字段中存储的值。

堆栈转换行为依次为： 1.将对象引用（或指针）推送到堆栈上。

2.将值推送到堆栈上。从堆栈中弹出该值和对象引用/指针；

3.用所提供的值替换对象中 field 的值。

   意思就是在往field存值时需要三个步骤：

1.将对象引用（或指针）推送到堆栈上：ilSetId.Emit(OpCodes.Ldarg_0);=》加载this

2.将值推送到堆栈上。从堆栈中弹出该值和对象引用/指针：ilSetId.Emit(OpCodes.Ldarg_1)=》将要存入field的值载入堆栈

3.用所提供的值替换对象中 field 的值：ilSetId.Emit(OpCodes.Stfld,  fldId)=》设置field的值

OpCodes.Ldfld:当然就是将指定field的值加载到堆栈上了。

OpCodes的成员命名都是很规范的，ldXXX一般就是加载什么到堆栈,stXXX则是设置xxx的值，ldcXX则是加载常量xx到堆栈，所以写代码时如果遇到不知道命令是什么就完全可以按照这种规则去推测。对于命令不知道如何用时去查查MSDN相应的堆栈转换规则是什么就一目了然了。

三、创建方法

在上一小节已经创建了几个方法，这里再大致描述下创建方法的流程:

1.使用TypeBuilder.DefineMethod创建一个方法;

2.调用 MethodBuilder.GetIlGenerator获取IL生成器

3.写入自己需要的IL代码。

我们在这里为Student添加一个ToString方法,我们要达到的目标如下:

public override string ToString() 
{ 
return string.Format("ID:{0} Name:{1}", this.id, this.name); 
} 

在这里要注意的是string.Format产生的结果并不会被推送到堆栈上，而是会被存储到一个局部变量当中。只不过平时写C#代码并未体现出这一点而已。因此可以如下创建此方法:

var methodToString = typeBldr.DefineMethod("ToString", MethodAttributes.Virtual | MethodAttributes.Public,typeof (string), null); 
var il = methodToString.GetILGenerator(); 
var local = il.DeclareLocal(typeof (string));//创建一个局部变量 
il.Emit(OpCodes.Ldstr,"ID:{0} Name:{1}"); 
il.Emit(OpCodes.Ldarg_0); 
il.Emit(OpCodes.Ldfld, fldId); 
il.Emit(OpCodes.Box, typeof(int)); 
il.Emit(OpCodes.Ldarg_0); 
il.Emit(OpCodes.Ldfld, fldName); 
il.Emit(OpCodes.Call, typeof(string).GetMethod("Format", new Type[]{typeof(string), typeof(object), typeof(object)})); 
il.Emit(OpCodes.Stloc, local); 
il.Emit(OpCodes.Ldloc, local); 
il.Emit(OpCodes.Ret); 

这里有几个新元素：

1.创建局部变量:使用ILGenerator.DeclareLocal完成

2.OpCodes.Box：对值类型装箱，注意第二个参数为该值类型的类型。

3.OpCodes.Stloc和OpCodes.Ldloc:设置局部变量的值和加载局部变量值到堆栈。

到现在为止，我们的Student反编译后大致如下：

public class Sdudent 
    { 
// Fields 
private int id; 
private string name; 
// Methods 
public override string ToString() 
        { 
return string.Format("ID:{0} Name:{1}", this.id, this.name); 
        } 
// Properties 
public int Id 
        { 
get 
            { 
return this.id; 
            } 
set 
            { 
this.id = value; 
            } 
        } 
public string Name 
        { 
get 
            { 
return this.name; 
            } 
set 
            { 
this.name = value; 
            } 
        } 
    } 

四.其他

上面的实例都是关于实例成员的，对于静态成员呢？

加载或设置静态实例字段会相应的变为:stsfld和ldsfld。而静态方法则由于不会将this作为第一个参数传递，因此ldarg_0就相应地变成了实际参数列表的第一个从参数。