共用方式為


ParameterBuilder 類別

定義

建立或關聯參數資訊。

public ref class ParameterBuilder
public ref class ParameterBuilder abstract
public ref class ParameterBuilder : System::Runtime::InteropServices::_ParameterBuilder
public class ParameterBuilder
public abstract class ParameterBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public class ParameterBuilder : System.Runtime.InteropServices._ParameterBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public class ParameterBuilder : System.Runtime.InteropServices._ParameterBuilder
type ParameterBuilder = class
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type ParameterBuilder = class
    interface _ParameterBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ParameterBuilder = class
    interface _ParameterBuilder
Public Class ParameterBuilder
Public MustInherit Class ParameterBuilder
Public Class ParameterBuilder
Implements _ParameterBuilder
繼承
ParameterBuilder
屬性
實作

範例

下列範例示範如何使用 以 傳址 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

備註

參數屬性必須與方法簽章一致。 如果您指定 Out 參數的屬性,您應該確定該方法參數的類型是 ByRef 類型。

某些 ParameterBuilder 屬性會要求您使用可行的參數呼叫 DefineMethod ,Microsoft 中繼語言 (MSIL) 才能在運行時間正常運作。 例如,如果您針對 的參數 1 使用 ParameterAttributes.Out 定義 ParameterBuilder ,則 的參數 MethodBuilder 1 MethodBuilder必須是 Type.GetType (“System.String&”) ,而不是 Type.GetType (“System.String”) 。

建構函式

ParameterBuilder()

初始化 ParameterBuilder 類別的新執行個體。

屬性

Attributes

擷取這個參數的屬性。

IsIn

擷取這是否為輸入參數。

IsOptional

擷取這個參數是否為選擇性項目。

IsOut

擷取這個參數是否為輸出參數。

Name

擷取這個參數的名稱。

Position

擷取這個參數的簽章位置。

方法

Equals(Object)

判斷指定的物件是否等於目前的物件。

(繼承來源 Object)
GetHashCode()

做為預設雜湊函式。

(繼承來源 Object)
GetToken()

擷取這個參數的語彙基元 (Token)。

GetType()

取得目前執行個體的 Type

(繼承來源 Object)
MemberwiseClone()

建立目前 Object 的淺層複製。

(繼承來源 Object)
SetConstant(Object)

設定參數的預設值。

SetCustomAttribute(ConstructorInfo, Byte[])

使用指定的自訂屬性 Blob 來設定自訂屬性。

SetCustomAttribute(CustomAttributeBuilder)

使用自訂屬性產生器來設定自訂屬性。

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

在衍生類別中覆寫時,在此元件上設定自定義屬性。

SetMarshal(UnmanagedMarshal)
已淘汰.

指定這個參數的封送處理 (Marshaling)。

ToString()

傳回代表目前物件的字串。

(繼承來源 Object)

明確介面實作

_ParameterBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

將一組名稱對應至一組對應的分派識別項 (Dispatch Identifier)。

_ParameterBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

擷取物件的類型資訊,可以用來取得介面的類型資訊。

_ParameterBuilder.GetTypeInfoCount(UInt32)

擷取物件提供的類型資訊介面數目 (0 或 1)。

_ParameterBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

提供物件所公開的屬性和方法的存取權。

適用於