example - generate documentation c#

¿Qué son los atributos en.NET?

Question

¿Qué son los atributos en .NET, para qué sirven y cómo puedo crear mis propios atributos?

Answer 1

Como se dijo, los atributos son relativamente fáciles de crear. La otra parte del trabajo es crear un código que lo use. En la mayoría de los casos, utilizará la reflexión en el tiempo de ejecución para modificar el comportamiento en función de la presencia de un atributo o sus propiedades. También hay escenarios en los que inspeccionarás los atributos en el código compilado para hacer algún tipo de análisis estático. Por ejemplo, los parámetros pueden marcarse como no nulos y la herramienta de análisis puede usar esto como una sugerencia.

Usar los atributos y conocer los escenarios apropiados para su uso es la mayor parte del trabajo.

Answer 2

En el proyecto en el que estoy trabajando actualmente, hay un conjunto de objetos de UI de varios tipos y un editor para ensamblar estos objetos para crear páginas para usar en la aplicación principal, un poco como el diseñador de formularios en DevStudio. Estos objetos existen en su propio ensamblaje y cada objeto es una clase derivada de UserControl y tiene un atributo personalizado. Este atributo se define así:

[AttributeUsage (AttributeTargets::Class)]
public ref class ControlDescriptionAttribute : Attribute
{
public:
  ControlDescriptionAttribute (String ^name, String ^description) :
    _name (name),
    _description (description)
  {
  }

  property String ^Name
  {
    String ^get () { return _name; }
  }

  property String ^Description
  {
    String ^get () { return _description; }
  }

private:
  String
    ^ _name,
    ^ _description;
};

y lo aplico a una clase como esta:

[ControlDescription ("Pie Chart", "Displays a pie chart")]
public ref class PieControl sealed : UserControl
{
  // stuff
};

que es lo que han dicho los pósters anteriores.

Para usar el atributo, el editor tiene un Generic::List <Type> contiene los tipos de control. Hay un cuadro de lista que el usuario puede arrastrar y soltar en la página para crear una instancia del control. Para rellenar el cuadro de lista, obtengo el ControlDescriptionAttribute para el control y completo una entrada en la lista:

// done for each control type
array <Object ^>
  // get all the custom attributes
  ^attributes = controltype->GetCustomAttributes (true);

Type
  // this is the one we''re interested in
  ^attributetype = ECMMainPageDisplay::ControlDescriptionAttribute::typeid;

// iterate over the custom attributes
for each (Object ^attribute in attributes)
{
  if (attributetype->IsInstanceOfType (attribute))
  {
    ECMMainPageDisplay::ControlDescriptionAttribute
      ^description = safe_cast <ECMMainPageDisplay::ControlDescriptionAttribute ^> (attribute);

    // get the name and description and create an entry in the list
    ListViewItem
      ^item = gcnew ListViewItem (description->Name);

    item->Tag = controltype->Name;
    item->SubItems->Add (description->Description);

    mcontrols->Items->Add (item);
    break;
  }
}

Nota: lo anterior es C ++ / CLI pero no es difícil convertir a C # (sí, lo sé, C ++ / CLI es una abominación pero es con lo que tengo que trabajar :-()

Puede poner atributos en la mayoría de las cosas y hay toda una gama de atributos predefinidos. El editor mencionado anteriormente también busca atributos personalizados en las propiedades que describen la propiedad y cómo editarla.

Una vez que tenga la idea completa, se preguntará cómo vivió sin ellos.

Answer 3

Los atributos son como los metadatos aplicados a clases, métodos o ensamblajes.

Son buenos para cualquier cantidad de cosas (visualización del depurador, marcando las cosas como obsoletas, marcando las cosas como serializables, la lista es infinita).

Crear tus propios diseños personalizados es muy fácil. Empieza aqui:

http://msdn.microsoft.com/en-us/library/sw480ze8(VS.71).aspx

Answer 4

Los atributos son un tipo de metadatos para etiquetar clases. Esto se usa a menudo en WinForms, por ejemplo, para ocultar los controles de la barra de herramientas, pero puede implementarse en su propia aplicación para permitir que las instancias de diferentes clases se comporten de maneras específicas.

Comience creando un atributo:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
public class SortOrderAttribute : Attribute
{
    public int SortOrder { get; set; }

    public SortOrderAttribute(int sortOrder)
    {
        this.SortOrder = sortOrder;
    }
}

Todas las clases de atributos deben tener el sufijo "Atributo" para ser válidos.
Una vez hecho esto, cree una clase que utiliza el atributo.

[SortOrder(23)]
public class MyClass
{
    public MyClass()
    {
    }
}

Ahora puede verificar una clase específica '' SortOrderAttribute (si tiene una) haciendo lo siguiente:

public class MyInvestigatorClass
{
    public void InvestigateTheAttribute()
    {
        // Get the type object for the class that is using
        // the attribute.
        Type type = typeof(MyClass);

        // Get all custom attributes for the type.
        object[] attributes = type.GetCustomAttributes(
            typeof(SortOrderAttribute), true);

        // Now let''s make sure that we got at least one attribute.
        if (attributes != null && attributes.Length > 0)
        {
            // Get the first attribute in the list of custom attributes
            // that is of the type "SortOrderAttribute". This should only
            // be one since we said "AllowMultiple=false".
            SortOrderAttribute attribute = 
                attributes[0] as SortOrderAttribute;

            // Now we can get the sort order for the class "MyClass".
            int sortOrder = attribute.SortOrder;
        }
    }
}

Si desea leer más sobre esto, siempre puede consultar MSDN que tiene una buena descripción.
¡Espero que esto te haya ayudado!

Answer 5

Los atributos son, esencialmente, bits de datos que desea adjuntar a sus tipos (clases, métodos, eventos, enumeraciones, etc.)

La idea es que en el tiempo de ejecución algún otro tipo / marco / herramienta consultará su tipo para obtener la información en el atributo y actuará sobre él.

Así, por ejemplo, Visual Studio puede consultar los atributos en un control de terceros para determinar qué propiedades del control deberían aparecer en el panel Propiedades en el momento del diseño.

Los atributos también se pueden usar en la Programación Orientada a Aspectos para inyectar / manipular objetos en el tiempo de ejecución en función de los atributos que los decoran y agregan validación, registro, etc. a los objetos sin afectar la lógica de negocios del objeto.

Answer 6

Los atributos también se usan comúnmente para la Programación Orientada a Aspectos. Para un ejemplo de esto, echa un vistazo al proyecto PostSharp .

Answer 7

Metadatos Datos sobre sus objetos / métodos / propiedades.

Por ejemplo, podría declarar un atributo llamado: DisplayOrder para poder controlar fácilmente en qué orden deben aparecer las propiedades en la interfaz de usuario. Luego podría agregarlo a una clase y escribir algunos componentes de la GUI que extraigan los atributos y ordenen los elementos de la IU de manera apropiada.

public class DisplayWrapper
{
    private UnderlyingClass underlyingObject;

    public DisplayWrapper(UnderlyingClass u)
    {
        underlyingObject = u;
    }

    [DisplayOrder(1)]
    public int SomeInt
    {
        get
        {
            return underlyingObject .SomeInt;
        }
    }

    [DisplayOrder(2)]
    public DateTime SomeDate
    {
        get
        {
            return underlyingObject .SomeDate;
        }
    }
}

De este modo, se asegura de que SomeInt siempre se muestre antes de SomeDate al trabajar con mis componentes GUI personalizados.

Sin embargo, los verá más comúnmente utilizados fuera del entorno de codificación directa. Por ejemplo, el Diseñador de Windows los usa ampliamente para que sepa cómo tratar con objetos hechos a la medida. Utilizando el atributo BrowsableAtributo:

[Browsable(false)]
public SomeCustomType DontShowThisInTheDesigner
{
    get{/*do something*/}
}

Le dice al diseñador que no incluya esto en las propiedades disponibles en la ventana Propiedades en tiempo de diseño, por ejemplo.

También puede usarlos para la generación de código, las operaciones de precompilación (como Post-Sharp) o las operaciones en tiempo de ejecución como Reflection.Emit. Por ejemplo, podría escribir un poco de código para perfilar que envolvió de manera transparente cada llamada que su código hace y la multiplica. Podría "excluirse" del tiempo a través de un atributo que coloca en métodos particulares.

public void SomeProfilingMethod(MethodInfo targetMethod, object target, params object[] args)
{
    bool time = true;
    foreach (Attribute a in target.GetCustomAttributes())
    {
        if (a.GetType() is NoTimingAttribute)
        {
            time = false;
            break;
        }
    }
    if (time)
    {
        StopWatch stopWatch = new StopWatch();
        stopWatch.Start();
        targetMethod.Invoke(target, args);
        stopWatch.Stop();
        HandleTimingOutput(targetMethod, stopWatch.Duration);
    }
    else
    {
        targetMethod.Invoke(target, args);
    }
}

Declararlos es fácil, solo haga una clase que herede de Attribute.

public class DisplayOrderAttribute : Attribute
{
    private int order;

    public DisplayOrderAttribute(int order)
    {
        this.order = order;
    }

    public int Order
    {
        get { return order; }
    }
}

Y recuerde que cuando usa el atributo puede omitir el sufijo "atributo", el compilador lo agregará por usted.

Answer 8

Muchas personas han respondido, pero nadie ha mencionado esto hasta ahora ...

Los atributos se utilizan mucho con la reflexión. La reflexión ya es bastante lenta.

Vale la pena marcar sus atributos personalizados como clases sealed para mejorar su rendimiento en tiempo de ejecución.

También es una buena idea considerar dónde sería apropiado usar place en tal atributo y atribuir su atributo (!) Para indicar esto a través de AttributeUsage . La lista de usos de atributos disponibles podría sorprenderte:

• Montaje
• Módulo
• Clase
• Struct
• Enumerar
• Constructor
• Método
• Propiedad
• Campo
• Evento
• Interfaz
• Parámetro
• Delegar
• Valor de retorno
• Parámetro genérico
• Todos

También es genial que el atributo AttributeUsage sea parte de la firma del atributo AttributeUsage. Whoa para dependencias circulares!

[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute

Answer 9

Para comenzar a crear un atributo, abra un archivo fuente de C #, escriba el attribute y presione [TAB]. Se expandirá a una plantilla para un nuevo atributo.

Answer 10

Puede usar atributos personalizados como una forma sencilla de definir valores de etiqueta en subclases sin tener que escribir el mismo código una y otra vez para cada subclase. Encontré un buen ejemplo conciso de John Waters sobre cómo definir y usar atributos personalizados en su propio código.

Hay un tutorial en http://msdn.microsoft.com/en-us/library/aa288454(VS.71).aspx

Answer 11

Un atributo es una clase que contiene un poco de funcionalidad que puede aplicar a los objetos en su código. Para crear uno, crea una clase que hereda de System.Attribute.

En cuanto a lo que son buenos para ... hay usos casi ilimitados para ellos.

http://www.codeproject.com/KB/cs/dotnetattributes.aspx