MethodInfo.MakeGenericMethod(Type[]) 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.
Geçerli genel yöntem tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen oluşturulur yöntemi temsil eden bir MethodInfo nesne döndürür.
public:
virtual System::Reflection::MethodInfo ^ MakeGenericMethod(... cli::array <Type ^> ^ typeArguments);
public virtual System.Reflection.MethodInfo MakeGenericMethod (params Type[] typeArguments);
abstract member MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo
Public Overridable Function MakeGenericMethod (ParamArray typeArguments As Type()) As MethodInfo
Parametreler
- typeArguments
- Type[]
Geçerli genel yöntem tanımının tür parametreleriyle değiştirilecek bir tür dizisi.
Döndürülenler
MethodInfo Geçerli genel yöntem tanımının tür parametreleri için öğelerinin typeArguments
yerini alarak oluşturulan yöntemi temsil eden bir nesne.
Özel durumlar
geçerli MethodInfo , genel bir yöntem tanımını temsil etmez. Yani döndürür IsGenericMethodDefinitionfalse
.
typeArguments
, null
değeridir.
-veya-
öğesinden herhangi biri typeArguments
şeklindedir null
.
içindeki typeArguments
öğelerin sayısı, geçerli genel yöntem tanımının tür parametrelerinin sayısıyla aynı değildir.
-veya-
öğesi typeArguments
, geçerli genel yöntem tanımının karşılık gelen tür parametresi için belirtilen kısıtlamaları karşılamıyor.
Bu yöntem desteklenmiyor.
Örnekler
Aşağıdaki kod örneği, genel yöntemlerin incelenmesini MethodInfo destekleyen özelliklerini ve yöntemlerini gösterir. Örnek aşağıdakileri yapar:
Genel bir yöntemi olan bir sınıf tanımlar.
Genel yöntemi temsil eden bir MethodInfo oluşturur.
Genel yöntem tanımının özelliklerini görüntüler.
türü bağımsız değişkenlerini öğesinin MethodInfotür parametrelerine atar ve sonuçta elde edilen genel yöntemi çağırır.
Yapılandırılan genel yöntemin özelliklerini görüntüler.
Yapılan yöntemden genel yöntem tanımını alır ve özgün tanımıyla karşılaştırır.
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
'
Açıklamalar
yöntemi, MakeGenericMethod genel bir yöntem tanımının tür parametrelerine belirli türler atayan kod yazmanıza olanak tanır, böylece belirli bir oluşturulur yöntemi temsil eden bir MethodInfo nesne oluşturur. Bu MethodInfo nesnenin ContainsGenericParameters özelliği döndürürsetrue
, yöntemini çağırmak veya yöntemini çağırmak için bir temsilci oluşturmak için kullanabilirsiniz.
yöntemiyle yapılan yöntemler açık olabilir, diğer bir ifadeyle MakeGenericMethod , tür bağımsız değişkenlerinden bazıları genel türleri kapsayan tür parametreleri olabilir. Dinamik derlemeler oluştururken bu tür açık oluşturulmuş yöntemleri kullanabilirsiniz. Örneğin, aşağıdaki C#, Visual Basic ve C++ kodunu göz önünde bulundurun.
class C
{
T N<T,U>(T t, U u) {...}
public V M<V>(V v)
{
return N<V,int>(v, 42);
}
}
Class C
Public Function N(Of T,U)(ByVal ta As T, ByVal ua As U) As T
...
End Function
Public Function M(Of V)(ByVal va As V ) As V
Return N(Of V, Integer)(va, 42)
End Function
End Class
ref class C
{
private:
generic <typename T, typename U> T N(T t, U u) {...}
public:
generic <typename V> V M(V v)
{
return N<V, int>(v, 42);
}
};
yönteminin M
yöntem gövdesi, türü parametresini M
ve türünü Int32belirten bir yöntemi N
çağrısı içerir.
IsGenericMethodDefinition özelliği yöntemi N<V,int>
için döndürürfalse
.
ContainsGenericParameters özelliği döndürürtrue
, bu nedenle yöntem N<V,int>
çağrılamaz.
Genel yöntemlere özgü koşulların sabit koşullarının listesi için özelliğine IsGenericMethod bakın. Genel yansımada kullanılan diğer terimlere ilişkin sabit koşulların listesi için özelliğine IsGenericType bakın.