Atributos mais úteis [fechado]

Eu sei que os atributos são extremamente úteis. Existem alguns predefinidos, como o [Browsable(false)]que permite ocultar propriedades na guia de propriedades. Aqui está uma boa pergunta para explicar os atributos: O que são atributos no .NET?

Quais são os atributos predefinidos (e seu espaço para nome) que você realmente usa em seus projetos?

[DebuggerDisplay]pode ser realmente útil ver rapidamente a saída personalizada de um Type quando você passa o mouse sobre a instância do Type durante a depuração. exemplo:

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

É assim que deve aparecer no depurador:

Além disso, vale ressaltar que o [WebMethod]atributo com CacheDurationconjunto de propriedades pode evitar a execução desnecessária do método de serviço da web.

System.Obsoleteé um dos atributos mais úteis na estrutura, na minha opinião. A capacidade de emitir um aviso sobre código que não deve mais ser usado é muito útil. Adoro ter uma maneira de dizer aos desenvolvedores que algo não deve mais ser usado, além de explicar o porquê e apontar a melhor / nova maneira de fazer alguma coisa.

Também Conditional attributeé bastante útil para o uso de depuração. Ele permite que você adicione métodos no seu código para fins de depuração que não serão compilados quando você criar sua solução para lançamento.

Existem muitos atributos específicos dos controles da Web que considero úteis, mas esses são mais específicos e não têm nenhum uso fora do desenvolvimento dos controles do servidor, conforme descobri.

[Flags]é bastante útil. Açúcar sintático, com certeza, mas ainda assim bastante agradável.

[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 aponta algo que eu não tinha percebido e que diminui meu entusiasmo por esse atributo: ele não instrui o compilador a permitir combinações de bits como valores válidos para variáveis ​​de enumeração, o compilador permite isso de enumerações independentemente. Meu plano de fundo em C ++ mostrando através de ... suspiro

Eu gosto [DebuggerStepThrough]de System.Diagnostics .

É muito útil para evitar a invasão de métodos ou propriedades de uma linha sem fazer nada (se você for forçado a trabalhar em um .Net inicial sem propriedades automáticas). Coloque o atributo em um método curto ou no getter ou setter de uma propriedade, e você voará direto mesmo quando pressionar "entrar" no depurador.

Para o que vale, aqui está uma lista de todos os atributos do .NET . Existem várias centenas.

Não conheço mais ninguém, mas tenho um RTFM sério para fazer!

Meu voto seria para Conditional

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

Você pode usar isso para adicionar uma função com recursos avançados de depuração; como Debug.Write, é chamado apenas em compilações de depuração e, portanto, permite que você encapsule lógica de depuração complexa fora do fluxo principal do seu programa.

Eu sempre uso os atributos DisplayName, Descriptione DefaultValuenas propriedades públicas dos meus controles de usuário, controles personalizados ou qualquer classe que editarei através de uma grade de propriedades. Essas tags são usadas pelo .NET PropertyGrid para formatar o nome, o painel de descrição e os valores em negrito que não estão definidos para os valores padrão.

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

Eu só gostaria que o IntelliSense do Visual Studio levasse o Descriptionatributo em consideração se nenhum comentário XML fosse encontrado. Evitaria ter que repetir a mesma frase duas vezes.

[Serializable]é usado o tempo todo para serializar e desserializar objetos de e para fontes de dados externas, como xml ou de um servidor remoto. Mais sobre isso aqui.

No espírito Hofstadt, o [Attribute]atributo é muito útil, pois é assim que você cria seus próprios atributos. Eu usei atributos em vez de interfaces para implementar sistemas de plugins, adicionar descrições ao Enums, simular vários despachos e outros truques.

Aqui está o post sobre o interessante atributo InternalsVisibleTo . Basicamente, o que ele faz simula a funcionalidade de acesso a amigos em C ++. É muito útil para testes de unidade.

Eu achei [DefaultValue]bastante útil.

Eu sugiro [TestFixture]e [Test]- da biblioteca nUnit .

Os testes de unidade no seu código fornecem segurança na refatoração e na documentação codificada.

[XmlIgnore]

pois isso permite que você ignore (em qualquer serialização xml) objetos 'pai' que de outra forma causariam exceções ao salvar.

Não é bem nomeado, não é bem suportado na estrutura e não deve exigir um parâmetro, mas esse atributo é um marcador útil para classes imutáveis:

[ImmutableObject(true)]

Eu gosto de usar o [ThreadStatic]atributo em combinação com programação baseada em thread e pilha. Por exemplo, se eu quero um valor que quero compartilhar com o restante de uma sequência de chamadas, mas quero fazê-lo fora da banda (ou seja, fora dos parâmetros de chamada), posso empregar algo assim.

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

Posteriormente no meu código, eu posso usá-lo para fornecer informações contextuais fora da banda para as pessoas a jusante do meu código. Exemplo:

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

O atributo ThreadStatic permite que eu faça o escopo da chamada apenas para o segmento em questão, evitando o problema confuso do acesso a dados entre segmentos.

O DebuggerHiddenAttribute que permite evitar a etapa do código que não deve ser depurado.

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

Também impede a exibição de métodos no rastreamento de pilha, útil ao ter um método que apenas envolve outro método:

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

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

Se você chamar agora GetElementAt(new Vector2(10, 10))e ocorrer um erro no método agrupado, a pilha de chamadas não mostrará o método que está chamando o método que gera o erro.

DesignerSerializationVisibilityAttributeé muito útil. Quando você coloca uma propriedade de tempo de execução em um controle ou componente e não deseja que o designer a serialize, use-a assim:

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

Apenas alguns atributos recebem suporte do compilador, mas um uso muito interessante de atributos está no AOP: o PostSharp usa seus atributos personalizados para injetar IL nos métodos, permitindo que todo tipo de habilidades ... log / trace sejam exemplos triviais - mas outros bons exemplos são coisas como a implementação automática de INotifyPropertyChanged ( aqui ).

Algumas que ocorrem e afetam diretamente o compilador ou o tempo de execução :

• [Conditional("FOO")] - as chamadas para esse método (incluindo avaliação de argumentos) só ocorrem se o símbolo "FOO" for definido durante a compilação
• [MethodImpl(...)] - usado para indicar algumas coisas como sincronização, inlining
• [PrincipalPermission(...)] - usado para injetar verificações de segurança no código automaticamente
• [TypeForwardedTo(...)]- usado para mover tipos entre montagens sem reconstruir os chamadores

Para coisas que são verificadas manualmente via reflexão - eu sou um grande fã dos System.ComponentModelatributos; coisas como [TypeDescriptionProvider(...)], [TypeConverter(...)]e [Editor(...)]que podem alterar completamente o comportamento de tipos em cenários de ligação de dados (ou seja, propriedades dinâmicas, etc).

Se eu fizesse um rastreamento de cobertura de código, acho que esses dois seriam os principais:

 [Serializable]
 [WebMethod]

Eu tenho usado o [DataObjectMethod]ultimamente. Ele descreve o método para que você possa usar sua classe com o ObjectDataSource (ou outros controles).

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

Mais informações

Em nosso projeto atual, usamos

[ComVisible(false)]

Controla a acessibilidade de um tipo ou membro gerenciado individual ou de todos os tipos em um assembly ao COM.

Mais informações

[TypeConverter(typeof(ExpandableObjectConverter))]

Diz ao designer para expandir as propriedades que são classes (de seu controle)

[Obfuscation]

Instrui as ferramentas de ofuscação a executar as ações especificadas para uma montagem, tipo ou membro. (Embora normalmente você use um nível de montagem[assembly:ObfuscateAssemblyAttribute(true)]

Os atributos que eu mais uso são os relacionados à serialização de XML.

XmlRoot

XmlElement

XmlAttribute

etc ...

Extremamente útil ao realizar qualquer análise ou serialização XML rápida e suja.

Sendo um desenvolvedor de nível intermediário, eu gosto

System.ComponentModel.EditorBrowsableAttribute Permite ocultar propriedades para que o desenvolvedor da interface do usuário não fique sobrecarregado com propriedades que eles não precisam ver.

System.ComponentModel.BindableAttributeAlgumas coisas não precisam ser vinculadas. Novamente, diminui o trabalho que os desenvolvedores da interface do usuário precisam fazer.

Também gosto do DefaultValueque Lawrence Johnston mencionou.

System.ComponentModel.BrowsableAttributee Flagssão usados ​​regularmente.

Eu uso System.STAThreadAttribute System.ThreadStaticAttribute quando necessário.

A propósito. Estes são igualmente valiosos para todos os desenvolvedores de framework .Net.

[EditorBrowsable(EditorBrowsableState.Never)]permite ocultar propriedades e métodos do IntelliSense se o projeto não estiver em sua solução. Muito útil para ocultar fluxos inválidos para interfaces fluentes. Com que frequência você deseja GetHashCode () ou Equals ()?

Para o MVC, [ActionName("Name")]você pode ter uma ação Get e Post action com a mesma assinatura de método, ou usar traços no nome da ação, o que de outra forma não seria possível sem a criação de uma rota para ela.

Considero importante mencionar aqui que os seguintes atributos também são muito importantes:

STAThreadAttribute 

Indica que o modelo de encadeamento COM para um aplicativo é STA (single-threaded apartment).

Por exemplo, este atributo é usado no Windows Forms Applications:

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 também ...

SuppressMessageAttribute

Suprime o relatório de uma violação específica da regra da ferramenta de análise estática, permitindo várias supressões em um único artefato de código.

Por exemplo:

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

Em primeiro lugar, aqui está uma lista rápida, mais ou menos classificada por frequência de uso, de atributos predefinidos que eu realmente uso em um grande projeto (~ 500k LoCs):

Sinalizadores, Serializáveis, WebMethod, COMVisible, TypeConverter, Condicional, ThreadStatic, Obsoleto, InternalsVisibleTo, DebuggerStepThrough.

Gero classe de entidade de dados via CodeSmith e uso atributos para alguma rotina de validação. Aqui está um exemplo:

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

E eu tenho uma classe de utilitário para fazer a validação com base nos atributos anexados à classe de entidade de dados. Aqui está o código:

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 do MSDN sobre DeploymentItem

Isso é realmente útil se você estiver testando em um arquivo ou usando o arquivo como entrada para o seu teste.

[System.Security.Permissions.PermissionSetAttribute] permite que ações de segurança para um PermissionSet sejam aplicadas ao código usando segurança declarativa.

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