ParameterInfo.IsOptional Propriedade

Referência

Definição

Namespace:: System.Reflection

Assembly:: System.Reflection.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: ParameterInfo.cs

Origem:: ParameterInfo.cs

Origem:: ParameterInfo.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Obtém um valor que indica se esse parâmetro é opcional.

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

public bool IsOptional { get; }

member this.IsOptional : bool

Public ReadOnly Property IsOptional As Boolean

Valor da propriedade

Boolean

true se o parâmetro for opcional; caso contrário, false.

Exemplos

O exemplo a seguir mostra como testar parâmetros de método para os ParameterAttributes.Inatributos , ParameterAttributes.Oute ParameterAttributes.Optional .

O exemplo contém um DefineMethod método que faz o seguinte:

Cria um assembly dinâmico que contém um MyType tipo.
Adiciona um MyMethod método a MyType. MyMethod tem três parâmetros. O primeiro parâmetro é definido com ParameterAttributes.In, o segundo com ParameterAttributes.Oute o terceiro com ParameterAttributes.Optional.
Chama TypeBuilder.CreateType para concluir o tipo.

Depois de DefineMethodexecutar , o exemplo pesquisa os assemblies que estão atualmente carregados até encontrar o assembly dinâmico. Ele carrega MyType do assembly, obtém um MethodInfo objeto para o MyMethod método e examina os parâmetros. O exemplo usa as IsInpropriedades , IsOute IsOptional para exibir informações sobre os parâmetros.

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" );
}

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");
        }
    }
}

Imports System.Reflection
Imports System.Threading
Imports System.Reflection.Emit

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
   
   
   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
End Class

Comentários

Esse método depende de um sinalizador de metadados opcional. Esse sinalizador pode ser inserido por compiladores, mas os compiladores não são obrigados a fazê-lo.

Esse método utiliza o Optional sinalizador do ParameterAttributes enumerador .

Para obter a ParameterInfo matriz, primeiro obtenha o método e, em seguida, chame MethodBase.GetParameters.

Aplica-se a

Compartilhar via