ParameterInfo::IsOptional Property


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Gets a value indicating whether this parameter is optional.

Namespace:   System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

property bool IsOptional {
	bool get();

Property Value

Type: System::Boolean

true if the parameter is optional; otherwise, false.

This method depends on an optional metadata flag. This flag can be inserted by compilers, but the compilers are not obligated to do so.

This method utilizes the Optional flag of the ParameterAttributes enumerator.

To get the ParameterInfo array, first get the method and then call MethodBase::GetParameters.

The following example shows how to test method parameters for the ParameterAttributes::In, ParameterAttributes::Out, and ParameterAttributes::Optional attributes.

The example contains a DefineMethod method that does the following:

After executing DefineMethod, the example searches the assemblies that are currently loaded until it finds the dynamic assembly. It loads MyType from the assembly, gets a MethodInfo object for the MyMethod method, and examines the parameters. The example uses the IsIn, IsOut, and IsOptional properties to display information about the parameters.

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.

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

   // 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 );
      Console::WriteLine( "Could not find a assembly named 'MyAssembly' for the current application domain" );

Universal Windows Platform
Available since 8
.NET Framework
Available since 1.1
Portable Class Library
Supported in: portable .NET platforms
Available since 2.0
Windows Phone Silverlight
Available since 7.0
Windows Phone
Available since 8.1
Return to top