MethodBuilder.SetParameters(Type[]) Metodo

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Origine:

MethodBuilder.cs

Imposta il numero e i tipi di parametri per un metodo.

public:
 void SetParameters(... cli::array <Type ^> ^ parameterTypes);

public void SetParameters (params Type[] parameterTypes);

member this.SetParameters : Type[] -> unit

Public Sub SetParameters (ParamArray parameterTypes As Type())

Parametri

parameterTypes

Type[]

Matrice di oggetti Type che rappresentano i tipi di parametro.

Eccezioni

InvalidOperationException

Il metodo corrente è un metodo generico, ma non una definizione di metodo generico. Questo significa che la proprietà IsGenericMethod è true, ma la proprietà IsGenericMethodDefinition è false.

Esempio

Nell'esempio di codice seguente viene utilizzato il DefineGenericParameters metodo per rendere un metodo generico. Il SetParameters metodo viene usato per assegnare al metodo un parametro, il cui tipo verrà specificato dal primo parametro di tipo generico. Il SetReturnType metodo viene usato per assegnare al metodo un tipo restituito, specificato dal secondo parametro di tipo generico.

Questo codice fa parte di un esempio più ampio fornito per il DefineGenericParameters metodo .

// 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.
//
array<String^>^ genericTypeNames = {"T", "U"};
array<GenericTypeParameterBuilder^>^ genericTypes =
    sampleMethodBuilder->DefineGenericParameters(
    genericTypeNames);

// 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);

' 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)

// Set parameter types for the method. The method takes
// one parameter, and its type is specified by the first
// type parameter, T.
array<Type^>^ parameterTypes = {genericTypes[0]};
sampleMethodBuilder->SetParameters(parameterTypes);

// Set the return type for the method. The return type is
// specified by the second type parameter, U.
sampleMethodBuilder->SetReturnType(genericTypes[1]);

// 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]);

' 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))

Commenti

Se il numero e i tipi dei parametri sono noti quando viene definito il metodo, possono essere impostati usando qualsiasi overload del TypeBuilder.DefineMethod metodo che accetta una matrice di tipi di parametro. Tuttavia, un metodo generico può avere parametri i cui tipi sono specificati da uno o più dei propri parametri di tipo generico, che non possono essere definiti fino a quando non è stato definito il metodo. Utilizzare questo metodo per impostare i tipi di parametro in questo caso.

Se il tipo restituito ha modificatori personalizzati facoltativi o obbligatori, ad esempio IsConst, usare l'overload del SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) metodo .

La chiamata a questo metodo sostituisce tutti i tipi di parametro impostati usando il TypeBuilder.DefineMethod metodo .

Vedi anche

• SetReturnType(Type)
• Procedura: Definire un metodo generico tramite reflection emit