ParameterInfo.IsOptional Proprietà

Definizione

Spazio dei nomi:

System.Reflection

Assembly:

System.Runtime.dll

Origine:

ParameterInfo.cs

Ottiene un valore che indica se questo parametro è opzionale.

C#

public bool IsOptional { get; }

Valore della proprietà

Boolean

true se il parametro è opzionale; in caso contrario,false.

Esempio

Nell'esempio seguente viene illustrato come testare i parametri del metodo per gli ParameterAttributes.Inattributi , ParameterAttributes.Oute ParameterAttributes.Optional .

L'esempio contiene un DefineMethod metodo che esegue le operazioni seguenti:

• Crea un assembly dinamico contenente un MyType tipo.

• Aggiunge un MyMethod metodo a MyType. MyMethod ha tre parametri. Il primo parametro viene definito con , il secondo con ParameterAttributes.InParameterAttributes.Oute il terzo con ParameterAttributes.Optional.

• Chiamate TypeBuilder.CreateType per completare il tipo.

Dopo l'esecuzione DefineMethod, nell'esempio vengono cercati gli assembly attualmente caricati finché non trova l'assembly dinamico. MyType Carica dall'assembly, ottiene un MethodInfo oggetto per il MyMethod metodo ed esamina i parametri. Nell'esempio vengono usate le IsInproprietà , IsOute IsOptional per visualizzare informazioni sui parametri.

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

Commenti

Questo metodo dipende da un flag di metadati facoltativo. Questo flag può essere inserito dai compilatori, ma i compilatori non sono obbligati a farlo.

Questo metodo usa il Optional flag dell'enumeratore ParameterAttributes .

Per ottenere la matrice, ottenere prima il ParameterInfo metodo e quindi chiamare MethodBase.GetParameters.

Si applica a