c# using tag




Nützlichste Attribute (20)

Ich weiß, dass Attribute sehr nützlich sind. Es gibt einige vordefinierte [Browsable(false)] wie [Browsable(false)] denen Sie Eigenschaften auf der Registerkarte Eigenschaften ausblenden können. Hier ist eine gute Frage, die Attribute erklärt: Was sind Attribute in .NET?

Welche vordefinierten Attribute (und deren Namespace) verwenden Sie eigentlich in Ihren Projekten?


Aus der Spitze meines Kopfes, hier ist eine kurze Liste, grob nach Nutzungshäufigkeit sortiert, von vordefinierten Attributen, die ich tatsächlich in einem großen Projekt verwende (~ 500k LoCs):

Flags, Serialisierbar, WebMethod, COMVisible, Typkonverter, Bedingt, ThreadStatic, Obsolet, InternalsVisibleTo, DebuggerStepThrough.


Das DebuggerHiddenAttribute das es ermöglicht, Schritte in Code zu vermeiden, die nicht debuggt werden sollen.

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 im Stack-Trace angezeigt werden. Dies ist nützlich, wenn Sie eine Methode verwenden, die 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 nun GetElementAt(new Vector2(10, 10)) und bei der umbrochenen Methode ein Fehler auftritt, zeigt der Aufrufstack nicht die Methode an, die die Methode aufruft, die den Fehler auslöst.


Es ist nicht gut benannt, 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)]

Für was es sich lohnt, hier ist eine Liste aller .NET-Attribute . Es gibt mehrere hundert.

Ich weiß nichts über andere, aber ich habe eine ernsthafte RTFM zu tun!


Ich denke, dass es wichtig ist, hier zu erwähnen, dass die folgenden Attribute auch sehr wichtig sind:

STAThreadAttribute 

Gibt an, dass das COM-Threadingmodell für eine Anwendung ein Singlethread-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 das Melden einer spezifischen Regelverletzung für statische Analysewerkzeuge, wodurch mehrere Unterdrückungen für ein einzelnes Codeartefakt möglich sind.

Beispielsweise:

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

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, um die Validierung basierend auf den Attributen durchzuführen, 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;
    }
}
}

Ich habe die [DataObjectMethod] letzter Zeit benutzt. Es beschreibt die Methode, sodass 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


Ich mag [DebuggerStepThrough] von System.Diagnostics .

Es ist sehr praktisch, wenn Sie nicht in diese One-Line-Do-Nothing-Methoden oder -Eigenschaften eintreten (wenn Sie gezwungen sind, in einem frühen .NET ohne automatische Eigenschaften zu arbeiten). Setzen Sie das Attribut auf eine kurze Methode oder den Getter oder Setter einer Eigenschaft, und Sie fliegen sogar dann weiter, wenn Sie im Debugger auf "Step in" klicken.


Ich verwende immer die DisplayName , Description und DefaultValue für öffentliche Eigenschaften meiner Benutzersteuerelemente, benutzerdefinierten Steuerelemente oder jeder Klasse, die ich über ein Eigenschaftenraster bearbeiten werde. Diese Tags werden vom .NET-PropertyGrid verwendet, um den Namen, das Beschreibungsfeld und die fett formatierten 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, dass IntelliSense von Visual Studio das Description Attribut berücksichtigen würde, wenn kein XML-Kommentar gefunden würde. Es würde vermieden, den gleichen Satz zweimal zu wiederholen.


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

Unit Tests in Ihrem Code sorgen für Sicherheit bei Refactoring und kodierter Dokumentation.


In unserem aktuellen Projekt verwenden wir

[ComVisible(false)]

Sie steuert die Zugriffsmöglichkeit eines einzelnen verwalteten Typs oder Members oder aller Typen innerhalb einer Assembly auf COM.

Mehr Info


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 Debugfunktionen hinzuzufügen. Wie Debug.Write wird es nur in Debug-Builds aufgerufen und ermöglicht Ihnen so, komplexe Debug-Logik außerhalb des Hauptflusses Ihres Programms zu kapseln.


Wenn ich Code Coverage crawlen würde, wären diese beiden wohl die besten:

 [Serializable]
 [WebMethod]

Here ist der Post über das interessante Attribut InternalsVisibleTo . Im Grunde, was es tut, ahmt es C ++ Freunde Zugriffsfunktionalität nach. Es ist sehr praktisch für Unit-Tests.


[Flags] ist ziemlich praktisch. Syntaktischer Zucker, aber immer noch ziemlich nett.

[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 auf etwas hin, das ich nicht realisiert habe und das meine Begeisterung für dieses Attribut eher dämpft: Es weist den Compiler nicht an, Bitkombinationen als gültige Werte für Enumerationsvariablen zuzulassen, der Compiler erlaubt dies jedoch für Aufzählungen. Mein C ++ Hintergrund zeigt durch ... Seufzer


System.Obsolete ist meiner Meinung nach eines der nützlichsten Attribute im Framework. Die Möglichkeit, eine Warnung über Code zu erzeugen, der nicht mehr verwendet werden sollte, ist sehr nützlich. Ich liebe es, Entwicklern zu sagen, dass etwas nicht mehr verwendet werden sollte, und dass ich eine Möglichkeit habe, den Grund dafür zu erklären und auf die bessere / neue Art, etwas zu tun, hinzuweisen.

Das Conditional attribute ist auch sehr praktisch für die Debug-Verwendung. Es ermöglicht Ihnen, Methoden in Ihrem Code für Debugzwecke hinzuzufügen, die nicht kompiliert werden, wenn Sie Ihre Lösung für die Veröffentlichung erstellen.

Dann gibt es eine Menge von spezifischen Attributen für Web-Steuerelemente, die ich nützlich finde, aber diese sind spezifischer und haben keine Verwendung außerhalb der Entwicklung von Server-Steuerelementen von dem, was ich gefunden habe.


[DeploymentItem("myFile1.txt")] MSDN- [DeploymentItem("myFile1.txt")] zu DeploymentItem

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


[EditorBrowsable(EditorBrowsableState.Never)] können Sie Eigenschaften und Methoden aus IntelliSense ausblenden, wenn das Projekt nicht in Ihrer Lösung enthalten ist. Sehr hilfreich zum Ausblenden ungültiger Flüsse für fließende Schnittstellen. Wie oft möchten Sie GetHashCode () oder Equals ()?

Für MVC [ActionName("Name")] können Sie eine Get-Aktion und eine Post-Aktion mit der gleichen Methodensignatur verwenden oder Bindestriche im Aktionsnamen verwenden, was andernfalls nicht möglich wäre, ohne eine Route dafür zu erstellen.


[System.Security.Permissions.PermissionSetAttribute] ermöglicht Sicherheitsaktionen für ein PermissionSet, das mit deklarativer Sicherheit auf Code angewendet wird.

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





.net-attributes