Accès aux attributs personnalisésAccessing Custom Attributes

Une fois que des attributs associés aux éléments de programme, la réflexion peut être utilisée pour interroger leur existence et leurs valeurs.After attributes have been associated with program elements, reflection can be used to query their existence and values. Dans le .NET Framework version 1.0 et 1.1, les attributs personnalisés sont examinés dans le contexte d’exécution.In the .NET Framework version 1.0 and 1.1, custom attributes are examined in the execution context. Le .NET Framework version 2.0 fournit un nouveau contexte de chargement, le contexte de réflexion uniquement, qui peut être utilisé pour examiner le code qui ne peut pas être chargé pour l’exécution.The .NET Framework version 2.0 provides a new load context, the reflection-only context, which can be used to examine code that cannot be loaded for execution.

Le contexte de réflexion uniquementThe Reflection-Only Context

Le code chargé dans le contexte de réflexion uniquement ne peut pas être exécuté.Code loaded into the reflection-only context cannot be executed. Cela signifie que des instances d’attributs personnalisés ne peuvent pas être créées, car cela nécessiterait l’exécution de leurs constructeurs.This means that instances of custom attributes cannot be created, because that would require executing their constructors. Pour charger et examiner des attributs personnalisés dans le contexte de réflexion uniquement, utilisez la classe CustomAttributeData.To load and examine custom attributes in the reflection-only context, use the CustomAttributeData class. Vous pouvez obtenir des instances de cette classe à l’aide de la surcharge appropriée de la méthode statique CustomAttributeData.GetCustomAttributes.You can obtain instances of this class by using the appropriate overload of the static CustomAttributeData.GetCustomAttributes method. Voir Guide pratique pour charger des assemblys dans le contexte de réflexion uniquement.See How to: Load Assemblies into the Reflection-Only Context.

Le contexte d’exécutionThe Execution Context

Les principales méthodes de réflexion pour interroger les attributs dans le contexte d’exécution sont MemberInfo.GetCustomAttributes et Attribute.GetCustomAttributes.The main reflection methods to query attributes in the execution context are MemberInfo.GetCustomAttributes and Attribute.GetCustomAttributes.

L’accessibilité d’un attribut personnalisé est vérifiée par rapport à l’assembly dans lequel il est attaché.The accessibility of a custom attribute is checked with respect to the assembly in which it is attached. Cela équivaut à vérifier si une méthode sur un type dans l’assembly dans lequel l’attribut personnalisé est attaché peut appeler le constructeur de l’attribut personnalisé.This is equivalent to checking whether a method on a type in the assembly in which the custom attribute is attached can call the constructor of the custom attribute.

Les méthodes comme Assembly.GetCustomAttributes(Boolean) vérifient la visibilité et l’accessibilité de l’argument de type.Methods such as Assembly.GetCustomAttributes(Boolean) check the visibility and accessibility of the type argument. Seul le code dans l’assembly qui contient le type défini par l’utilisateur peut récupérer un attribut personnalisé de ce type à l’aide de GetCustomAttributes.Only code in the assembly that contains the user-defined type can retrieve a custom attribute of that type using GetCustomAttributes.

L’exemple C# suivant est un modèle de conception d’attribut personnalisé classique.The following C# example is a typical custom attribute design pattern. Il illustre le modèle de réflexion d’attribut personnalisé du runtime.It illustrates the runtime custom attribute reflection model.

System.DLL  
public class DescriptionAttribute : Attribute  
{  
}  
  
System.Web.DLL  
internal class MyDescriptionAttribute : DescriptionAttribute  
{  
}  
  
public class LocalizationExtenderProvider  
{  
    [MyDescriptionAttribute(...)]  
    public CultureInfo GetLanguage(...)  
    {  
    }  
}  

Si le runtime tente de récupérer les attributs personnalisés pour le type d’attribut personnalisé public DescriptionAttribute attaché à la méthode GetLanguage, il effectue les actions suivantes :If the runtime is attempting to retrieve the custom attributes for the public custom attribute type DescriptionAttribute attached to the GetLanguage method, it performs the following actions:

  1. Le runtime vérifie que l’argument de type DescriptionAttribute pour Type.GetCustomAttributes(Type type) est public, et est par conséquent visible et accessible.The runtime checks that the type argument DescriptionAttribute to Type.GetCustomAttributes(Type type) is public, and therefore is visible and accessible.

  2. Le runtime vérifie que le type défini par l’utilisateur MyDescriptionAttribute qui est dérivé de DescriptionAttribute est visible et accessible dans l’assembly System.Web.DLL, où il est attaché à la méthode GetLanguage().The runtime checks that the user-defined type MyDescriptionAttribute that is derived from DescriptionAttribute is visible and accessible within the System.Web.DLL assembly, where it is attached to the method GetLanguage().

  3. Le runtime vérifie que le constructeur de MyDescriptionAttribute est visible et accessible dans l’assembly System.Web.DLL.The runtime checks that the constructor of MyDescriptionAttribute is visible and accessible within the System.Web.DLL assembly.

  4. Le runtime appelle le constructeur de MyDescriptionAttribute avec les paramètres de l’attribut personnalisé et retourne le nouvel objet à l’appelant.The runtime calls the constructor of MyDescriptionAttribute with the custom attribute parameters and returns the new object to the caller.

Le modèle de réflexion d’attribut personnalisé peut laisser fuiter des instances de types définis par l’utilisateur en dehors de l’assembly dans lequel le type est défini.The custom attribute reflection model could leak instances of user-defined types outside the assembly in which the type is defined. Cela ne diffère pas des membres de la bibliothèque système du runtime qui retournent des instances de types définis par l’utilisateur, comme Type.GetMethods, qui retourne un tableau d’objets RuntimeMethodInfo.This is no different from the members in the runtime system library that return instances of user-defined types, such as Type.GetMethods returning an array of RuntimeMethodInfo objects. Pour empêcher un client de découvrir des informations relatives à un type d’attribut personnalisé défini par l’utilisateur, définissez les membres du type comme étant non publics.To prevent a client from discovering information about a user-defined custom attribute type, define the type's members to be nonpublic.

L’exemple suivant montre comment utiliser simplement la réflexion pour accéder à des attributs personnalisés.The following example demonstrates the basic way of using reflection to get access to custom attributes.

using namespace System;

public ref class ExampleAttribute : Attribute
{
private:
    String^ stringVal;

public:
    ExampleAttribute()
    {
        stringVal = "This is the default string.";
    }


    property String^ StringValue
    {
        String^ get() { return stringVal; }
        void set(String^ value) { stringVal = value; }
    }
};

[Example(StringValue="This is a string.")]
public ref class Class1
{
public:
    static void Main()
    {
        System::Reflection::MemberInfo^ info = Type::GetType("Class1");
        for each (Object^ attrib in info->GetCustomAttributes(true))
        {
            Console::WriteLine(attrib);
        }
    }
};

int main()
{
    Class1::Main();
}
using System;

public class ExampleAttribute : Attribute
{
    private string stringVal;

    public ExampleAttribute()
    {
        stringVal = "This is the default string.";
    }

    public string StringValue
    {
        get { return stringVal; }
        set { stringVal = value; }
    }
}

[Example(StringValue="This is a string.")]
class Class1
{
    public static void Main()
    {
        System.Reflection.MemberInfo info = typeof(Class1);
        foreach (object attrib in info.GetCustomAttributes(true))
        {
            Console.WriteLine(attrib);
        }
    }
}
Public Class ExampleAttribute
    Inherits Attribute

    Private stringVal As String

    Public Sub New()
        stringVal = "This is the default string."
    End Sub

    Public Property StringValue() As String
        Get
            Return stringVal
        End Get
        Set(Value As String)
            stringVal = Value
        End Set
    End Property
End Class

<Example(StringValue := "This is a string.")> _
Class Class1
    Public Shared Sub Main()
    Dim info As System.Reflection.MemberInfo = GetType(Class1)
        For Each attrib As Object In info.GetCustomAttributes(true)
            Console.WriteLine(attrib)
        Next attrib
    End Sub
End Class

Voir aussiSee also