次の方法で共有


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 の属性では、実行時に Microsoft 中間言語 (MSIL) が正しく動作するために、実行可能なパラメーターを使用して を呼び出す DefineMethod 必要があります。 たとえば、 のパラメーター 1 に ParameterAttributes.Out を定義ParameterBuilderする場合、 のパラメーター 1 MethodBuilderMethodBuilder は、Type.GetType("System.String") ではなく、Type.GetType("System.String&") などの参照である必要があります。

コンストラクター

ParameterBuilder()

ParameterBuilder クラスの新しいインスタンスを初期化します。

プロパティ

Attributes

このパラメーターの属性を取得します。

IsIn

入力パラメーターかどうかを取得します。

IsOptional

パラメーターが省略可能かどうかを取得します。

IsOut

このパラメーターが出力パラメーターかどうかを取得します。

Name

このパラメーターの名前を取得します。

Position

このパラメーターのシグネチャ位置を取得します。

メソッド

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判断します。

(継承元 Object)
GetHashCode()

既定のハッシュ関数として機能します。

(継承元 Object)
GetToken()

このパラメーターのトークンを取得します。

GetType()

現在のインスタンスの Type を取得します。

(継承元 Object)
MemberwiseClone()

現在の Object の簡易コピーを作成します。

(継承元 Object)
SetConstant(Object)

パラメーターの既定値を設定します。

SetCustomAttribute(ConstructorInfo, Byte[])

指定されたカスタム属性の blob を使用して、カスタム属性を設定します。

SetCustomAttribute(CustomAttributeBuilder)

カスタム属性ビルダーを使用して、カスタム属性を設定します。

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

派生クラスでオーバーライドされた場合は、このアセンブリにカスタム属性を設定します。

SetMarshal(UnmanagedMarshal)
古い.

このパラメーターのマーシャリングを指定します。

ToString()

現在のオブジェクトを表す文字列を返します。

(継承元 Object)

明示的なインターフェイスの実装

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

一連の名前を対応する一連のディスパッチ識別子に割り当てます。

_ParameterBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この型情報を使用して、インターフェイスの型情報を取得できます。

_ParameterBuilder.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。

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

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。

適用対象