ParameterInfo.IsIn Propriété

Définition

Espace de noms:

System.Reflection

Assembly:

System.Runtime.dll

Source:

ParameterInfo.cs

Obtient une valeur indiquant s'il s'agit d'un paramètre d'entrée.

C#

public bool IsIn { get; }

Valeur de propriété

Boolean

true si le paramètre est un paramètre d'entrée ; sinon, false.

Exemples

L’exemple suivant montre comment tester les paramètres de méthode pour les ParameterAttributes.Inattributs , ParameterAttributes.Outet ParameterAttributes.Optional .

L’exemple contient une DefineMethod méthode qui effectue les opérations suivantes :

• Crée un assembly dynamique contenant un MyType type.

• Ajoute une MyMethod méthode à MyType. MyMethod a trois paramètres. Le premier paramètre est défini avec ParameterAttributes.In, le second avec ParameterAttributes.Outet le troisième avec ParameterAttributes.Optional.

• Appelle TypeBuilder.CreateType pour terminer le type.

Après avoir exécuté DefineMethod, l’exemple recherche les assemblys actuellement chargés jusqu’à ce qu’il trouve l’assembly dynamique. Il charge MyType à partir de l’assembly, obtient un MethodInfo objet pour la MyMethod méthode et examine les paramètres. L’exemple utilise les IsInpropriétés , IsOutet IsOptional pour afficher des informations sur les paramètres.

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

Remarques

Cette méthode dépend d’un indicateur de métadonnées facultatif. Cet indicateur peut être inséré par les compilateurs, mais les compilateurs ne sont pas obligés de le faire.

Cette méthode utilise l’indicateur In de l’énumérateur ParameterAttributes .

Pour obtenir le ParameterInfo tableau, commencez par obtenir la méthode ou le constructeur, puis appelez MethodBase.GetParameters.

S’applique à