MethodBuilder.DefineGenericParameters(String[]) Metod
Definition
Viktigt
En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.
Anger antalet generiska typparametrar för den aktuella metoden, anger deras namn och returnerar en matris med GenericTypeParameterBuilder objekt som kan användas för att definiera deras begränsningar.
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()Parametrar
- names
- String[]
En matris med strängar som representerar namnen på de generiska typparametrarna.
Returer
En matris med GenericTypeParameterBuilder objekt som representerar typparametrarna för den generiska metoden.
Undantag
Generiska typparametrar har redan definierats för den här metoden.
-eller-
Metoden har redan slutförts.
-eller-
Metoden SetImplementationFlags(MethodImplAttributes) har anropats för den aktuella metoden.
names är en tom matris.
Exempel
I följande kodexempel skapas en dynamisk typ, DemoType, som innehåller den dynamiska generiska metoden DemoMethod. Den här metoden har två generiska typparametrar, varav den ena används som en parameter och den andra som returtyp.
När koden körs sparas den dynamiska sammansättningen som DemoGenericMethod1.dlloch kan undersökas med hjälp avIldasm.exe (IL Disassembler).
Note
Det här kodexemplet genererar en enkel metodtext som bara returnerar en null-referens. Ett kodexempel med en mer fullständigt utvecklad metodtext som skapar och använder generiska typer finns i Så här definierar du en generisk metod med reflektionsemitta.
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)
Kommentarer
DefineGenericParameters Om du anropar metoden blir den aktuella metoden generisk. Det finns inget sätt att ångra den här ändringen. Att anropa den här metoden en andra gång orsakar en InvalidOperationException.
Typparametrarna för den generiska metoden kan hämtas senare med hjälp GetGenericArguments av metoden.
Enligt konventionen är ett typparameternamn en enda versal.
Mer information finns i MethodBase.IsGenericMethod och MethodInfo.GetGenericMethodDefinition. Information om generiska typer finns i Type.IsGenericType.