Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Attribute-Klasse

Stellt die Basisklasse für benutzerdefinierte Attribute dar.

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

[SerializableAttribute] 
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
[ComVisibleAttribute(true)] 
[AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false)] 
public abstract class Attribute : _Attribute
/** @attribute SerializableAttribute() */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false) */ 
public abstract class Attribute implements _Attribute
SerializableAttribute 
ClassInterfaceAttribute(ClassInterfaceType.None) 
ComVisibleAttribute(true) 
AttributeUsageAttribute(AttributeTargets.All, Inherited=true, AllowMultiple=false) 
public abstract class Attribute implements _Attribute

Die Attribute-Klasse ordnet einem Zielelement vordefinierte Systeminformationen oder benutzerdefinierte Informationen zu. Das Zielelement kann eine Assembly, eine Klasse, ein Konstruktor, ein Delegat, eine Enumeration, ein Ereignis, ein Feld, eine Schnittstelle, eine Methode, ein Modul einer übertragbaren ausführbaren Datei (Portable Executable, PE), ein Parameter, eine Eigenschaft, ein Rückgabewert, ein Werttyp oder ein anderes Attribut sein.

Von einem einem Attribut zur Verfügung gestellte Informationen werden auch als Metadaten bezeichnet. Metadaten können zur Laufzeit von der Anwendung daraufhin überprüft werden, wie das Programm Daten verarbeitet. Die Metadaten können auch vor der Laufzeit von einem externen Tool daraufhin überprüft werden, wie die Anwendung selbst verarbeitet oder verwaltet wird. Attributtypen werden z. B. von .NET Framework vordefiniert und verwendet, um das Laufzeitverhalten zu steuern. Einige Programmiersprachen verwenden Attributtypen, um Sprachfeatures darzustellen, die nicht direkt vom gemeinsamen Typsystem in .NET Framework unterstützt werden.

Alle Attributtypen werden direkt oder indirekt von der Attribute-Klasse abgeleitet. Attribute können auf jedes Zielelement angewendet werden. Mehrere Attribute können auf dasselbe Zielelement angewendet werden, und Attribute können von einem Element geerbt werden, das von einem Zielelement abgeleitet ist. Mithilfe der AttributeTargets-Klasse kann das Zielelement angegeben werden, auf das das Attribut angewendet wird.

Die Attribute-Klasse stellt benutzerfreundliche Methoden zur Verfügung, um benutzerdefinierte Attribute aufzurufen und diese zu testen. Weitere Informationen zum Verwenden von Attributen finden Sie unter Erweitern von Metadaten mithilfe von Attributen.

Das folgende Codebeispiel veranschaulicht die Verwendung von Attribute.

using System;
using System.Reflection;

namespace CustomAttrCS {
	// An enumeration of animals. Start at 1 (0 = uninitialized).
	public enum Animal {
		// Pets.
		Dog = 1,
		Cat,
		Bird,
	}

	// A custom attribute to allow a target to have a pet.
	public class AnimalTypeAttribute : Attribute {
		// The constructor is called when the attribute is set.
		public AnimalTypeAttribute(Animal pet) {
			thePet = pet;
		}

		// Keep a variable internally ...
		protected Animal thePet;

		// .. and show a copy to the outside world.
		public Animal Pet {
			get { return thePet; }
			set { thePet = Pet; }
		}
	}

	// A test class where each method has its own pet.
	class AnimalTypeTestClass {
		[AnimalType(Animal.Dog)]
		public void DogMethod() {}

		[AnimalType(Animal.Cat)]
		public void CatMethod() {}

		[AnimalType(Animal.Bird)]
		public void BirdMethod() {}
	}

	class DemoClass {
		static void Main(string[] args) {
			AnimalTypeTestClass testClass = new AnimalTypeTestClass();
			Type type = testClass.GetType();
			// Iterate through all the methods of the class.
			foreach(MethodInfo mInfo in type.GetMethods()) {
				// Iterate through all the Attributes for each method.
				foreach (Attribute attr in 
					Attribute.GetCustomAttributes(mInfo)) {
					// Check for the AnimalType attribute.
					if (attr.GetType() == typeof(AnimalTypeAttribute))
						Console.WriteLine(
							"Method {0} has a pet {1} attribute.", 
							mInfo.Name, ((AnimalTypeAttribute)attr).Pet);
				}

			}
		}
	}
}

/*
 * Output:
 * Method DogMethod has a pet Dog attribute.
 * Method CatMethod has a pet Cat attribute.
 * Method BirdMethod has a pet Bird attribute.
 */


package CustomAttrJSL; 

import System.*;
import System.Reflection.*;
  
public class Animal
{
    protected int pet;
    public static final int dog = 1;
    public static final int cat = 2;
    public static final int bird = 3;

    public Animal()
    {
        pet = 0;
    } //Animal
    public Animal(int p)
    {
        pet = p;
    } //Animal
    public String getPet()
    {
        switch (pet) {
            case 1 :
                return "Dog";
            case 2 :
                return "Cat";
            case 3 :
                return "Bird";
            default :
                return null;
        }
    } //getPet
} //Animal
      
// A custom attribute to allow a target to have a pet.
/** @attribute System.AttributeUsageAttribute(AttributeTargets.Method)
 */
public class AnimalTypeAttribute extends Attribute
{
    public AnimalTypeAttribute() { }
    // The constructor is called when the attribute is set.
    public AnimalTypeAttribute(int pet)
    {
        thePet = new Animal(pet);
    } //AnimalTypeAttribute

    // Keep a variable internally...
    protected Animal thePet;

    //.. and show a copy to the outside world.
    /** @property 
     */
    public Animal get_Pet()
    {
        return thePet;
    } //get_Pet

    /** @property 
     */
    public void set_Pet(Animal value)
    {
        thePet = value;
    } //set_Pet
} //AnimalTypeAttribute
      
 // A test class where each method has its own pet.
class AnimalTypeTestClass
{
    /** @attribute AnimalType(Animal.dog)
     */
    public void DogMethod()
    {
    } //DogMethod

    /** @attribute AnimalType(Animal.cat)
     */
    public void CatMethod()
    {
    } //CatMethod

    /** @attribute AnimalType(Animal.bird)
     */
    public void BirdMethod()
    {
    } //BirdMethod
} //AnimalTypeTestClass
   
class DemoClass
{
    public static void main(String[] args)
    {
        AnimalTypeTestClass testClass = new AnimalTypeTestClass();
        Type type = testClass.GetType();
        // Iterate through all the methods of the class.
        for (int iCtr1 = 0; iCtr1 < type.GetMethods().length; iCtr1++) {
            MethodInfo mInfo = type.GetMethods()[iCtr1];
            // Iterate through all the Attributes for each method.
            for (int iCtr2 = 0; 
                iCtr2 < Attribute.GetCustomAttributes(mInfo).length; 
                iCtr2++) {
               
                Attribute attr = Attribute.GetCustomAttributes(mInfo)[iCtr2];
                // Check for the AnimalType attribute.
                if (attr.GetType().
                    Equals(AnimalTypeAttribute.class.ToType())) {                
                    Console.WriteLine("Method {0} has a pet {1} attribute.", 
                        mInfo.get_Name(), 
                        ((AnimalTypeAttribute)attr).get_Pet().getPet());
                }
            }
        }
    } //main
} //DemoClass 

/*
 Output:
 Method DogMethod has a pet Dog attribute.
 Method CatMethod has a pet Cat attribute.
 Method BirdMethod has a pet Bird attribute.
*/

import System;
import System.Reflection;
import CustomAttrJS;

package CustomAttrJS {
	// An enumeration of animals. Start at 1 (0 = uninitialized).
	public enum Animal {
		// Pets.
		Dog = 1,
		Cat,
		Bird,
	}

	// A custom attribute to allow a target to have a pet.
	public AttributeUsage(AttributeTargets.Method) class AnimalTypeAttribute extends Attribute {
		// The constructor is called when the attribute is set.
		public function AnimalTypeAttribute(pet : Animal) {
			thePet = pet;
		}

		// Keep a variable internally ...
		protected var thePet : Animal;

		// .. and show a copy to the outside world.
		public function get Pet() : Animal {
	                return thePet; 
                }
		
                public function set Pet(pet : Animal) {
	                thePet = pet; 
                }
	}

	// A test class where each method has its own pet.
	class AnimalTypeTestClass {
		public AnimalTypeAttribute(Animal.Dog) 
                function DogMethod() {}

		public AnimalTypeAttribute(Animal.Cat)
		function CatMethod() {}

		public AnimalTypeAttribute(Animal.Bird)
		function BirdMethod() {}
	}
}



var testClass : AnimalTypeTestClass = new AnimalTypeTestClass();
var type : Type = testClass.GetType();
// Iterate through all the methods of the class.
            var mInfo : MethodInfo[] = type.GetMethods();
for (var i : int = 0; i < mInfo.length; i++) {
    // Iterate through all the Attributes for each method.
                    var attr : Attribute[] = Attribute.GetCustomAttributes(mInfo[i]);
    for (var j : int = 0; j < attr.length; j++) 
    {
        // Check for the AnimalType attribute.
        if (attr[j].GetType() == AnimalTypeAttribute)
            Console.WriteLine(
                "Method {0} has a pet {1} attribute.", 
                mInfo[i].Name, AnimalTypeAttribute(attr[j]).Pet);
    }

}


/*
 * Output:
 * Method BirdMethod has a pet Bird attribute.
 * Method CatMethod has a pet Cat attribute.
 * Method DogMethod has a pet Dog attribute.
 *
 */

Dieser Typ ist sicher bei Multithreadoperationen.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

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

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0
Anzeigen: