MethodBuilder.SetParameters(Type[]) Método

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

Parâmetros

Exceções

Exemplos

O exemplo de código a seguir usa o DefineGenericParameters método para tornar um método genérico. O SetParameters método é usado para fornecer ao método um parâmetro, cujo tipo será especificado pelo primeiro parâmetro de tipo genérico. O SetReturnType método é usado para dar ao método um tipo de retorno, especificado pelo segundo parâmetro de tipo genérico.

Esse código faz parte de um exemplo maior fornecido para o DefineGenericParameters método .

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

Comentários

Se o número e os tipos dos parâmetros forem conhecidos quando o método for definido, eles poderão ser definidos usando qualquer sobrecarga do TypeBuilder.DefineMethod método que aceite uma matriz de tipos de parâmetro. No entanto, um método genérico pode ter parâmetros cujos tipos são especificados por um ou mais de seus próprios parâmetros de tipo genérico, que não podem ser definidos até que o método tenha sido definido. Use esse método para definir os tipos de parâmetro nesse caso.

Se o tipo de retorno tiver modificadores personalizados opcionais ou necessários, como IsConst, use a sobrecarga de SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][]) método.

Chamar esse método substitui todos os tipos de parâmetro que foram definidos usando o TypeBuilder.DefineMethod método .

Aplica-se a

Confira também

• SetReturnType(Type)
• Como: Definir um método genérico com a emissão de reflexão