Delen via

Aangepaste kenmerken openen

  • Artikel

Nadat kenmerken zijn gekoppeld aan programma-elementen, kan reflectie worden gebruikt om hun bestaan en waarden op te vragen. .NET biedt de MetadataLoadContext, die u kunt gebruiken om code te onderzoeken die niet kan worden geladen voor uitvoering.

MetadataLoadContext

Code die in de MetadataLoadContext context is geladen, kan niet worden uitgevoerd. Dit betekent dat exemplaren van aangepaste kenmerken niet kunnen worden gemaakt, omdat hiervoor de constructors moeten worden uitgevoerd. Als u aangepaste kenmerken in de MetadataLoadContext context wilt laden en onderzoeken, gebruikt u de CustomAttributeData klasse. U kunt exemplaren van deze klasse verkrijgen met behulp van de juiste overbelasting van de statische CustomAttributeData.GetCustomAttributes methode. Zie Instructies voor meer informatie : Assembly-inhoud inspecteren met MetadataLoadContext.

De uitvoeringscontext

De belangrijkste reflectiemethoden voor het opvragen van kenmerken in de uitvoeringscontext zijn MemberInfo.GetCustomAttributes en Attribute.GetCustomAttributes.

De toegankelijkheid van een aangepast kenmerk wordt gecontroleerd met betrekking tot de assembly waarin het is gekoppeld. Dit komt overeen met het controleren of een methode voor een type in de assembly waarin het aangepaste kenmerk is gekoppeld, de constructor van het aangepaste kenmerk kan aanroepen.

Methoden zoals Assembly.GetCustomAttributes(Boolean) de zichtbaarheid en toegankelijkheid van het typeargument controleren. Alleen code in de assembly die het door de gebruiker gedefinieerde type bevat, kan een aangepast kenmerk van dat type ophalen met behulp van GetCustomAttributes.

Het volgende C#-voorbeeld is een typisch aangepast kenmerkontwerppatroon. Het illustreert het weerspiegelingsmodel voor aangepaste runtimekenmerken.

System.DLL
public class DescriptionAttribute : Attribute
{
}

System.Web.DLL
internal class MyDescriptionAttribute : DescriptionAttribute
{
}

public class LocalizationExtenderProvider
{
    [MyDescriptionAttribute(...)]
    public CultureInfo GetLanguage(...)
    {
    }
}

Als de runtime probeert de aangepaste kenmerken op te halen voor het openbare aangepaste kenmerktype DescriptionAttribute dat is gekoppeld aan de GetLanguage methode, worden de volgende acties uitgevoerd:

  1. De runtime controleert of het typeargument DescriptionAttributeType.GetCustomAttributes(Type type) openbaar is en daarom zichtbaar en toegankelijk is.
  2. De runtime controleert of het door de gebruiker gedefinieerde type MyDescriptionAttribute dat is afgeleid DescriptionAttribute , zichtbaar en toegankelijk is binnen de System.Web.dll assembly, waar het is gekoppeld aan de methode GetLanguage().
  3. De runtime controleert of de constructor MyDescriptionAttribute zichtbaar en toegankelijk is binnen de System.Web.dll assembly.
  4. De runtime roept de constructor aan MyDescriptionAttribute met de aangepaste kenmerkparameters en retourneert het nieuwe object aan de aanroeper.

Het aangepaste kenmerkspiegelingsmodel kan exemplaren van door de gebruiker gedefinieerde typen buiten de assembly lekken waarin het type is gedefinieerd. Dit verschilt niet van de leden in de runtimesysteembibliotheek die exemplaren van door de gebruiker gedefinieerde typen retourneert, zoals Type.GetMethods het retourneren van een matrix met RuntimeMethodInfo objecten. Als u wilt voorkomen dat een client informatie over een door de gebruiker gedefinieerd aangepast kenmerktype ontdekt, definieert u de leden van het type die niet openbaar zijn.

In het volgende voorbeeld ziet u de basiswijze voor het gebruik van weerspiegeling om toegang te krijgen tot aangepaste kenmerken.

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

Zie ook