Quali sono gli attributi .NET?

StackOverflow https://stackoverflow.com/questions/20346

Domanda

Quali sono gli attributi .NET, a cosa servono, e come faccio a creare il mio attributi?

È stato utile?

Soluzione

Metadati.I dati circa i vostri oggetti/metodi/proprietà.

Per esempio io potrei dichiarare un Attributo denominato:DisplayOrder in modo da poter facilmente controllare in che ordine proprietà dovrebbe essere visualizzato nell'interfaccia utente.Quindi potrei aggiungerla a una classe e a scrivere alcuni componenti dell'interfaccia grafica che consente di estrarre gli attributi e ordinare gli elementi dell'interfaccia utente in modo appropriato.

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;
        }
    }
}

Garantendo in tal modo che SomeInt è sempre visualizzato prima SomeDate quando lavoro con i miei personalizzato componenti dell'interfaccia grafica.

Tuttavia, li vedrete più comunemente utilizzati al di fuori del diretto ambiente di codifica.Per esempio il Windows Designer li utilizza estensivamente in modo da sapere come comportarsi personalizzati con gli oggetti.Utilizzando il BrowsableAttribute in questo modo:

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

Racconta la stilista non elenco disponibili proprietà nella finestra delle proprietà in fase di progettazione, per esempio.

Si potrebbe li usano anche per la generazione del codice, pre-compilare le operazioni (ad esempio Post-Sharp) o in fase di esecuzione di operazioni quali la Riflessione.Emettono.Per esempio, si potrebbe scrivere un po di codice per la profilatura che in modo trasparente avvolto ogni singola chiamata il codice e tempi.Si potrebbe "opt-out" dei tempi tramite un attributo che si svolge su particolari metodi.

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);
    }
}

Dichiarando di loro è facile, basta fare una classe che eredita da un Attributo. 

public class DisplayOrderAttribute : Attribute
{
    private int order;

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

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

E ricordate che quando si utilizza l'attributo è possibile omettere il suffisso "attributo", il compilatore aggiunge che per voi.

NOTA: Attributi non fare nulla da se stessi - ci deve essere qualche altro codice che li utilizza.A volte che il codice è stato scritto per voi, ma a volte è necessario scrivere voi stessi.Per esempio, il compilatore C# si preoccupa per alcuni e alcuni quadri di quadri di utilizzare alcuni (ad es.NUnit cerca [TestFixture] classe e [Test] su un metodo di prova durante il caricamento di un'assemblea).
Quindi, quando si crea il proprio attributo personalizzato di essere consapevole che non avrà un impatto il comportamento del vostro codice.Devi scrivere l'altra parte che controlla gli attributi (via di riflessione) e di agire su di essi.

Altri suggerimenti

Molte persone hanno risposto, ma nessuno ha parlato di questo finora...

Gli attributi sono utilizzati pesantemente con la riflessione.La riflessione è già abbastanza lento.

È molto utile marcatura personalizzata attributi come sealed classi di migliorare le loro prestazioni di runtime.

E ' anche una buona idea di prendere in considerazione in cui sarebbe opportuno utilizzare, come un attributo, e di attributo attributo (!) per indicare questa via AttributeUsage.L'elenco dei attributo usi potrebbe sorprendervi:

  • Assemblea
  • Modulo
  • Classe
  • Struct
  • Enum
  • Costruttore
  • Metodo
  • Proprietà
  • Campo
  • Evento
  • Interfaccia
  • Parametro
  • Delegato
  • ReturnValue
  • GenericParameter
  • Tutti

E ' anche cool che l'attributo AttributeUsage è parte di attributo AttributeUsage firma.Whoa le dipendenze circolari!

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

Gli attributi sono una sorta di meta-dati per la codifica di classi.Questo è spesso utilizzato in windows form, per esempio, per nascondere i controlli dalla barra degli strumenti, ma può essere implementato nella propria applicazione per attivare istanze di classi diverse a comportarsi in determinati modi.

Iniziare con la creazione di un attributo:

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

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

Tutte le classi di attributo deve avere il suffisso "Attributo" per essere valido.
Dopo aver fatto questo, creare una classe che utilizza l'attributo.

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

Ora è possibile controllare una classe specifica SortOrderAttribute (se ne ha uno) effettuando le seguenti operazioni:

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;
        }
    }
}

Se volete leggere di più su questo, si può sempre controllare MSDN che ha una buona descrizione.
Spero che questo ha aiutato!

Un attributo è una classe che contiene un po ' di funzionalità che è possibile applicare agli oggetti nel codice.Per crearne uno, creare una classe che eredita da System.Attributo.

Come per quello che stanno bene per...ci sono quasi illimitate usi per loro.

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

Gli attributi sono come metadati applicati alle classi, metodi o assemblee.

Essi sono buoni per qualsiasi numero di cose (debugger di visualizzazione, marcatura cose come obsoleti, marcatura cose come serializzabile, la lista è infinita).

Creazione personalizzata di quelli è facile come torta.Inizia da qui:

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

Il progetto a cui sto lavorando, c'è un set di oggetti dell'interfaccia utente di vari gusti, e un editor per il montaggio di questi oggetti per creare pagine per l'uso nell'applicazione principale, un po ' come il progettista del modulo in DevStudio.Questi oggetti si trovano nel loro assemblaggio e ogni oggetto è una classe derivata da UserControl e ha un attributo personalizzato.Questo attributo è definito come questa:

[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;
};

e la applico a una classe come questa:

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

che è quello che la precedente manifesti hanno detto.

Per utilizzare l'attributo, l'editor ha un Generic::List <Type> contenente i tipi di controllo.C'è una casella di riepilogo in cui l'utente può trascinare e rilasciare la pagina per creare un'istanza del controllo.Per popolare la casella di riepilogo, ho l' ControlDescriptionAttribute per il controllo e compilare una voce nell'elenco:

// 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:sopra è C++/CLI, ma non è difficile da convertire in C# (sì, lo so, C++/CLI è un abominio, ma è quello che ho da lavorare :-( )

Si può mettere gli attributi sulla maggior parte delle cose e ci sono tutta una serie di attributi predefiniti.L'editor di cui sopra sembra anche per gli attributi personalizzati sulla proprietà che descrivono la struttura e come modificarlo.

Una volta che si ottiene l'idea, vi chiederete come mai vissuto senza di loro.

Come detto, gli Attributi sono relativamente facili da creare.L'altra parte del lavoro è la creazione di codice che utilizza.Nella maggior parte dei casi si utilizzerà la riflessione in fase di runtime per modificare un comportamento basato su la presenza di un attributo o di sua proprietà.Ci sono anche gli scenari in cui si verificherà attributi codice compilato di fare una sorta di analisi statica.Per esempio, i parametri possono essere contrassegnati come non-null e lo strumento di analisi può utilizzare questo come un suggerimento.

Utilizzando gli attributi e sapendo scenari per il loro uso è il grosso del lavoro.

Gli attributi sono, essenzialmente, i bit di dati che si desidera collegare al vostro tipi di (classi, metodi, eventi, enumerazioni, etc.)

L'idea è che in fase di esecuzione di qualche altro tipo/quadro/strumento di query il il tipo di informazioni di attributo e di agire su di esso.

Così, per esempio, Visual Studio possono interrogare gli attributi su un 3rd party di controllo per capire quali sono le proprietà del controllo deve essere visualizzato nel riquadro Proprietà in fase di progettazione.

Gli attributi possono anche essere utilizzati nella Programmazione Orientata agli aspetti di iniettare/manipolare gli oggetti in fase di esecuzione sulla base degli attributi che li decorano e aggiungere la validazione, registrazione, etc.per gli oggetti senza intaccare la logica di business dell'oggetto.

È possibile utilizzare gli attributi personalizzati come un modo semplice per definire i valori dei tag in classi senza dover scrivere lo stesso codice più e più volte per ogni sottoclasse.Mi sono imbattuto in un bel conciso esempio da John Waters di come definire e utilizzare gli attributi personalizzati nel proprio codice.

C'è un tutorial a http://msdn.microsoft.com/en-us/library/aa288454(VS.71).aspx

Per iniziare la creazione di un attributo, aprire un file di origine C#, tipo attribute e premere il tasto [TAB].Si espanderà verso un modello per un nuovo attributo.

Gli attributi sono anche comunemente utilizzati per la Programmazione Orientata agli aspetti.Per un esempio di questo check out il PostSharp progetto.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top