Attributs les plus utiles [fermé]

Je sais que les attributs sont extrêmement utiles. Il y en a des prédéfinies, telles que celles [Browsable(false)]qui vous permettent de masquer les propriétés dans l'onglet Propriétés. Voici une bonne question expliquant les attributs: Que sont les attributs dans .NET?

Quels sont les attributs prédéfinis (et leur espace de noms) que vous utilisez réellement dans vos projets?

[DebuggerDisplay]peut être très utile pour voir rapidement la sortie personnalisée d'un type lorsque vous passez la souris sur l'instance du type pendant le débogage. exemple:

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

Voici à quoi cela devrait ressembler dans le débogueur:

En outre, il convient de mentionner que l' [WebMethod]attribut avec le CacheDurationjeu de propriétés peut éviter l'exécution inutile de la méthode de service Web.

System.Obsoleteest l'un des attributs les plus utiles dans le cadre, à mon avis. La possibilité de déclencher un avertissement concernant le code qui ne devrait plus être utilisé est très utile. J'adore avoir un moyen de dire aux développeurs que quelque chose ne devrait plus être utilisé, ainsi que d'avoir un moyen d'expliquer pourquoi et de pointer vers la meilleure / nouvelle façon de faire quelque chose.

Le Conditional attributeest également très pratique pour l'utilisation du débogage. Il vous permet d'ajouter des méthodes dans votre code à des fins de débogage qui ne seront pas compilées lorsque vous générez votre solution pour publication.

Ensuite, il y a beaucoup d'attributs spécifiques aux contrôles Web que je trouve utiles, mais ils sont plus spécifiques et n'ont aucune utilisation en dehors du développement des contrôles serveur à partir de ce que j'ai trouvé.

[Flags]est assez pratique. Sucre syntaxique certes, mais quand même plutôt sympa.

[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 souligne quelque chose que je n'avais pas réalisé, et qui atténue plutôt mon enthousiasme pour cet attribut: il n'indique pas au compilateur d'autoriser les combinaisons de bits comme valeurs valides pour les variables d'énumération, le compilateur autorise cela pour les énumérations malgré tout. Mon arrière-plan C ++ à travers ... soupir

J'aime [DebuggerStepThrough]de System.Diagnostics .

C'est très pratique pour éviter de pénétrer dans ces méthodes ou propriétés d'une ligne de ne rien faire (si vous êtes obligé de travailler dans un .Net précoce sans propriétés automatiques). Mettez l'attribut sur une méthode courte ou sur le getter ou le setter d'une propriété, et vous volerez à droite même en appuyant sur "step into" dans le débogueur.

Pour ce que ça vaut, voici une liste de tous les attributs .NET . Il y en a plusieurs centaines.

Je ne connais personne d'autre mais j'ai de la RTFM sérieuse à faire!

Mon vote serait pour Conditional

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

Vous pouvez l'utiliser pour ajouter une fonction avec des fonctionnalités de débogage avancées; comme Debug.Write, il est uniquement appelé dans les versions de débogage, et vous permet donc d'encapsuler une logique de débogage complexe en dehors du flux principal de votre programme.

Je l' utilise toujours DisplayName, Descriptionet les DefaultValueattributs sur les propriétés publiques de mes contrôles utilisateur, les contrôles personnalisés ou toute catégorie , je vais modifier à travers une grille de la propriété. Ces balises sont utilisées par le .NET PropertyGrid pour formater le nom, le panneau de description et les valeurs en gras qui ne sont pas définies sur les valeurs par défaut.

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

Je souhaite juste que IntelliSense de Visual Studio prenne Descriptionen compte l' attribut si aucun commentaire XML n'est trouvé. Cela éviterait d'avoir à répéter deux fois la même phrase.

[Serializable]est utilisé tout le temps pour sérialiser et désérialiser des objets vers et depuis des sources de données externes telles que xml ou depuis un serveur distant. Plus d'informations ici.

Dans l'esprit hofstadtien, l' [Attribute]attribut est très utile, car c'est ainsi que vous créez vos propres attributs. J'ai utilisé des attributs au lieu d'interfaces pour implémenter des systèmes de plugins, ajouter des descriptions à Enums, simuler plusieurs répartitions et autres astuces.

Voici le post sur l'attribut intéressant InternalsVisibleTo . Fondamentalement, il imite la fonctionnalité d'accès aux amis C ++. Il est très pratique pour les tests unitaires.

Je l'ai trouvé [DefaultValue]très utile.

Je suggère [TestFixture]et [Test]- de la bibliothèque nUnit .

Les tests unitaires dans votre code offrent une sécurité dans la refactorisation et la documentation codifiée.

[XmlIgnore]

car cela vous permet d'ignorer (dans toute sérialisation xml) les objets «parents» qui provoqueraient autrement des exceptions lors de l'enregistrement.

Il n'est pas bien nommé, n'est pas bien pris en charge dans le cadre et ne devrait pas nécessiter de paramètre, mais cet attribut est un marqueur utile pour les classes immuables:

[ImmutableObject(true)]

J'aime utiliser l' [ThreadStatic]attribut en combinaison avec la programmation basée sur les threads et la pile. Par exemple, si je veux une valeur que je veux partager avec le reste d'une séquence d'appel, mais que je veux le faire hors bande (c'est-à-dire en dehors des paramètres d'appel), je pourrais utiliser quelque chose comme ça.

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

Plus loin dans mon code, je peux l'utiliser pour fournir des informations contextuelles hors bande aux personnes en aval de mon code. Exemple:

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

L'attribut ThreadStatic me permet d'étendre l'appel uniquement au thread en question en évitant le problème compliqué d'accès aux données entre les threads.

Le DebuggerHiddenAttribute qui permet d'éviter d'entrer dans le code qui ne doit pas être débogué.

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

Cela empêche également d'afficher les méthodes dans la trace de la pile, utile lorsque vous disposez d'une méthode qui encapsule simplement une autre méthode:

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

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

Si vous appelez maintenant GetElementAt(new Vector2(10, 10))et qu'une erreur se produit au niveau de la méthode encapsulée, la pile d'appels n'affiche pas la méthode qui appelle la méthode qui renvoie l'erreur.

DesignerSerializationVisibilityAttributeest très utile. Lorsque vous placez une propriété d'exécution sur un contrôle ou un composant et que vous ne voulez pas que le concepteur la sérialise, vous l'utilisez comme ceci:

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

Seuls quelques attributs sont pris en charge par le compilateur, mais une utilisation très intéressante des attributs est dans AOP: PostSharp utilise vos attributs sur mesure pour injecter IL dans les méthodes, permettant toutes sortes de capacités ... log / trace étant des exemples triviaux - mais quelques autres bons exemples sont des choses comme la mise en œuvre automatique INotifyPropertyChanged ( ici ).

Certaines se produisent et ont un impact direct sur le compilateur ou le runtime :

• [Conditional("FOO")] - les appels à cette méthode (y compris l'évaluation des arguments) ne se produisent que si le symbole "FOO" est défini pendant la construction
• [MethodImpl(...)] - utilisé pour indiquer quelques éléments comme la synchronisation, l'inlining
• [PrincipalPermission(...)] - utilisé pour injecter automatiquement des contrôles de sécurité dans le code
• [TypeForwardedTo(...)]- utilisé pour déplacer les types entre les assemblys sans reconstruire les appelants

Pour les choses qui sont vérifiées manuellement par réflexion - je suis un grand fan des System.ComponentModelattributs; des choses comme [TypeDescriptionProvider(...)], [TypeConverter(...)]et [Editor(...)]qui peut complètement changer le comportement des types dans les scénarios de liaison de données ( par exemple propriétés dynamiques , etc.).

Si je devais faire une analyse de couverture de code, je pense que ces deux seraient les meilleurs:

 [Serializable]
 [WebMethod]

J'utilise ces [DataObjectMethod]derniers temps. Il décrit la méthode afin que vous puissiez utiliser votre classe avec l'ObjectDataSource (ou d'autres contrôles).

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

Plus d'informations

Dans notre projet actuel, nous utilisons

[ComVisible(false)]

Il contrôle l'accessibilité d'un COM ou d'un type géré individuel, ou de tous les types au sein d'un assembly.

Plus d'informations

[TypeConverter(typeof(ExpandableObjectConverter))]

Indique au concepteur d'étendre les propriétés qui sont des classes (de votre contrôle)

[Obfuscation]

Demande aux outils d'obscurcissement d'effectuer les actions spécifiées pour un assemblage, un type ou un membre. (Bien que vous utilisiez généralement un niveau d'assemblage[assembly:ObfuscateAssemblyAttribute(true)]

Les attributs que j'utilise le plus sont ceux liés à la sérialisation XML.

XmlRoot

XmlElement

XmlAttribute

etc...

Extrêmement utile lors de toute analyse ou sérialisation XML rapide et sale.

Être un développeur de niveau intermédiaire que j'aime

System.ComponentModel.EditorBrowsableAttribute Me permet de masquer les propriétés afin que le développeur de l'interface utilisateur ne soit pas submergé de propriétés qu'il n'a pas besoin de voir.

System.ComponentModel.BindableAttributeCertaines choses n'ont pas besoin d'être liées aux données. Encore une fois, réduit le travail que les développeurs d'interface utilisateur doivent faire.

J'aime aussi ce DefaultValueque Lawrence Johnston a mentionné.

System.ComponentModel.BrowsableAttributeet Flagssont utilisés régulièrement.

J'utilise en System.STAThreadAttribute System.ThreadStaticAttribute cas de besoin.

Au fait. Ces derniers sont tout aussi précieux pour tous les développeurs de framework .Net.

[EditorBrowsable(EditorBrowsableState.Never)]vous permet de masquer les propriétés et les méthodes d'IntelliSense si le projet n'est pas dans votre solution. Très utile pour masquer les flux invalides pour les interfaces fluides. À quelle fréquence voulez-vous GetHashCode () ou Equals ()?

Car MVC [ActionName("Name")]vous permet d'avoir une action Get et une action Post avec la même signature de méthode, ou d'utiliser des tirets dans le nom de l'action, ce qui autrement ne serait pas possible sans créer un itinéraire pour celle-ci.

Je considère qu'il est important de mentionner ici que les attributs suivants sont également très importants:

STAThreadAttribute 

Indique que le modèle de thread COM pour une application est cloisonné (STA).

Par exemple, cet attribut est utilisé dans les applications Windows Forms:

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

Et aussi ...

SuppressMessageAttribute

Supprime le signalement d'une violation de règle d'outil d'analyse statique spécifique, autorisant plusieurs suppressions sur un seul artefact de code.

Par exemple:

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

En haut de ma tête, voici une liste rapide, grossièrement triée par fréquence d'utilisation, des attributs prédéfinis que j'utilise réellement dans un grand projet (~ 500k LoCs):

Drapeaux, Sérialisable, WebMethod, COMVisible, TypeConverter, Conditionnel, ThreadStatic, Obsolete, InternalsVisibleTo, DebuggerStepThrough.

Je génère une classe d'entité de données via CodeSmith et j'utilise des attributs pour une certaine routine de validation. Voici un exemple:

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

Et j'ai obtenu une classe utilitaire pour faire la validation basée sur les attributs attachés à la classe d'entité de données. Voici le 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")] Doc MSDN sur DeploymentItem

Ceci est vraiment utile si vous testez un fichier ou utilisez le fichier comme entrée pour votre test.

[System.Security.Permissions.PermissionSetAttribute] permet d'appliquer des actions de sécurité pour un PermissionSet au code à l'aide de la sécurité déclarative.

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