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

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

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

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

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

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

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

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

[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 ++ просвечивает ... вздох

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

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

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

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

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

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

Я всегда использую атрибуты 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-комментарий не найден. Это позволило бы избежать повторения одного и того же предложения дважды.

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

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

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

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

Я бы предложил [TestFixture] и [Test] - из библиотеки nUnit.

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

[XmlIgnore]

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

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

[ImmutableObject(true)]

Мне нравится использовать атрибут [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 позволяет мне ограничивать вызов только рассматриваемым потоком, избегая запутанной проблемы доступа к данным между потоками.

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)) и в обернутом методе возникает ошибка, стек вызовов не показывает метод, который вызывает метод, который вызывает ошибку.

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

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

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

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

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

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

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

 [Serializable]
 [WebMethod]

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

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

Дополнительная информация

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

[ComVisible(false)]

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

Дополнительная информация

[TypeConverter(typeof(ExpandableObjectConverter))]

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

[Obfuscation]

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

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

XmlRoot

XmlElement

XmlAttribute

и т.д...

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

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

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

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

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

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

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

Кстати. Я не менее ценен для всех разработчиков фреймворка .Net.

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

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

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

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

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

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

Я генерирую класс сущности данных через 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;
    }
}
}

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

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

[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() { }
}

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

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

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