Nützlichste Attribute [geschlossen]

Ich weiß, dass Attribute äußerst nützlich sind. Es gibt einige vordefinierte, mit [Browsable(false)]denen Sie Eigenschaften auf der Registerkarte Eigenschaften ausblenden können. Hier ist eine gute Frage zur Erklärung von Attributen: Was sind Attribute in .NET?

Welche vordefinierten Attribute (und deren Namespace) verwenden Sie tatsächlich in Ihren Projekten?

[DebuggerDisplay]Dies kann sehr hilfreich sein, um die angepasste Ausgabe eines Typs schnell anzuzeigen, wenn Sie beim Debuggen mit der Maus über die Instanz des Typs fahren. Beispiel:

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

So sollte es im Debugger aussehen:

Erwähnenswert ist auch, dass ein [WebMethod]Attribut mit CacheDurationEigenschaftssatz eine unnötige Ausführung der Webdienstmethode vermeiden kann.

System.Obsoleteist meiner Meinung nach eines der nützlichsten Attribute im Framework. Die Möglichkeit, eine Warnung über Code auszulösen, der nicht mehr verwendet werden sollte, ist sehr nützlich. Ich mag es, Entwicklern zu sagen, dass etwas nicht mehr verwendet werden sollte, und zu erklären, warum und auf die bessere / neue Art hinzuweisen, etwas zu tun.

Das Conditional attributeist auch ziemlich praktisch für die Debug-Verwendung. Sie können Ihrem Code Methoden für Debug-Zwecke hinzufügen, die beim Erstellen Ihrer Release-Lösung nicht kompiliert werden.

Dann gibt es viele Attribute, die für Web Controls spezifisch sind und die ich nützlich finde, aber diese sind spezifischer und haben keine Verwendung außerhalb der Entwicklung von Server Controls, die ich gefunden habe.

[Flags]ist ziemlich praktisch. Syntaktischer Zucker zwar, aber immer noch ziemlich schön.

[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 weist darauf hin , etwas , das ich nicht erkannt hatte, und die eher dämpft meine Begeisterung für dieses Attribut: es funktioniert nicht anweisen , den Compiler Bit - Kombinationen als gültige Werte für Aufzählungs Variablen zu ermöglichen, der Compiler dies unabhängig für Aufzählungen ermöglicht. Mein C ++ - Hintergrund zeigt sich durch ... seufz

Ich mag [DebuggerStepThrough]von System.Diagnostics .

Dies ist sehr praktisch, um zu vermeiden, dass Sie in diese einzeiligen Do-Nothing-Methoden oder -Eigenschaften eintreten (wenn Sie gezwungen sind, in einem frühen .Net ohne automatische Eigenschaften zu arbeiten). Wenn Sie das Attribut auf eine kurze Methode oder den Getter oder Setter einer Eigenschaft setzen, fliegen Sie direkt vorbei, selbst wenn Sie im Debugger auf "step into" klicken.

Hier ist eine Liste aller .NET-Attribute . Es gibt mehrere hundert.

Ich weiß von niemand anderem, aber ich habe ernsthaftes RTFM zu tun!

Meine Stimme wäre für Conditional

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

Sie können dies verwenden, um eine Funktion mit erweiterten Debugging-Funktionen hinzuzufügen. wie Debug.Writeist es nur genannt in Debug - Builds, und so können Sie komplexe Debug - Logik außerhalb der Hauptströmung des Programms verkapseln.

Ich benutze immer das DisplayName, Descriptionund DefaultValueAttribute über öffentliche Eigenschaften meiner Benutzersteuerungen, benutzerdefinierten Steuerelemente oder jede Klasse I durch einen Eigenschaftenraster bearbeiten werden. Diese Tags werden vom .NET PropertyGrid verwendet, um den Namen, das Beschreibungsfeld und fettgedruckte Werte zu formatieren, die nicht auf die Standardwerte festgelegt sind.

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

Ich wünschte nur, IntelliSense von Visual Studio würde das DescriptionAttribut berücksichtigen, wenn kein XML-Kommentar gefunden wird. Es würde vermeiden, denselben Satz zweimal wiederholen zu müssen.

[Serializable]wird ständig zum Serialisieren und Deserialisieren von Objekten zu und von externen Datenquellen wie XML oder von einem Remote-Server verwendet. Mehr dazu hier.

Im Hofstadtschen Geist ist das [Attribute]Attribut sehr nützlich, da Sie so Ihre eigenen Attribute erstellen. Ich habe Attribute anstelle von Schnittstellen verwendet, um Plugin-Systeme zu implementieren, Beschreibungen zu Enums hinzuzufügen, mehrere Versendungen und andere Tricks zu simulieren.

Hier ist der Beitrag über das interessante Attribut InternalsVisibleTo . Grundsätzlich ahmt es die Zugriffsfunktionen von C ++ - Freunden nach. Es ist sehr praktisch für Unit-Tests.

Ich habe festgestellt [DefaultValue], dass es sehr nützlich ist.

Ich würde vorschlagen [TestFixture]und [Test]- aus der nUnit- Bibliothek.

Unit-Tests in Ihrem Code bieten Sicherheit beim Refactoring und bei der kodifizierten Dokumentation.

[XmlIgnore]

Auf diese Weise können Sie (in jeder XML-Serialisierung) übergeordnete Objekte ignorieren, die sonst beim Speichern Ausnahmen verursachen würden.

Es ist nicht gut benannt, wird im Framework nicht gut unterstützt und sollte keinen Parameter erfordern, aber dieses Attribut ist ein nützlicher Marker für unveränderliche Klassen:

[ImmutableObject(true)]

Ich verwende das [ThreadStatic]Attribut gerne in Kombination mit Thread- und Stack-basierter Programmierung. Wenn ich beispielsweise einen Wert möchte, den ich mit dem Rest einer Anrufsequenz teilen möchte, der jedoch außerhalb des Bandes ausgeführt werden soll (dh außerhalb der Aufrufparameter), kann ich so etwas verwenden.

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

Später in meinem Code kann ich dies verwenden, um kontextbezogenen Kontextinformationen für Personen bereitzustellen, die meinem Code nachgeschaltet sind. Beispiel:

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

Mit dem ThreadStatic-Attribut kann ich den Aufruf nur auf den betreffenden Thread beschränken, um das unordentliche Problem des Datenzugriffs über Threads hinweg zu vermeiden.

Das DebuggerHiddenAttribute , mit dem das Eindringen in Code vermieden werden kann, der nicht debuggt werden sollte.

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

Außerdem wird verhindert, dass Methoden in der Stapelverfolgung angezeigt werden. Dies ist nützlich, wenn eine Methode nur eine andere Methode umschließt:

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

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

Wenn Sie jetzt aufrufen GetElementAt(new Vector2(10, 10))und bei der umschlossenen Methode ein Fehler auftritt, zeigt der Aufrufstapel nicht die Methode an, die die Methode aufruft, die den Fehler auslöst.

DesignerSerializationVisibilityAttributeist sehr nützlich. Wenn Sie eine Runtime-Eigenschaft in ein Steuerelement oder eine Komponente einfügen und nicht möchten, dass der Designer sie serialisiert, verwenden Sie sie wie folgt:

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

Nur wenige Attribute erhalten Compiler-Unterstützung, aber eine sehr interessante Verwendung von Attributen ist in AOP: PostSharp verwendet Ihre maßgeschneiderten Attribute, um IL in Methoden einzufügen , sodass alle Arten von Fähigkeiten möglich sind ... log / trace sind triviale Beispiele - aber einige andere gute Beispiele sind Dinge wie die automatische INotifyPropertyChanged-Implementierung ( hier ).

Einige, die auftreten und direkt auf den Compiler oder die Laufzeit auswirken :

• [Conditional("FOO")] - Aufrufe dieser Methode (einschließlich Argumentauswertung) erfolgen nur, wenn das Symbol "FOO" während der Erstellung definiert wird
• [MethodImpl(...)] - wird verwendet, um ein paar Dinge wie Synchronisation, Inlining anzuzeigen
• [PrincipalPermission(...)] - wird verwendet, um Sicherheitsüberprüfungen automatisch in den Code einzufügen
• [TypeForwardedTo(...)]- Wird verwendet, um Typen zwischen Assemblys zu verschieben, ohne die Aufrufer neu zu erstellen

Für Dinge, die manuell durch Reflexion überprüft werden - ich bin ein großer Fan der System.ComponentModelAttribute; Dinge wie [TypeDescriptionProvider(...)], [TypeConverter(...)]und [Editor(...)]die das Verhalten von Typen in Datenbindungsszenarien (dh dynamische Eigenschaften usw.) vollständig ändern können.

Wenn ich einen Crawl zur Codeabdeckung durchführen würde, wären diese beiden meiner Meinung nach die besten:

 [Serializable]
 [WebMethod]

Ich habe das in [DataObjectMethod]letzter Zeit benutzt. Es beschreibt die Methode, damit Sie Ihre Klasse mit der ObjectDataSource (oder anderen Steuerelementen) verwenden können.

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

Mehr Info

In unserem aktuellen Projekt verwenden wir

[ComVisible(false)]

Es steuert den Zugriff eines einzelnen verwalteten Typs oder Mitglieds oder aller Typen innerhalb einer Assembly auf COM.

Mehr Info

[TypeConverter(typeof(ExpandableObjectConverter))]

Weist den Designer an, die Eigenschaften zu erweitern, die Klassen (Ihres Steuerelements) sind.

[Obfuscation]

Weist Verschleierungswerkzeuge an, die angegebenen Aktionen für eine Baugruppe, einen Typ oder ein Element auszuführen. (Obwohl Sie normalerweise eine Assembly-Ebene verwenden[assembly:ObfuscateAssemblyAttribute(true)]

Die Attribute, die ich am häufigsten verwende, beziehen sich auf die XML-Serialisierung.

XmlRoot

XmlElement

XmlAttribute

usw...

Sehr nützlich, wenn Sie schnell und schmutzig XML analysieren oder serialisieren möchten.

Als mittelständischer Entwickler mag ich

System.ComponentModel.EditorBrowsableAttribute Ermöglicht es mir, Eigenschaften auszublenden, damit der UI-Entwickler nicht mit Eigenschaften überfordert ist, die er nicht sehen muss.

System.ComponentModel.BindableAttributeEinige Dinge müssen nicht datengebunden sein. Dies verringert wiederum die Arbeit, die die Benutzeroberflächenentwickler leisten müssen.

Ich mag auch das DefaultValue, was Lawrence Johnston erwähnt hat.

System.ComponentModel.BrowsableAttributeund die Flagswerden regelmäßig verwendet.

Ich benutze System.STAThreadAttribute System.ThreadStaticAttribute bei Bedarf.

Apropos. Ich diese sind für alle .NET Framework-Entwickler genauso wertvoll.

[EditorBrowsable(EditorBrowsableState.Never)]Mit dieser Option können Sie Eigenschaften und Methoden in IntelliSense ausblenden, wenn sich das Projekt nicht in Ihrer Lösung befindet. Sehr hilfreich, um ungültige Flows für fließende Schnittstellen zu verbergen. Wie oft möchten Sie GetHashCode () oder Equals ()?

Mit MVC [ActionName("Name")]können Sie eine Get-Aktion und eine Post-Aktion mit derselben Methodensignatur ausführen oder Bindestriche im Aktionsnamen verwenden, die sonst nicht möglich wären, ohne eine Route dafür zu erstellen.

Ich halte es für wichtig, hier zu erwähnen, dass die folgenden Attribute ebenfalls sehr wichtig sind:

STAThreadAttribute 

Gibt an, dass das COM-Threading-Modell für eine Anwendung Single-Threaded-Apartment (STA) ist.

Dieses Attribut wird beispielsweise in Windows Forms-Anwendungen verwendet:

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

Und auch ...

SuppressMessageAttribute

Unterdrückt die Meldung einer bestimmten Regelverletzung durch ein statisches Analysetool und ermöglicht die mehrfache Unterdrückung eines einzelnen Code-Artefakts.

Zum Beispiel:

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

Hier ist eine kurze Liste der vordefinierten Attribute, die ich tatsächlich in einem großen Projekt verwende (~ 500.000 LoCs), grob sortiert nach Verwendungshäufigkeit:

Flags, Serializable, WebMethod, COMVisible, TypeConverter, Conditional, ThreadStatic, Obsolete, InternalsVisibleTo, DebuggerStepThrough.

Ich generiere eine Datenentitätsklasse über CodeSmith und verwende Attribute für eine Validierungsroutine. Hier ist ein Beispiel:

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

Und ich habe eine Utility-Klasse für die Validierung basierend auf den Attributen, die an die Datenentitätsklasse angehängt sind. Hier ist der Code:

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")] MSDN Doc on DeploymentItem

Dies ist sehr nützlich, wenn Sie anhand einer Datei testen oder die Datei als Eingabe für Ihren Test verwenden.

[System.Security.Permissions.PermissionSetAttribute] Ermöglicht die Anwendung von Sicherheitsaktionen für ein PermissionSet auf Code mithilfe deklarativer Sicherheit.

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