TypeBuilder.DefineMethod Methode

Definitie

Naamruimte:: System.Reflection.Emit

Assembly's:: netstandard.dll, System.Reflection.Emit.dll

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Hiermee voegt u een methode toe aan het type.

Overloads

Name	Description
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])	Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken, aanroepende conventie, methodehandtekening en aangepaste modifiers.
DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])	Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken, aanroepende conventie en methodehandtekening.
DefineMethod(String, MethodAttributes, CallingConventions)	Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken en aanroepende conventie.
DefineMethod(String, MethodAttributes)	Voegt een nieuwe methode toe aan het type, met de opgegeven naam en methodekenmerken.
DefineMethod(String, MethodAttributes, Type, Type[])	Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken en methodehandtekening.

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken, aanroepende conventie, methodehandtekening en aangepaste modifiers.

public:
 System::Reflection::Emit::MethodBuilder ^ DefineMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ returnTypeRequiredCustomModifiers, cli::array <Type ^> ^ returnTypeOptionalCustomModifiers, cli::array <Type ^> ^ parameterTypes, cli::array <cli::array <Type ^> ^> ^ parameterTypeRequiredCustomModifiers, cli::array <cli::array <Type ^> ^> ^ parameterTypeOptionalCustomModifiers);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers);

member this.DefineMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] * Type[] * Type[] * Type[][] * Type[][] -> System.Reflection.Emit.MethodBuilder

Public Function DefineMethod (name As String, attributes As MethodAttributes, callingConvention As CallingConventions, returnType As Type, returnTypeRequiredCustomModifiers As Type(), returnTypeOptionalCustomModifiers As Type(), parameterTypes As Type(), parameterTypeRequiredCustomModifiers As Type()(), parameterTypeOptionalCustomModifiers As Type()()) As MethodBuilder

Parameters

name: String

De naam van de methode. name kan geen ingesloten null-waarden bevatten.

attributes: MethodAttributes

De kenmerken van de methode.

callingConvention: CallingConventions

De aanroepconventie van de methode.

returnType: Type

Het retourtype van de methode.

returnTypeRequiredCustomModifiers: Type[]

Een matrix van typen die de vereiste aangepaste modifiers vertegenwoordigen, zoals IsConst, voor het retourtype van de methode. Als het retourtype geen vereiste aangepaste aanpassingstypen heeft, geeft u op null.

returnTypeOptionalCustomModifiers: Type[]

Een matrix van typen die de optionele aangepaste modifiers vertegenwoordigen, zoals IsConst, voor het retourtype van de methode. Als het retourtype geen optionele aangepaste aanpassingstypen heeft, geeft u op null.

parameterTypes: Type[]

De typen van de parameters van de methode.

parameterTypeRequiredCustomModifiers: Type[][]

Een matrix van matrices van typen. Elke matrix van typen vertegenwoordigt de vereiste aangepaste aanpassingen voor de bijbehorende parameter, zoals IsConst. Als een bepaalde parameter geen vereiste aangepaste aanpassingen heeft, geeft u null deze op in plaats van een matrix met typen. Als geen van de parameters aangepaste aanpassingsaanpassingen vereist heeft, geeft u null dit op in plaats van een matrix met matrices.

parameterTypeOptionalCustomModifiers: Type[][]

Een matrix van matrices van typen. Elke matrix van typen vertegenwoordigt de optionele aangepaste aanpassingen voor de bijbehorende parameter, zoals IsConst. Als een bepaalde parameter geen optionele aangepaste modifiers heeft, geeft u null in plaats van een matrix van typen op. Als geen van de parameters optionele aangepaste aanpassingen heeft, geeft u null deze op in plaats van een matrix met matrices.

Retouren

MethodBuilder

Een MethodBuilder object dat de zojuist toegevoegde methode vertegenwoordigt.

Uitzonderingen

ArgumentException

De lengte is name nul.

– of –

Het type van het bovenliggende element van deze methode is een interface en deze methode is niet virtueel (Overridable in Visual Basic).

– of –

De grootte van parameterTypeRequiredCustomModifiers of parameterTypeOptionalCustomModifiers is niet gelijk aan de grootte van parameterTypes.

ArgumentNullException

name is null.

InvalidOperationException

Het type is eerder gemaakt met behulp van CreateType().

– of –

Voor het huidige dynamische type is de IsGenericType eigenschap , maar de true eigenschap is IsGenericTypeDefinition.false

Opmerkingen

Gebruik deze overbelasting als u aangepaste modifiers moet opgeven. Als u aangepaste modifiers wilt opgeven nadat de methode is gemaakt, zoals u bijvoorbeeld zou doen met een algemene methode waarvan de parametertypen zijn opgegeven door de algemene typeparameters, kunt u de DefineMethod(String, MethodAttributes) of DefineMethod(String, MethodAttributes, CallingConventions) methode overloads gebruiken om de methode te definiëren en vervolgens de methode te gebruiken om de MethodBuilder.SetSignature parameter te definiëren en typen met aangepaste modifiers te retourneren.

Note

Zie ECMA C# en Common Language Infrastructure Standards and Standard ECMA-335 - Common Language Infrastructure (CLI) voor meer informatie over aangepaste modifiers.

Van toepassing op

DefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken, aanroepende conventie en methodehandtekening.

public:
 System::Reflection::Emit::MethodBuilder ^ DefineMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ parameterTypes);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type returnType, Type[] parameterTypes);

member this.DefineMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] -> System.Reflection.Emit.MethodBuilder

Public Function DefineMethod (name As String, attributes As MethodAttributes, callingConvention As CallingConventions, returnType As Type, parameterTypes As Type()) As MethodBuilder

Parameters

name: String

De naam van de methode. name kan geen ingesloten null-waarden bevatten.

attributes: MethodAttributes

De kenmerken van de methode.

callingConvention: CallingConventions

De aanroepconventie van de methode.

returnType: Type

Het retourtype van de methode.

parameterTypes: Type[]

De typen van de parameters van de methode.

Retouren

MethodBuilder

Een MethodBuilder weergave van de zojuist gedefinieerde methode.

Uitzonderingen

ArgumentException

De lengte is name nul.

– of –

Het type van het bovenliggende element van deze methode is een interface en deze methode is niet virtueel (Overridable in Visual Basic).

ArgumentNullException

name is null.

InvalidOperationException

Het type is eerder gemaakt met behulp van CreateType().

– of –

Voor het huidige dynamische type is de IsGenericType eigenschap , maar de true eigenschap is IsGenericTypeDefinition.false

Voorbeelden

In het volgende codevoorbeeld wordt het gebruik gedemonstreerd van het instellen van DefineMethod de specifieke handtekening en kenmerken van een constructor op een dynamisch type en het retourneren van een corresponderende MethodBuilder MSIL-populatie.

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

public interface IMyInterface
{
   String HelloMethod(String parameter);
}

public class Example
{
   public static void Main()
   {
      Type myNestedClassType = CreateCallee(Thread.GetDomain());
      // Cretae an instance of 'MyNestedClass'.
      IMyInterface myInterface =
         (IMyInterface)Activator.CreateInstance(myNestedClassType);
      Console.WriteLine(myInterface.HelloMethod("Bill"));
   }

   // Create the callee transient dynamic assembly.
   private static Type CreateCallee(AppDomain myAppDomain)
   {
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "Example";
      // Create the callee dynamic assembly.
      AssemblyBuilder myAssembly =
         myAppDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run);
      // Create a dynamic module in the callee assembly.
      ModuleBuilder myModule = myAssembly.DefineDynamicModule("EmittedModule");
      // Define a public class named "MyHelloWorld".
      TypeBuilder myHelloWorldType =
         myModule.DefineType("MyHelloWorld", TypeAttributes.Public);
      // Define a public nested class named 'MyNestedClass'.
      TypeBuilder myNestedClassType =
         myHelloWorldType.DefineNestedType("MyNestedClass",
            TypeAttributes.NestedPublic, typeof(Example),
            new Type[]{typeof(IMyInterface)});
      // Implement 'IMyInterface' interface.
      myNestedClassType.AddInterfaceImplementation(typeof(IMyInterface));
      // Define 'HelloMethod' of 'IMyInterface'.
      MethodBuilder myHelloMethod =
         myNestedClassType.DefineMethod("HelloMethod",
            MethodAttributes.Public | MethodAttributes.Virtual,
            typeof(String), new Type[]{typeof(String)});
      // Generate IL for 'GetGreeting' method.
      ILGenerator myMethodIL = myHelloMethod.GetILGenerator();
      myMethodIL.Emit(OpCodes.Ldstr, "Hi! ");
      myMethodIL.Emit(OpCodes.Ldarg_1);
      MethodInfo infoMethod =
         typeof(String).GetMethod("Concat",new Type[]{typeof(string),typeof(string)});
      myMethodIL.Emit(OpCodes.Call, infoMethod);
      myMethodIL.Emit(OpCodes.Ret);

      MethodInfo myHelloMethodInfo =
         typeof(IMyInterface).GetMethod("HelloMethod");
      // Implement 'HelloMethod' of 'IMyInterface'.
      myNestedClassType.DefineMethodOverride(myHelloMethod, myHelloMethodInfo);
      // Create 'MyHelloWorld' type.
      Type myType = myHelloWorldType.CreateType();
      // Create 'MyNestedClass' type.
      return myNestedClassType.CreateType();
   }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

Public Interface IMyInterface
   Function HelloMethod(parameter As String) As String
End Interface 'IMyInterface

Public Class Example
   <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
   Public Shared Sub Main()
      Dim myNestedClassType As Type = CreateCallee(Thread.GetDomain())
      ' Create an instance of 'MyNestedClass'.
      Dim myInterface As IMyInterface = _
            CType(Activator.CreateInstance(myNestedClassType), IMyInterface)
      Console.WriteLine(myInterface.HelloMethod("Bill"))
   End Sub

   ' Create the callee transient dynamic assembly.
   Private Shared Function CreateCallee(myAppDomain As AppDomain) As Type
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "Example"
      ' Create the callee dynamic assembly.
      Dim myAssembly As AssemblyBuilder = _
               myAppDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)
      ' Create a dynamic module in the callee assembly.
      Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule")
      ' Define a public class named "MyHelloWorld".
      Dim myHelloWorldType As TypeBuilder = _
               myModule.DefineType("MyHelloWorld", TypeAttributes.Public)
      ' Define a public nested class named 'MyNestedClass'.
      Dim myNestedClassType As TypeBuilder = _
               myHelloWorldType.DefineNestedType("MyNestedClass", TypeAttributes.NestedPublic, _
               GetType(Example), New Type() {GetType(IMyInterface)})
      ' Implement 'IMyInterface' interface.
      myNestedClassType.AddInterfaceImplementation(GetType(IMyInterface))
      ' Define 'HelloMethod' of 'IMyInterface'.
      Dim myHelloMethod As MethodBuilder = _
               myNestedClassType.DefineMethod("HelloMethod", MethodAttributes.Public Or _
               MethodAttributes.Virtual, GetType(String), New Type() {GetType(String)})
      ' Generate IL for 'GetGreeting' method.
      Dim myMethodIL As ILGenerator = myHelloMethod.GetILGenerator()
      myMethodIL.Emit(OpCodes.Ldstr, "Hi! ")
      myMethodIL.Emit(OpCodes.Ldarg_1)
      Dim infoMethod As MethodInfo = _
               GetType(String).GetMethod("Concat", New Type() {GetType(String), GetType(String)})
      myMethodIL.Emit(OpCodes.Call, infoMethod)
      myMethodIL.Emit(OpCodes.Ret)

      Dim myHelloMethodInfo As MethodInfo = GetType(IMyInterface).GetMethod("HelloMethod")
      ' Implement 'HelloMethod' of 'IMyInterface'.
      myNestedClassType.DefineMethodOverride(myHelloMethod, myHelloMethodInfo)
      ' Create 'MyHelloWorld' type.
      Dim myType As Type = myHelloWorldType.CreateType()
      ' Create 'MyNestedClass' type.
      Return myNestedClassType.CreateType()
   End Function 'CreateCallee
End Class

Van toepassing op

DefineMethod(String, MethodAttributes, CallingConventions)

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken en aanroepende conventie.

public:
 System::Reflection::Emit::MethodBuilder ^ DefineMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, System::Reflection::CallingConventions callingConvention);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention);

member this.DefineMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions -> System.Reflection.Emit.MethodBuilder

Public Function DefineMethod (name As String, attributes As MethodAttributes, callingConvention As CallingConventions) As MethodBuilder

Parameters

name: String

De naam van de methode. name kan geen ingesloten null-waarden bevatten.

attributes: MethodAttributes

De kenmerken van de methode.

callingConvention: CallingConventions

De aanroepconventie van de methode.

Retouren

MethodBuilder

Een MethodBuilder weergave van de zojuist gedefinieerde methode.

Uitzonderingen

ArgumentException

De lengte is name nul.

– of –

Het type van het bovenliggende element van deze methode is een interface en deze methode is niet virtueel (Overridable in Visual Basic).

ArgumentNullException

name is null.

InvalidOperationException

Het type is eerder gemaakt met behulp van CreateType().

– of –

Voor het huidige dynamische type is de IsGenericType eigenschap , maar de true eigenschap is IsGenericTypeDefinition.false

Opmerkingen

Gebruik deze methode overbelast wanneer u de handtekening van de methode niet kent op het moment dat u de methode definieert. De parametertypen en het retourtype van een algemene methode kunnen bijvoorbeeld worden opgegeven door de algemene typeparameters van de methode, die moeten worden gedefinieerd nadat de methode is toegevoegd aan het type. De parameters en het retourtype van de methode kunnen later worden ingesteld met behulp van de MethodBuilder.SetSignature methode.

Zie ook

DefineGenericParameters(String[])

Van toepassing op

DefineMethod(String, MethodAttributes)

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Voegt een nieuwe methode toe aan het type, met de opgegeven naam en methodekenmerken.

public:
 System::Reflection::Emit::MethodBuilder ^ DefineMethod(System::String ^ name, System::Reflection::MethodAttributes attributes);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes);

member this.DefineMethod : string * System.Reflection.MethodAttributes -> System.Reflection.Emit.MethodBuilder

Public Function DefineMethod (name As String, attributes As MethodAttributes) As MethodBuilder

Parameters

name: String

De naam van de methode. name kan geen ingesloten null-waarden bevatten.

attributes: MethodAttributes

De kenmerken van de methode.

Retouren

MethodBuilder

Een MethodBuilder weergave van de zojuist gedefinieerde methode.

Uitzonderingen

ArgumentException

De lengte is name nul.

– of –

Het type van het bovenliggende element van deze methode is een interface en deze methode is niet virtueel (Overridable in Visual Basic).

ArgumentNullException

name is null.

InvalidOperationException

Het type is eerder gemaakt met behulp van CreateType().

– of –

Voor het huidige dynamische type is de IsGenericType eigenschap , maar de true eigenschap is IsGenericTypeDefinition.false

Voorbeelden

In het volgende codevoorbeeld wordt een algemene methode gedefinieerd met de naam DemoMethod waarvan het parametertype en het retourtype worden opgegeven door de algemene typeparameters. De methode wordt gedefinieerd zonder handtekening, met behulp van de standaardconventie voor aanroepen. De MethodBuilder.DefineGenericParameters methode wordt gebruikt om een algemene methode te maken DemoMethod en de zojuist gedefinieerde typeparameters worden vervolgens gebruikt voor de handtekening en het retourtype.

Dit codevoorbeeld maakt deel uit van een groter voorbeeld dat is opgegeven voor de DefineGenericParameters methode.

// Define a Shared, Public method with standard calling
// conventions. Do not specify the parameter types or the
// return type, because type parameters will be used for
// those types, and the type parameters have not been
// defined yet.
MethodBuilder demoMethod = demoType.DefineMethod(
    "DemoMethod",
    MethodAttributes.Public | MethodAttributes.Static
);

' Define a Shared, Public method with standard calling
' conventions. Do not specify the parameter types or the
' return type, because type parameters will be used for 
' those types, and the type parameters have not been
' defined yet.
Dim demoMethod As MethodBuilder = _
    demoType.DefineMethod("DemoMethod", _
        MethodAttributes.Public Or MethodAttributes.Static)

// Defining generic parameters for the method makes it a
// generic method. By convention, type parameters are
// single alphabetic characters. T and U are used here.
//
string[] typeParamNames = {"T", "U"};
GenericTypeParameterBuilder[] typeParameters =
    demoMethod.DefineGenericParameters(typeParamNames);

// The second type parameter is constrained to be a
// reference type.
typeParameters[1].SetGenericParameterAttributes(
    GenericParameterAttributes.ReferenceTypeConstraint);

' Defining generic parameters for the method makes it a
' generic method. By convention, type parameters are 
' single alphabetic characters. T and U are used here.
'
Dim typeParamNames() As String = {"T", "U"}
Dim typeParameters() As GenericTypeParameterBuilder = _
    demoMethod.DefineGenericParameters(typeParamNames)

' The second type parameter is constrained to be a 
' reference type.
typeParameters(1).SetGenericParameterAttributes( _
    GenericParameterAttributes.ReferenceTypeConstraint)

// Set parameter types for the method. The method takes
// one parameter, and its type is specified by the first
// type parameter, T.
Type[] parms = {typeParameters[0]};
demoMethod.SetParameters(parms);

// Set the return type for the method. The return type is
// specified by the second type parameter, U.
demoMethod.SetReturnType(typeParameters[1]);

' Set parameter types for the method. The method takes
' one parameter, and its type is specified by the first
' type parameter, T.
Dim params() As Type = {typeParameters(0)}
demoMethod.SetParameters(params)

' Set the return type for the method. The return type is
' specified by the second type parameter, U.
demoMethod.SetReturnType(typeParameters(1))

Opmerkingen

Deze overbelasting van de methode definieert een methode met CallingConventions.Standard. Als u een methode zonder handtekening wilt definiëren, met een andere aanroepconventie, gebruikt u de overbelasting van de DefineMethod(String, MethodAttributes, CallingConventions) methode.

Zie ook

DefineGenericParameters(String[])

Van toepassing op

DefineMethod(String, MethodAttributes, Type, Type[])

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Bron:: TypeBuilder.cs

Voegt een nieuwe methode toe aan het type, met de opgegeven naam, methodekenmerken en methodehandtekening.

public:
 System::Reflection::Emit::MethodBuilder ^ DefineMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, Type ^ returnType, cli::array <Type ^> ^ parameterTypes);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, Type? returnType, Type[]? parameterTypes);

public System.Reflection.Emit.MethodBuilder DefineMethod(string name, System.Reflection.MethodAttributes attributes, Type returnType, Type[] parameterTypes);

member this.DefineMethod : string * System.Reflection.MethodAttributes * Type * Type[] -> System.Reflection.Emit.MethodBuilder

Public Function DefineMethod (name As String, attributes As MethodAttributes, returnType As Type, parameterTypes As Type()) As MethodBuilder

Parameters

name: String

De naam van de methode. name kan geen ingesloten null-waarden bevatten.

attributes: MethodAttributes

De kenmerken van de methode.

returnType: Type

Het retourtype van de methode.

parameterTypes: Type[]

De typen van de parameters van de methode.

Retouren

MethodBuilder

De gedefinieerde methode.

Uitzonderingen

ArgumentException

De lengte is name nul.

– of –

Het type van het bovenliggende element van deze methode is een interface en deze methode is niet virtueel (Overridable in Visual Basic).

ArgumentNullException

name is null.

InvalidOperationException

Het type is eerder gemaakt met behulp van CreateType().

– of –

Voor het huidige dynamische type is de IsGenericType eigenschap , maar de true eigenschap is IsGenericTypeDefinition.false

Voorbeelden

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

public interface IMyInterface
{
   String HelloMethod(String parameter);
}

public class Example
{
   public static void Main()
   {
      Type myNestedClassType = CreateCallee(Thread.GetDomain());
      // Cretae an instance of 'MyNestedClass'.
      IMyInterface myInterface =
         (IMyInterface)Activator.CreateInstance(myNestedClassType);
      Console.WriteLine(myInterface.HelloMethod("Bill"));
   }

   // Create the callee transient dynamic assembly.
   private static Type CreateCallee(AppDomain myAppDomain)
   {
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "Example";
      // Create the callee dynamic assembly.
      AssemblyBuilder myAssembly =
         myAppDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run);
      // Create a dynamic module in the callee assembly.
      ModuleBuilder myModule = myAssembly.DefineDynamicModule("EmittedModule");
      // Define a public class named "MyHelloWorld".
      TypeBuilder myHelloWorldType =
         myModule.DefineType("MyHelloWorld", TypeAttributes.Public);
      // Define a public nested class named 'MyNestedClass'.
      TypeBuilder myNestedClassType =
         myHelloWorldType.DefineNestedType("MyNestedClass",
            TypeAttributes.NestedPublic, typeof(Example),
            new Type[]{typeof(IMyInterface)});
      // Implement 'IMyInterface' interface.
      myNestedClassType.AddInterfaceImplementation(typeof(IMyInterface));
      // Define 'HelloMethod' of 'IMyInterface'.
      MethodBuilder myHelloMethod =
         myNestedClassType.DefineMethod("HelloMethod",
            MethodAttributes.Public | MethodAttributes.Virtual,
            typeof(String), new Type[]{typeof(String)});
      // Generate IL for 'GetGreeting' method.
      ILGenerator myMethodIL = myHelloMethod.GetILGenerator();
      myMethodIL.Emit(OpCodes.Ldstr, "Hi! ");
      myMethodIL.Emit(OpCodes.Ldarg_1);
      MethodInfo infoMethod =
         typeof(String).GetMethod("Concat",new Type[]{typeof(string),typeof(string)});
      myMethodIL.Emit(OpCodes.Call, infoMethod);
      myMethodIL.Emit(OpCodes.Ret);

      MethodInfo myHelloMethodInfo =
         typeof(IMyInterface).GetMethod("HelloMethod");
      // Implement 'HelloMethod' of 'IMyInterface'.
      myNestedClassType.DefineMethodOverride(myHelloMethod, myHelloMethodInfo);
      // Create 'MyHelloWorld' type.
      Type myType = myHelloWorldType.CreateType();
      // Create 'MyNestedClass' type.
      return myNestedClassType.CreateType();
   }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

Public Interface IMyInterface
   Function HelloMethod(parameter As String) As String
End Interface 'IMyInterface

Public Class Example
   <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
   Public Shared Sub Main()
      Dim myNestedClassType As Type = CreateCallee(Thread.GetDomain())
      ' Create an instance of 'MyNestedClass'.
      Dim myInterface As IMyInterface = _
            CType(Activator.CreateInstance(myNestedClassType), IMyInterface)
      Console.WriteLine(myInterface.HelloMethod("Bill"))
   End Sub

   ' Create the callee transient dynamic assembly.
   Private Shared Function CreateCallee(myAppDomain As AppDomain) As Type
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "Example"
      ' Create the callee dynamic assembly.
      Dim myAssembly As AssemblyBuilder = _
               myAppDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)
      ' Create a dynamic module in the callee assembly.
      Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule")
      ' Define a public class named "MyHelloWorld".
      Dim myHelloWorldType As TypeBuilder = _
               myModule.DefineType("MyHelloWorld", TypeAttributes.Public)
      ' Define a public nested class named 'MyNestedClass'.
      Dim myNestedClassType As TypeBuilder = _
               myHelloWorldType.DefineNestedType("MyNestedClass", TypeAttributes.NestedPublic, _
               GetType(Example), New Type() {GetType(IMyInterface)})
      ' Implement 'IMyInterface' interface.
      myNestedClassType.AddInterfaceImplementation(GetType(IMyInterface))
      ' Define 'HelloMethod' of 'IMyInterface'.
      Dim myHelloMethod As MethodBuilder = _
               myNestedClassType.DefineMethod("HelloMethod", MethodAttributes.Public Or _
               MethodAttributes.Virtual, GetType(String), New Type() {GetType(String)})
      ' Generate IL for 'GetGreeting' method.
      Dim myMethodIL As ILGenerator = myHelloMethod.GetILGenerator()
      myMethodIL.Emit(OpCodes.Ldstr, "Hi! ")
      myMethodIL.Emit(OpCodes.Ldarg_1)
      Dim infoMethod As MethodInfo = _
               GetType(String).GetMethod("Concat", New Type() {GetType(String), GetType(String)})
      myMethodIL.Emit(OpCodes.Call, infoMethod)
      myMethodIL.Emit(OpCodes.Ret)

      Dim myHelloMethodInfo As MethodInfo = GetType(IMyInterface).GetMethod("HelloMethod")
      ' Implement 'HelloMethod' of 'IMyInterface'.
      myNestedClassType.DefineMethodOverride(myHelloMethod, myHelloMethodInfo)
      ' Create 'MyHelloWorld' type.
      Dim myType As Type = myHelloWorldType.CreateType()
      ' Create 'MyNestedClass' type.
      Return myNestedClassType.CreateType()
   End Function 'CreateCallee
End Class

Van toepassing op

Feedback

Is deze pagina nuttig?