(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

CustomAttributeData-Klasse

Stellt Zugriff auf benutzerdefinierte Attributdaten für Assemblys, Module, Typen, Member und Parameter bereit, die in den ReflectionOnly-Kontext geladen werden.

System.Object
  System.Reflection.CustomAttributeData

Namespace:  System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class CustomAttributeData

Der CustomAttributeData-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Geschützte MethodeCustomAttributeDataInitialisiert eine neue Instanz der CustomAttributeData-Klasse.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt in .NET für Windows Store-AppsAttributeTypeRuft den Attributtyp ab.
Öffentliche EigenschaftConstructorRuft ein ConstructorInfo-Objekt ab, das den Konstruktor darstellt, der das benutzerdefinierte Attribut initialisiert hätte.
Öffentliche EigenschaftUnterstützt in .NET für Windows Store-AppsConstructorArgumentsRuft die Liste positioneller Argumente ab, die für die durch das CustomAttributeData-Objekt dargestellte Attributinstanz angegeben werden.
Öffentliche EigenschaftUnterstützt in .NET für Windows Store-AppsNamedArgumentsRuft die Liste benannter Argumente ab, die für die durch das CustomAttributeData-Objekt dargestellte Attributinstanz angegeben werden.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeEqualsGibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Überschreibt Object.Equals(Object).)
Geschützte MethodeUnterstützt in .NET für Windows Store-AppsFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberGetCustomAttributes(Assembly)Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten über die für die Zielassembly übernommenen Attribute darstellen.
Öffentliche MethodeStatischer MemberGetCustomAttributes(MemberInfo)Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten über die für das Ziel übernommenen Attribute darstellen.
Öffentliche MethodeStatischer MemberGetCustomAttributes(Module)Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten über die für das Zielmodul übernommenen Attribute darstellen.
Öffentliche MethodeStatischer MemberGetCustomAttributes(ParameterInfo)Gibt eine Liste von CustomAttributeData-Objekten zurück, die Daten über die für den Zielparameter übernommenen Attribute darstellen.
Öffentliche MethodeGetHashCodeFungiert als die Standardhashfunktion. (Überschreibt Object.GetHashCode().)
Öffentliche MethodeUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Geschützte MethodeUnterstützt in .NET für Windows Store-AppsMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Öffentliche MethodeToStringGibt eine Zeichenfolgendarstellung des benutzerdefinierten Attributs zurück. (Überschreibt Object.ToString().)
Zum Seitenanfang

Code, der in einem ReflectionOnly-Kontext überprüft wird, kann nicht ausgeführt werden. Daher ist es nicht immer möglich, benutzerdefinierte Attribute durch das Erstellen von Instanzen derselben und anschließendes Überprüfen der Eigenschaften mithilfe von Methoden wie Attribute.GetCustomAttributes, MemberInfo.GetCustomAttributes usw. zu überprüfen. Wenn der Code für den Attributtyp selbst in einen ReflectionOnly-Kontext geladen wird, kann er nicht ausgeführt werden.

Mit der CustomAttributeData-Klasse können benutzerdefinierte Attribute im ReflectionOnly-Kontext durch Bereitstellen einer Abstraktion für Attribute überprüft werden. Die Member dieser Klasse können verwendet werden, um die positionellen Argumente und die benannten Argumente des Attributs abzurufen. Rufen Sie mit der ConstructorArguments-Eigenschaft eine Liste von CustomAttributeTypedArgument-Strukturen ab, die die positionellen Argumente darstellen, und rufen Sie mit der NamedArguments-Eigenschaft eine Liste von CustomAttributeNamedArgument-Strukturen ab, die die benannten Argumente darstellen.

HinweisHinweis

Die CustomAttributeNamedArgument-Struktur stellt nur Informationen darüber bereit, wie mit der Attributeigenschaft der Argumentwert abgerufen und festgelegt wird. Verwenden Sie zum Abrufen des Typs und des Werts für das Argument die CustomAttributeNamedArgument.TypedValue-Eigenschaft, um eine CustomAttributeTypedArgument-Struktur abzurufen.

Wenn Sie über eine CustomAttributeTypedArgument-Struktur für ein Argument verfügen (benannt oder positionell), rufen Sie mit der CustomAttributeTypedArgument.ArgumentType-Eigenschaft den Typ und mit der CustomAttributeTypedArgument.Value-Eigenschaft den Wert ab.

HinweisHinweis

Bei einem Arrayargument gibt die CustomAttributeTypedArgument.Value-Eigenschaft eine generische ReadOnlyCollection<T> von CustomAttributeTypedArgument-Objekten zurück. Jedes CustomAttributeTypedArgument-Objekt in der Auflistung stellt das entsprechende Element des Arrays dar.

CustomAttributeData kann sowohl im Ausführungskontext als auch im ReflectionOnly-Kontext verwendet werden. Sie können beispielsweise verhindern, dass die Assembly geladen wird, die den Code für ein benutzerdefiniertes Attribut enthält. Die Verwendung der CustomAttributeData-Klasse unterscheidet sich von der Verwendung von Methoden wie Attribute.GetCustomAttributes:

  • Die Eigenschaften und Methoden von CustomAttributeData stellen nur die Werte bereit, die für die Attributinstanz angegeben wurden, nicht aber die Semantik des Konstruktors. Beispielsweise kann ein Zeichenfolgenargument eines Attributs intern in eine beliebige andere Darstellung konvertiert und in einer kanonischen Form zurückgegeben werden. Oder eine Eigenschaft zeigt beim Ausführen des tatsächlichen Attributcodes Nebeneffekte.

  • Mit den Eigenschaften und Methoden von CustomAttributeData können Sie nicht die von Basisklassen geerbten benutzerdefinierten Attribute abrufen.

Wenn Sie Instanzen der CustomAttributeData-Klasse erstellen möchten, verwenden Sie die static (Shared in Visual Basic) GetCustomAttributes-Factorymethoden.

Im folgenden Beispiel wird ein benutzerdefiniertes Attribut mit vier Konstruktoren und vier Eigenschaften definiert. Zwei Eigenschaften sind schreibgeschützt und werden mit den positionellen Parameter der Konstruktoren festgelegt. Die anderen beiden Eigenschaften sind Lese-/Schreibeigenschaften und können nur mit benannten Argumenten festgelegt werden. Eine positionelle Eigenschaft ist ein Zeichenfolgenarray, und eine benannte Eigenschaft ist ein Array ganzer Zahlen.

Das Attribut wird auf die Assembly, einen in der Assembly deklarierten Typ, eine Methode des Typs und einen Parameter der Methode angewendet. Dabei werden jeweils unterschiedliche Konstruktoren verwendet. Beim Ausführen lädt sich die Assembly selbst in den ReflectionOnly-Kontext und zeigt Informationen zu den benutzerdefinierten Attributen an, die auf sie und auf den in ihr enthaltenen Typ sowie die in ihr enthaltenen Member angewendet wurden.

Das auf den Typ angewendete Attribut veranschaulicht Arrayeigenschaften mit positionellen und benannten Argumenten.


using System;
using System.Reflection;
using System.Collections.Generic;
using System.Collections.ObjectModel;

// The example attribute is applied to the assembly.
[assembly:Example(ExampleKind.ThirdKind, Note="This is a note on the assembly.")]

// An enumeration used by the ExampleAttribute class.
public enum ExampleKind
{
    FirstKind, 
    SecondKind, 
    ThirdKind, 
    FourthKind
};

// An example attribute. The attribute can be applied to all
// targets, from assemblies to parameters.
//
[AttributeUsage(AttributeTargets.All)]
public class ExampleAttribute : Attribute
{
    // Data for properties.
    private ExampleKind kindValue;
    private string noteValue;
    private string[] arrayStrings;
    private int[] arrayNumbers;

    // Constructors. The parameterless constructor (.ctor) calls
    // the constructor that specifies ExampleKind and an array of 
    // strings, and supplies the default values.
    //
    public ExampleAttribute(ExampleKind initKind, string[] initStrings)
    {
        kindValue = initKind;
        arrayStrings = initStrings;
    }
    public ExampleAttribute(ExampleKind initKind) : this(initKind, null) {}
    public ExampleAttribute() : this(ExampleKind.FirstKind, null) {}

    // Properties. The Note and Numbers properties must be read/write, so they
    // can be used as named parameters.
    //
    public ExampleKind Kind { get { return kindValue; }}
    public string[] Strings { get { return arrayStrings; }}
    public string Note    
    {
        get { return noteValue; }
        set { noteValue = value; }
    }
    public int[] Numbers
    {
        get { return arrayNumbers; }
        set { arrayNumbers = value; }
    }
}

// The example attribute is applied to the test class.
//
[Example(ExampleKind.SecondKind, 
         new string[] { "String array argument, line 1", 
                        "String array argument, line 2", 
                        "String array argument, line 3" }, 
         Note="This is a note on the class.",
         Numbers = new int[] { 53, 57, 59 })] 
public class Test
{
    // The example attribute is applied to a method, using the
    // parameterless constructor and supplying a named argument.
    // The attribute is also applied to the method parameter.
    //
    [Example(Note="This is a note on a method.")]
    public void TestMethod([Example] object arg) { }

    // Main() gets objects representing the assembly, the test
    // type, the test method, and the method parameter. Custom
    // attribute data is displayed for each of these.
    //
    public static void Main()
    {
        Assembly asm = Assembly.ReflectionOnlyLoad("Source");
        Type t = asm.GetType("Test");
        MethodInfo m = t.GetMethod("TestMethod");
        ParameterInfo[] p = m.GetParameters();

        Console.WriteLine("\r\nAttributes for assembly: '{0}'", asm);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(asm));
        Console.WriteLine("\r\nAttributes for type: '{0}'", t);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(t));
        Console.WriteLine("\r\nAttributes for member: '{0}'", m);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(m));
        Console.WriteLine("\r\nAttributes for parameter: '{0}'", p);
        ShowAttributeData(CustomAttributeData.GetCustomAttributes(p[0]));
    }

    private static void ShowAttributeData(
        IList<CustomAttributeData> attributes)
    {
        foreach( CustomAttributeData cad in attributes )
        {
            Console.WriteLine("   {0}", cad);
            Console.WriteLine("      Constructor: '{0}'", cad.Constructor);

            Console.WriteLine("      Constructor arguments:");
            foreach( CustomAttributeTypedArgument cata 
                in cad.ConstructorArguments )
            {
                ShowValueOrArray(cata);
            }

            Console.WriteLine("      Named arguments:");
            foreach( CustomAttributeNamedArgument cana 
                in cad.NamedArguments )
            {
                Console.WriteLine("         MemberInfo: '{0}'", 
                    cana.MemberInfo);
                ShowValueOrArray(cana.TypedValue);
            }
        }
    }

    private static void ShowValueOrArray(CustomAttributeTypedArgument cata)
    {
        if (cata.Value.GetType() == typeof(ReadOnlyCollection<CustomAttributeTypedArgument>))
        {
            Console.WriteLine("         Array of '{0}':", cata.ArgumentType);

            foreach (CustomAttributeTypedArgument cataElement in 
                (ReadOnlyCollection<CustomAttributeTypedArgument>) cata.Value)
            {
                Console.WriteLine("             Type: '{0}'  Value: '{1}'",
                    cataElement.ArgumentType, cataElement.Value);
            }
        }
        else
        {
            Console.WriteLine("         Type: '{0}'  Value: '{1}'", 
                cata.ArgumentType, cata.Value);
        }
    }
}

/* This code example produces output similar to the following:

Attributes for assembly: 'source, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'
   [System.Runtime.CompilerServices.CompilationRelaxationsAttribute((Int32)8)]
      Constructor: 'Void .ctor(Int32)'
      Constructor arguments:
         Type: 'System.Int32'  Value: '8'
      Named arguments:
   [System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = True)]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'Boolean WrapNonExceptionThrows'
         Type: 'System.Boolean'  Value: 'True'
   [ExampleAttribute((ExampleKind)2, Note = "This is a note on the assembly.")]
      Constructor: 'Void .ctor(ExampleKind)'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '2'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the assembly.'

Attributes for type: 'Test'
   [ExampleAttribute((ExampleKind)1, new String[3] { "String array argument, line 1", "String array argument, line 2", "String array argument, line 3" }, Note = "This is a note on the class.", Numbers = new Int32[3] { 53, 57, 59 })]
      Constructor: 'Void .ctor(ExampleKind, System.String[])'
      Constructor arguments:
         Type: 'ExampleKind'  Value: '1'
         Array of 'System.String[]':
             Type: 'System.String'  Value: 'String array argument, line 1'
             Type: 'System.String'  Value: 'String array argument, line 2'
             Type: 'System.String'  Value: 'String array argument, line 3'
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on the class.'
         MemberInfo: 'Int32[] Numbers'
         Array of 'System.Int32[]':
             Type: 'System.Int32'  Value: '53'
             Type: 'System.Int32'  Value: '57'
             Type: 'System.Int32'  Value: '59'

Attributes for member: 'Void TestMethod(System.Object)'
   [ExampleAttribute(Note = "This is a note on a method.")]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
         MemberInfo: 'System.String Note'
         Type: 'System.String'  Value: 'This is a note on a method.'

Attributes for parameter: 'System.Object arg'
   [ExampleAttribute()]
      Constructor: 'Void .ctor()'
      Constructor arguments:
      Named arguments:
*/


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft