Share via

TypeBuilder.DefineMethodOverride(MethodInfo, MethodInfo) Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Reflection.Emit
Bütünleştirilmiş Kod:
System.Reflection.Emit.dll
Bütünleştirilmiş Kod:
mscorlib.dll
Bütünleştirilmiş Kod:
netstandard.dll
Paket:
System.Reflection.Emit v4.7.0
Kaynak:
TypeBuilder.cs
Kaynak:
TypeBuilder.cs
Kaynak:
TypeBuilder.cs

Belirli bir yöntem bildirimini uygulayan ve büyük olasılıkla farklı bir ada sahip olan belirli bir yöntem gövdesini belirtir.

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)

Parametreler

methodInfoBody
MethodInfo

Kullanılacak yöntem gövdesi. Bu bir MethodBuilder nesne olmalıdır.

methodInfoDeclaration
MethodInfo

Bildirimi kullanılacak yöntemi.

Özel durumlar

ArgumentException

methodInfoBody bu sınıfa ait değil.

ArgumentNullException

methodInfoBody veya methodInfoDeclaration şeklindedir null.

InvalidOperationException

Türü daha önce kullanılarak CreateType()oluşturulmuştur.

-veya-

Bildirim türü methodInfoBody , bu TypeBuildertarafından temsil edilen tür değildir.

Örnekler

Aşağıdaki kod örneği yöntemine M()sahip bir arabirimI, arabirimini uygulayan bir temel sınıf A ve temel sınıf C uygulamasını M() geçersiz kılan ve ayrıca ayrı bir açık uygulaması I.M()sağlayan türetilmiş bir sınıf içerir.

main() Kod örneğinin yöntemi, türetilmiş sınıfının Cnasıl yayılmış olduğunu gösterir. geçersiz kılma A.M() işlemi yalnızca aynı imzaya sahip bir yöntem M() yayılarak gerçekleştirilir. Ancak, ayrı bir uygulaması I.M()sağlamak için bir yöntem gövdesi tanımlamanız ve ardından yöntemini kullanarak bu yöntem gövdesini DefineMethodOverride temsil eden I.M()bir MethodInfo ile ilişkilendirmeniz gerekir. Yöntem gövdesinin adı önemli değildir.

Kod örneği, yayılan sınıfın bir örneğini oluşturur. için bir MethodInfo nesnesi alır ve bunu, yayılan sınıfın açık arabirim uygulamasını çağırmak için I.M()kullanır. Ardından için bir MethodInfo nesnesi alır ve bu nesneyi, yayılan sınıfın bu yöntemi geçersiz kılmasını çağırmak için A.M()kullanır.

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
'

Açıklamalar

Yöntem geçersiz kılmalarını veya arabirim uygulamalarını yaymak için bu yöntemi kullanmayın. Bir temel sınıfın yöntemini geçersiz kılmak veya bir arabirimin yöntemini uygulamak için, kod örneğinde gösterildiği gibi geçersiz kılınacak veya uygulanacak yöntemle aynı ada ve imzaya sahip bir yöntem yaymak yeterlidir.

DefineMethodOverride yöntem gövdesi ve yöntem bildirimi farklı adlara sahip olduğunda yöntemi kullanılır. Örneğin, bir sınıf temel sınıf yöntemini geçersiz kılıp kod örneğinde gösterildiği gibi aynı ada sahip bir arabirim üyesi için ayrı bir uygulama sağlayabilir.

DefineMethodOverride , bir methodimplçift meta veri belirteci içeren bir öğesini tanımlar. Belirteçlerden biri bir uygulamaya, diğer belirteç ise gövdenin uyguladığı bir bildirime işaret eder. Gövde, impl yönteminin tanımlandığı tür üzerinde tanımlanmalıdır ve gövde sanal olmalıdır (Overridable Visual Basic'te). Bildirim türü tarafından uygulanan bir arabirimde tanımlanan bir yönteme, türetilmiş bir sınıftaki bir yönteme veya türünde tanımlanan bir yönteme yapılabilir. Bildirim yalnızca bir arabirimdeyse, arabirim için tanımlanan yuva değiştirilir. Bildirim bir temel türdeki bir yönteme yapılırsa, yöntemin yuvası geçersiz kılınmış olur ve geçersiz kılınan yöntemin yinelemeleri de değiştirilir. Geçersiz kılınan yöntem, bildirilen gerçek yöntem olamaz. Yöntem aynı türdeyse yuva değiştirilir ve değiştirilen yöntemlerin yinelemeleri geçersiz kılınabilir.

Not

Yöntem imp'leri hakkında daha fazla bilgi için ECMA C# ve Ortak Dil Altyapısı Standartları veStandart ECMA-335 - Ortak Dil Altyapısı (CLI) konusundaki ECMA Bölüm II Meta Verileri belgelerine bakınMethodImpl.

Önemli

DefineMethodOverride yöntemi çağrıldıktan sonra bazı özellikleri methodInfoBody değiştirilemez. Örneğin, yöntemini kullanarak SetGenericParameterAttributes genel tür parametresine methodInfoBody özniteliği uygulayamazsınız. yöntemini kullanmanız DefineMethodOverride gerekiyorsa, tüm özellikleri methodInfoBody tanımlandıktan sonra bunu yapın.

Şunlara uygulanır