ParameterBuilder Classe

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Origem:

ParameterBuilder.cs

Cria ou associa informações de parâmetro.

public ref class ParameterBuilder abstract

public abstract class ParameterBuilder

type ParameterBuilder = class

Public MustInherit Class ParameterBuilder

Herança

Object

ParameterBuilder

Exemplos

O exemplo a seguir demonstra como criar um método dinâmico com um parâmetro passado por referência usando ParameterBuilder.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildCustomerDataType()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
   ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( "MyMod" );
   TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( "CustomerData", TypeAttributes::Public );
   FieldBuilder^ customerNameBldr = myTypeBuilder->DefineField( "customerName", String::typeid, FieldAttributes::Private );
   FieldBuilder^ acctIDBldr = myTypeBuilder->DefineField( "acctID", String::typeid, FieldAttributes::Private );
   FieldBuilder^ balanceAmtBldr = myTypeBuilder->DefineField( "balanceAmt", double::typeid, FieldAttributes::Private );
   array<Type^>^temp0 = {String::typeid,String::typeid,double::typeid};
   ConstructorBuilder^ myCtorBuilder = myTypeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::HasThis, temp0 );
   ILGenerator^ ctorIL = myCtorBuilder->GetILGenerator();
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<Type^>(0) );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Call, objCtor );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_1 );
   ctorIL->Emit( OpCodes::Stfld, customerNameBldr );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_2 );
   ctorIL->Emit( OpCodes::Stfld, acctIDBldr );
   ctorIL->Emit( OpCodes::Ldarg_0 );
   ctorIL->Emit( OpCodes::Ldarg_3 );
   ctorIL->Emit( OpCodes::Stfld, balanceAmtBldr );
   ctorIL->Emit( OpCodes::Ret );
   
   // This method will take an amount from a static pool and add it to the balance.
   // Note that we are passing the first parameter, fundsPool, by reference. Therefore,
   // we need to inform the MethodBuilder to expect a ref, by declaring the first
   // parameter's type to be System::Double& (a reference to a double).
   array<Type^>^temp4 = {Type::GetType( "System.Double&" ),double::typeid};
   MethodBuilder^ myMthdBuilder = myTypeBuilder->DefineMethod( "AddFundsFromPool", MethodAttributes::Public, double::typeid, temp4 );
   ParameterBuilder^ poolRefBuilder = myMthdBuilder->DefineParameter( 1, ParameterAttributes::Out, "fundsPool" );
   ParameterBuilder^ amountFromPoolBuilder = myMthdBuilder->DefineParameter( 2, ParameterAttributes::In, "amountFromPool" );
   ILGenerator^ mthdIL = myMthdBuilder->GetILGenerator();
   mthdIL->Emit( OpCodes::Ldarg_1 );
   mthdIL->Emit( OpCodes::Ldarg_1 );
   mthdIL->Emit( OpCodes::Ldind_R8 );
   mthdIL->Emit( OpCodes::Ldarg_2 );
   mthdIL->Emit( OpCodes::Sub );
   mthdIL->Emit( OpCodes::Stind_R8 );
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldfld, balanceAmtBldr );
   mthdIL->Emit( OpCodes::Ldarg_2 );
   mthdIL->Emit( OpCodes::Add );
   mthdIL->Emit( OpCodes::Stfld, balanceAmtBldr );
   mthdIL->Emit( OpCodes::Ldarg_0 );
   mthdIL->Emit( OpCodes::Ldfld, balanceAmtBldr );
   mthdIL->Emit( OpCodes::Ret );
   return myTypeBuilder->CreateType();
}

int main()
{
   Type^ custType = nullptr;
   Object^ custObj = nullptr;
   array<Type^>^custArgTypes = {String::typeid,String::typeid,double::typeid};
   
   // Call the method to build our dynamic class.
   custType = BuildCustomerDataType();
   Console::WriteLine( "---" );
   ConstructorInfo^ myCustCtor = custType->GetConstructor( custArgTypes );
   double initialBalance = 100.00;
   array<Object^>^temp5 = {"Joe Consumer","5678-XYZ",initialBalance};
   custObj = myCustCtor->Invoke( temp5 );
   array<MemberInfo^>^myMemberInfo = custType->GetMember( "AddFundsFromPool" );
   double thePool = 1000.00;
   Console::WriteLine( "The pool is currently ${0}", thePool );
   Console::WriteLine( "The original balance of the account instance is ${0}", initialBalance );
   double amountFromPool = 50.00;
   Console::WriteLine( "The amount to be subtracted from the pool and added to the account is ${0}", amountFromPool );
   Console::WriteLine( "---" );
   Console::WriteLine( "Calling {0} ...", myMemberInfo[ 0 ] );
   Console::WriteLine( "---" );
   array<Object^>^passMe = {thePool,amountFromPool};
   Console::WriteLine( "The new balance in the account instance is ${0}", custType->InvokeMember( "AddFundsFromPool", BindingFlags::InvokeMethod, nullptr, custObj, passMe ) );
   thePool = safe_cast<double>(passMe[ 0 ]);
   Console::WriteLine( "The new amount in the pool is ${0}", thePool );
}

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class ParamBuilderDemo

{

   public static Type BuildCustomerDataType()
   {

    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,
                        AssemblyBuilderAccess.Run);

    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule("MyMod");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("CustomerData",
                        TypeAttributes.Public);

    FieldBuilder customerNameBldr = myTypeBuilder.DefineField("customerName",
                            typeof(string),
                            FieldAttributes.Private);
    FieldBuilder acctIDBldr = myTypeBuilder.DefineField("acctID",
                            typeof(string),
                            FieldAttributes.Private);
    FieldBuilder balanceAmtBldr = myTypeBuilder.DefineField("balanceAmt",
                            typeof(double),
                            FieldAttributes.Private);
                                
    ConstructorBuilder myCtorBuilder = myTypeBuilder.DefineConstructor(
                            MethodAttributes.Public,
                            CallingConventions.HasThis,
                            new Type[] { typeof(string),
                                     typeof(string),
                                     typeof(double) });

    ILGenerator ctorIL = myCtorBuilder.GetILGenerator();

    Type objType = Type.GetType("System.Object");
        ConstructorInfo objCtor = objType.GetConstructor(new Type[] {});

    ctorIL.Emit(OpCodes.Ldarg_0);
    ctorIL.Emit(OpCodes.Call, objCtor);

    ctorIL.Emit(OpCodes.Ldarg_0);
    ctorIL.Emit(OpCodes.Ldarg_1);
    ctorIL.Emit(OpCodes.Stfld, customerNameBldr);

    ctorIL.Emit(OpCodes.Ldarg_0);
    ctorIL.Emit(OpCodes.Ldarg_2);
    ctorIL.Emit(OpCodes.Stfld, acctIDBldr);

    ctorIL.Emit(OpCodes.Ldarg_0);
    ctorIL.Emit(OpCodes.Ldarg_3);
    ctorIL.Emit(OpCodes.Stfld, balanceAmtBldr);

    ctorIL.Emit(OpCodes.Ret);

    // This method will take an amount from a static pool and add it to the balance.

    // Note that we are passing the first parameter, fundsPool, by reference. Therefore,
    // we need to inform the MethodBuilder to expect a ref, by declaring the first
    // parameter's type to be System.Double& (a reference to a double).

    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("AddFundsFromPool",
                        MethodAttributes.Public,
                        typeof(double),
                        new Type[] { Type.GetType("System.Double&"),
                                 typeof(double) });

    ParameterBuilder poolRefBuilder = myMthdBuilder.DefineParameter(1,
                        ParameterAttributes.Out,
                        "fundsPool");

    ParameterBuilder amountFromPoolBuilder = myMthdBuilder.DefineParameter(2,
                        ParameterAttributes.In,
                            "amountFromPool");

    ILGenerator mthdIL = myMthdBuilder.GetILGenerator();

    mthdIL.Emit(OpCodes.Ldarg_1);
    mthdIL.Emit(OpCodes.Ldarg_1);
    mthdIL.Emit(OpCodes.Ldind_R8);
    mthdIL.Emit(OpCodes.Ldarg_2);
    mthdIL.Emit(OpCodes.Sub);

    mthdIL.Emit(OpCodes.Stind_R8);

    mthdIL.Emit(OpCodes.Ldarg_0);
    mthdIL.Emit(OpCodes.Ldarg_0);
    mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr);
    mthdIL.Emit(OpCodes.Ldarg_2);
    mthdIL.Emit(OpCodes.Add);

    mthdIL.Emit(OpCodes.Stfld, balanceAmtBldr);

    mthdIL.Emit(OpCodes.Ldarg_0);
    mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr);
    mthdIL.Emit(OpCodes.Ret);

    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type custType = null;
    object custObj = null;

    Type[] custArgTypes = new Type[] {typeof(string), typeof(string), typeof(double)};
    
    // Call the method to build our dynamic class.

    custType = BuildCustomerDataType();

    Console.WriteLine("---");

    ConstructorInfo myCustCtor = custType.GetConstructor(custArgTypes);
    double initialBalance = 100.00;
    custObj = myCustCtor.Invoke(new object[] { "Joe Consumer",
                           "5678-XYZ",
                           initialBalance });

    MemberInfo[] myMemberInfo = custType.GetMember("AddFundsFromPool");

    double thePool = 1000.00;
    Console.WriteLine("The pool is currently ${0}", thePool);
    Console.WriteLine("The original balance of the account instance is ${0}",
                            initialBalance);

    double amountFromPool = 50.00;
    Console.WriteLine("The amount to be subtracted from the pool and added " +
              "to the account is ${0}", amountFromPool);
    
    Console.WriteLine("---");
    Console.WriteLine("Calling {0} ...", myMemberInfo[0].ToString());
    Console.WriteLine("---");

    object[] passMe = new object[] { thePool, amountFromPool };
    Console.WriteLine("The new balance in the account instance is ${0}",
                    custType.InvokeMember("AddFundsFromPool",
                    BindingFlags.InvokeMethod,
                    null, custObj, passMe));
    thePool = (double)passMe[0];
    Console.WriteLine("The new amount in the pool is ${0}", thePool);
   }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class ParamBuilderDemo
   
   Public Shared Function BuildCustomerDataType() As Type
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                        AssemblyBuilderAccess.Run)
      
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyMod")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("CustomerData", TypeAttributes.Public)
      
      Dim customerNameBldr As FieldBuilder = myTypeBuilder.DefineField("customerName", _
                                GetType(String), _
                                FieldAttributes.Private)
      Dim acctIDBldr As FieldBuilder = myTypeBuilder.DefineField("acctID", _
                                GetType(String), _
                                FieldAttributes.Private)
      Dim balanceAmtBldr As FieldBuilder = myTypeBuilder.DefineField("balanceAmt", _
                                GetType(Double), _
                                FieldAttributes.Private)
      
      Dim myCtorBuilder As ConstructorBuilder = myTypeBuilder.DefineConstructor(MethodAttributes.Public, _
                                CallingConventions.HasThis, _
                                New Type() {GetType(String), _
                                        GetType(String), _
                                        GetType(Double)})
      
      
      Dim ctorIL As ILGenerator = myCtorBuilder.GetILGenerator()
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
      
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, customerNameBldr)
      
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, acctIDBldr)
      
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, balanceAmtBldr)
      
      ctorIL.Emit(OpCodes.Ret)
      
      ' This method will take an amount from a static pool and add it to the balance.
      ' Note that we are passing the first parameter, fundsPool, by reference. Therefore,
      ' we need to inform the MethodBuilder to expect a ref, by declaring the first
      ' parameter's type to be System.Double& (a reference to a double).

      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("AddFundsFromPool", _
                                MethodAttributes.Public, _
                                GetType(Double), _
                                New Type() {Type.GetType("System.Double&"), _
                                         GetType(Double)})
      
      Dim poolRefBuilder As ParameterBuilder = myMthdBuilder.DefineParameter(1, _
                            ParameterAttributes.Out, "fundsPool")
      
      Dim amountFromPoolBuilder As ParameterBuilder = myMthdBuilder.DefineParameter(2, _
                            ParameterAttributes.In, "amountFromPool")
      
      Dim mthdIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldarg_1)
      mthdIL.Emit(OpCodes.Ldind_R8)
      mthdIL.Emit(OpCodes.Ldarg_2)
      mthdIL.Emit(OpCodes.Sub)
      
      mthdIL.Emit(OpCodes.Stind_R8)
      
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr)
      mthdIL.Emit(OpCodes.Ldarg_2)
      mthdIL.Emit(OpCodes.Add)
      
      mthdIL.Emit(OpCodes.Stfld, balanceAmtBldr)
      
      mthdIL.Emit(OpCodes.Ldarg_0)
      mthdIL.Emit(OpCodes.Ldfld, balanceAmtBldr)
      mthdIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildCustomerDataType
    
   
   Public Shared Sub Main()

      Dim custType As Type = Nothing
      Dim custObj As Object = Nothing
      
      Dim custArgTypes() As Type = {GetType(String), GetType(String), GetType(Double)}
      
      ' Call the method to build our dynamic class.
      custType = BuildCustomerDataType()
      
      Console.WriteLine("---")
      
      Dim myCustCtor As ConstructorInfo = custType.GetConstructor(custArgTypes)
      Dim initialBalance As Double = 100.0
      custObj = myCustCtor.Invoke(New Object() {"Joe Consumer", "5678-XYZ", initialBalance})
      
      Dim myMemberInfo As MemberInfo() = custType.GetMember("AddFundsFromPool")
      
      
      Dim thePool As Double = 1000.0
      Console.WriteLine("The pool is currently ${0}", thePool)
      Console.WriteLine("The original balance of the account instance is ${0}", initialBalance)
      
      Dim amountFromPool As Double = 50.0
      Console.WriteLine("The amount to be subtracted from the pool and added " & _
            "to the account is ${0}", amountFromPool)
      
      Console.WriteLine("---")
      Console.WriteLine("Calling {0} ...", myMemberInfo(0).ToString())
      Console.WriteLine("---")
      
      Dim passMe() As Object = {thePool, amountFromPool}
      Console.WriteLine("The new balance in the account instance is ${0}", _
                custType.InvokeMember("AddFundsFromPool", _
                BindingFlags.InvokeMethod, Nothing, custObj, passMe))
      thePool = CDbl(passMe(0))
      Console.WriteLine("The new amount in the pool is ${0}", thePool)

   End Sub

End Class

Comentários

Os atributos de parâmetro precisam ser consistentes com a assinatura do método. Se você especificar Out atributos para um parâmetro, deverá garantir que o tipo desse parâmetro de método seja um ByRef tipo.

Alguns ParameterBuilder atributos exigem que você chame DefineMethod com parâmetros viáveis para que a MSIL (Linguagem Intermediária da Microsoft) funcione corretamente em runtime. Por exemplo, se você definir um ParameterBuilder com ParameterAttributes.Out para o parâmetro 1 de um MethodBuilder, o parâmetro 1 de MethodBuilder deverá ser uma referência como Type.GetType("System.String&"), em vez de Type.GetType("System.String").

Construtores

ParameterBuilder()

Inicializa uma nova instância da classe ParameterBuilder.

Propriedades

Attributes	Recupera os atributos para esse parâmetro.
IsIn	Recupera se esse é um parâmetro de entrada.
IsOptional	Recupera se esse parâmetro é opcional.
IsOut	Recupera se esse parâmetro é um parâmetro de saída.
Name	Recupera o nome do parâmetro.
Position	Recupera a posição de assinatura para esse parâmetro.

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
SetConstant(Object)	Define o valor padrão do parâmetro.
SetCustomAttribute(ConstructorInfo, Byte[])	Define um atributo personalizado usando um blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Defina um atributo personalizado usando um construtor de atributos personalizados.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, define um atributo personalizado neste assembly.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)