Esta documentación está archivada y no tiene mantenimiento.

Attribute (Clase)

Representa la clase base para los atributos personalizados.

Espacio de nombres: System
Ensamblado: mscorlib (en 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

La clase Attribute asocia la información predefinida del sistema o la información personalizada definida por el usuario a un elemento de destino. Un elemento de destino puede ser un ensamblado, clase, constructor, delegado, enumeración, evento, campo, interfaz, método, módulo de archivo ejecutable portable, parámetro, propiedad, valor devuelto, estructura u otro atributo.

La información que proporciona un atributo se conoce también por el nombre de metadatos. La aplicación puede encargarse de examinar los metadatos en tiempo de ejecución para controlar la forma en que el programa debe procesar los datos o bien puede realizarse mediante herramientas externas, antes del tiempo de ejecución, para controlar la forma en que debe procesarse o mantenerse la propia aplicación. Por ejemplo, .NET Framework predefine y utiliza tipos de atributos para controlar el comportamiento en tiempo de ejecución y algunos lenguajes de programación utilizan tipos de atributos para representar características del lenguaje no compatibles con el sistema de tipos común de .NET Framework.

Todos los tipos de atributos se derivan directa o indirectamente de la clase Attribute. Se pueden aplicar atributos a cualquier elemento de destino; se pueden aplicar varios atributos al mismo elemento de destino; y un elemento derivado de un elemento de destino puede heredar los atributos. Utilice la clase AttributeTargets para especificar el elemento de destino al que aplicar el atributo.

La clase Attribute proporciona métodos útiles para recuperar y probar los atributos personalizados. Para obtener más información acerca del uso de atributos, vea Extender metadatos mediante atributos.

En el siguiente código de ejemplo se muestra el uso de la clase 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.
 *
 */

Este tipo es seguro para operaciones multiproceso.

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

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0
Mostrar: