Export (0) Print
Expand All

ParameterInfo.IsOptional Property

Gets a value indicating whether this parameter is optional.

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

Public ReadOnly Property IsOptional As Boolean

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.

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.
      ' End the creation of the type.
   End Sub 'DefineMethod

   Public Shared Sub Main()
      ' Create a dynamic assembly with a type named 'MyType'.

      ' 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
         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 

.NET Framework

Supported in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

© 2014 Microsoft