Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Escribir atributos personalizados

Para diseñar atributos personalizados propios no se requiere conocer a fondo muchos conceptos nuevos. Si está familiarizado con programación orientada a objetos y sabe diseñar clases, posee la práctica totalidad de conocimientos necesarios. Los atributos personalizados son esencialmente clases tradicionales que se derivan directa o indirectamente de System.Attribute. Al igual que las clases tradicionales, los atributos personalizados contienen métodos que almacenan y recuperan datos.

A continuación se enumeran los pasos principales para diseñar correctamente clases de atributos personalizadas.

En esta sección se describen cada uno de estos pasos y dicha sección termina con un ejemplo de atributo personalizado.

La declaración de un atributo personalizado empieza con el atributo AttributeUsageAttribute, que define algunas de las características clave de la clase de atributos. Por ejemplo, se puede especificar si el atributo puede ser heredado por otras clases o a qué elementos se puede aplicar el atributo. El fragmento de código siguiente muestra cómo se utiliza el atributo AttributeUsageAttribute.


[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]


System.AttributeUsageAttribute tiene tres miembros que son importantes para la creación de atributos personalizados: AttributeTargets, Inherited y AllowMultiple.

84c42s56.collapse_all(es-es,VS.110).gifAttributeTargets (Miembro)

En el ejemplo anterior, se especifica AttributeTargets.All, indicando que este atributo se puede aplicar a todos los elementos de programa. También se puede especificar AttributeTargets.Class, que indica que el atributo puede aplicarse sólo a una clase, o bien AttributeTargets.Method que indica que el atributo puede aplicarse sólo a un método. Todos los elementos de programa pueden ser marcados a efectos de descripción por un atributo personalizado de este modo.

También se pueden pasar varias instancias de AttributeTargets. El fragmento de código siguiente especifica que un atributo personalizado se puede aplicar a cualquier clase o método.


[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]


84c42s56.collapse_all(es-es,VS.110).gifInherited (Propiedad)

La propiedad Inherited indica si el atributo puede ser heredado por clases derivadas de las clases a las que se aplica el atributo. Esta propiedad puede tomar el marcador true (valor predeterminado) o false. Por ejemplo, en el siguiente ejemplo de código, MyAttribute tiene el valor predeterminado true para Inherited, mientras que YourAttribute tiene el valor false también para Inherited.


// This defaults to Inherited = true.
public class MyAttribute : Attribute
{
    //...
}

[AttributeUsage(AttributeTargets.Method, Inherited = false)]
public class YourAttribute : Attribute
{
    //...
}


Los dos atributos se aplican después a un método de la clase base MyClass.


public class MyClass
{
    [MyAttribute]
    [YourAttribute]
    public virtual void MyMethod()
    {
        //...
    }
}


Finalmente, la clase YourClass se hereda de la clase base MyClass. El método MyMethod muestra MyAttribute, pero no YourAttribute.


public class YourClass : MyClass
{
    // MyMethod will have MyAttribute but not YourAttribute.
    public override void MyMethod()
    {
        //...
    }

}


84c42s56.collapse_all(es-es,VS.110).gifAllowMultiple (Propiedad)

La propiedad AllowMultiple indica si pueden existir varias instancias del atributo en un elemento. Si se establece en true, se permiten varias instancias; si se establece en false (valor predeterminado), sólo se permite una instancia.

En el siguiente ejemplo de código, MyAttribute tiene el valor predeterminado false para AllowMultiple, mientras que YourAttribute tiene el valor true.


//This defaults to AllowMultiple = false.
public class MyAttribute : Attribute
{
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class YourAttribute : Attribute
{
}


Cuando se aplican varias instancias de estos atributos, MyAttribute genera un error del compilador. El ejemplo de código siguiente muestra un uso válido de YourAttribute y un uso no válido de MyAttribute.


public class MyClass
{
    // This produces an error.
    // Duplicates are not allowed.
    [MyAttribute]
    [MyAttribute]
    public void MyMethod()
    {
        //...
    }

    // This is valid.
    [YourAttribute]
    [YourAttribute]
    public void YourMethod()
    {
        //...
    }
}


Si las propiedades AllowMultiple e Inherited se establecen ambas en true, una clase heredada de otra puede heredar un atributo y tener aplicada otra instancia del mismo atributo en la misma clase secundaria. Si la propiedad AllowMultiple se establece en false, los valores de los atributos de la clase primaria serán sobrescritos por las instancias nuevas del mismo atributo de la clase secundaria.

Después de aplicar el atributo AttributeUsageAttribute, se puede empezar a definir las especificaciones del atributo. La declaración de una clase de atributos es similar a la declaración de una clase tradicional, como muestra el código siguiente.


[AttributeUsage(AttributeTargets.Method)]
public class MyAttribute : Attribute
{
    // . . .
}


Esta definición de atributo muestra los puntos siguientes:

  • Las clases de atributos se deben declarar como clases de tipo public.

  • Por convención, el nombre de la clase de atributos termina con la palabra Attribute. Aunque no se requiera, se recomienda esta convención por cuestiones de legibilidad. Cuando se aplica el atributo, la inclusión de la palabra Attribute es opcional.

  • Todas las clases de atributos deben heredar directa o indirectamente de System.Attribute.

  • En Microsoft Visual Basic, todas las clases de atributos personalizadas deben tener el atributo AttributeUsageAttribute.

Los atributos se inicializan con constructores del mismo modo que las clases tradicionales. El fragmento de código siguiente muestra un constructor de atributos típico. Este constructor de tipo public acepta un parámetro y establece su valor en una variable miembro.


public MyAttribute(bool myvalue)
{
    this.myvalue = myvalue;
}


Se puede sobrecargar el constructor para que incluya diferentes combinaciones de valores. Si también se define una propiedad para la clase de atributos personalizada, se puede utilizar una combinación de parámetros con nombre y parámetros posicionales al inicializar el atributo. Normalmente, se definen todos los parámetros requeridos como posicionales y todos los parámetros opcionales como parámetros con nombre. En este caso, el atributo no se puede inicializar sin el parámetro requerido. Todos los demás parámetros son opcionales. Tenga en cuenta que, en Visual Basic, los constructores de una clase de atributos no deberían utilizar un argumento ParamArray.

El ejemplo de código siguiente muestra cómo un atributo que utiliza el constructor anterior se puede aplicar utilizando parámetros requeridos y opcionales. Se supone que el atributo tiene un valor booleano requerido y una propiedad de cadena opcional.


// One required (positional) and one optional (named) parameter are applied.
[MyAttribute(false, OptionalParameter = "optional data")]
public class SomeClass
{
    //...
}
// One required (positional) parameter is applied.
[MyAttribute(false)]
public class SomeOtherClass
{
    //...
}


Si se desea definir un parámetro con nombre o proporcionar un método sencillo para devolver los valores almacenados por el atributo, se ha de declarar una propiedad. Las propiedades de atributo se deben declarar como entidades de tipo public con una descripción del tipo de datos que se devolverá. Se ha de definir la variable que contendrá el valor de la propiedad y asociarla a los métodos get y set. El ejemplo de código siguiente muestra cómo se implementa una propiedad simple en el atributo.


public bool MyProperty
{
    get {return this.myvalue;}
    set {this.myvalue = value;}
}


Esta sección incorpora la información anterior y muestra cómo se diseña un atributo simple que documenta información relativa al autor de una sección de código. El atributo de este ejemplo almacena el nombre y el nivel del programador, y si se ha revisado el código. Utiliza tres variables de tipo private para almacenar los valores reales que se han de guardar. Cada variable se representa mediante una propiedad de tipo public que obtiene y establece los valores. Finalmente, el constructor se define con dos parámetros requeridos.


[AttributeUsage(AttributeTargets.All)]
public class DeveloperAttribute : Attribute
{
    // Private fields.
    private string name;
    private string level;
    private bool reviewed;

    // This constructor defines two required parameters: name and level.

    public DeveloperAttribute(string name, string level)
    {
        this.name = name;
        this.level = level;
        this.reviewed = false;
    }

    // Define Name property.
    // This is a read-only attribute.

    public virtual string Name
    {
        get {return name;}
    }

    // Define Level property.
    // This is a read-only attribute.

    public virtual string Level
    {
        get {return level;}
    }

    // Define Reviewed property.
    // This is a read/write attribute.

    public virtual bool Reviewed
    {
        get {return reviewed;}
        set {reviewed = value;}
    }
}


Se puede aplicar este atributo utilizando el nombre completo, DeveloperAttribute, o el nombre abreviado, Developer, mediante una de las formas siguientes.


[Developer("Joan Smith", "1")]

-or-

[Developer("Joan Smith", "1", Reviewed = true)]


El primer ejemplo muestra el atributo aplicado con sólo los parámetros con nombre requeridos, mientras que el segundo muestra el atributo aplicado con los parámetros requeridos y opcionales.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft