TypeBuilder.DefineMethodOverride(MethodInfo, MethodInfo) Metoda

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Emit.dll

Źródło:

TypeBuilder.cs

Określa daną treść metody, która implementuje daną deklarację metody, potencjalnie o innej nazwie.

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)

Parametry

methodInfoBody

MethodInfo

Treść metody do użycia. Powinien to być MethodBuilder obiekt.

methodInfoDeclaration

MethodInfo

Metoda, której deklaracja ma być używana.

Wyjątki

ArgumentException

methodInfoBody nie należy do tej klasy.

ArgumentNullException

methodInfoBody lub methodInfoDeclaration ma wartość null.

InvalidOperationException

Typ został wcześniej utworzony przy użyciu polecenia CreateType().

-lub-

Typ deklarowania methodInfoBody nie jest typem reprezentowanym przez ten TypeBuilderelement .

Przykłady

Poniższy przykład kodu zawiera interfejs I z metodą M(), klasą bazową, która implementuje interfejs, oraz klasą AC pochodną, która zastępuje implementację klasy bazowej M() , a także udostępnia oddzielną jawną implementację I.M()klasy .

Metoda main() przykładu kodu pokazuje, jak emitować klasę Cpochodną . Przesłonięcie A.M() metody jest realizowane po prostu przez emitowanie metody M() z tym samym podpisem. Jednak aby zapewnić oddzielną implementację I.M()klasy , należy zdefiniować treść metody, a następnie użyć DefineMethodOverride metody , aby skojarzyć treść tej metody z reprezentacją MethodInfoI.M(). Nazwa treści metody nie ma znaczenia.

Przykładowy kod tworzy wystąpienie emitowanego klasy. MethodInfo Uzyskuje obiekt dla I.M()elementu i używa go do wywoływania implementacji interfejsu jawnego emitowanego klasy. Następnie uzyskuje MethodInfo obiekt dla A.M()klasy i używa go do wywoływania zastąpienia emitowanego klasy tej metody.

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
'

Uwagi

Nie należy używać tej metody do emitowania przesłonięć metod ani implementacji interfejsu. Aby zastąpić metodę klasy bazowej lub zaimplementować metodę interfejsu, po prostu emituj metodę o tej samej nazwie i podpisie co metoda, która ma zostać zastąpiona lub zaimplementowana, jak pokazano w przykładzie kodu.

Metoda DefineMethodOverride jest używana, gdy treść metody i deklaracja metody mają różne nazwy. Na przykład klasa może zastąpić metodę klasy bazowej, a także zapewnić oddzielną implementację elementu członkowskiego interfejsu o tej samej nazwie, jak pokazano w przykładzie kodu.

DefineMethodOverride definiuje element methodimpl, który składa się z pary tokenów metadanych. Jeden token wskazuje implementację, a drugi wskazuje deklarację, że treść implementuje. Treść musi być zdefiniowana w typie zdefiniowanym przez metodę impl, a treść musi być wirtualna (Overridable w Visual Basic). Deklarację można wykonać w metodzie zdefiniowanej w interfejsie zaimplementowanym przez typ, metodę w klasie pochodnej lub metodę zdefiniowaną w typie. Jeśli deklaracja znajduje się tylko w interfejsie, miejsce zdefiniowane dla interfejsu jest zmieniane. Jeśli deklaracja jest stosowana do metody w typie podstawowym, miejsce dla metody jest zastępowane, a wszelkie duplikaty metody zastępowanej również są zastępowane. Metoda przesłonięć nie może być rzeczywistą metodą zadeklarowaną. Jeśli metoda jest w tym samym typie, miejsce jest zastępowane i wszelkie duplikaty dla zastąpionych metod są zastępowane.

Uwaga

Aby uzyskać więcej informacji na temat metody impls, zobacz MethodImpl dokumentację metadanych partycji ECMA II w temacie ECMA C# and Common Language Infrastructure Standards andStandard ECMA-335 - Common Language Infrastructure (CLI).

Ważne

Po wywołaniu DefineMethodOverride metody nie można zmienić niektórych funkcji methodInfoBody . Na przykład nie można zastosować atrybutu do parametru methodInfoBody typu ogólnego przy użyciu SetGenericParameterAttributes metody . Jeśli musisz użyć DefineMethodOverride metody , zrób to po zdefiniowaniu wszystkich cech methodInfoBody .