Type.DeclaringMethod Propriedade
Definição
Obtém um MethodBase que representa o método declarativo, se o Type atual representa um parâmetro de tipo de um método genérico.Gets a MethodBase that represents the declaring method, if the current Type represents a type parameter of a generic method.
public:
virtual property System::Reflection::MethodBase ^ DeclaringMethod { System::Reflection::MethodBase ^ get(); };
public virtual System.Reflection.MethodBase? DeclaringMethod { get; }
public virtual System.Reflection.MethodBase DeclaringMethod { get; }
member this.DeclaringMethod : System.Reflection.MethodBase
Public Overridable ReadOnly Property DeclaringMethod As MethodBase
Valor da propriedade
Se o Type atual representa um parâmetro de tipo de um método genérico, um MethodBase que representa o método declarativo; caso contrário, null.If the current Type represents a type parameter of a generic method, a MethodBase that represents declaring method; otherwise, null.
Exemplos
O exemplo de código a seguir define uma classe que tem um método genérico, atribui um argumento de tipo ao método e invoca o método genérico construído resultante.The following code example defines a class that has a generic method, assigns a type argument to the method, and invokes the resulting constructed generic method. Ele também exibe informações sobre a definição do método genérico e o método construído.It also displays information about the generic method definition and the constructed method. Ao exibir informações sobre os parâmetros de tipo da definição de método genérico, no DisplayGenericMethodInfo método, o código de exemplo mostra o valor da DeclaringMethod propriedade para o parâmetro de tipo genérico do método.When displaying information about the type parameters of the generic method definition, in the DisplayGenericMethodInfo method, the example code shows the value of the DeclaringMethod property for the method's generic type parameter.
using namespace System;
using namespace System::Reflection;
// 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);
}
};
void DisplayGenericMethodInfo(MethodInfo^ mi)
{
Console::WriteLine("\r\n{0}", mi);
Console::WriteLine("\tIs this a generic method definition? {0}",
mi->IsGenericMethodDefinition);
Console::WriteLine("\tIs it a generic method? {0}",
mi->IsGenericMethod);
Console::WriteLine("\tDoes it have unassigned generic parameters? {0}",
mi->ContainsGenericParameters);
// If this is a generic method, display its type arguments.
//
if (mi->IsGenericMethod)
{
array<Type^>^ typeArguments = mi->GetGenericArguments();
Console::WriteLine("\tList type arguments ({0}):",
typeArguments->Length);
for each (Type^ tParam in typeArguments)
{
// IsGenericParameter is true only for generic type
// parameters.
//
if (tParam->IsGenericParameter)
{
Console::WriteLine("\t\t{0} parameter position {1}" +
"\n\t\t declaring method: {2}",
tParam,
tParam->GenericParameterPosition,
tParam->DeclaringMethod);
}
else
{
Console::WriteLine("\t\t{0}", tParam);
}
}
}
};
void main()
{
Console::WriteLine("\r\n--- Examine a generic method.");
// 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);
// Invoke the method.
array<Object^>^ args = { 42 };
miConstructed->Invoke((Object^) 0, args);
// Invoke the method normally.
Example::Generic<int>(42);
// 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);
};
/* This example produces the following output:
--- Examine a generic method.
Void Generic[T](T)
Is this a generic method definition? True
Is it a generic method? True
Does it have unassigned generic parameters? True
List type arguments (1):
T parameter position 0
declaring method: Void Generic[T](T)
Void Generic[Int32](Int32)
Is this a generic method definition? False
Is it a generic method? True
Does it have unassigned generic parameters? False
List type arguments (1):
System.Int32
Here it is: 42
Here it is: 42
The definition is the same: True
*/
using System;
using System.Reflection;
// 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);
}
}
public class Test
{
public static void Main()
{
Console.WriteLine("\r\n--- Examine a generic method.");
// 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);
// Invoke the method.
object[] args = {42};
miConstructed.Invoke(null, args);
// Invoke the method normally.
Example.Generic<int>(42);
// 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);
}
private static void DisplayGenericMethodInfo(MethodInfo mi)
{
Console.WriteLine("\r\n{0}", mi);
Console.WriteLine("\tIs this a generic method definition? {0}",
mi.IsGenericMethodDefinition);
Console.WriteLine("\tIs it a generic method? {0}",
mi.IsGenericMethod);
Console.WriteLine("\tDoes it have unassigned generic parameters? {0}",
mi.ContainsGenericParameters);
// If this is a generic method, display its type arguments.
//
if (mi.IsGenericMethod)
{
Type[] typeArguments = mi.GetGenericArguments();
Console.WriteLine("\tList type arguments ({0}):",
typeArguments.Length);
foreach (Type tParam in typeArguments)
{
// IsGenericParameter is true only for generic type
// parameters.
//
if (tParam.IsGenericParameter)
{
Console.WriteLine("\t\t{0} parameter position {1}" +
"\n\t\t declaring method: {2}",
tParam,
tParam.GenericParameterPosition,
tParam.DeclaringMethod);
}
else
{
Console.WriteLine("\t\t{0}", tParam);
}
}
}
}
}
/* This example produces the following output:
--- Examine a generic method.
Void Generic[T](T)
Is this a generic method definition? True
Is it a generic method? True
Does it have unassigned generic parameters? True
List type arguments (1):
T parameter position 0
declaring method: Void Generic[T](T)
Void Generic[Int32](Int32)
Is this a generic method definition? False
Is it a generic method? True
Does it have unassigned generic parameters? False
List type arguments (1):
System.Int32
Here it is: 42
Here it is: 42
The definition is the same: True
*/
Imports System.Reflection
' 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
Public Class Test
Public Shared Sub Main()
Console.WriteLine(vbCrLf & "--- Examine a generic method.")
' 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)
' Invoke the method.
Dim args() As Object = { 42 }
miConstructed.Invoke(Nothing, args)
' Invoke the method normally.
Example.Generic(Of Integer)(42)
' 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)
End Sub
Private Shared Sub DisplayGenericMethodInfo(ByVal mi As MethodInfo)
Console.WriteLine(vbCrLf & mi.ToString())
Console.WriteLine(vbTab _
& "Is this a generic method definition? {0}", _
mi.IsGenericMethodDefinition)
Console.WriteLine(vbTab & "Is it a generic method? {0}", _
mi.IsGenericMethod)
Console.WriteLine(vbTab _
& "Does it have unassigned generic parameters? {0}", _
mi.ContainsGenericParameters)
' If this is a generic method, display its type arguments.
'
If mi.IsGenericMethod Then
Dim typeArguments As Type() = mi.GetGenericArguments()
Console.WriteLine(vbTab & "List type arguments ({0}):", _
typeArguments.Length)
For Each tParam As Type In typeArguments
' IsGenericParameter is true only for generic type
' parameters.
'
If tParam.IsGenericParameter Then
Console.WriteLine(vbTab & vbTab _
& "{0} parameter position: {1}" _
& vbCrLf & vbTab & vbTab _
& " declaring method: {2}", _
tParam, _
tParam.GenericParameterPosition, _
tParam.DeclaringMethod)
Else
Console.WriteLine(vbTab & vbTab & tParam.ToString())
End If
Next tParam
End If
End Sub
End Class
' This example produces the following output:
'
'--- Examine a generic method.
'
'Void Generic[T](T)
' Is this a generic method definition? True
' Is it a generic method? True
' Does it have unassigned generic parameters? True
' List type arguments (1):
' T parameter position: 0
' declaring method: Void Generic[T](T)
'
'Void Generic[Int32](Int32)
' Is this a generic method definition? False
' Is it a generic method? True
' Does it have unassigned generic parameters? False
' List type arguments (1):
' System.Int32
'
'Here it is: 42
'
'Here it is: 42
'
'The definition is the same: True
'
Comentários
O método declarativo é uma definição de método genérico.The declaring method is a generic method definition. Ou seja, se não DeclaringMethod retornar null , DeclaringMethod.IsGenericMethodDefinition retornará true .That is, if DeclaringMethod does not return null, then DeclaringMethod.IsGenericMethodDefinition returns true.
As DeclaringType DeclaringMethod Propriedades e identificam a definição de tipo genérico ou definição de método genérico no qual o parâmetro de tipo genérico foi originalmente definido:The DeclaringType and DeclaringMethod properties identify the generic type definition or generic method definition in which the generic type parameter was originally defined:
Se a DeclaringMethod Propriedade retornar um MethodInfo , que MethodInfo representa uma definição de método genérico, e o Type objeto atual representar um parâmetro de tipo dessa definição de método genérico.If the DeclaringMethod property returns a MethodInfo, that MethodInfo represents a generic method definition, and the current Type object represents a type parameter of that generic method definition.
Se a DeclaringMethod Propriedade retornar
null, a DeclaringType propriedade sempre retornará um Type objeto que representa uma definição de tipo genérico e o Type objeto atual representará um parâmetro de tipo dessa definição de tipo genérico.If the DeclaringMethod property returnsnull, then the DeclaringType property always returns a Type object representing a generic type definition, and the current Type object represents a type parameter of that generic type definition.Obtendo a DeclaringMethod propriedade em um tipo cuja IsGenericParameter propriedade é
falselançada um InvalidOperationException .Getting the DeclaringMethod property on a type whose IsGenericParameter property isfalsethrows an InvalidOperationException.
O MethodBase que é retornado pela DeclaringMethod propriedade é um MethodInfo no caso de um método genérico ou um ConstructorInfo no caso de um Construtor genérico.The MethodBase that is returned by the DeclaringMethod property is either a MethodInfo in the case of a generic method, or a ConstructorInfo in the case of a generic constructor.
Observação
No .NET Framework versão 2,0, não há suporte para construtores genéricos.In the .NET Framework version 2.0, generic constructors are not supported.
Para obter uma lista das condições invariáveis para termos usados na reflexão genérica, consulte os comentários da propriedade IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.