ParameterInfo.IsOptional プロパティ

.NET Framework クラス ライブラリ リファレンス

ParameterInfo.IsOptional プロパティ

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

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

Visual Basic (宣言)

Public ReadOnly Property
 IsOptional As Boolean

Visual Basic (使用法)

Dim instance As ParameterInfo
Dim value As Boolean

value = instance.IsOptional

C#

public bool IsOptional { get;
 }

C++

public:
property bool IsOptional {
    bool get ();
}

J#

/** @property */
public boolean get_IsOptional ()

JScript

public function get IsOptional
 () : boolean

プロパティ値
パラメータが省略可能な場合は true。それ以外の場合は false。

解説

このメソッドは、オプションのメタデータ フラグに依存します。このフラグは、コンパイラで挿入できますが、必ず挿入されるとは限りません。

このメソッドは、ParameterAttributes 列挙子の Optional フラグを利用します。

ParameterInfo 配列を取得するには、最初にメソッドを取得してから MethodBase.GetParameters を呼び出します。

使用例

Visual Basic

Imports System
Imports System.Reflection
Imports System.Threading
Imports System.Reflection.Emit
Imports Microsoft.VisualBasic



Public Class ParameterInfo_IsIn_IsOut_IsOptional
   
   Public Shared Sub DefineMethod()
      Dim myAssemblyName As New
 AssemblyName()
      myAssemblyName.Name = "MyAssembly"
      ' Get the assesmbly builder from the application domain associated
 with the current thread.
      Dim myAssemblyBuilder As AssemblyBuilder
 = Thread.GetDomain().DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.RunAndSave)
      ' Create a dynamic module in the assembly.
      Dim myModuleBuilder As ModuleBuilder
 = myAssemblyBuilder.DefineDynamicModule("MyModule",
 "MyAssembly.dll")
      ' Create a type in the module.
      Dim myTypeBuilder As TypeBuilder = myModuleBuilder.DefineType("MyType")
      ' Create a method called MyMethod.
      Dim myMethodBuilder As MethodBuilder
 = myTypeBuilder.DefineMethod("MyMethod", MethodAttributes.Public
 Or MethodAttributes.HideBySig Or MethodAttributes.Static, GetType(String), New
 Type() {GetType(Integer), GetType(Short), GetType(Long)})
      ' Set the attributes for the parameters of the method.
      ' Set the attribute for the first parameter to IN.
      Dim myParameterBuilder As ParameterBuilder
 = myMethodBuilder.DefineParameter(1, ParameterAttributes.In, "MyIntParameter")
      ' Set the attribute for the second parameter to OUT.
      myParameterBuilder = myMethodBuilder.DefineParameter(2, ParameterAttributes.Out,
 "MyShortParameter")
      ' Set the attribute for the third parameter to OPTIONAL.
      myParameterBuilder = myMethodBuilder.DefineParameter(3, ParameterAttributes.Optional
 Or ParameterAttributes.HasDefault, "MyLongParameter")
      ' Get the Microsoft Intermediate Language generator for the method.
      Dim myILGenerator As ILGenerator = myMethodBuilder.GetILGenerator()
      ' Use the utility method to generate the MSIL instructions that
 print a string to the console.
      myILGenerator.EmitWriteLine("Hello World!")
      ' Generate the "ret" MSIL instruction.
      myILGenerator.Emit(OpCodes.Ret)
      ' End the creation of the type.
      myTypeBuilder.CreateType()
   End Sub 'DefineMethod
   
   
   Public Shared Sub Main()
      ' Create a dynamic assembly with a type named 'MyType'.
      DefineMethod()
      
      ' Get the assemblies currently loaded in the application domain.
      Dim myAssemblies As [Assembly]() = Thread.GetDomain().GetAssemblies()
      Dim myAssembly As [Assembly] = Nothing
      ' Get the assembly named MyAssembly.
      Dim i As Integer
      For i = 0 To myAssemblies.Length - 1
         If [String].Compare(myAssemblies(i).GetName(False).Name,
 "MyAssembly") = 0 Then
            myAssembly = myAssemblies(i)
         End If 
      Next i
      If Not (myAssembly Is
 Nothing) Then
         ' Get a type named MyType.
         Dim myType As Type = myAssembly.GetType("MyType")
         ' Get a method named MyMethod from the type.
         Dim myMethodBase As MethodBase = myType.GetMethod("MyMethod")
         ' Get the parameters associated with the method.
         Dim myParameters As ParameterInfo()
 = myMethodBase.GetParameters()
         Console.WriteLine(ControlChars.Cr + "The method {0} has
 the {1} parameters :", myMethodBase, myParameters.Length)
         ' Print the IN, OUT and OPTIONAL attributes associated with
 each of the parameters.
         For i = 0 To myParameters.Length -
 1
            If myParameters(i).IsIn Then
               Console.WriteLine(ControlChars.Tab + "The {0} parameter
 has the In attribute", i + 1)
            End If
            If myParameters(i).IsOptional Then
               Console.WriteLine(ControlChars.Tab + "The {0} parameter
 has the Optional attribute", i + 1)
            End If
            If myParameters(i).IsOut Then
               Console.WriteLine(ControlChars.Tab + "The {0} parameter
 has the Out attribute", i + 1)
            End If
         Next i
      Else
         Console.WriteLine("Could not find a assembly
 named 'MyAssembly' for the current application domain")
      End If
   End Sub 'Main
End Class 'ParameterInfo_IsIn_IsOut_IsOptional
 

C#

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

public class ParameterInfo_IsIn_IsOut_IsOptional
{
   public static void DefineMethod()
   {
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "MyAssembly";
      // Get the assembly builder from the application domain associated
 with the current thread.
      AssemblyBuilder myAssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(myAssemblyName,
 AssemblyBuilderAccess.RunAndSave);
      // Create a dynamic module in the assembly.
      ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("MyModule",
 "MyAssembly.dll");
      // Create a type in the module.
      TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyType");
      // Create a method called MyMethod.
      MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("MyMethod",MethodAttributes.Public
 | MethodAttributes.HideBySig |
                                                                           MethodAttributes.Static,
 typeof(string), new Type[] {typeof(int),
 typeof(short), typeof(long)});
      // Set the attributes for the parameters of the method.
      // Set the attribute for the first parameter to IN.
      ParameterBuilder myParameterBuilder = myMethodBuilder.DefineParameter(1, ParameterAttributes.In,
 "MyIntParameter");
      // Set the attribute for the second parameter to OUT.
      myParameterBuilder = myMethodBuilder.DefineParameter(2, ParameterAttributes.Out,
 "MyShortParameter");
      // Set the attribute for the third parameter to OPTIONAL.
      myParameterBuilder = myMethodBuilder.DefineParameter(3, ParameterAttributes.Optional
 | ParameterAttributes.HasDefault, "MyLongParameter");
      // Get the Microsoft Intermediate Language generator for the method.
      ILGenerator myILGenerator = myMethodBuilder.GetILGenerator();
      // Use the utility method to generate the MSIL instructions that
 print a string to the console.
      myILGenerator.EmitWriteLine("Hello World!");
      // Generate the "ret" MSIL instruction.
      myILGenerator.Emit(OpCodes.Ret);
      // End the creation of the type.
      myTypeBuilder.CreateType();
   }

   public static void Main()
   {
      // Create a dynamic assembly with a type named MyType.
      DefineMethod();

      // Get the assemblies currently loaded in the application domain.
      Assembly[] myAssemblies = Thread.GetDomain().GetAssemblies();
      Assembly myAssembly = null;
      // Get the assembly named MyAssembly.
      for(int i = 0; i < myAssemblies.Length;
 i++)
         if(String.Compare(myAssemblies[i].GetName(false).Name,
 "MyAssembly") == 0)
            myAssembly = myAssemblies[i];

      if(myAssembly != null)
      {
         // Get a type named MyType.
         Type myType = myAssembly.GetType("MyType");
         // Get a method named MyMethod from the type.
         MethodBase myMethodBase = myType.GetMethod("MyMethod");
         // Get the parameters associated with the method.
         ParameterInfo[] myParameters = myMethodBase.GetParameters();
         Console.WriteLine("\nThe method {0} has the {1} parameters :",
 
            myMethodBase, myParameters.Length);
         // Print the IN, OUT and OPTIONAL attributes associated with
 each of the parameters.
         for(int i = 0; i < myParameters.Length;
 i++)
         {
            if(myParameters[i].IsIn)
               Console.WriteLine("\tThe {0} parameter has the In attribute",
 
                                       i + 1);
            if(myParameters[i].IsOptional)
               Console.WriteLine("\tThe {0} parameter has the Optional attribute"
,
                                       i + 1);
            if(myParameters[i].IsOut)
               Console.WriteLine("\tThe {0} parameter has the Out attribute"
,
                                       i + 1);
         }
      }
      else
         Console.WriteLine("Could not find a assembly named 'MyAssembly' for
 the current application domain");
   }
}

C++

using namespace System;
using namespace System::Reflection;
using namespace System::Threading;
using namespace System::Reflection::Emit;
void DefineMethod()
{
   AssemblyName^ myAssemblyName = gcnew AssemblyName;
   myAssemblyName->Name = "MyAssembly";

   // Get the assembly builder from the application domain associated
 with the current thread.
   AssemblyBuilder^ myAssemblyBuilder = Thread::GetDomain()->DefineDynamicAssembly(
 myAssemblyName, AssemblyBuilderAccess::RunAndSave );

   // Create a dynamic module in the assembly.
   ModuleBuilder^ myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "MyModule",
 "MyAssembly.dll" );

   // Create a type in the module.
   TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "MyType"
 );

   // Create a method called MyMethod.
   array<Type^>^type1 = {int::typeid,short::typeid,long::typeid};
   MethodBuilder^ myMethodBuilder = myTypeBuilder->DefineMethod( "MyMethod",
 static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::HideBySig
 | MethodAttributes::Static), String::typeid, type1 );

   // Set the attributes for the parameters of the method.
   // Set the attribute for the first parameter to IN.
   ParameterBuilder^ myParameterBuilder = myMethodBuilder->DefineParameter( 1,
 ParameterAttributes::In, "MyIntParameter" );

   // Set the attribute for the second parameter to OUT.
   myParameterBuilder = myMethodBuilder->DefineParameter( 2, ParameterAttributes::Out,
 "MyShortParameter" );

   // Set the attribute for the third parameter to OPTIONAL.
   myParameterBuilder = myMethodBuilder->DefineParameter( 3, static_cast<ParameterAttributes>(ParameterAttributes::Optional
 | ParameterAttributes::HasDefault), "MyLongParameter" );

   // Get the Microsoft Intermediate Language generator for the method.
   ILGenerator^ myILGenerator = myMethodBuilder->GetILGenerator();

   // Use the utility method to generate the MSIL instructions that
 print a String* to the console.
   myILGenerator->EmitWriteLine( "Hello World!" );

   // Generate the S"ret" MSIL instruction.
   myILGenerator->Emit( OpCodes::Ret );

   // End the creation of the type.
   myTypeBuilder->CreateType();
}

int main()
{
   // Create a dynamic assembly with a type named MyType.
   DefineMethod();

   // Get the assemblies currently loaded in the application domain.
   array<Assembly^>^myAssemblies = Thread::GetDomain()->GetAssemblies();
   Assembly^ myAssembly = nullptr;

   // Get the assembly named MyAssembly.
   for ( int i = 0; i < myAssemblies->Length;
 i++ )
      if ( String::Compare( myAssemblies[ i ]->GetName( false
 )->Name, "MyAssembly" ) == 0 )
            myAssembly = myAssemblies[ i ];

   if ( myAssembly != nullptr )
   {
      // Get a type named MyType.
      Type^ myType = myAssembly->GetType( "MyType" );

      // Get a method named MyMethod from the type.
      MethodBase^ myMethodBase = myType->GetMethod( "MyMethod" );

      // Get the parameters associated with the method.
      array<ParameterInfo^>^myParameters = myMethodBase->GetParameters();
      Console::WriteLine( "\nThe method {0} has the {1} parameters :",
 myMethodBase, myParameters->Length );

      // Print the IN, OUT and OPTIONAL attributes associated with each
 of the parameters.
      for ( int i = 0; i < myParameters->Length;
 i++ )
      {
         if ( myParameters[ i ]->IsIn )
                  Console::WriteLine( "\tThe {0} parameter has the In attribute",
 i + 1 );
         if ( myParameters[ i ]->IsOptional )
                  Console::WriteLine( "\tThe {0} parameter has the Optional
 attribute", i + 1 );
         if ( myParameters[ i ]->IsOut )
                  Console::WriteLine( "\tThe {0} parameter has the Out attribute",
 i + 1 );
      }
   }
   else
      Console::WriteLine( "Could not find a assembly named 'MyAssembly' for
 the current application domain" );
}

J#

import System.*;  
import System.Reflection.*;  
import System.Threading.*;  
import System.Reflection.Emit.*;  

public class ParameterInfo_IsIn_IsOut_IsOptional
{
    public static void DefineMethod()
    {
        AssemblyName myAssemblyName = new AssemblyName();
        myAssemblyName.set_Name("MyAssembly");
        // Get the assembly builder from the application domain associated
 
        // with the current thread.
        AssemblyBuilder myAssemblyBuilder = System.Threading.Thread.
            GetDomain().DefineDynamicAssembly(myAssemblyName,
            AssemblyBuilderAccess.RunAndSave);
        // Create a dynamic module in the assembly.
        ModuleBuilder myModuleBuilder = myAssemblyBuilder.
            DefineDynamicModule("MyModule", "MyAssembly.dll");
        // Create a type in the module.
        TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("MyType");
        // Create a method called MyMethod.
        MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("MyMethod"
,
            MethodAttributes.Public | MethodAttributes.HideBySig 
            | MethodAttributes.Static, String.class.ToType(),
 
            new Type[] { int.class.ToType(),
 short.class.ToType(),
            long.class.ToType() });
        // Set the attributes for the parameters of the method.
        // Set the attribute for the first parameter to IN.
        ParameterBuilder myParameterBuilder = myMethodBuilder.
            DefineParameter(1, ParameterAttributes.In, "MyIntParameter");
        // Set the attribute for the second parameter to OUT.
        myParameterBuilder = myMethodBuilder.
            DefineParameter(2, ParameterAttributes.Out, "MyShortParameter");
        // Set the attribute for the third parameter to OPTIONAL.
        myParameterBuilder = myMethodBuilder.
            DefineParameter(3, ParameterAttributes.Optional 
            | ParameterAttributes.HasDefault, "MyLongParameter");
        // Get the Microsoft Intermediate Language generator for the
 method.
        ILGenerator myILGenerator = myMethodBuilder.GetILGenerator();
        // Use the utility method to generate the MSIL instructions
 
        // that print a string to the console.
        myILGenerator.EmitWriteLine("Hello World!");
        // Generate the "ret" MSIL instruction.
        myILGenerator.Emit(OpCodes.Ret);
        // End the creation of the type.
        myTypeBuilder.CreateType();
    } //DefineMethod

    public static void main(String[]
 args)
    {
        // Create a dynamic assembly with a type named MyType.
        DefineMethod();
        // Get the assemblies currently loaded in the application domain.
        Assembly myAssemblies[] = System.Threading.Thread.GetDomain().
            GetAssemblies();
        Assembly myAssembly = null;
        // Get the assembly named MyAssembly.
        for (int i = 0; i < myAssemblies.get_Length();
 i++) {
            if (String.Compare(myAssemblies[i].GetName(false).get_Name()
,
                "MyAssembly") == 0) {
                myAssembly = (Assembly)myAssemblies.get_Item(i);
            }
        }
        if (myAssembly != null) {
            // Get a type named MyType.
            Type myType = myAssembly.GetType("MyType");
            // Get a method named MyMethod from the type.
            MethodBase myMethodBase = myType.GetMethod("MyMethod");
            // Get the parameters associated with the method.
            ParameterInfo myParameters[] = myMethodBase.GetParameters();
            Console.WriteLine("\nThe method {0} has the {1} parameters :",
 
                myMethodBase, (Int32)myParameters.get_Length());
            // Print the IN, OUT and OPTIONAL attributes associated
 with 
            // each of the parameters.
            for (int i = 0; i < myParameters.get_Length();
 i++) {
                if (myParameters[i].get_IsIn()) {
                    Console.WriteLine("\tThe {0} parameter has the In attribute"
,
                        (Int32)(i + 1));
                }
                if (myParameters[i].get_IsOptional()) {
                    Console.WriteLine("\tThe {0} parameter has the Optional
 "
                        + "attribute", (Int32)(i + 1));
                }
                if (myParameters[i].get_IsOut()) {
                    Console.WriteLine("\tThe {0} parameter has the Out "
                        + "attribute", (Int32)(i + 1));
                }
            }
        }
        else {
            Console.WriteLine("Could not find a assembly named 'MyAssembly'
 "
                + "for the current application domain");
        }
    } //main
} //ParameterInfo_IsIn_IsOut_IsOptional 

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, 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

参照

関連項目
ParameterInfo クラス
ParameterInfo メンバ
System.Reflection 名前空間