TypeBuilder.DefineMethodOverride(MethodInfo, MethodInfo) Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Spécifie un corps de méthode donné qui implémente une déclaration de méthode donnée, éventuellement avec un nom différent.
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)
Paramètres
- methodInfoBody
- MethodInfo
Corps de méthode à utiliser. Il doit s’agir d’un objet MethodBuilder
.
- methodInfoDeclaration
- MethodInfo
Méthode dont la déclaration doit être utilisée.
Exceptions
methodInfoBody
n’appartient pas à cette classe.
methodInfoBody
ou methodInfoDeclaration
est null
.
Le type a déjà été créé en utilisant CreateType().
- ou -
Le type déclarant de methodInfoBody
n’est pas le type représenté par ce TypeBuilder.
Exemples
L’exemple de code suivant contient une interface I
avec une méthode M()
, une classe A
de base qui implémente l’interface et une classe C
dérivée qui remplace l’implémentation de la classe de base de M()
et fournit également une implémentation explicite distincte de I.M()
.
La main()
méthode de l’exemple de code montre comment émettre la classe C
dérivée . La substitution de s’effectue A.M()
simplement en émettant une méthode M()
avec la même signature. Toutefois, pour fournir une implémentation distincte de , vous devez définir un corps de I.M()
méthode, puis utiliser la DefineMethodOverride méthode pour associer ce corps de méthode à un MethodInfo représentant I.M()
. Le nom du corps de la méthode n’a pas d’importance.
L’exemple de code crée une instance de la classe émise. Il obtient un MethodInfo objet pour et l’utilise pour I.M()
appeler l’implémentation d’interface explicite de la classe émise. Il obtient ensuite un MethodInfo objet pour et l’utilise pour A.M()
appeler le remplacement de la classe émise de cette méthode.
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
'
Remarques
N’utilisez pas cette méthode pour émettre des remplacements de méthode ou des implémentations d’interface. Pour remplacer une méthode d’une classe de base ou pour implémenter une méthode d’une interface, il suffit d’émettre une méthode portant le même nom et la même signature que la méthode à remplacer ou à implémenter, comme illustré dans l’exemple de code.
La DefineMethodOverride méthode est utilisée quand un corps de méthode et une déclaration de méthode ont des noms différents. Par exemple, une classe peut remplacer une méthode de classe de base et fournir une implémentation distincte pour un membre d’interface portant le même nom, comme illustré dans l’exemple de code.
DefineMethodOverride
définit un methodimpl
, qui se compose d’une paire de jetons de métadonnées. Un jeton pointe vers une implémentation, et l’autre vers une déclaration que le corps implémente. Le corps doit être défini sur le type sur lequel la méthode impl est définie et le corps doit être virtuel (Overridable
en Visual Basic). La déclaration peut être effectuée sur une méthode définie sur une interface implémentée par le type, une méthode sur une classe dérivée ou une méthode définie dans le type. Si la déclaration se trouve sur une interface uniquement, l’emplacement défini pour l’interface est modifié. Si la déclaration est effectuée sur une méthode sur un type de base, l’emplacement de la méthode est remplacé et tous les doublons de la méthode remplacée sont également remplacés. La méthode remplacée ne peut pas être la méthode réelle déclarée. Si la méthode est sur le même type, l’emplacement est remplacé et tous les doublons des méthodes remplacées sont remplacés.
Notes
Pour plus d’informations sur les impls de méthode, consultez MethodImpl
la documentation sur les métadonnées de partition II ECMA à l’adresse C# ECMA et Common Language Infrastructure Standards et Standard ECMA-335 - Common Language Infrastructure (CLI).
Important
Une fois la DefineMethodOverride méthode appelée, certaines fonctionnalités de methodInfoBody
ne peuvent pas être modifiées. Par exemple, vous ne pouvez pas appliquer un attribut à un paramètre de type générique de à l’aide de methodInfoBody
la SetGenericParameterAttributes méthode . Si vous devez utiliser la méthode, faites-le DefineMethodOverride une fois que toutes les caractéristiques de methodInfoBody
ont été définies.