MethodBuilder.DefineGenericParameters(String[]) Metódus
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Beállítja az aktuális metódus általános típusparamétereinek számát, megadja a nevüket, és egy objektumtömböt GenericTypeParameterBuilder ad vissza, amely a kényszerek meghatározására használható.
public:
cli::array <System::Reflection::Emit::GenericTypeParameterBuilder ^> ^ DefineGenericParameters(... cli::array <System::String ^> ^ names);public System.Reflection.Emit.GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names);member this.DefineGenericParameters : string[] -> System.Reflection.Emit.GenericTypeParameterBuilder[]Public Function DefineGenericParameters (ParamArray names As String()) As GenericTypeParameterBuilder()Paraméterek
- names
- String[]
Sztringek tömbje, amelyek az általános típusparaméterek nevét jelölik.
Válaszok
Az általános metódus típusparamétereit képviselő objektumtömb GenericTypeParameterBuilder .
Kivételek
Ehhez a metódushoz már definiáltak általános típusparamétereket.
-vagy-
A metódus már befejeződött.
-vagy-
A SetImplementationFlags(MethodImplAttributes) metódus az aktuális metódushoz lett meghívva.
names üres tömb.
Példák
Az alábbi példakód egy dinamikus típust hoz létre, DemoTypeamely a dinamikus általános metódust DemoMethodtartalmazza. Ez a metódus két általános típusparaméterrel rendelkezik, amelyek közül az egyik paraméterként, a másik pedig visszatérési típusként van használva.
A kód végrehajtásakor a dinamikus szerelvény DemoGenericMethod1.dllként lesz mentve, és a Ildasm.exe (IL-szétszerelő) használatával vizsgálható meg.
Note
Ez a példakód egy egyszerű metódustörzset hoz létre, amely csupán null hivatkozást ad vissza. Az általános típusokat létrehozó és használó, teljes körűen kifejlesztett metódustörzset tartalmazó kódért lásd : Általános metódus definiálása a Reflection Emit használatával.
using System;
using System.Reflection;
using System.Reflection.Emit;
class DemoMethodBuilder
{
public static void Main()
{
// Creating a dynamic assembly requires an AssemblyName
// object, and the current application domain.
//
AssemblyName asmName =
new AssemblyName("DemoMethodBuilder1");
AppDomain domain = AppDomain.CurrentDomain;
AssemblyBuilder demoAssembly =
domain.DefineDynamicAssembly(
asmName,
AssemblyBuilderAccess.RunAndSave
);
// Define the module that contains the code. For an
// assembly with one module, the module name is the
// assembly name plus a file extension.
ModuleBuilder demoModule =
demoAssembly.DefineDynamicModule(
asmName.Name,
asmName.Name + ".dll"
);
TypeBuilder demoType = demoModule.DefineType(
"DemoType",
TypeAttributes.Public | TypeAttributes.Abstract
);
// Define a Shared, Public method with standard calling
// conventions. Do not specify the parameter types or the
// return type, because type parameters will be used for
// those types, and the type parameters have not been
// defined yet.
MethodBuilder demoMethod = demoType.DefineMethod(
"DemoMethod",
MethodAttributes.Public | MethodAttributes.Static
);
// Defining generic parameters for the method makes it a
// generic method. By convention, type parameters are
// single alphabetic characters. T and U are used here.
//
string[] typeParamNames = {"T", "U"};
GenericTypeParameterBuilder[] typeParameters =
demoMethod.DefineGenericParameters(typeParamNames);
// The second type parameter is constrained to be a
// reference type.
typeParameters[1].SetGenericParameterAttributes(
GenericParameterAttributes.ReferenceTypeConstraint);
// Use the IsGenericMethod property to find out if a
// dynamic method is generic, and IsGenericMethodDefinition
// to find out if it defines a generic method.
Console.WriteLine("Is DemoMethod generic? {0}",
demoMethod.IsGenericMethod);
Console.WriteLine("Is DemoMethod a generic method definition? {0}",
demoMethod.IsGenericMethodDefinition);
// Set parameter types for the method. The method takes
// one parameter, and its type is specified by the first
// type parameter, T.
Type[] parms = {typeParameters[0]};
demoMethod.SetParameters(parms);
// Set the return type for the method. The return type is
// specified by the second type parameter, U.
demoMethod.SetReturnType(typeParameters[1]);
// Generate a code body for the method. The method doesn't
// do anything except return null.
//
ILGenerator ilgen = demoMethod.GetILGenerator();
ilgen.Emit(OpCodes.Ldnull);
ilgen.Emit(OpCodes.Ret);
// Complete the type.
Type dt = demoType.CreateType();
// To bind types to a dynamic generic method, you must
// first call the GetMethod method on the completed type.
// You can then define an array of types, and bind them
// to the method.
MethodInfo m = dt.GetMethod("DemoMethod");
Type[] typeArgs = {typeof(string), typeof(DemoMethodBuilder)};
MethodInfo bound = m.MakeGenericMethod(typeArgs);
// Display a string representing the bound method.
Console.WriteLine(bound);
// Save the assembly, so it can be examined with Ildasm.exe.
demoAssembly.Save(asmName.Name + ".dll");
}
}
/* This code example produces the following output:
Is DemoMethod generic? True
Is DemoMethod a generic method definition? True
DemoMethodBuilder DemoMethod[String,DemoMethodBuilder](System.String)
*/
Imports System.Reflection
Imports System.Reflection.Emit
Class DemoMethodBuilder
Public Shared Sub Main()
' Creating a dynamic assembly requires an AssemblyName
' object, and the current application domain.
'
Dim asmName As New AssemblyName("DemoMethodBuilder1")
Dim domain As AppDomain = AppDomain.CurrentDomain
Dim demoAssembly As AssemblyBuilder = _
domain.DefineDynamicAssembly(asmName, _
AssemblyBuilderAccess.RunAndSave)
' Define the module that contains the code. For an
' assembly with one module, the module name is the
' assembly name plus a file extension.
Dim demoModule As ModuleBuilder = _
demoAssembly.DefineDynamicModule( _
asmName.Name, _
asmName.Name & ".dll")
Dim demoType As TypeBuilder = demoModule.DefineType( _
"DemoType", _
TypeAttributes.Public Or TypeAttributes.Abstract)
' Define a Shared, Public method with standard calling
' conventions. Do not specify the parameter types or the
' return type, because type parameters will be used for
' those types, and the type parameters have not been
' defined yet.
Dim demoMethod As MethodBuilder = _
demoType.DefineMethod("DemoMethod", _
MethodAttributes.Public Or MethodAttributes.Static)
' Defining generic parameters for the method makes it a
' generic method. By convention, type parameters are
' single alphabetic characters. T and U are used here.
'
Dim typeParamNames() As String = {"T", "U"}
Dim typeParameters() As GenericTypeParameterBuilder = _
demoMethod.DefineGenericParameters(typeParamNames)
' The second type parameter is constrained to be a
' reference type.
typeParameters(1).SetGenericParameterAttributes( _
GenericParameterAttributes.ReferenceTypeConstraint)
' Use the IsGenericMethod property to find out if a
' dynamic method is generic, and IsGenericMethodDefinition
' to find out if it defines a generic method.
Console.WriteLine("Is DemoMethod generic? {0}", _
demoMethod.IsGenericMethod)
Console.WriteLine("Is DemoMethod a generic method definition? {0}", _
demoMethod.IsGenericMethodDefinition)
' Set parameter types for the method. The method takes
' one parameter, and its type is specified by the first
' type parameter, T.
Dim params() As Type = {typeParameters(0)}
demoMethod.SetParameters(params)
' Set the return type for the method. The return type is
' specified by the second type parameter, U.
demoMethod.SetReturnType(typeParameters(1))
' Generate a code body for the method. The method doesn't
' do anything except return Nothing.
'
Dim ilgen As ILGenerator = demoMethod.GetILGenerator()
ilgen.Emit(OpCodes.Ldnull)
ilgen.Emit(OpCodes.Ret)
' Complete the type.
Dim dt As Type = demoType.CreateType()
' To bind types to a dynamic generic method, you must
' first call the GetMethod method on the completed type.
' You can then define an array of types, and bind them
' to the method.
Dim m As MethodInfo = dt.GetMethod("DemoMethod")
Dim typeArgs() As Type = _
{GetType(String), GetType(DemoMethodBuilder)}
Dim bound As MethodInfo = m.MakeGenericMethod(typeArgs)
' Display a string representing the bound method.
Console.WriteLine(bound)
' Save the assembly, so it can be examined with Ildasm.exe.
demoAssembly.Save(asmName.Name & ".dll")
End Sub
End Class
' This code example produces the following output:
'Is DemoMethod generic? True
'Is DemoMethod a generic method definition? True
'DemoMethodBuilder DemoMethod[String,DemoMethodBuilder](System.String)
Megjegyzések
A metódus meghívása DefineGenericParameters általánossá teszi az aktuális metódust. Ezt a módosítást nem lehet visszavonni. A metódus második meghívása egy InvalidOperationException.
Az általános metódus típusparaméterei később lekérhetők a GetGenericArguments metódus használatával.
Konvenció szerint a típusparaméter neve egyetlen nagybetű.
További információ: MethodBase.IsGenericMethod és MethodInfo.GetGenericMethodDefinition. Az általános típusokkal kapcsolatos információkért lásd: Type.IsGenericType.
