高性能反射初体验2

主要代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

namespace Reflx_Method
{
    public class Class1
    {
        public Class1()
        { }
      
        

      
        /// <summary>
        /// BeginCatchBlock()用法
        /// </summary>
        public void ILGenerator_BeginCatchBlock()
        {
            AppDomain current = AppDomain.CurrentDomain;
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "AdderExceptionAsm";
            AssemblyBuilder myAsmBldr = current.DefineDynamicAssembly(myAsmName,
                                     AssemblyBuilderAccess.RunAndSave);

            ModuleBuilder myModBldr = myAsmBldr.DefineDynamicModule(myAsmName.Name,
                               myAsmName.Name + ".dll");
            //internal class Adder{

            TypeBuilder myTypeBldr = myModBldr.DefineType("Adder");

            

            // This method will add two numbers which are 100 or less. If either of the 此方法将添加两个数字是100或更少。如果任
            // passed integer vales are greater than 100, it will throw an exception. 通过整数山谷大于100 ，它会抛出一个异常
        
            //  public static int DoAdd(int num1, int num2){
            //参数

            Type[] adderParams = new Type[] { typeof(int), typeof(int) };
            ///DoAdd方法
            MethodBuilder adderBldr = myTypeBldr.DefineMethod("DoAdd",
                               MethodAttributes.Public |
                               MethodAttributes.Static,
                               typeof(int),
                               adderParams);

            ILGenerator adderIL = adderBldr.GetILGenerator();

            // Types and methods used in the code to throw, catch, and 抛出，捕捉，在代码中使用的类型和方法
            // display OverflowException. Note that if the catch block were 显示引发OverflowException 。请注意，如果catch块
            // for a more general type, such as Exception, we would need  更普遍的类型，如异常，我们需要
            // a MethodInfo for that type's ToString method.  该类型的ToString方法的MethodInfo 。

            //    OverflowException exception = new OverflowException("Cannot accept values over 100 for add."); throw new OverflowException();
            ///
            /// <summary>
            /// OverflowException异常Type
            /// </summary>
            Type overflow = typeof(OverflowException);
            ConstructorInfo exCtorInfo = overflow.GetConstructor(
                              new Type[] { typeof(string) });
            //  Console.WriteLine("Caught {0}", exception1.ToString());

            ///OverflowException异常Type的ToString方法
            MethodInfo exToStrMI = overflow.GetMethod("ToString");
            ///Console对象Type的WriteLine方法
            MethodInfo writeLineMI = typeof(Console).GetMethod("WriteLine",
                              new Type[] 
                        {typeof(string),
                         typeof(object)});
           // int num;
            ///局部变量 int num
            LocalBuilder tmp1 = adderIL.DeclareLocal(typeof(int));

            ///OverflowException exception1 异常变量 
            LocalBuilder tmp2 = adderIL.DeclareLocal(overflow);

            // In order to successfully branch, we need to create labels  为了成功的分支，我们需要创建标签
            // representing the offset IL instruction block to branch to. 代表跳转到偏移的IL指令块。
            // These labels, when the MarkLabel(Label) method is invoked, 这些标签的MarkLabel （标签）方法被调用时，
            // will specify the IL instruction to branch to.   将跳转到指定的IL指令
            // 
            ///标签1
            Label failed = adderIL.DefineLabel();
            ///标签2
            Label endOfMthd = adderIL.DefineLabel();

            /// Begin the try block. 开始的try块。  try{ 
            Label exBlock = adderIL.BeginExceptionBlock();

          
          
           
            // First, load argument 0 and the integer value of "100" onto the  首先，加载参数0和整数值到“100"
            adderIL.Emit(OpCodes.Ldarg_0);
            // stack. If arg0 > 100, branch to the label "failed", which is marked  叠加。如果arg0的> 100，分支标签“失败” ，这标志着
            adderIL.Emit(OpCodes.Ldc_I4_S, 100);
            // as the address of the block that throws an exception.  块抛出一个异常的地址
            adderIL.Emit(OpCodes.Bgt_S, failed);



            // branching unconditionally to the instruction at the label "endOfMthd". 无条件分支的指令在标签“ endOfMthd ” 。
           
            adderIL.Emit(OpCodes.Ldarg_1);
            // Now, check to see if argument 1 was greater than 100. If it was,  现在，请检查，如果参数1大于100 。如果是，
            adderIL.Emit(OpCodes.Ldc_I4_S, 100);
            // branch to "failed." Otherwise, fall through and perform the addition, 分支“失败。 ”否则，属于通过并执行另外，
            adderIL.Emit(OpCodes.Bgt_S, failed);

            //参数0
            adderIL.Emit(OpCodes.Ldarg_0);
            //参数1
            adderIL.Emit(OpCodes.Ldarg_1);
            //无符号相加
            adderIL.Emit(OpCodes.Add_Ovf_Un);
            // Store the result of the addition. 存储在另外的结果。
            adderIL.Emit(OpCodes.Stloc_S, tmp1); 

            adderIL.Emit(OpCodes.Br_S, endOfMthd);

            // If one of the arguments was greater than 100, we need to throw an  如果一个参数是大于100 ，我们需要抛出
            // exception. We'll use "OverflowException" with a customized message. 例外。我们将使用一个定制的消息“引发OverflowException ” 。
            // First, we load our message onto the stack, and then create a new   首先，我们加载到堆栈上我们的信息，然后创建一个新的
            // exception object using the constructor overload that accepts a 使用构造函数重载，它接受一个异常对象
            // string message.  字符串消息
            // OverflowException exception = new OverflowException("不能接受的增加值超过100 。.");

            adderIL.MarkLabel(failed);
            adderIL.Emit(OpCodes.Ldstr, "不能接受的增加值超过100 。");
            adderIL.Emit(OpCodes.Newobj, exCtorInfo);

            // We're going to need to refer to that exception object later, so let's 我们要需要参考该异常对象后，让我们
            // store it in a temporary variable. Since the store function pops the 存储在一个临时变量。由于存储功能弹出
            // the value/reference off the stack, and we'll need it to throw the 堆栈的值/参考，我们需要它扔
            // exception, we will subsequently load it back onto the stack as well.例外，我们将随后加载它放回堆栈以及。
             
            adderIL.Emit(OpCodes.Stloc_S, tmp2);
            adderIL.Emit(OpCodes.Ldloc_S, tmp2);

            // Throw the exception now on the stack. 现在抛出异常堆栈  throw new OverflowException();

            adderIL.ThrowException(overflow);

            // Start the catch block for OverflowException.
            /// 开始为引发OverflowException catch块。 
            adderIL.BeginCatchBlock(overflow);

            // When we enter the catch block, the thrown exception    当我们进入catch块，抛出异常
            // is on the stack. Store it, then load the format string  是在堆栈上。储存，然后加载格式字符串
            // for WriteLine. 的WriteLine 。

            //
            adderIL.Emit(OpCodes.Stloc_S, tmp2);
            adderIL.Emit(OpCodes.Ldstr, "Caught {0}");

            // Push the thrown exception back on the stack, then   推抛出的异常堆栈上的背部，然后
            // call its ToString() method. Note that if this catch block 调用其ToString （）方法。请注意，如果该catch块
            // were for a more general exception type, like Exception,  为更一般的异常类型，如异常
            // it would be necessary to use the ToString for that type. 就必须使用这种类型的ToString 。
            // Console.WriteLine("Caught {0}", exception1.ToString());

            adderIL.Emit(OpCodes.Ldloc_S, tmp2);
            adderIL.EmitCall(OpCodes.Callvirt, exToStrMI, null);

            // The format string and the return value from ToString() are 格式字符串的ToString（）的返回值
            // now on the stack. Call WriteLine(string, object). 现在堆栈。调用的WriteLine （字符串，对象） 。
            //
            adderIL.EmitCall(OpCodes.Call, writeLineMI, null);

            // Since our function has to return an integer value, we'll load -1 onto 因为我们的函数返回一个整型值，我们将载入-1到
            // the stack to indicate an error, and store it in local variable tmp1. 堆栈显示一个错误，它存储在局部变量TMP1 。
            // num = -1;

            adderIL.Emit(OpCodes.Ldc_I4_M1);
            adderIL.Emit(OpCodes.Stloc_S, tmp1);

            // End the exception handling block.  num = -1;


            adderIL.EndExceptionBlock();

            // The end of the method. If no exception was thrown, the correct value  该方法的结束。如果没有异常被抛出，正确的值
            // will be saved in tmp1. If an exception was thrown, tmp1 will be equal  将被保存在TMP1 。如果一个异常被抛出， TMP1将等于
            // to -1. Either way, we'll load the value of tmp1 onto the stack and return. -1。无论哪种方式，我们将加载到堆栈，并返回TMP1价值。
            // return num;

            adderIL.MarkLabel(endOfMthd);
            adderIL.Emit(OpCodes.Ldloc_S, tmp1);
            adderIL.Emit(OpCodes.Ret);

           

            Type adderType = myTypeBldr.CreateType();

            object addIns = Activator.CreateInstance(adderType);

            object[] addParams = new object[2];

            Console.Write("Enter an integer value: ");
            addParams[0] = (object)Convert.ToInt32(Console.ReadLine());

            Console.Write("Enter another integer value: ");
            addParams[1] = (object)Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("If either integer was > 100, an exception will be thrown.");
            Console.WriteLine("---");

            Console.WriteLine("{0} + {1} = {2}",
                  addParams[0], addParams[1],
                  adderType.InvokeMember("DoAdd",
                     BindingFlags.InvokeMethod,
                     null,
                     addIns,
                     addParams));
            myAsmBldr.Save("AdderExceptionAsm.dll");
          
        }
        
        /// <summary>
        /// BeginScope()与EndScope()用法
        /// </summary>
        public void ILGenerator_Begin_End_Scope()
        {
            // 获取当前AppDomain 。

            AppDomain myAppDomain = AppDomain.CurrentDomain;
            AssemblyName myAssemblyName = new AssemblyName();
            myAssemblyName.Name = "SampleAssembly";

            // Create a dynamic assembly 'myAssembly' with access mode 'Run'.创建一个动态的组装与访问模式“运行” “ myAssembly的” 。

            AssemblyBuilder myAssembly = myAppDomain.DefineDynamicAssembly(
                                    myAssemblyName, AssemblyBuilderAccess.RunAndSave);
            // Create a dynamic module 'myModule' in 'myAssembly'. 创建一个动态模块myAssembly的“ MyModule的” 。

            ModuleBuilder myModule = myAssembly.DefineDynamicModule("MyDynamicModule", "MyDynamicModule.dll", true);
            // Define a public class 'MyDynamicClass'.  定义一个公共类的“ MyDynamicClass ' 。

            TypeBuilder myTypeBuilder = myModule.DefineType("MyDynamicClass",
                                             TypeAttributes.Public);
            // Define a public string field.  定义一个公共的字符串字段。

            FieldBuilder myField = myTypeBuilder.DefineField("MyDynamicField1",
                                     typeof(String), FieldAttributes.Public);
            // Create the constructor.  创建构造。

            Type[] myConstructorArgs = { typeof(String) };
            ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
               MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);
            ConstructorInfo mySuperConstructor = typeof(Object).GetConstructor(new Type[0]);
            // Generate IL for 'myConstructor'.  生成IL ' myConstructor “ ”

            ILGenerator myConstructorIL = myConstructor.GetILGenerator();
            // Emit the necessary opcodes. 发出了必要的操作码

            myConstructorIL.Emit(OpCodes.Ldarg_0); 
            myConstructorIL.Emit(OpCodes.Call, mySuperConstructor);
            myConstructorIL.Emit(OpCodes.Ldarg_0);
            myConstructorIL.Emit(OpCodes.Ldarg_1);
            myConstructorIL.Emit(OpCodes.Stfld, myField);
            myConstructorIL.Emit(OpCodes.Ret);

            // Define a dynamic method named 'MyDynamicMethod'.  定义和动态的方法，名为“ MyDynamicMethod

        

            
            MethodBuilder myMethod = myTypeBuilder.DefineMethod("MyDynamicMethod",
               MethodAttributes.Public | MethodAttributes.SpecialName, typeof(string), Type.EmptyTypes);
            // Generate IL for 'myMethod'.
            ILGenerator myMethodIL = myMethod.GetILGenerator();

            // Begin the scope for a local variable.开始的一个局部变量的范围。

            myMethodIL.BeginScope();

            LocalBuilder myLocalBuilder = myMethodIL.DeclareLocal(typeof(int));

            LocalBuilder shili = myMethodIL.DeclareLocal(typeof(int));
            Console.WriteLine("\n试图访问的范围内，局部变量.");
            Console.WriteLine("'myLocalBuilder' type is: {0}", myLocalBuilder.LocalType);
            myMethodIL.Emit(OpCodes.Ldstr, "Local value");
            myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder);

            
             myMethodIL.Emit(OpCodes.Ldstr, "Local value111");
             myMethodIL.Emit(OpCodes.Stloc_S, shili);




             Console.WriteLine("\n试图访问的范围内，局部变量.");
             Console.WriteLine("'myLocalBuilder' type is: {0}", shili.LocalType);

           
            // End the scope of 'myLocalBuilder'.
            myMethodIL.EndScope();

            // Access the local variable outside the scope.
            Console.WriteLine("\nTrying to access the local variable outside the scope:");
            myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder);
            myMethodIL.Emit(OpCodes.Ldloc_S, shili);
            myMethodIL.Emit(OpCodes.Ret);

            // Create 'MyDynamicClass' class.
            Type myType1 = myTypeBuilder.CreateType();


            myAssembly.Save("MyDynamicModule.dll");
        }


       

        


    }
}

调用代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;

namespace Reflx_Method
{
   
    class Program
    {
       
        static void Main(string[] args)
        { 
            new Class1().ILGenerator_Begin_End_Scope();

            new Class1().ILGenerator_BeginCatchBlock();

        }
         
    } 

}
 

方法ILGenerator_BeginCatchBlock（）等效

public class Adder
{
    // Methods
    public static int DoAdd(int num1, int num2)
    {
        int num;
        OverflowException exception;
        try
        {
            if ((num1 <= 100) && (num2 <= 100))
            {
                return (num1 + num2);
            }
            exception = new OverflowException("不能接受超过100的参数");
            throw new OverflowException();
        }
        catch (OverflowException exception2)
        {
            Console.WriteLine("捕捉 {0}{1}", exception.ToString(), exception2.ToString());
            num = -1;
        }
        return num;
    }
}

 

方法ILGenerator_Begin_End_Scope（）等效

public class MyDynamicClass
{
    // Fields
    public string MyDynamicField1;

    // Methods
    public MyDynamicClass(string text1)
    {
        this.MyDynamicField1 = text1;
    }

    public string MyDynamicMethod()
    {
        int num2 = "Local value111";
        return (string) num2;
    }
}

 

 

DEMO