DynamicMethod 类

2013/12/13

定义并表示一种可编译、执行和丢弃的动态方法。丢弃的方法可用于垃圾回收。

Namespace:  System.Reflection.Emit
程序集:  mscorlib(位于 mscorlib.dll 中)

public sealed class DynamicMethod : MethodInfo

DynamicMethod 类型公开以下成员。

  名称说明
公共方法DynamicMethod(String, Type, Type[])创建匿名承载的动态方法,指定方法名称、返回类型和参数类型。
公共方法DynamicMethod(String, Type, Type[], Boolean)创建匿名承载的动态方法,指定方法名称、返回类型、参数类型,并指定动态方法的 Microsoft 中间语言 (MSIL) 访问的类型和成员是否应跳过实时 (JIT) 可见性检查。
公共方法DynamicMethod(String, Type, Type[], Module)安全非常关键。 创建一个对模块全局有效的动态方法,指定方法名称、返回类型、参数类型和模块。
公共方法DynamicMethod(String, Type, Type[], Type)安全非常关键。 创建一个动态方法,指定方法名称、返回类型、参数类型和动态方法逻辑关联的类型。
公共方法DynamicMethod(String, Type, Type[], Module, Boolean)安全非常关键。 创建一个对模块全局有效的动态方法,指定方法名称、返回类型、参数类型和模块,并指定动态方法的 Microsoft 中间语言 (MSIL) 访问的类型和成员是否应跳过实时 (JIT) 可见性检查。
公共方法DynamicMethod(String, Type, Type[], Type, Boolean)安全非常关键。 创建一个动态方法,指定方法名称、返回类型、参数类型、动态方法逻辑关联的类型,并指定动态方法的 Microsoft 中间语言 (MSIL) 访问的类型和成员是否应跳过实时 (JIT) 可见性检查。
公共方法DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)安全非常关键。 创建一个对模块全局有效的动态方法,指定方法名称、特性、调用约定、返回类型、参数类型和模块,并指定动态方法的 Microsoft 中间语言 (MSIL) 访问的类型和成员是否应跳过实时 (JIT) 可见性检查。
公共方法DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)安全非常关键。 创建一个动态方法,指定方法名称、特性、调用约定、返回类型、参数类型、动态方法逻辑关联的类型,并指定动态方法的 Microsoft 中间语言 (MSIL) 访问的类型和成员是否应跳过实时 (JIT) 可见性检查。
返回顶部

  名称说明
公共属性Attributes获取创建动态方法时指定的特性。 (重写 MethodBase.Attributes。)
公共属性CallingConvention获取创建动态方法时指定的调用约定。 (重写 MethodBase.CallingConvention。)
公共属性ContainsGenericParameters获取一个值,该值指示泛型方法是否包含未赋值的泛型类型参数。 (从 MethodBase 继承。)
公共属性CustomAttributes获取包含此成员的自定义特性的集合。 (从 MemberInfo 继承。)
公共属性DeclaringType获取声明方法的类型,对于动态方法,类型始终为 null (重写 MemberInfo.DeclaringType。)
公共属性InitLocals获取或设置一个值,该值指示方法中的局部变量是否初始化为零。
公共属性IsAbstract获取一个值,该值指示方法是否为抽象方法(在 Visual Basic 中为 MustInherit)。 (从 MethodBase 继承。)
公共属性IsAssembly获取一个值,该值指示此方法或构造函数的潜在可见性是否由 MethodAttributes.Assembly 描述;也就是说,此方法或构造函数只对同一程序集中的其他类型可见,而对该程序集以外的派生类型则不可见。 (从 MethodBase 继承。)
公共属性IsConstructor获取指示该方法是否为构造函数的值。 (从 MethodBase 继承。)
公共属性IsFamily获取一个值,该值指示此方法或构造函数的可见性是否由 MethodAttributes.Family 描述;也就是说,此方法或构造函数仅在其类和派生类内可见。 (从 MethodBase 继承。)
公共属性IsFamilyAndAssembly获取一个值,该值指示此方法或构造函数的可见性是否由 MethodAttributes.FamANDAssem 描述;也就是说,此方法或构造函数可由派生类调用,但仅当这些派生类在同一程序集中时。 (从 MethodBase 继承。)
公共属性IsFamilyOrAssembly获取一个值,该值指示此方法或构造函数的潜在可见性是否由 MethodAttributes.FamORAssem 描述;也就是说,此方法或构造函数可由派生类(无论其位置如何)和同一程序集中的类调用。 (从 MethodBase 继承。)
公共属性IsFinal获取一个值,该值指示此方法是否为 final(在 Visual Basic 中为 NotOverridable)。 (从 MethodBase 继承。)
公共属性IsGenericMethod获取指示该方法是否为泛型方法的值。 (从 MethodBase 继承。)
公共属性IsGenericMethodDefinition获取指示该方法是否为泛型方法定义的值。 (从 MethodBase 继承。)
公共属性IsHideBySig获取一个值,该值指示是否只有一个签名完全相同的同一种类的成员在派生类中是隐藏的。 (从 MethodBase 继承。)
公共属性IsPrivate获取一个值,该值指示此成员是否为私有的。 (从 MethodBase 继承。)
公共属性IsPublic获取一个值,该值指示此方法是否为一个公共方法。 (从 MethodBase 继承。)
公共属性IsSpecialName获取一个值,该值指示此方法是否具有特殊名称。 (从 MethodBase 继承。)
公共属性IsStatic获取一个值,该值指示该方法是否标记有 static(在 Visual Basic 中为 Shared)。 (从 MethodBase 继承。)
公共属性IsVirtual获取一个值,该值指示方法是否为 virtual(在 Visual Basic 中为 Overridable)。 (从 MethodBase 继承。)
公共属性MemberType获取一个 MemberTypes 值,该值指示此成员是方法。 (从 MethodInfo 继承。)
公共属性MetadataToken获取一个值,该值标识元数据元素。 (从 MemberInfo 继承。)
公共属性MethodHandle动态方法不支持。 (重写 MethodBase.MethodHandle。)
公共属性MethodImplementationFlags获取指定方法实现特性的 MethodImplAttributes 标志。 (从 MethodBase 继承。)
公共属性Module获取动态方法逻辑关联的模块。 (重写 MemberInfo.Module。)
公共属性Name获取动态方法的名称。 (重写 MemberInfo.Name。)
公共属性ReflectedType获取在反射中用于获取方法的类。 (重写 MemberInfo.ReflectedType。)
公共属性ReturnParameter获取动态方法的返回参数。 (重写 MethodInfo.ReturnParameter。)
公共属性ReturnType获取动态方法的返回值的类型。 (重写 MethodInfo.ReturnType。)
公共属性ReturnTypeCustomAttributes获取动态方法的返回类型的自定义特性。 (重写 MethodInfo.ReturnTypeCustomAttributes。)
返回顶部

  名称说明
公共方法CreateDelegate(Type)完成动态方法,并创建一个指定类型的委托,该委托可用于执行此动态方法。 (重写 MethodInfo.CreateDelegate(Type)。)
公共方法CreateDelegate(Type, Object)完成动态方法并创建一个可用于执行该方法的委托,指定委托类型和委托绑定到的对象。 (重写 MethodInfo.CreateDelegate(Type, Object)。)
公共方法DefineParameter定义动态方法的参数。
公共方法Equals返回一个值,该值指示此实例是否与指定的对象相等。 (从 MethodInfo 继承。)
受保护的方法Finalize允许 Object 在垃圾回收器回收该对象之前尝试释放资源并执行其他清理操作。 (从 Object 继承。)
公共方法GetBaseDefinition返回方法的基实现。 (重写 MethodInfo.GetBaseDefinition()。)
公共方法GetCustomAttributes(Boolean)返回为此方法定义的所有自定义特性。 (重写 MemberInfo.GetCustomAttributes(Boolean)。)
公共方法GetCustomAttributes(Type, Boolean)返回应用于此方法的指定类型的自定义特性。 (重写 MemberInfo.GetCustomAttributes(Type, Boolean)。)
公共方法GetGenericArguments返回 Type 对象的数组,这些对象表示泛型方法的类型实参或泛型方法定义的类型形参。 (从 MethodInfo 继承。)
公共方法GetGenericMethodDefinition返回一个 MethodInfo 对象,该对象表示可从其构造当前方法的泛型方法定义。 (从 MethodInfo 继承。)
公共方法GetHashCode返回此实例的哈希代码。 (从 MethodInfo 继承。)
公共方法GetILGenerator()为该方法返回一个具有默认 MSIL 流大小(64 字节)的 Microsoft 中间语言 (MSIL) 生成器。
公共方法GetILGenerator(Int32)为方法返回一个具有指定 MSIL 流大小的 Microsoft 中间语言 (MSIL) 生成器。
公共方法GetMethodImplementationFlags返回此方法的实现标志。 (重写 MethodBase.GetMethodImplementationFlags()。)
公共方法GetParameters返回动态方法的参数。 (重写 MethodBase.GetParameters()。)
公共方法GetType获取当前实例的 Type (从 Object 继承。)
公共方法Invoke(Object, Object[])使用指定的参数调用当前实例所表示的方法或构造函数。 (从 MethodBase 继承。)
公共方法Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)使用指定的参数,在指定的联编程序的约束下,使用指定的区域性信息调用动态方法。 (重写 MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)。)
公共方法IsDefined指示是否定义了指定的自定义特性类型。 (重写 MemberInfo.IsDefined(Type, Boolean)。)
公共方法MakeGenericMethod用类型数组的元素替代当前泛型方法定义的类型参数,并返回表示结果构造方法的 MethodInfo 对象。 (从 MethodInfo 继承。)
受保护的方法MemberwiseClone创建当前 Object 的浅表副本。 (从 Object 继承。)
公共方法ToString返回方法的签名,以字符串表示。 (重写 Object.ToString()。)
返回顶部

  名称说明
公共扩展方法GetCustomAttribute(Type)重载。 检索应用于指定的成员的指定类型的自定义特性。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttribute(Type, Boolean)重载。 检索应用于指定成员的指定类型的自定义特性,还可以选择检查该成员的上级。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttribute<T>()重载。 检索应用于指定的成员的指定类型的自定义特性。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttribute<T>(Boolean)重载。 检索应用于指定成员的指定类型的自定义特性,还可以选择检查该成员的上级。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttributes()重载。 检索应用于指定成员的自定义特性的集合。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttributes(Type)重载。 检索应用于指定成员的指定类型的自定义特性的集合。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttributes<T>()重载。 检索应用于指定成员的指定类型的自定义特性的集合。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetCustomAttributes<T>(Boolean)重载。 检索应用于指定成员的指定类型的自定义特性的集合,还可以选择检查该成员的上级。 (由 CustomAttributeExtensions 定义。)
公共扩展方法GetRuntimeBaseDefinition检索表示在直接或间接基类上的指定方法的对象(在直接或间接基类中第一次声明该方法)。 (由 RuntimeReflectionExtensions 定义。)
公共扩展方法IsDefined指示是否将指定类型的自定义特性应用于指定的成员。 (由 CustomAttributeExtensions 定义。)
返回顶部

可以使用 DynamicMethod 类在运行时生成和执行方法,而不必生成动态程序集和动态类型来包含该方法。回收 DynamicMethod 对象时,由实时 (JIT) 编译器创建的可执行代码也将回收。动态方法是生成和执行少量代码的最有效方式。

在 Windows Phone 应用程序中,所有动态方法都是匿名承载的。匿名承载的动态方法位于系统提供的程序集中,因此独立于其他代码。它们不能访问任何非公共数据。

无需对动态方法及其参数进行命名,但是可以指定名称以协助调试。动态方法或其属性不支持自定义特性。

说明注意:

动态方法不支持符号信息,即局部变量名和行号映射。在未来版本中可能会移除该限制。

尽管动态方法的行为类似于 static 方法(在 Visual Basic 中为 Shared 方法),但委托绑定的规则允许将动态方法绑定到对象,这使得在使用该委托实例调用动态方法时,可以像调用实例方法那样来调用。下面提供的 CreateDelegate(Type, Object) 方法重载示例对此进行了演示。有关委托绑定规则的更多信息,请参见 Delegate 类。

下面的示例创建一个带有两个参数的动态方法。该示例发出一个简单的函数体,该函数体返回已格式化的字符串。第一个参数是该方法嵌入在已格式化的字符串中的字符串;第二个参数是该方法平方后嵌入在已格式化的字符串中的整数。该示例通过创建委托来完成方法,使用不同参数调用委托,最后使用 Invoke 方法调用动态方法。

说明注意:

要运行此示例,请参见生成具有静态 Windows Phone TextBlock 控件的示例


using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Example
{
   // Declare a delegate type that can be used to execute the completed
   // dynamic method. 
   private delegate string HelloDelegate(string sendee, int square);

   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Create an array that specifies the types of the parameters
      // of the dynamic method. This dynamic method has a String
      // parameter and an Integer parameter.
      Type[] helloArgs = { typeof(string), typeof(int) };

      // Create a dynamic method with the name "Hello", a return type
      // of String, and two parameters whose types are specified by
      // the array helloArgs. 
      DynamicMethod hello = new DynamicMethod("Hello",
          typeof(string),
          helloArgs);

      // Create an array that specifies the parameter types of the
      // overload of String.Format to be used in Hello.
      Type[] formatStringArgs = { typeof(string), typeof(object), typeof(object), 
                                 typeof(object) };
      // Get the overload of String.Format that has one String 
      // parameter for the format, and three object parameters.
      MethodInfo formatString = typeof(String).GetMethod("Format",
          formatStringArgs);

      // Get an ILGenerator and emit a body for the dynamic method,
      // using a stream size larger than the IL that will be
      // emitted.
      ILGenerator il = hello.GetILGenerator(256);
      // Push the format string for String.Format on the stack.
      il.Emit(OpCodes.Ldstr, "Hello, {0}, {1} squared is {2}!");
      // Load the first argument, which is a string, onto the stack,
      // as the second argument of String.Format.
      il.Emit(OpCodes.Ldarg_0);
      // Load the second argument, and box it. This is the third argument
      // of String.Format, and because it is a value type it must be boxed
      // in order to pass it as an object.
      il.Emit(OpCodes.Ldarg_1);
      il.Emit(OpCodes.Box, typeof(int));
      // Load the second argument twice more, as the arguments of the 
      // multiply operation that will square it. 
      il.Emit(OpCodes.Ldarg_1);
      il.Emit(OpCodes.Ldarg_1);
      // Multiply the last two arguments on the stack, leaving the 
      // result on the stack. The result must be boxed, so it can be passed
      // as the fourth argument of String.Format.
      il.Emit(OpCodes.Mul);
      il.Emit(OpCodes.Box, typeof(int));
      // Call the overload of String.Format that prints a string, formatting
      // it to include the next three objects on the stack.
      il.Emit(OpCodes.Call, formatString);
      // The Hello method returns the formatted string, which is already
      // on the stack after the call to String.Format.
      il.Emit(OpCodes.Ret);

      // Add parameter information to the dynamic method. (This is not
      // necessary, but can be useful for debugging.) For each parameter,
      // identified by position, supply the parameter attributes and a 
      // parameter name.
      hello.DefineParameter(1, ParameterAttributes.In, "message");
      hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

      // Create a delegate that represents the dynamic method. This
      // action completes the method. Any further attempts to
      // change the method are ignored.
      HelloDelegate hi =
          (HelloDelegate)hello.CreateDelegate(typeof(HelloDelegate));

      // Use the delegate to execute the dynamic method.
      outputBlock.Text += "\r\nUse the delegate to execute the dynamic method:" + "\n";
      outputBlock.Text += "hi(\"Dad\", 42) returned: '" 
                       + hi("Dad", 42) + "'\n";
      // Execute it again, with different arguments.
      outputBlock.Text += "hi(\"Mom\", 5280) returned:  '" 
                       + hi("Mom", 5280) + "'\n";

      outputBlock.Text += "\r\nUse the Invoke method to execute the dynamic method:" + "\n";
      // Create an array of arguments to use with the Invoke method.
      object[] invokeArgs = { "Mom", 42 };
      // Invoke the dynamic method using the arguments. This is much
      // slower than using the delegate, because you must create an
      // array to contain the arguments, and value-type arguments
      // must be boxed.
      object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
      outputBlock.Text += "hello.Invoke(...) returned:  '" + objRet + "'\n";

      outputBlock.Text += "\r\n ----- Display information about the dynamic method -----" + "\n";
      // Display MethodAttributes for the dynamic method, set when 
      // the dynamic method was created.
      outputBlock.Text += String.Format("Method Attributes: {0}", hello.Attributes) + "\n";

      // Display the calling convention of the dynamic method, set when the 
      // dynamic method was created.
      outputBlock.Text += String.Format("Calling convention: {0}", hello.CallingConvention) + "\n";

      // Display the declaring type, which is always null for dynamic
      // methods.
      if (hello.DeclaringType == null)
      {
         outputBlock.Text += "DeclaringType is always null for dynamic methods." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("DeclaringType: {0}", hello.DeclaringType) + "\n";
      }

      // Display the default value for InitLocals.
      if (hello.InitLocals)
      {
         outputBlock.Text += "This method contains verifiable code.";
      }
      else
      {
         outputBlock.Text += "This method contains unverifiable code.";
      }
      outputBlock.Text += String.Format(" (InitLocals = {0})", hello.InitLocals) + "\n";

      // Display the module specified when the dynamic method was created.
      outputBlock.Text += String.Format("Module: {0}", hello.Module) + "\n";

      // Display the name specified when the dynamic method was created.
      // Note that the name can be blank.
      outputBlock.Text += String.Format("Name: {0}", hello.Name) + "\n";

      // For dynamic methods, the reflected type is always null.
      if (hello.ReflectedType == null)
      {
         outputBlock.Text += "ReflectedType is null." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("ReflectedType: {0}", hello.ReflectedType) + "\n";
      }

      if (hello.ReturnParameter == null)
      {
         outputBlock.Text += "Method has no return parameter." + "\n";
      }
      else
      {
         outputBlock.Text += String.Format("Return parameter: {0}", hello.ReturnParameter) + "\n";
      }

      // If the method has no return type, ReturnType is System.Void.
      outputBlock.Text += String.Format("Return type: {0}", hello.ReturnType) + "\n";

      // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
      // that can be used to enumerate the custom attributes of the
      // return value. At present, there is no way to set such custom
      // attributes, so the list is empty.
      if (hello.ReturnType == typeof(void))
      {
         outputBlock.Text += "The method has no return type." + "\n";
      }
      else
      {
         ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
         object[] returnAttributes = caProvider.GetCustomAttributes(true);
         if (returnAttributes.Length == 0)
         {
            outputBlock.Text += "The return type has no custom attributes." + "\n";
         }
         else
         {
            outputBlock.Text += "The return type has the following custom attributes:" + "\n";
            foreach (object attr in returnAttributes)
            {
               outputBlock.Text += "     " + attr.ToString() + "\n";
            }
         }
      }

      outputBlock.Text += String.Format("ToString: {0}", hello.ToString()) + "\n";

      // Display parameter information.
      ParameterInfo[] parameters = hello.GetParameters();
      outputBlock.Text += String.Format("Parameters: name, type, ParameterAttributes") + "\n";
      foreach (ParameterInfo p in parameters)
      {
         outputBlock.Text += String.Format("     {0}, {1}, {2}",
             p.Name, p.ParameterType, p.Attributes) + "\n";
      }
   }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:
hi("Dad", 42) returned:  'Hello, Dad, 42 squared is 1764!'
hi("Mom", 5280) returned:  'Hello, Mom, 5280 squared is 27878400!'

Use the Invoke method to execute the dynamic method:
hello.Invoke returned:  'Hello, Mom, 42 squared is 1764!'

 ----- Display information about the dynamic method -----
Method Attributes: PrivateScope, Public, Static
Calling convention: Standard
DeclaringType is always null for dynamic methods.
This method contains verifiable code. (InitLocals = True)
Module: RefEmit_InMemoryManifestModule
Name: Hello
ReflectedType is null.
Method has no return parameter.
Return type: System.Int32
The return type has no custom attributes.
ToString: Int32 Hello(System.String, Int32)
Parameters: name, type, ParameterAttributes
        sendee, System.String, In
        valueToSquare, System.Int32, In
 */


Windows Phone OS

受以下版本支持: 8.0, 7.1

Windows Phone

此类型的所有公共 static(在 Visual Basic 中为 Shared) 成员都是线程安全的。但不保证所有实例成员都是线程安全的。

显示:
© 2014 Microsoft