TypeBuilder.DefineMethodOverride(MethodInfo, MethodInfo) Methode

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Quelle:

TypeBuilder.cs

Gibt einen bestimmten Methodentext an, der eine bestimmte Methodendeklaration, möglicherweise mit einem anderen Namen, implementiert.

public:
 void DefineMethodOverride(System::Reflection::MethodInfo ^ methodInfoBody, System::Reflection::MethodInfo ^ methodInfoDeclaration);

public void DefineMethodOverride (System.Reflection.MethodInfo methodInfoBody, System.Reflection.MethodInfo methodInfoDeclaration);

member this.DefineMethodOverride : System.Reflection.MethodInfo * System.Reflection.MethodInfo -> unit

Public Sub DefineMethodOverride (methodInfoBody As MethodInfo, methodInfoDeclaration As MethodInfo)

Parameter

methodInfoBody

MethodInfo

Der zu verwendende Methodentext. Dies sollte ein MethodBuilder -Objekt sein.

methodInfoDeclaration

MethodInfo

Die Methode, deren Deklaration verwendet werden soll.

Ausnahmen

ArgumentException

methodInfoBody gehört nicht zu dieser Klasse.

ArgumentNullException

methodInfoBody oder methodInfoDeclaration ist null.

InvalidOperationException

Der Typ wurde zuvor mit CreateType()erstellt.

- oder -

Der deklarierende Typ des methodInfoBody ist nicht der von diesem TypeBuilder dargestellte Typ.

Beispiele

Das folgende Codebeispiel enthält eine Schnittstelle I mit einer -Methode M(), eine Basisklasse A , die die -Schnittstelle implementiert, und eine abgeleitete Klasse C , die die Basisklassenimplementierung von M() außer Kraft setzt und auch eine separate explizite Implementierung von I.M()bereitstellt.

Die main() -Methode des Codebeispiels zeigt, wie die abgeleitete Klasse Causgegeben wird. Die Überschreibung von A.M() erfolgt einfach durch Ausgeben einer Methode M() mit derselben Signatur. Um jedoch eine separate Implementierung von I.M()bereitzustellen, müssen Sie einen Methodentext definieren und dann die DefineMethodOverride -Methode verwenden, um diesen Methodentext einem MethodInfo darstellenden I.M()zuzuordnen. Der Name des Methodentexts spielt keine Rolle.

Im Codebeispiel wird eine instance der ausgegebenen Klasse erstellt. Es ruft ein MethodInfo -Objekt für I.M()ab und verwendet es, um die explizite Schnittstellenimplementierung der ausgegebenen Klasse aufzurufen. Anschließend ruft sie ein MethodInfo -Objekt für A.M()ab und verwendet es, um die Außerkraftsetzung dieser Methode durch die ausgegebene Klasse aufzurufen.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

public interface class I 
{
    void M();
};

public ref class A 
{
public:
    virtual void M() { Console::WriteLine("In method A.M"); }
};

// The object of this code example is to emit code equivalent to
// the following C++ code:
//
public ref class C : A, I 
{
public:
    virtual void M() override 
    { 
        Console::WriteLine("Overriding A.M from C.M"); 
    }

private:
    // In order to provide a different implementation from C.M when 
    // emitting the following explicit interface implementation, 
    // it is necessary to use a MethodImpl.
    //
    virtual void IM() sealed = I::M 
    {
        Console::WriteLine("The I::M implementation of C");
    }
};

void main() 
{
    String^ name = "DefineMethodOverrideExample";
    AssemblyName^ asmName = gcnew AssemblyName(name);
    AssemblyBuilder^ ab = 
        AppDomain::CurrentDomain->DefineDynamicAssembly(
            asmName, AssemblyBuilderAccess::RunAndSave);
    ModuleBuilder^ mb = ab->DefineDynamicModule(name, name + ".dll");

    TypeBuilder^ tb = 
        mb->DefineType("C", TypeAttributes::Public, A::typeid);
    tb->AddInterfaceImplementation(I::typeid);

    // Build the method body for the explicit interface 
    // implementation. The name used for the method body 
    // can be anything. Here, it is the name of the method,
    // qualified by the interface name.
    //
    MethodBuilder^ mbIM = tb->DefineMethod("I.M", 
        MethodAttributes::Private | MethodAttributes::HideBySig |
            MethodAttributes::NewSlot | MethodAttributes::Virtual | 
            MethodAttributes::Final,
        nullptr,
        Type::EmptyTypes);
    ILGenerator^ il = mbIM->GetILGenerator();
    il->Emit(OpCodes::Ldstr, "The I.M implementation of C");
    il->Emit(OpCodes::Call, Console::typeid->GetMethod("WriteLine", 
        gcnew array<Type^> { String::typeid }));
    il->Emit(OpCodes::Ret);

    // DefineMethodOverride is used to associate the method 
    // body with the interface method that is being implemented.
    //
    tb->DefineMethodOverride(mbIM, I::typeid->GetMethod("M"));

    MethodBuilder^ mbM = tb->DefineMethod("M", 
        MethodAttributes::Public | MethodAttributes::ReuseSlot | 
            MethodAttributes::Virtual | MethodAttributes::HideBySig, 
        nullptr, 
        Type::EmptyTypes);
    il = mbM->GetILGenerator();
    il->Emit(OpCodes::Ldstr, "Overriding A.M from C.M");
    il->Emit(OpCodes::Call, Console::typeid->GetMethod("WriteLine", 
        gcnew array<Type^> { String::typeid }));
    il->Emit(OpCodes::Ret);

    Type^ tc = tb->CreateType();

    // Save the emitted assembly, to examine with Ildasm.exe.
    ab->Save(name + ".dll");

    Object^ test = Activator::CreateInstance(tc);

    MethodInfo^ mi = I::typeid->GetMethod("M");
    mi->Invoke(test, nullptr);

    mi = A::typeid->GetMethod("M");
    mi->Invoke(test, nullptr);
}

/* This code example produces the following output:

The I.M implementation of C
Overriding A.M from C.M
 */

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

public interface I
{
    void M();
}

public class A
{
    public virtual void M() { Console.WriteLine("In method A.M"); }
}

// The object of this code example is to emit code equivalent to
// the following C# code:
//
public class C : A, I
{
    public override void M()
    {
        Console.WriteLine("Overriding A.M from C.M");
    }

    // In order to provide a different implementation from C.M when
    // emitting the following explicit interface implementation,
    // it is necessary to use a MethodImpl.
    //
    void I.M()
    {
        Console.WriteLine("The I.M implementation of C");
    }
}

class Test
{
    static void Main()
    {
        string name = "DefineMethodOverrideExample";
        AssemblyName asmName = new AssemblyName(name);
        AssemblyBuilder ab =
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                asmName, AssemblyBuilderAccess.RunAndSave);
        ModuleBuilder mb = ab.DefineDynamicModule(name, name + ".dll");

        TypeBuilder tb =
            mb.DefineType("C", TypeAttributes.Public, typeof(A));
        tb.AddInterfaceImplementation(typeof(I));

        // Build the method body for the explicit interface
        // implementation. The name used for the method body
        // can be anything. Here, it is the name of the method,
        // qualified by the interface name.
        //
        MethodBuilder mbIM = tb.DefineMethod("I.M",
            MethodAttributes.Private | MethodAttributes.HideBySig |
                MethodAttributes.NewSlot | MethodAttributes.Virtual |
                MethodAttributes.Final,
            null,
            Type.EmptyTypes);
        ILGenerator il = mbIM.GetILGenerator();
        il.Emit(OpCodes.Ldstr, "The I.M implementation of C");
        il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine",
            new Type[] { typeof(string) }));
        il.Emit(OpCodes.Ret);

        // DefineMethodOverride is used to associate the method
        // body with the interface method that is being implemented.
        //
        tb.DefineMethodOverride(mbIM, typeof(I).GetMethod("M"));

        MethodBuilder mbM = tb.DefineMethod("M",
            MethodAttributes.Public | MethodAttributes.ReuseSlot |
                MethodAttributes.Virtual | MethodAttributes.HideBySig,
            null,
            Type.EmptyTypes);
        il = mbM.GetILGenerator();
        il.Emit(OpCodes.Ldstr, "Overriding A.M from C.M");
        il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine",
            new Type[] { typeof(string) }));
        il.Emit(OpCodes.Ret);

        Type tc = tb.CreateType();

        // Save the emitted assembly, to examine with Ildasm.exe.
        ab.Save(name + ".dll");

        Object test = Activator.CreateInstance(tc);

        MethodInfo mi = typeof(I).GetMethod("M");
        mi.Invoke(test, null);

        mi = typeof(A).GetMethod("M");
        mi.Invoke(test, null);
    }
}

/* This code example produces the following output:

The I.M implementation of C
Overriding A.M from C.M
 */

Imports System.Reflection
Imports System.Reflection.Emit

Public Interface I
    Sub M() 
End Interface

Public Class A
    Public Overridable Sub M() 
        Console.WriteLine("In method A.M")
    End Sub
End Class

' The object of this code example is to emit code equivalent to
' the following C# code:
'
Public Class C
    Inherits A
    Implements I
    
    Public Overrides Sub M() 
        Console.WriteLine("Overriding A.M from C.M")
    End Sub
    
    ' In order to provide a different implementation from C.M when 
    ' emitting the following explicit interface implementation, 
    ' it is necessary to use a MethodImpl.
    '
    Private Sub IM() Implements I.M
        Console.WriteLine("The I.M implementation of C")
    End Sub
End Class

Class Test
    
    Shared Sub Main() 

        Dim name As String = "DefineMethodOverrideExample"
        Dim asmName As New AssemblyName(name)
        Dim ab As AssemblyBuilder = _
            AppDomain.CurrentDomain.DefineDynamicAssembly( _
                asmName, AssemblyBuilderAccess.RunAndSave)
        Dim mb As ModuleBuilder = _
            ab.DefineDynamicModule(name, name & ".dll")
        
        Dim tb As TypeBuilder = _
            mb.DefineType("C", TypeAttributes.Public, GetType(A))
        tb.AddInterfaceImplementation(GetType(I))
        
        ' Build the method body for the explicit interface 
        ' implementation. The name used for the method body 
        ' can be anything. Here, it is the name of the method,
        ' qualified by the interface name.
        '
        Dim mbIM As MethodBuilder = _
            tb.DefineMethod("I.M", _
            MethodAttributes.Private Or MethodAttributes.HideBySig Or _
                MethodAttributes.NewSlot Or MethodAttributes.Virtual Or _
                MethodAttributes.Final, _
            Nothing, _
            Type.EmptyTypes)
        Dim il As ILGenerator = mbIM.GetILGenerator()
        il.Emit(OpCodes.Ldstr, "The I.M implementation of C")
        il.Emit(OpCodes.Call, GetType(Console).GetMethod("WriteLine", _
            New Type() {GetType(String)}))
        il.Emit(OpCodes.Ret)
        
        ' DefineMethodOverride is used to associate the method 
        ' body with the interface method that is being implemented.
        '
        tb.DefineMethodOverride(mbIM, GetType(I).GetMethod("M"))
        
        Dim mbM As MethodBuilder = tb.DefineMethod("M", _
            MethodAttributes.Public Or MethodAttributes.ReuseSlot Or _
                MethodAttributes.Virtual Or MethodAttributes.HideBySig, _
            Nothing, _
            Type.EmptyTypes)
        il = mbM.GetILGenerator()
        il.Emit(OpCodes.Ldstr, "Overriding A.M from C.M")
        il.Emit(OpCodes.Call, GetType(Console).GetMethod("WriteLine", _
            New Type() {GetType(String)}))
        il.Emit(OpCodes.Ret)
        
        Dim tc As Type = tb.CreateType()
        
        ' Save the emitted assembly, to examine with Ildasm.exe.
        ab.Save(name & ".dll")
        
        Dim test As Object = Activator.CreateInstance(tc)
        
        Dim mi As MethodInfo = GetType(I).GetMethod("M")
        mi.Invoke(test, Nothing)
        
        mi = GetType(A).GetMethod("M")
        mi.Invoke(test, Nothing)
    
    End Sub
End Class

' This code example produces the following output:
'
'The I.M implementation of C
'Overriding A.M from C.M
'

Hinweise

Verwenden Sie diese Methode nicht zum Ausgeben von Methodenüberschreibungen oder Schnittstellenimplementierungen. Um eine Methode einer Basisklasse zu überschreiben oder eine Methode einer Schnittstelle zu implementieren, geben Sie einfach eine Methode mit demselben Namen und derselben Signatur wie die methode aus, die überschrieben oder implementiert werden soll, wie im Codebeispiel veranschaulicht.

Die DefineMethodOverride -Methode wird verwendet, wenn ein Methodentext und eine Methodendeklaration unterschiedliche Namen haben. Beispielsweise kann eine Klasse eine Basisklassenmethode außer Kraft setzen und eine separate Implementierung für einen Schnittstellenmember mit demselben Namen bereitstellen, wie im Codebeispiel veranschaulicht.

DefineMethodOverride definiert eine methodimpl, die aus einem Paar von Metadatentoken besteht. Ein Token verweist auf eine Implementierung, und das andere Token verweist auf eine Deklaration, die der Text implementiert. Der Text muss für den Typ definiert werden, für den die Methode impl definiert ist, und der Text muss virtuell sein (Overridable in Visual Basic). Die Deklaration kann für eine Methode erfolgen, die für eine vom Typ implementierte Schnittstelle, eine Methode für eine abgeleitete Klasse oder eine im Typ definierte Methode definiert ist. Wenn sich die Deklaration nur auf einer Schnittstelle befindet, wird der für die Schnittstelle definierte Slot geändert. Wenn die Deklaration für eine Methode für einen Basistyp erfolgt, wird der Slot für die -Methode überschrieben, und alle Duplikate für die überschriebene Methode werden ebenfalls ersetzt. Die überschriebene Methode kann nicht die tatsächliche Methode sein, die deklariert wird. Wenn sich die Methode auf demselben Typ befindet, wird der Slot ersetzt, und alle Duplikate für die ersetzten Methoden werden überschrieben.

Hinweis

Weitere Informationen zu Methodenimpls finden Sie MethodImpl in der EcMA Partition II Metadata-Dokumentation unter ECMA C#- und Common Language Infrastructure Standards und Standard ECMA-335 – Common Language Infrastructure (CLI).

Wichtig

Nachdem die DefineMethodOverride -Methode aufgerufen wurde, können einige Features von methodInfoBody nicht mehr geändert werden. Beispielsweise können Sie mit der SetGenericParameterAttributes -Methode kein Attribut auf einen generischen Typparameter von methodInfoBody anwenden. Wenn Sie die -Methode verwenden müssen, tun Sie dies DefineMethodOverride , nachdem alle Merkmale von methodInfoBody definiert wurden.