共用方式為


MethodBuilder Class

Microsoft Silverlight will reach end of support after October 2021. Learn more.

Defines and represents a method (or constructor) on a dynamic class.

Inheritance Hierarchy

System.Object
  System.Reflection.MemberInfo
    System.Reflection.MethodBase
      System.Reflection.MethodInfo
        System.Reflection.Emit.MethodBuilder

Namespace:  System.Reflection.Emit
Assembly:  mscorlib (in mscorlib.dll)

Syntax

'Declaration
<ComVisibleAttribute(True)> _
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
Public NotInheritable Class MethodBuilder _
    Inherits MethodInfo
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
public sealed class MethodBuilder : MethodInfo

The MethodBuilder type exposes the following members.

Properties

  Name Description
Public property Attributes Gets the attributes for this method. (Overrides MethodBase.Attributes.)
Public property CallingConvention Returns the calling convention of the method. (Overrides MethodBase.CallingConvention.)
Public property ContainsGenericParameters Not supported for this type. (Overrides MethodBase.ContainsGenericParameters.)
Public property DeclaringType Returns the type that declares this method. (Overrides MemberInfo.DeclaringType.)
Public property InitLocals Gets or sets a Boolean value that specifies whether the local variables in this method are zero-initialized. The default value of this property is true.
Public property IsAbstract Gets a value that indicates whether the method is abstract (MustInherit in Visual Basic). (Inherited from MethodBase.)
Public property IsAssembly Gets a value that indicates whether the potential visibility of this method or constructor is described by MethodAttributes.Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly. (Inherited from MethodBase.)
Public property IsConstructor Gets a value that indicates whether the method is a constructor. (Inherited from MethodBase.)
Public property IsFamily Gets a value that indicates whether the visibility of this method or constructor is described by MethodAttributes.Family; that is, the method or constructor is visible only within its class and derived classes. (Inherited from MethodBase.)
Public property IsFamilyAndAssembly Gets a value that indicates whether the visibility of this method or constructor is described by MethodAttributes.FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly. (Inherited from MethodBase.)
Public property IsFamilyOrAssembly Gets a value that indicates whether the potential visibility of this method or constructor is described by MethodAttributes.FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly. (Inherited from MethodBase.)
Public property IsFinal Gets a value that indicates whether this method is final (NotOverridable in Visual Basic). (Inherited from MethodBase.)
Public property IsGenericMethod Gets a value that indicates whether the method is a generic method. (Overrides MethodBase.IsGenericMethod.)
Public property IsGenericMethodDefinition Gets a value that indicates whether the current MethodBuilder object represents the definition of a generic method. (Overrides MethodBase.IsGenericMethodDefinition.)
Public property IsHideBySig Gets a value that indicates whether only a member of the same kind with exactly the same signature is hidden in the derived class. (Inherited from MethodBase.)
Public property IsPrivate Gets a value that indicates whether this member is private. (Inherited from MethodBase.)
Public property IsPublic Gets a value that indicates whether this is a public method. (Inherited from MethodBase.)
Public property IsSpecialName Gets a value that indicates whether this method has a special name. (Inherited from MethodBase.)
Public property IsStatic Gets a value that indicates whether the method is static (Shared in Visual Basic). (Inherited from MethodBase.)
Public property IsVirtual Gets a value that indicates whether the method is virtual (Overridable in Visual Basic). (Inherited from MethodBase.)
Public property MemberType Gets a MemberTypes value indicating that this member is a method. (Inherited from MethodInfo.)
Public property MetadataToken Gets a value that identifies a metadata element. (Inherited from MemberInfo.)
Public property MethodHandle Retrieves the internal handle for the method. Use this handle to access the underlying metadata handle. (Overrides MethodBase.MethodHandle.)
Public property Module Gets the module in which the current method is being defined. (Overrides MemberInfo.Module.)
Public property Name Retrieves the name of this method. (Overrides MemberInfo.Name.)
Public property ReflectedType Retrieves the class that was used in reflection to obtain this object. (Overrides MemberInfo.ReflectedType.)
Public property ReturnParameter Gets a ParameterInfo object that contains information about the return type of the method, such as whether the return type has custom modifiers. (Overrides MethodInfo.ReturnParameter.)
Public property ReturnType Gets the return type of the method represented by this MethodBuilder. (Overrides MethodInfo.ReturnType.)
Public property ReturnTypeCustomAttributes Returns the custom attributes of the method's return type. (Overrides MethodInfo.ReturnTypeCustomAttributes.)
Public property Signature Retrieves the signature of the method.

Top

Methods

  Name Description
Public method CreateDelegate(Type) Creates a delegate of the specified type from this method. (Inherited from MethodInfo.)
Public method CreateDelegate(Type, Object) Creates a delegate of the specified type with the specified target from this method. (Inherited from MethodInfo.)
Public method DefineGenericParameters Sets the number of generic type parameters for the current method, specifies their names, and returns an array of GenericTypeParameterBuilder objects that can be used to define their constraints.
Public method DefineParameter Sets the parameter attributes and the name of a parameter of this method, or of the return value of this method. Returns a ParameterBuilder that can be used to apply custom attributes.
Public method Equals Determines whether the given object is equal to this instance. (Overrides Object.Equals(Object).)
Protected method Finalize Allows an object to try to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Public method GetBaseDefinition Returns the base implementation for a method. (Overrides MethodInfo.GetBaseDefinition().)
Public method GetCustomAttributes(Boolean) Returns all the custom attributes defined for this method. (Overrides MemberInfo.GetCustomAttributes(Boolean).)
Public method GetCustomAttributes(Type, Boolean) Returns the custom attributes identified by the given type. (Overrides MemberInfo.GetCustomAttributes(Type, Boolean).)
Public method GetGenericArguments Returns an array of GenericTypeParameterBuilder objects that represent the type parameters of the method, if it is generic. (Overrides MethodInfo.GetGenericArguments().)
Public method GetGenericMethodDefinition Returns this method. (Overrides MethodInfo.GetGenericMethodDefinition().)
Public method GetHashCode Gets the hash code for this method. (Overrides Object.GetHashCode().)
Public method GetILGenerator() Returns an ILGenerator for this method with a default Microsoft intermediate language (MSIL) stream size of 64 bytes.
Public method GetILGenerator(Int32) Returns an ILGenerator for this method with the specified Microsoft intermediate language (MSIL) stream size.
Public method GetMethodImplementationFlags Returns the implementation flags for the method. (Overrides MethodBase.GetMethodImplementationFlags().)
Public method GetModule Returns a reference to the module that contains this method.
Public method GetParameters Returns the parameters of this method. (Overrides MethodBase.GetParameters().)
Public method GetToken Returns the MethodToken that represents the token for this method.
Public method GetType Gets the Type of the current instance. (Inherited from Object.)
Public method Invoke(Object, array<Object[]) Invokes the method or constructor represented by the current instance, using the specified parameters. (Inherited from MethodBase.)
Public method Invoke(Object, BindingFlags, Binder, array<Object[], CultureInfo) Dynamically invokes the method reflected by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder. (Overrides MethodBase.Invoke(Object, BindingFlags, Binder, array<Object[], CultureInfo).)
Public method IsDefined Checks if the specified custom attribute type is defined. (Overrides MemberInfo.IsDefined(Type, Boolean).)
Public method MakeGenericMethod Returns a generic method constructed from the current generic method definition using the specified generic type arguments. (Overrides MethodInfo.MakeGenericMethod(array<Type[]).)
Protected method MemberwiseClone Creates a shallow copy of the current Object. (Inherited from Object.)
Public method SetCustomAttribute Sets a custom attribute using a custom attribute builder.
Public method SetImplementationFlags Sets the implementation flags for this method.
Public method SetParameters Sets the number and types of parameters for a method.
Public method SetReturnType Sets the return type of the method.
Public method SetSignature Sets the method signature, including the return type, the parameter types, and the required and optional custom modifiers of the return type and parameter types.
Public method ToString Returns this MethodBuilder instance as a string. (Overrides Object.ToString().)

Top

Remarks

MethodBuilder is used to fully describe a method in Microsoft intermediate language (MSIL), including the name, attributes, signature, and method body. It is used in conjunction with the TypeBuilder class to create classes at runtime.

Examples

The following example shows how to use the MethodBuilder class to create a method within a dynamic type. The example defines a dynamic assembly with one module. The module in the example assembly contains one type, MyDynamicType, which has a private field, a property that gets and sets the private field, constructors that initialize the private field, and a method that multiplies a user-supplied number by the private field value and returns the result.

Imports System.Reflection
Imports System.Reflection.Emit

Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      ' In this version of the runtime, an assembly consists of one 
      ' module which contains zero or more types. This example 
      ' creates an assembly containing one public type named
      ' "MyDynamicType". The type has a private field, a property 
      ' that gets and sets the private field, constructors that 
      ' initialize the private field, and a method that multiplies
      ' a user-supplied number by the private field value and returns 
      ' the result. The code might look like this in Visual Basic:
      '
      'Public Class MyDynamicType
      '    Private m_number As Integer
      '
      '    Public Sub New()
      '        Me.New(42)
      '    End Sub
      '    Public Sub New(ByVal initNumber As Integer)
      '        m_number = initNumber
      '    End Sub
      '    Public Property Number As Integer
      '        Get
      '            Return m_number
      '        End Get
      '        Set
      '            m_Number = Value
      '        End Set
      '    End Property
      '
      '    Public Function MyMethod(ByVal multiplier As Integer) As Integer
      '        Return m_Number * multiplier
      '    End Function

      Dim aName As New AssemblyName("DynamicAssemblyExample")
      Dim ab As AssemblyBuilder = _
          AppDomain.CurrentDomain.DefineDynamicAssembly( _
              aName, _
              AssemblyBuilderAccess.Run)

      ' Create the module.
      Dim mb As ModuleBuilder = ab.DefineDynamicModule(aName.Name)

      Dim tb As TypeBuilder = _
          mb.DefineType("MyDynamicType", TypeAttributes.Public)

      ' Add a private field of type Integer (Int32).
      Dim fbNumber As FieldBuilder = tb.DefineField( _
          "m_number", _
          GetType(Integer), _
          FieldAttributes.Private)

      ' Define a constructor that takes an integer argument and 
      ' stores it in the private field. 
      Dim parameterTypes() As Type = {GetType(Integer)}
      Dim ctor1 As ConstructorBuilder = _
          tb.DefineConstructor( _
              MethodAttributes.Public, _
              CallingConventions.Standard, _
              parameterTypes)

      Dim ctor1IL As ILGenerator = ctor1.GetILGenerator()
      ' For a constructor, argument zero is a reference to the new
      ' instance. Push it on the stack before calling the base
      ' class constructor. Specify the default constructor of the 
      ' base class (System.Object) by passing an empty array of 
      ' types (Type.EmptyTypes) to GetConstructor.
      ctor1IL.Emit(OpCodes.Ldarg_0)
      ctor1IL.Emit(OpCodes.Call, _
          GetType(Object).GetConstructor(Type.EmptyTypes))
      ' Push the instance on the stack before pushing the argument
      ' that is to be assigned to the private field m_number.
      ctor1IL.Emit(OpCodes.Ldarg_0)
      ctor1IL.Emit(OpCodes.Ldarg_1)
      ctor1IL.Emit(OpCodes.Stfld, fbNumber)
      ctor1IL.Emit(OpCodes.Ret)

      ' Define a default constructor that supplies a default value
      ' for the private field. For parameter types, pass the empty
      ' array of types or pass Nothing.
      Dim ctor0 As ConstructorBuilder = tb.DefineConstructor( _
          MethodAttributes.Public, _
          CallingConventions.Standard, _
          Type.EmptyTypes)

      Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
      ' For a constructor, argument zero is a reference to the new
      ' instance. Push it on the stack before pushing the default
      ' value on the stack, then call constructor ctor1.
      ctor0IL.Emit(OpCodes.Ldarg_0)
      ctor0IL.Emit(OpCodes.Ldc_I4_S, 42)
      ctor0IL.Emit(OpCodes.Call, ctor1)
      ctor0IL.Emit(OpCodes.Ret)

      ' Define a property named Number that gets and sets the private 
      ' field.
      '
      ' The last argument of DefineProperty is Nothing, because the
      ' property has no parameters. (If you don't specify Nothing, you must
      ' specify an array of Type objects. For a parameterless property,
      ' use the built-in array with no elements: Type.EmptyTypes)
      Dim pbNumber As PropertyBuilder = tb.DefineProperty( _
          "Number", _
          PropertyAttributes.HasDefault, _
          GetType(Integer), _
          Nothing)

      ' The property Set and property Get methods require a special
      ' set of attributes.
      Dim getSetAttr As MethodAttributes = _
          MethodAttributes.Public Or MethodAttributes.SpecialName _
              Or MethodAttributes.HideBySig

      ' Define the "get" accessor method for Number. The method returns
      ' an integer and has no arguments. (Note that Nothing could be 
      ' used instead of Types.EmptyTypes)
      Dim mbNumberGetAccessor As MethodBuilder = tb.DefineMethod( _
          "get_Number", _
          getSetAttr, _
          GetType(Integer), _
          Type.EmptyTypes)

      Dim numberGetIL As ILGenerator = mbNumberGetAccessor.GetILGenerator()
      ' For an instance property, argument zero is the instance. Load the 
      ' instance, then load the private field and return, leaving the
      ' field value on the stack.
      numberGetIL.Emit(OpCodes.Ldarg_0)
      numberGetIL.Emit(OpCodes.Ldfld, fbNumber)
      numberGetIL.Emit(OpCodes.Ret)

      ' Define the "set" accessor method for Number, which has no return
      ' type and takes one argument of type Integer (Int32).
      Dim mbNumberSetAccessor As MethodBuilder = _
          tb.DefineMethod( _
              "set_Number", _
              getSetAttr, _
              Nothing, _
              New Type() {GetType(Integer)})

      Dim numberSetIL As ILGenerator = mbNumberSetAccessor.GetILGenerator()
      ' Load the instance and then the numeric argument, then store the
      ' argument in the field.
      numberSetIL.Emit(OpCodes.Ldarg_0)
      numberSetIL.Emit(OpCodes.Ldarg_1)
      numberSetIL.Emit(OpCodes.Stfld, fbNumber)
      numberSetIL.Emit(OpCodes.Ret)

      ' Last, map the "get" and "set" accessor methods to the 
      ' PropertyBuilder. The property is now complete. 
      pbNumber.SetGetMethod(mbNumberGetAccessor)
      pbNumber.SetSetMethod(mbNumberSetAccessor)

      ' Define a method that accepts an integer argument and returns
      ' the product of that integer and the private field m_number. This
      ' time, the array of parameter types is created on the fly.
      Dim meth As MethodBuilder = tb.DefineMethod( _
          "MyMethod", _
          MethodAttributes.Public, _
          GetType(Integer), _
          New Type() {GetType(Integer)})

      Dim methIL As ILGenerator = meth.GetILGenerator()
      ' To retrieve the private instance field, load the instance it
      ' belongs to (argument zero). After loading the field, load the 
      ' argument one and then multiply. Return from the method with 
      ' the return value (the product of the two numbers) on the 
      ' execution stack.
      methIL.Emit(OpCodes.Ldarg_0)
      methIL.Emit(OpCodes.Ldfld, fbNumber)
      methIL.Emit(OpCodes.Ldarg_1)
      methIL.Emit(OpCodes.Mul)
      methIL.Emit(OpCodes.Ret)

      ' Finish the type.
      Dim t As Type = tb.CreateType()

      ' The code can be executed immediately. Start by getting reflection
      ' objects for the method and the property.
      Dim mi As MethodInfo = t.GetMethod("MyMethod")
      Dim pi As PropertyInfo = t.GetProperty("Number")

      ' Create an instance of MyDynamicType using the default 
      ' constructor. 
      Dim o1 As Object = Activator.CreateInstance(t)

      ' Display the value of the property, then change it to 127 and 
      ' display it again. Use Nothing to indicate that the property
      ' has no index.
      outputBlock.Text += String.Format("o1.Number: {0}" & vbCrLf, _
          pi.GetValue(o1, Nothing)) 
      pi.SetValue(o1, 127, Nothing)
      outputBlock.Text += String.Format("o1.Number: {0}" & vbCrLf, _
          pi.GetValue(o1, Nothing)) 

      ' Call MyMethod, passing 22, and display the return value, 22
      ' times 127. Arguments must be passed as an array, even when
      ' there is only one.
      Dim arguments() As Object = {22}
      outputBlock.Text &= String.Format("o1.MyMethod(22): {0}" & vbCrLf, _
          mi.Invoke(o1, arguments))

      ' Create an instance of MyDynamicType using the constructor
      ' that specifies m_Number. The constructor is identified by
      ' matching the types in the argument array. In this case, 
      ' the argument array is created on the fly. Display the 
      ' property value.
      Dim o2 As Object = Activator.CreateInstance(t, _
          New Object() {5280})
      outputBlock.Text += String.Format("o2.Number: {0}" & vbCrLf, _
          pi.GetValue(o2, Nothing))

   End Sub
End Class

' This code produces the following output:
'
'o1.Number: 42
'o1.Number: 127
'o1.MyMethod(22): 2794
'o2.Number: 5280
using System;
using System.Reflection;
using System.Reflection.Emit;

class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // In this version of the runtime, an assembly consists of one 
      // module which contains zero or more types. This example 
      // creates an assembly containing one public type named
      // "MyDynamicType". The type has a private field, a property 
      // that gets and sets the private field, constructors that 
      // initialize the private field, and a method that multiplies 
      // a user-supplied number by the private field value and returns
      // the result. In C# the type might look like this:
      /*
      public class MyDynamicType
      {
          private int m_number;

          public MyDynamicType() : this(42) {}
          public MyDynamicType(int initNumber)
          {
              m_number = initNumber;
          }

          public int Number
          {
              get { return m_number; }
              set { m_number = value; }
          }

          public int MyMethod(int multiplier)
          {
              return m_number * multiplier;
          }
      }
      */

      AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
      AssemblyBuilder ab =
          AppDomain.CurrentDomain.DefineDynamicAssembly(
              aName,
              AssemblyBuilderAccess.Run);

      // Create the module.
      ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);

      TypeBuilder tb = mb.DefineType(
          "MyDynamicType",
           TypeAttributes.Public);

      // Add a private field of type int (Int32).
      FieldBuilder fbNumber = tb.DefineField(
          "m_number",
          typeof(int),
          FieldAttributes.Private);

      // Define a constructor that takes an integer argument and 
      // stores it in the private field. 
      Type[] parameterTypes = { typeof(int) };
      ConstructorBuilder ctor1 = tb.DefineConstructor(
          MethodAttributes.Public,
          CallingConventions.Standard,
          parameterTypes);

      ILGenerator ctor1IL = ctor1.GetILGenerator();
      // For a constructor, argument zero is a reference to the new
      // instance. Push it on the stack before calling the base
      // class constructor. Specify the default constructor of the 
      // base class (System.Object) by passing an empty array of 
      // types (Type.EmptyTypes) to GetConstructor.
      ctor1IL.Emit(OpCodes.Ldarg_0);
      ctor1IL.Emit(OpCodes.Call,
          typeof(object).GetConstructor(Type.EmptyTypes));
      // Push the instance on the stack before pushing the argument
      // that is to be assigned to the private field m_number.
      ctor1IL.Emit(OpCodes.Ldarg_0);
      ctor1IL.Emit(OpCodes.Ldarg_1);
      ctor1IL.Emit(OpCodes.Stfld, fbNumber);
      ctor1IL.Emit(OpCodes.Ret);

      // Define a default constructor that supplies a default value
      // for the private field. For parameter types, pass the empty
      // array of types or pass null.
      ConstructorBuilder ctor0 = tb.DefineConstructor(
          MethodAttributes.Public,
          CallingConventions.Standard,
          Type.EmptyTypes);

      ILGenerator ctor0IL = ctor0.GetILGenerator();
      // For a constructor, argument zero is a reference to the new
      // instance. Push it on the stack before pushing the default
      // value on the stack, then call constructor ctor1.
      ctor0IL.Emit(OpCodes.Ldarg_0);
      ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
      ctor0IL.Emit(OpCodes.Call, ctor1);
      ctor0IL.Emit(OpCodes.Ret);

      // Define a property named Number that gets and sets the private 
      // field.
      //
      // The last argument of DefineProperty is null, because the
      // property has no parameters. (If you don't specify null, you must
      // specify an array of Type objects. For a parameterless property,
      // use the built-in array with no elements: Type.EmptyTypes)
      PropertyBuilder pbNumber = tb.DefineProperty(
          "Number",
          PropertyAttributes.HasDefault,
          typeof(int),
          null);

      // The property "set" and property "get" methods require a special
      // set of attributes.
      MethodAttributes getSetAttr = MethodAttributes.Public |
          MethodAttributes.SpecialName | MethodAttributes.HideBySig;

      // Define the "get" accessor method for Number. The method returns
      // an integer and has no arguments. (Note that null could be 
      // used instead of Types.EmptyTypes)
      MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
          "get_Number",
          getSetAttr,
          typeof(int),
          Type.EmptyTypes);

      ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
      // For an instance property, argument zero is the instance. Load the 
      // instance, then load the private field and return, leaving the
      // field value on the stack.
      numberGetIL.Emit(OpCodes.Ldarg_0);
      numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
      numberGetIL.Emit(OpCodes.Ret);

      // Define the "set" accessor method for Number, which has no return
      // type and takes one argument of type int (Int32).
      MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
          "set_Number",
          getSetAttr,
          null,
          new Type[] { typeof(int) });

      ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
      // Load the instance and then the numeric argument, then store the
      // argument in the field.
      numberSetIL.Emit(OpCodes.Ldarg_0);
      numberSetIL.Emit(OpCodes.Ldarg_1);
      numberSetIL.Emit(OpCodes.Stfld, fbNumber);
      numberSetIL.Emit(OpCodes.Ret);

      // Last, map the "get" and "set" accessor methods to the 
      // PropertyBuilder. The property is now complete. 
      pbNumber.SetGetMethod(mbNumberGetAccessor);
      pbNumber.SetSetMethod(mbNumberSetAccessor);

      // Define a method that accepts an integer argument and returns
      // the product of that integer and the private field m_number. This
      // time, the array of parameter types is created on the fly.
      MethodBuilder meth = tb.DefineMethod(
          "MyMethod",
          MethodAttributes.Public,
          typeof(int),
          new Type[] { typeof(int) });

      ILGenerator methIL = meth.GetILGenerator();
      // To retrieve the private instance field, load the instance it
      // belongs to (argument zero). After loading the field, load the 
      // argument one and then multiply. Return from the method with 
      // the return value (the product of the two numbers) on the 
      // execution stack.
      methIL.Emit(OpCodes.Ldarg_0);
      methIL.Emit(OpCodes.Ldfld, fbNumber);
      methIL.Emit(OpCodes.Ldarg_1);
      methIL.Emit(OpCodes.Mul);
      methIL.Emit(OpCodes.Ret);

      // Finish the type.
      Type t = tb.CreateType();

      // The code can be executed immediately. Start by getting reflection
      // objects for the method and the property.
      MethodInfo mi = t.GetMethod("MyMethod");
      PropertyInfo pi = t.GetProperty("Number");

      // Create an instance of MyDynamicType using the default 
      // constructor. 
      object o1 = Activator.CreateInstance(t);

      // Display the value of the property, then change it to 127 and 
      // display it again. Use null to indicate that the property
      // has no index.
      outputBlock.Text += String.Format("o1.Number: {0}\n", pi.GetValue(o1, null));
      pi.SetValue(o1, 127, null);
      outputBlock.Text += String.Format("o1.Number: {0}\n", pi.GetValue(o1, null));

      // Call MyMethod, passing 22, and display the return value, 22
      // times 127. Arguments must be passed as an array, even when
      // there is only one.
      object[] arguments = { 22 };
      outputBlock.Text += String.Format("o1.MyMethod(22): {0}\n",
          mi.Invoke(o1, arguments));

      // Create an instance of MyDynamicType using the constructor
      // that specifies m_Number. The constructor is identified by
      // matching the types in the argument array. In this case, 
      // the argument array is created on the fly. Display the 
      // property value.
      object o2 = Activator.CreateInstance(t,
          new object[] { 5280 });
      outputBlock.Text += String.Format("o2.Number: {0}\n", pi.GetValue(o2, null));
   }
}

/* This code produces the following output:

o1.Number: 42
o1.Number: 127
o1.MyMethod(22): 2794
o2.Number: 5280
 */

Version Information

Silverlight

Supported in: 5, 4, 3

Platforms

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.

Thread Safety

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.