MethodInfo.GetGenericMethodDefinition Méthode

Définition

Retourne un objet MethodInfo qui représente une définition de méthode générique à partir de laquelle la méthode actuelle peut être construite.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

public:
 virtual System::Reflection::MethodInfo ^ GetGenericMethodDefinition();
[System.Runtime.InteropServices.ComVisible(true)]
public virtual System.Reflection.MethodInfo GetGenericMethodDefinition ();
abstract member GetGenericMethodDefinition : unit -> System.Reflection.MethodInfo
override this.GetGenericMethodDefinition : unit -> System.Reflection.MethodInfo
Public Overridable Function GetGenericMethodDefinition () As MethodInfo

Retours

Objet MethodInfo représentant une définition de méthode générique à partir de laquelle la méthode actuelle peut être construite.A MethodInfo object representing a generic method definition from which the current method can be constructed.

Attributs

Exceptions

La méthode actuelle est une méthode générique.The current method is not a generic method. Autrement dit, IsGenericMethod retourne false.That is, IsGenericMethod returns false.

Cette méthode n'est pas prise en charge.This method is not supported.

Exemples

L’exemple de code suivant montre une classe avec une méthode générique et le code requis pour obtenir une MethodInfo pour la méthode, lier la méthode aux arguments de type et récupérer la définition de type générique d’origine à partir de la méthode liée.The following code example shows a class with a generic method and the code required to obtain a MethodInfo for the method, bind the method to type arguments, and get the original generic type definition back from the bound method.

Cet exemple fait partie d’un exemple plus complet fourni pour la méthode MakeGenericMethod.This example is part of a larger example provided for the MakeGenericMethod method.

// Define a class with a generic method.
ref class Example
{
public:
    generic<typename T> static void Generic(T toDisplay)
    {
        Console::WriteLine("\r\nHere it is: {0}", toDisplay);
    }
};
// Define a class with a generic method.
public class Example
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}
' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}", toDisplay)
    End Sub
End Class
// Create a Type object representing class Example, and
// get a MethodInfo representing the generic method.
//
Type^ ex = Example::typeid;
MethodInfo^ mi = ex->GetMethod("Generic");

DisplayGenericMethodInfo(mi);

// Assign the int type to the type parameter of the Example 
// method.
//
MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid);

DisplayGenericMethodInfo(miConstructed);
// Create a Type object representing class Example, and
// get a MethodInfo representing the generic method.
//
Type ex = typeof(Example);
MethodInfo mi = ex.GetMethod("Generic");

DisplayGenericMethodInfo(mi);

// Assign the int type to the type parameter of the Example 
// method.
//
MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

DisplayGenericMethodInfo(miConstructed);
' Create a Type object representing class Example, and
' get a MethodInfo representing the generic method.
'
Dim ex As Type = GetType(Example)
Dim mi As MethodInfo = ex.GetMethod("Generic")

DisplayGenericMethodInfo(mi)

' Assign the Integer type to the type parameter of the Example 
' method.
'
Dim arguments() As Type = { GetType(Integer) }
Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)

DisplayGenericMethodInfo(miConstructed)
// Get the generic type definition from the closed method,
// and show it's the same as the original definition.
//
MethodInfo^ miDef = miConstructed->GetGenericMethodDefinition();
Console::WriteLine("\r\nThe definition is the same: {0}",
        miDef == mi);
// Get the generic type definition from the closed method,
// and show it's the same as the original definition.
//
MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
Console.WriteLine("\r\nThe definition is the same: {0}",
    miDef == mi);
' Get the generic type definition from the constructed method,
' and show that it's the same as the original definition.
'
Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
Console.WriteLine(vbCrLf & "The definition is the same: {0}", _
    miDef Is mi)

Remarques

Une définition de méthode générique est un modèle à partir duquel les méthodes peuvent être construites.A generic method definition is a template from which methods can be constructed. Par exemple, à partir de la définition de méthode générique T M<T>(T t) C# (exprimé dans la syntaxe ; Function M(Of T)(ByVal tVal As T) As T dans Visual Basic) vous pouvez construire et appeler la méthode int M<int>(int t) (Function M(Of Integer)(ByVal tVal As Integer) As Integer dans Visual Basic).For example, from the generic method definition T M<T>(T t) (expressed in C# syntax; Function M(Of T)(ByVal tVal As T) As T in Visual Basic) you can construct and invoke the method int M<int>(int t) (Function M(Of Integer)(ByVal tVal As Integer) As Integer in Visual Basic). À partir d’un objet MethodInfo représentant cette méthode construite, la méthode GetGenericMethodDefinition retourne la définition de méthode générique.Given a MethodInfo object representing this constructed method, the GetGenericMethodDefinition method returns the generic method definition.

Si deux méthodes construites sont créées à partir de la même définition de méthode générique, la méthode GetGenericMethodDefinition retourne le même objet MethodInfo pour les deux méthodes.If two constructed methods are created from the same generic method definition, the GetGenericMethodDefinition method returns the same MethodInfo object for both methods.

Si vous appelez GetGenericMethodDefinition sur un MethodInfo qui représente déjà une définition de méthode générique, elle retourne le MethodInfoen cours.If you call GetGenericMethodDefinition on a MethodInfo that already represents a generic method definition, it returns the current MethodInfo.

Si une définition de méthode générique inclut des paramètres génériques du type déclarant, il y aura une définition de méthode générique spécifique à chaque type construit.If a generic method definition includes generic parameters of the declaring type, there will be a generic method definition specific to each constructed type. Par exemple, considérez les C#éléments suivants, Visual Basic C++ et code :For example, consider the following C#, Visual Basic, and C++ code:

class B<U,V> {}  
class C<T> { public B<T,S> M<S>() {...}}  
  
Class B(Of U, V)  
End Class  
Class C(Of T)  
    Public Function M(Of S)() As B(Of T, S)  
        ...  
    End Function  
End Class   
  
generic <typename U, typename V> ref class B {};  
generic <typename T> ref class C  
{  
public:  
    generic <typename S> B<T,S>^ M() {...};  
};  

Dans le C<int> de type construit (C(Of Integer) dans Visual Basic), la méthode générique M retourne B<int, S>.In the constructed type C<int> (C(Of Integer) in Visual Basic), the generic method M returns B<int, S>. Dans le C<T>de type ouvert, M retourne B<T, S>.In the open type C<T>, M returns B<T, S>. Dans les deux cas, la propriété IsGenericMethodDefinition retourne true pour le MethodInfo qui représente M, par conséquent MakeGenericMethod peut être appelée sur les deux objets MethodInfo.In both cases, the IsGenericMethodDefinition property returns true for the MethodInfo that represents M, so MakeGenericMethod can be called on both MethodInfo objects. Dans le cas du type construit, le résultat de l’appel de MakeGenericMethod est un MethodInfo qui peut être appelé.In the case of the constructed type, the result of calling MakeGenericMethod is a MethodInfo that can be invoked. Dans le cas du type Open, le MethodInfo retourné par MakeGenericMethod ne peut pas être appelé.In the case of the open type, the MethodInfo returned by MakeGenericMethod cannot be invoked.

Pour obtenir la liste des conditions invariantes pour les termes spécifiques aux méthodes génériques, consultez la propriété IsGenericMethod.For a list of the invariant conditions for terms specific to generic methods, see the IsGenericMethod property. Pour obtenir la liste des conditions invariantes pour les autres termes utilisés dans la réflexion générique, consultez la propriété IsGenericType.For a list of the invariant conditions for other terms used in generic reflection, see the IsGenericType property.

S’applique à

Voir aussi