ParameterBuilder クラスとは？ わかりやすく解説

.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

ParameterBuilder クラス

パラメータ情報の作成または関連付けを行います。

名前空間: System.Reflection.Emit
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
<ComVisibleAttribute(True)> _
Public Class ParameterBuilder
    Implements _ParameterBuilder
Visual Basic (使用法)
Dim instance As ParameterBuilder
C#
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
[ComVisibleAttribute(true)] 
public class ParameterBuilder : _ParameterBuilder
C++
[ClassInterfaceAttribute(ClassInterfaceType::None)] 
[ComVisibleAttribute(true)] 
public ref class ParameterBuilder : _ParameterBuilder
J#
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
/** @attribute ComVisibleAttribute(true) */ 
public class ParameterBuilder implements _ParameterBuilder
JScript
ClassInterfaceAttribute(ClassInterfaceType.None) 
ComVisibleAttribute(true) 
public class ParameterBuilder implements _ParameterBuilder
解説解説

パラメータ属性は、メソッド シグネチャと矛盾しないようにする必要があります。パラメータに Out 属性を指定する場合は、そのメソッド パラメータの型を ByRef 型にする必要があります。

ParameterBuilder 属性を使用する場合、属性によっては、MSIL (Microsoft Intermediate Language) が実行時に正しく動作するように有効なパラメータで DefineMethod を呼び出す必要があります。たとえば、MethodBuilder のパラメータ 1 に ParameterAttributes.Out を使用して ParameterBuilder を定義する場合、MethodBuilder のパラメータ 1 は、Type.GetType("System.String") ではなく、Type.GetType("System.String&") のような参照にする必要があります。

使用例使用例

ParameterBuilder を使用して参照を渡すパラメータを持つ動的メソッドを作成する方法を次の例に示します。

Visual Basic
Imports System
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 'Main 

End Class 'ParamBuilderDemo
C#
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);

   }

}
C++
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 );
}
J#
import System.*;
import System.Threading.*;
import System.Reflection.*;
import System.Reflection.Emit.*;

class ParamBuilderDemo
{
    public static Type BuildCustomerDataType()
 
    {
        AppDomain myDomain = System.Threading.Thread.GetDomain();
        AssemblyName myAsmName = new AssemblyName();
        myAsmName.set_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.class.ToType(),
 FieldAttributes.Private);
        FieldBuilder acctIDBldr = myTypeBuilder.DefineField("acctID",
            String.class.ToType(), FieldAttributes.Private);
        FieldBuilder balanceAmtBldr = myTypeBuilder.DefineField("balanceAmt"
,
            double.class.ToType(), FieldAttributes.Private);
          ConstructorBuilder myCtorBuilder = myTypeBuilder.DefineConstructor
            (MethodAttributes.Public, CallingConventions.HasThis,
            new Type[]{String.class.ToType(),
 String.class.ToType(),
            double.class.ToType()});
        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,
            double.class.ToType(),
            new Type[]{Type.GetType("System.Double&")
,
            double.class.ToType()});
        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() ;
    } //BuildCustomerDataType

    public static void main(String[]
 args)
    {
        Type custType = null;
        Object custObj = null;
        Type custArgTypes[] = new Type[]{String.class.ToType()
,
            String.class.ToType(), double.class.ToType()};
        
        // Call the method to build our dynamic class.
        custType = BuildCustomerDataType();
        Console.WriteLine("---");
        ConstructorInfo myCustCtor = custType.GetConstructor(custArgTypes);
        double initialBalance = 100.0;
        custObj = myCustCtor.Invoke(new Object[]{"Joe Consumer",
 "5678-XYZ",
            (System.Double)(initialBalance)});
        MemberInfo myMemberInfo[] = custType.GetMember("AddFundsFromPool");

        double thePool = 1000.0;
        Console.WriteLine("The pool is currently ${0}",
            System.Convert.ToString(thePool));
        Console.WriteLine(
            "The original balance of the account instance is ${0}",
            new Object[] { (System.Double)(initialBalance) });
        
        double amountFromPool = 50.0;
        Console.WriteLine("The amount to be subtracted from the pool and added"
            + " to the account is ${0}", (System.Double)(amountFromPool));
        Console.WriteLine("---");
        Console.WriteLine("Calling {0} ...",
            myMemberInfo .get_Item( 0).ToString());
        Console.WriteLine("---");
        Object passMe[] = new Object[] { (System.Double)(thePool)
,
            (System.Double)(amountFromPool) };
        Console.WriteLine("The new balance in
 the account instance is ${0}",
            custType.InvokeMember("AddFundsFromPool",
            BindingFlags.InvokeMethod, null, custObj, passMe));
        thePool = (double)Double.parseDouble(passMe[0].toString());
        Console.WriteLine("The new amount in
 the pool is ${0}",
            (System.Double)(thePool));
    } //main 
} //ParamBuilderDemo
継承階層継承階層
System.Object
  System.Reflection.Emit.ParameterBuilder
スレッド セーフスレッド セーフ
この型の public static (Visual Basic では Shared) メンバはすべて、スレッド セーフです。インスタンス メンバの場合は、スレッド セーフであるとは限りません。
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
ParameterBuilder メンバ
System.Reflection.Emit 名前空間

急上昇のことば

ほとばしる
ひもじい
慄然
取り繕う
Linux
このページでは「.NET Framework クラス ライブラリ リファレンス」からParameterBuilder クラスを検索した結果を表示しています。
Weblioに収録されているすべての辞書からParameterBuilder クラスを検索する場合は、下記のリンクをクリックしてください。
 全ての辞書からParameterBuilder クラス を検索
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「ParameterBuilder クラス」の関連用語

1
ParameterBuilder.SetCustomAttribute メソッド
.NET Framework クラス ライブラリ リファレンス
100% |||||

2
ParameterBuilder.System.Runtime.InteropServices._ParameterBuilder.GetTypeInfo メソッド
.NET Framework クラス ライブラリ リファレンス
74% |||||

3
ParameterBuilder.System.Runtime.InteropServices._ParameterBuilder.GetTypeInfoCount メソッド
.NET Framework クラス ライブラリ リファレンス
74% |||||

4
_ParameterBuilder インターフェイス
.NET Framework クラス ライブラリ リファレンス
70% |||||

5
ConstructorBuilder.DefineParameter メソッド
.NET Framework クラス ライブラリ リファレンス
58% |||||

6
MethodBuilder.DefineParameter メソッド
.NET Framework クラス ライブラリ リファレンス
58% |||||

7
ParameterBuilder.System.Runtime.InteropServices._ParameterBuilder.GetIDsOfNames メソッド
.NET Framework クラス ライブラリ リファレンス
56% |||||

8
ParameterBuilder.System.Runtime.InteropServices._ParameterBuilder.Invoke メソッド
.NET Framework クラス ライブラリ リファレンス
56% |||||

9
DynamicMethod.DefineParameter メソッド
.NET Framework クラス ライブラリ リファレンス
56% |||||

10
ParameterBuilder.GetToken メソッド
.NET Framework クラス ライブラリ リファレンス
56% |||||

ParameterBuilder クラスのお隣キーワード

Parameter.Clone メソッド

ParameterBuilder クラス

ParameterBuilder プロパティ

ParameterBuilder.Attributes プロパティ

ParameterBuilder.GetToken メソッド

ParameterBuilder.IsIn プロパティ

ParameterBuilder.IsOptional プロパティ

ParameterBuilder.IsOut プロパティ

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


ParameterBuilder クラスのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS