TypeBuilder.DefineMethodOverride(MethodInfo, MethodInfo) Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
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
methodInfoBody
bu sınıfa ait değil.
methodInfoBody
veya methodInfoDeclaration
şeklindedir null
.
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 C
nası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
Geri Bildirim
https://aka.ms/ContentUserFeedback.
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz.Gönderin ve geri bildirimi görüntüleyin