Attributi più utili [chiuso]

So che gli attributi sono estremamente utili. Ce ne sono alcuni predefiniti come quelli [Browsable(false)]che ti permettono di nascondere le proprietà nella scheda delle proprietà. Ecco una buona domanda che spiega gli attributi: Cosa sono gli attributi in .NET?

Quali sono gli attributi predefiniti (e il loro spazio dei nomi) che usi effettivamente nei tuoi progetti?

[DebuggerDisplay]può essere davvero utile per visualizzare rapidamente l'output personalizzato di un tipo quando si passa con il mouse sull'istanza del tipo durante il debug. esempio:

[DebuggerDisplay("FirstName={FirstName}, LastName={LastName}")]
class Customer
{
    public string FirstName;
    public string LastName;
}

Ecco come dovrebbe apparire nel debugger:

Inoltre, vale la pena ricordare che l' [WebMethod]attributo con CacheDurationset di proprietà può evitare l'esecuzione non necessaria del metodo del servizio Web.

System.Obsoleteè uno degli attributi più utili nel framework, secondo me. La possibilità di generare un avviso sul codice che non deve più essere utilizzato è molto utile. Adoro avere un modo per dire agli sviluppatori che qualcosa non dovrebbe più essere usato, così come avere un modo per spiegare perché e indicare il modo migliore / nuovo di fare qualcosa.

Il Conditional attributeè piuttosto comodo anche per l'utilizzo di debug. Ti consente di aggiungere metodi nel tuo codice per scopi di debug che non verranno compilati quando crei la tua soluzione per il rilascio.

Quindi ci sono molti attributi specifici dei controlli Web che trovo utili, ma quelli sono più specifici e non hanno alcun uso al di fuori dello sviluppo dei controlli server da quello che ho trovato.

[Flags]è abbastanza utile. Zucchero sintattico per essere sicuri, ma comunque piuttosto carino.

[Flags] 
enum SandwichStuff
{
   Cheese = 1,
   Pickles = 2,
   Chips = 4,
   Ham = 8,
   Eggs = 16,
   PeanutButter = 32,
   Jam = 64
};

public Sandwich MakeSandwich(SandwichStuff stuff)
{
   Console.WriteLine(stuff.ToString());
   // ...
}

// ...

MakeSandwich(SandwichStuff.Cheese 
   | SandwichStuff.Ham 
   | SandwichStuff.PeanutButter);
// produces console output: "Cheese, Ham, PeanutButter"

Leppie sottolinea qualcosa che non avevo realizzato e che piuttosto smorza il mio entusiasmo per questo attributo: non indica al compilatore di consentire combinazioni di bit come valori validi per le variabili di enumerazione, il compilatore lo consente indipendentemente dalle enumerazioni. Il mio background C ++ che mostra attraverso ... sigh

Mi piace [DebuggerStepThrough]da System.Diagnostics .

È molto utile per evitare di entrare in quei metodi o proprietà del fare una sola riga (se sei costretto a lavorare in una .Net iniziale senza proprietà automatiche). Metti l'attributo su un metodo breve o sul getter o sul setter di una proprietà, e volerai subito anche quando premi "step in" nel debugger.

Per quello che vale, ecco un elenco di tutti gli attributi .NET . Ce ne sono diverse centinaia.

Non conosco nessun altro, ma ho qualche serio RTFM da fare!

Il mio voto sarebbe per Conditional

[Conditional("DEBUG")]
public void DebugOnlyFunction()
{
    // your code here
}

Puoi usarlo per aggiungere una funzione con funzionalità di debug avanzate; ad esempio Debug.Write, viene chiamato solo nelle build di debug e quindi consente di incapsulare una logica di debug complessa al di fuori del flusso principale del programma.

Io uso sempre la DisplayName, Descriptione DefaultValuegli attributi su proprietà pubbliche dei miei controlli utente, i controlli personalizzati o qualsiasi classe Io modificare attraverso una griglia di proprietà. Questi tag vengono utilizzati da .NET PropertyGrid per formattare i valori di nome, pannello di descrizione e grassetto che non sono impostati sui valori predefiniti.

[DisplayName("Error color")]
[Description("The color used on nodes containing errors.")]
[DefaultValue(Color.Red)]
public Color ErrorColor
{
    ...
} 

Vorrei solo che IntelliSense di Visual Studio avrebbe preso Descriptionin considerazione l' attributo se non fosse stato trovato alcun commento XML. Eviterebbe di dover ripetere la stessa frase due volte.

[Serializable]viene utilizzato continuamente per serializzare e deserializzare oggetti da e verso origini dati esterne come xml o da un server remoto. Maggiori informazioni qui.

Nello spirito di Hofstadt, l' [Attribute]attributo è molto utile, poiché è il modo in cui crei i tuoi attributi. Ho usato gli attributi invece delle interfacce per implementare i sistemi di plugin, aggiungere descrizioni a Enum, simulare più invii e altri trucchi.

Ecco il post sull'attributo interessante InternalsVisibleTo . Fondamentalmente ciò che fa imita la funzionalità di accesso agli amici C ++. È molto utile per i test unitari.

Ho trovato [DefaultValue]molto utile.

Suggerirei [TestFixture]e [Test]- dalla libreria nUnit .

I test unitari nel codice forniscono sicurezza nel refactoring e nella documentazione codificata.

[XmlIgnore]

in quanto ciò consente di ignorare (in qualsiasi serializzazione xml) oggetti "parent" che altrimenti causerebbero eccezioni durante il salvataggio.

Non è ben definito, non ben supportato nel framework e non dovrebbe richiedere un parametro, ma questo attributo è un marcatore utile per le classi immutabili:

[ImmutableObject(true)]

Mi piace usare l' [ThreadStatic]attributo in combinazione con la programmazione basata su thread e stack. Ad esempio, se voglio un valore che voglio condividere con il resto di una sequenza di chiamate, ma voglio farlo fuori banda (cioè al di fuori dei parametri di chiamata), potrei impiegare qualcosa del genere.

class MyContextInformation : IDisposable {
    [ThreadStatic] private static MyContextInformation current;

    public static MyContextInformation Current {
        get { return current; }
    }

    private MyContextInformation previous;


    public MyContextInformation(Object myData) {
       this.myData = myData;
       previous = current;
       current = this;
    }

    public void Dispose() {
       current = previous;
    }
}

Più avanti nel mio codice, posso utilizzarlo per fornire informazioni contestuali fuori banda alle persone a valle del mio codice. Esempio:

using(new MyContextInformation(someInfoInContext)) {
   ...
}

L'attributo ThreadStatic mi consente di estendere la chiamata solo al thread in questione evitando il disordinato problema di accesso ai dati tra thread.

Il DebuggerHiddenAttribute che permette di evitare passo in codice che non dovrebbe essere debug.

public static class CustomDebug
{
    [DebuggerHidden]
    public static void Assert(Boolean condition, Func<Exception> exceptionCreator) { ... }
}

...

// The following assert fails, and because of the attribute the exception is shown at this line
// Isn't affecting the stack trace
CustomDebug.Assert(false, () => new Exception()); 

Inoltre impedisce di mostrare metodi nella traccia dello stack, utile quando si ha un metodo che avvolge solo un altro metodo:

[DebuggerHidden]
public Element GetElementAt(Vector2 position)
{
    return GetElementAt(position.X, position.Y);
}

public Element GetElementAt(Single x, Single y) { ... }

Se ora si chiama GetElementAt(new Vector2(10, 10))e si verifica un errore nel metodo wrapped, lo stack di chiamate non mostra il metodo che chiama il metodo che genera l'errore.

DesignerSerializationVisibilityAttributeè molto utile Quando si inserisce una proprietà di runtime su un controllo o un componente e non si desidera che il designer la serializzi, la si utilizza in questo modo:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Foo Bar {
    get { return baz; }
    set { baz = value; }
}

Solo pochi attributi ottengono il supporto del compilatore, ma un uso molto interessante degli attributi è in AOP: PostSharp usa i tuoi attributi su misura per iniettare IL in metodi, consentendo ogni tipo di abilità ... log / trace sono esempi banali - ma alcuni altri buoni esempi sono cose come l'implementazione automatica di INotifyPropertyChanged ( qui ).

Alcuni che si verificano e influiscono direttamente sul compilatore o sul runtime :

• [Conditional("FOO")] - le chiamate a questo metodo (inclusa la valutazione dell'argomento) si verificano solo se durante la compilazione viene definito il simbolo "FOO"
• [MethodImpl(...)] - usato per indicare alcune cose come sincronizzazione, allineamento
• [PrincipalPermission(...)] - utilizzato per inserire automaticamente i controlli di sicurezza nel codice
• [TypeForwardedTo(...)]- utilizzato per spostare i tipi tra assiemi senza ricostruire i chiamanti

Per le cose che vengono controllate manualmente tramite la riflessione, sono un grande fan degli System.ComponentModelattributi; cose come [TypeDescriptionProvider(...)], [TypeConverter(...)]e [Editor(...)]che possono cambiare completamente il comportamento dei tipi negli scenari di associazione dei dati (es. proprietà dinamiche ecc.).

Se dovessi eseguire una scansione della copertura del codice, penso che questi due sarebbero i migliori:

 [Serializable]
 [WebMethod]

Ho usato [DataObjectMethod]ultimamente. Descrive il metodo in modo da poter utilizzare la classe con ObjectDataSource (o altri controlli).

[DataObjectMethod(DataObjectMethodType.Select)] 
[DataObjectMethod(DataObjectMethodType.Delete)] 
[DataObjectMethod(DataObjectMethodType.Update)] 
[DataObjectMethod(DataObjectMethodType.Insert)] 

Ulteriori informazioni

Nel nostro progetto attuale, usiamo

[ComVisible(false)]

Controlla l'accessibilità di un singolo tipo o membro gestito, o di tutti i tipi all'interno di un assembly, a COM.

Ulteriori informazioni

[TypeConverter(typeof(ExpandableObjectConverter))]

Indica al designer di espandere le proprietà che sono classi (di tuo controllo)

[Obfuscation]

Indica agli strumenti di offuscamento di eseguire le azioni specificate per un assieme, tipo o membro. (Anche se in genere si utilizza un livello Assembly[assembly:ObfuscateAssemblyAttribute(true)]

Gli attributi che utilizzo di più sono quelli relativi alla serializzazione XML.

XmlRoot

XmlElement

XmlAttribute

eccetera...

Estremamente utile quando si eseguono analisi o serializzazioni XML rapide e sporche.

Essere uno sviluppatore di livello intermedio che mi piace

System.ComponentModel.EditorBrowsableAttribute Mi permette di nascondere le proprietà in modo che lo sviluppatore dell'interfaccia utente non sia sopraffatto dalle proprietà che non devono vedere.

System.ComponentModel.BindableAttributeAlcune cose non hanno bisogno di essere databound. Ancora una volta, riduce il lavoro che gli sviluppatori dell'interfaccia utente devono fare.

Mi piace anche il DefaultValue quello menzionato da Lawrence Johnston.

System.ComponentModel.BrowsableAttribute e il Flags sono usati regolarmente.

Io uso System.STAThreadAttribute System.ThreadStaticAttribute quando necessario.

A proposito. I questi sono altrettanto preziosi per tutti gli sviluppatori di framework .Net.

[EditorBrowsable(EditorBrowsableState.Never)]consente di nascondere proprietà e metodi da IntelliSense se il progetto non è nella soluzione. Molto utile per nascondere flussi non validi per interfacce fluide. Quanto spesso vuoi GetHashCode () o Equals ()?

Perché MVC [ActionName("Name")]ti consente di avere un'azione Ottieni e Pubblica azione con la stessa firma del metodo o di utilizzare trattini nel nome dell'azione, che altrimenti non sarebbe possibile senza creare un percorso per esso.

Ritengo sia importante menzionare qui che anche i seguenti attributi sono molto importanti:

STAThreadAttribute 

Indica che il modello di threading COM per un'applicazione è l'appartamento a thread singolo (STA).

Ad esempio questo attributo viene utilizzato nelle applicazioni Windows Form:

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

E anche ...

SuppressMessageAttribute

Sopprime la segnalazione di una specifica violazione delle regole dello strumento di analisi statica, consentendo più soppressioni su un singolo artefatto di codice.

Per esempio:

[SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "isChecked")]
[SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "fileIdentifier")]
static void FileNode(string name, bool isChecked)
{
    string fileIdentifier = name;
    string fileName = name;
    string version = String.Empty;
}

In cima alla mia testa, ecco un breve elenco, approssimativamente ordinato in base alla frequenza d'uso, di attributi predefiniti che effettivamente uso in un grande progetto (~ 500k LoC):

Flag, serializzabili, WebMethod, COMVisible, TypeConverter, Conditional, ThreadStatic, Obsolete, InternVisibleTo, DebuggerStepThrough.

Genero classe di entità dati tramite CodeSmith e utilizzo gli attributi per alcune routine di convalida. Ecco un esempio:

/// <summary>
/// Firm ID
/// </summary>
[ChineseDescription("送样单位编号")]
[ValidRequired()]
public string FirmGUID
{
    get { return _firmGUID; }
    set { _firmGUID = value; }
}

E ho ottenuto una classe di utilità per eseguire la convalida in base agli attributi associati alla classe di entità dati. Ecco il codice:

namespace Reform.Water.Business.Common
{
/// <summary>
/// Validation Utility
/// </summary>
public static class ValidationUtility
{
    /// <summary>
    /// Data entity validation
    /// </summary>
    /// <param name="data">Data entity object</param>
    /// <returns>return true if the object is valid, otherwise return false</returns>
    public static bool Validate(object data)
    {
        bool result = true;
        PropertyInfo[] properties = data.GetType().GetProperties();
        foreach (PropertyInfo p in properties)
        {
            //Length validatioin
            Attribute attribute = Attribute.GetCustomAttribute(p,typeof(ValidLengthAttribute), false);
            if (attribute != null)
            {
                ValidLengthAttribute validLengthAttribute = attribute as ValidLengthAttribute;
                if (validLengthAttribute != null)
                {
                    int maxLength = validLengthAttribute.MaxLength;
                    int minLength = validLengthAttribute.MinLength;
                    string stringValue = p.GetValue(data, null).ToString();
                    if (stringValue.Length < minLength || stringValue.Length > maxLength)
                    {
                        return false;
                    }
                }
            }
            //Range validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRangeAttribute), false);
            if (attribute != null)
            {
                ValidRangeAttribute validRangeAttribute = attribute as ValidRangeAttribute;
                if (validRangeAttribute != null)
                {
                    decimal maxValue = decimal.MaxValue;
                    decimal minValue = decimal.MinValue;
                    decimal.TryParse(validRangeAttribute.MaxValueString, out maxValue);
                    decimal.TryParse(validRangeAttribute.MinValueString, out minValue);
                    decimal decimalValue = 0;
                    decimal.TryParse(p.GetValue(data, null).ToString(), out decimalValue);
                    if (decimalValue < minValue || decimalValue > maxValue)
                    {
                        return false;
                    }
                }
            }
            //Regex validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRegExAttribute), false);
            if (attribute != null)
            {
                ValidRegExAttribute validRegExAttribute = attribute as ValidRegExAttribute;
                if (validRegExAttribute != null)
                {
                    string objectStringValue = p.GetValue(data, null).ToString();
                    string regExString = validRegExAttribute.RegExString;
                    Regex regEx = new Regex(regExString);
                    if (regEx.Match(objectStringValue) == null)
                    {
                        return false;
                    }
                }
            }
            //Required field validation
            attribute = Attribute.GetCustomAttribute(p,typeof(ValidRequiredAttribute), false);
            if (attribute != null)
            {
                ValidRequiredAttribute validRequiredAttribute = attribute as ValidRequiredAttribute;
                if (validRequiredAttribute != null)
                {
                    object requiredPropertyValue = p.GetValue(data, null);
                    if (requiredPropertyValue == null || string.IsNullOrEmpty(requiredPropertyValue.ToString()))
                    {
                        return false;
                    }
                }
            }
        }
        return result;
    }
}
}

[DeploymentItem("myFile1.txt")] Documento MSDN su DeploymentItem

Ciò è molto utile se si esegue il test su un file o si utilizza il file come input per il test.

[System.Security.Permissions.PermissionSetAttribute] consente azioni di sicurezza per un PermissionSet da applicare al codice usando la sicurezza dichiarativa.

// usage:
public class FullConditionUITypeEditor : UITypeEditor
{
    // The immediate caller is required to have been granted the FullTrust permission.
    [PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
    public FullConditionUITypeEditor() { }
}