Самые полезные атрибуты

[Serializable] постоянно используется для сериализации и десериализации объектов во внешние источники данных, такие как xml или с удаленного сервера, и из них. Подробнее об этом здесь.

[Flags] довольно удобен. Синтаксический сахар, конечно, но все же довольно приятный.

[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"

Леппи указывает на то, чего я не осознавал, и что скорее ослабляет мой энтузиазм по поводу этого атрибута: он дает команду нет компилятору разрешить битовые комбинации в качестве допустимых значений для переменных перечисления, компилятор позволяет это для перечислений независимо. Мой фон C++ просматривается через ... вздох

Если бы я провел сканирование покрытия кода, я думаю, что эти два были бы лучшими:

 [Serializable]
 [WebMethod]

В духе Хофштадта атрибут [Attribute] очень полезен, поскольку с его помощью вы создаете свои собственные атрибуты. Я использовал атрибуты вместо интерфейсов для реализации систем плагинов, добавления описаний в Enums, имитации множественной диспетчеризации и других трюков.

На мой взгляд, System.Obsolete - один из самых полезных атрибутов в фреймворке. Возможность выдавать предупреждение о коде, который больше не следует использовать, очень полезна. Мне нравится иметь способ сказать разработчикам, что что-то больше не следует использовать, а также иметь способ объяснить, почему и указать на лучший / новый способ что-то делать.

Conditional attribute также очень удобен для отладки. Он позволяет добавлять в код методы для отладки, которые не будут компилироваться при сборке решения для выпуска.

Кроме того, есть много атрибутов, специфичных для веб-элементов управления, которые я считаю полезными, но они более специфичны и не используются вне рамок разработки серверных элементов управления из того, что я нашел.

Как бы то ни было, вот список всех атрибутов .NET. Их несколько сотен.

Я не знаю ни о ком другом, но мне нужно серьезно заняться RTFM!

Я нашел [DefaultValue] весьма полезным.

[DebuggerDisplay] может быть действительно полезен для быстрого просмотра настроенного вывода типа при наведении указателя мыши на экземпляр типа во время отладки. пример:

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

Вот так это должно выглядеть в отладчике:

Также стоит упомянуть, что атрибут [WebMethod] с набором свойств CacheDuration позволяет избежать ненужного выполнения метода веб-службы.

Я бы посоветовал [TestFixture] и [Test] - из библиотеки nUnit.

Модульные тесты в вашем коде обеспечивают безопасность при рефакторинге и кодифицированной документации.

Мне нравится [DebuggerStepThrough] из System.Diagnostics.

Это очень удобно, чтобы избежать использования однострочных методов или свойств, которые ничего не делают (если вы вынуждены работать в раннем .Net без автоматических свойств). Поместите атрибут в короткий метод или в средство получения или установки свойства, и вы пролетите мимо, даже нажав «шаг в» в отладчике.

Как разработчик среднего уровня мне нравится

System.ComponentModel.EditorBrowsableAttribute Позволяет мне скрывать свойства, чтобы разработчик пользовательского интерфейса не был перегружен свойствами, которые им не нужно видеть.

System.ComponentModel.BindableAttribute Некоторые вещи не нужно связывать с данными. Опять же, сокращает объем работы, необходимой разработчикам пользовательского интерфейса.

Мне также нравится DefaultValue, о котором упоминал Лоуренс Джонстон.

System.ComponentModel.BrowsableAttribute и Flags используются регулярно.

я использую System.STAThreadAttribute System.ThreadStaticAttribute при необходимости.

Кстати. Они не менее ценны для всех разработчиков .Net framework.

Чаще всего я использую атрибуты, связанные с сериализацией XML.

XmlRoot

XmlElement

XmlAttribute

так далее...

Чрезвычайно полезно при выполнении любого быстрого и грязного синтаксического анализа или сериализации XML.

Компилятор поддерживает только несколько атрибутов, но одно очень интересное использование атрибутов находится в AOP: PostSharp использует ваши индивидуальные атрибуты для внедрения IL в методы, позволяя использовать всевозможные возможности ... log / trace являются тривиальными примерами, но некоторые другие хорошие примеры такие вещи, как автоматическая реализация INotifyPropertyChanged (здесь).

Некоторые из них встречаются и напрямую влиять на компилятор или среду выполнения:

• [Conditional("FOO")] - вызовы этого метода (включая оценку аргументов) происходят только в том случае, если во время сборки определен символ "FOO".
• [MethodImpl(...)] - используется для обозначения некоторых вещей, таких как синхронизация, встраивание
• [PrincipalPermission(...)] - используется для автоматической вставки проверок безопасности в код
• [TypeForwardedTo(...)] - используется для перемещения типов между сборками без перестройки звонящих

Для вещей, которые проверяются вручную через отражение - я большой поклонник атрибутов System.ComponentModel; такие вещи, как [TypeDescriptionProvider(...)], [TypeConverter(...)] и [Editor(...)], которые могут полностью изменить поведение типов в сценариях привязки данных (например, динамические свойства и т. д.).

[TypeConverter(typeof(ExpandableObjectConverter))]

Сообщает дизайнеру расширить свойства, которые являются классами (вашего контроля)

[Obfuscation]

Дает указание средствам обфускации выполнять указанные действия для сборки, типа или элемента. (хотя обычно вы используете уровень сборки [assembly:ObfuscateAssemblyAttribute(true)]

[XmlIgnore]

поскольку это позволяет игнорировать (в любой сериализации xml) «родительские» объекты, которые в противном случае могли бы вызвать исключения при сохранении.

// on configuration sections
[ConfigurationProperty] 

// in asp.net
[NotifyParentProperty(true)]

В последнее время пользуюсь [DataObjectMethod]. Он описывает метод, поэтому вы можете использовать свой класс с ObjectDataSource (или другими элементами управления).

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

Больше информации

В нашем текущем проекте мы используем

[ComVisible(false)]

Он контролирует доступность отдельного управляемого типа или члена или всех типов в сборке для COM.

Больше информации

Мне нравится использовать атрибут [ThreadStatic] в сочетании с программированием на основе потоков и стека. Например, если мне нужно значение, которым я хочу поделиться с остальной частью последовательности вызовов, но я хочу сделать это вне диапазона (т.е. вне параметров вызова), я могу использовать что-то вроде этого.

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

Позже в своем коде я могу использовать это для внеполосного предоставления контекстной информации людям, находящимся ниже по течению от моего кода. Пример:

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

Атрибут ThreadStatic позволяет мне ограничивать вызов только рассматриваемым потоком, избегая запутанной проблемы доступа к данным между потоками.

DesignerSerializationVisibilityAttribute очень полезен. Когда вы помещаете свойство среды выполнения в элемент управления или компонент и не хотите, чтобы дизайнер сериализовал его, вы используете его следующим образом:

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

Я всегда использую атрибуты DisplayName, Description и DefaultValue поверх общедоступных свойств моих пользовательских элементов управления, настраиваемых элементов управления или любого класса, который я редактирую через сетку свойств. Эти теги используются .NET PropertyGrid для форматирования имени, панели описания и значений, выделенных жирным шрифтом, для которых не заданы значения по умолчанию.

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

Я просто хочу, чтобы IntelliSense в Visual Studio учла атрибут Description, если XML-комментарий не найден. Это позволило бы избежать повторения одного и того же предложения дважды.

[System.Security.Permissions.PermissionSetAttribute] позволяет применять меры безопасности для PermissionSet к коду с использованием декларативной безопасности.

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

Здесь - пост про интересный атрибут Внутреннее устройство. В основном то, что он делает, он имитирует функциональность доступа друзей C++. Это очень удобно для модульного тестирования.

Я бы проголосовал за Conditional

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

Вы можете использовать это, чтобы добавить функцию с расширенными функциями отладки; как и Debug.Write, он вызывается только в отладочных сборках и поэтому позволяет вам инкапсулировать сложную логику отладки вне основного потока вашей программы.

Он плохо назван, плохо поддерживается во фреймворке и не требует параметра, но этот атрибут является полезным маркером для неизменяемых классов:

[ImmutableObject(true)]

[DeploymentItem("myFile1.txt")]Документ MSDN по DeploymentItem

Это действительно полезно, если вы тестируете файл или используете файл в качестве входных данных для вашего теста.

Я генерирую класс сущности данных через CodeSmith и использую атрибуты для некоторой процедуры проверки. Вот пример:

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

И у меня есть служебный класс для проверки на основе атрибутов, прикрепленных к классу сущности данных. Вот код:

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

Внезапно, вот краткий список, примерно отсортированный по частоте использования, предопределенных атрибутов, которые я действительно использую в большом проекте (~ 500k LoC):

Флаги, Сериализуемый, WebMethod, COMVisible, TypeConverter, Conditional, ThreadStatic, Obsolete, InternalsVisibleTo, DebuggerStepThrough.

[EditorBrowsable(EditorBrowsableState.Never)] позволяет скрыть свойства и методы от IntelliSense, если проект отсутствует в вашем решении. Очень полезно для сокрытия недопустимых потоков для свободных интерфейсов. Как часто вы хотите использовать GetHashCode () или Equals ()?

Для MVC [ActionName("Name")] позволяет вам иметь действия Get и Post с одной и той же сигнатурой метода или использовать тире в имени действия, что в противном случае было бы невозможно без создания для него маршрута.

Я всегда использую атрибуты, [Serializable], [WebMethod], [DefaultValue], [Description("description here")].

но кроме этого в C# есть Глобальные атрибуты.

[assembly: System.CLSCompliant(true)]
[assembly: AssemblyCulture("")]
[assembly: AssemblyDescription("")]

Я считаю важным упомянуть здесь, что следующие атрибуты также очень важны:

STAThreadAttribute 

Указывает, что модель потоков COM для приложения является однопоточным подразделением (STA).

Например, этот атрибут используется в приложениях 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());
    }
}

А также ...

SuppressMessageAttribute

Подавляет сообщение о конкретном нарушении правил инструмента статического анализа, разрешая множественное подавление одного артефакта кода.

Например:

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

DebuggerHiddenAttribute, который позволяет избежать ввода кода, который не следует отлаживать.

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

Также он предотвращает отображение методов в трассировке стека, что полезно при наличии метода, который просто обертывает другой метод:

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

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

Если теперь вы вызываете GetElementAt(new Vector2(10, 10)) и в обернутом методе возникает ошибка, стек вызовов не показывает метод, который вызывает метод, который вызывает ошибку.