MethodInfo.GetGenericMethodDefinition Metodo

Definizione

Restituisce un oggetto MethodInfo che rappresenta la definizione di un metodo generica da cui è possibile costruire il metodo corrente.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

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

Restituisce

MethodInfo

Oggetto MethodInfo che rappresenta la definizione di un metodo generica da cui è possibile costruire il metodo corrente.A MethodInfo object representing a generic method definition from which the current method can be constructed.

Attributi

Eccezioni

Il metodo corrente non è un metodo generico.The current method is not a generic method. Ciò significa che IsGenericMethod restituisce false.That is, IsGenericMethod returns false.

Questo metodo non è supportato.This method is not supported.

Esempio

Nell'esempio di codice seguente viene illustrata una classe con un metodo generico e il codice necessario per ottenere un oggetto MethodInfo per il metodo, associare il metodo agli argomenti di tipo e ottenere la definizione di tipo generico originale dal metodo associato.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.

Questo esempio fa parte di un esempio più ampio fornito per il MakeGenericMethod metodo.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)

Commenti

Una definizione di metodo generico è un modello da cui è possibile costruire metodi.A generic method definition is a template from which methods can be constructed. Ad esempio, dalla definizione di metodo generico T M<T>(T t) (espressa nella sintassi C#, Function M(Of T)(ByVal tVal As T) As T in Visual Basic) è possibile costruire e richiamare il metodo int M<int>(int t) ( Function M(Of Integer)(ByVal tVal As Integer) As Integer in 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). Dato un MethodInfo oggetto che rappresenta questo metodo costruito, il GetGenericMethodDefinition metodo restituisce la definizione di metodo generico.Given a MethodInfo object representing this constructed method, the GetGenericMethodDefinition method returns the generic method definition.

Se vengono creati due metodi costruiti dalla stessa definizione di metodo generico, il GetGenericMethodDefinition metodo restituisce lo stesso MethodInfo oggetto per entrambi i metodi.If two constructed methods are created from the same generic method definition, the GetGenericMethodDefinition method returns the same MethodInfo object for both methods.

Se si chiama GetGenericMethodDefinition su un MethodInfo che rappresenta già una definizione di metodo generico, restituisce l'oggetto corrente MethodInfo .If you call GetGenericMethodDefinition on a MethodInfo that already represents a generic method definition, it returns the current MethodInfo.

Se una definizione di metodo generico include parametri generici del tipo dichiarante, sarà disponibile una definizione di metodo generica specifica per ogni tipo costruito.If a generic method definition includes generic parameters of the declaring type, there will be a generic method definition specific to each constructed type. Si consideri, ad esempio, il codice C#, Visual Basic e C++ riportato di seguito: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() {...};  
};  

Nel tipo costruito C<int> ( C(Of Integer) in Visual Basic), il metodo generico M restituisce B<int, S> .In the constructed type C<int> (C(Of Integer) in Visual Basic), the generic method M returns B<int, S>. Nel tipo aperto C<T> , M restituisce B<T, S> .In the open type C<T>, M returns B<T, S>. In entrambi i casi, la IsGenericMethodDefinition proprietà restituisce true per l'oggetto MethodInfo che rappresenta M , pertanto MakeGenericMethod può essere chiamato su entrambi MethodInfo gli oggetti.In both cases, the IsGenericMethodDefinition property returns true for the MethodInfo that represents M, so MakeGenericMethod can be called on both MethodInfo objects. Nel caso del tipo costruito, il risultato della chiamata di MakeGenericMethod è un oggetto MethodInfo che può essere richiamato.In the case of the constructed type, the result of calling MakeGenericMethod is a MethodInfo that can be invoked. Nel caso del tipo aperto, MethodInfo MakeGenericMethod non è possibile richiamare l'oggetto restituito da.In the case of the open type, the MethodInfo returned by MakeGenericMethod cannot be invoked.

Per un elenco delle condizioni invariabili per i termini specifici dei metodi generici, vedere la IsGenericMethod Proprietà.For a list of the invariant conditions for terms specific to generic methods, see the IsGenericMethod property. Per un elenco delle condizioni invariabili per altri termini usati nella reflection generica, vedere la IsGenericType Proprietà.For a list of the invariant conditions for other terms used in generic reflection, see the IsGenericType property.

Si applica a

Vedi anche