Что такое атрибуты в .NET?

Метаданные. Данные о вашем objects/methods/properties.

Например, я могу объявить атрибут с именем: DisplayOrder, чтобы легко управлять тем, в каком порядке свойства должны появляться в UI. Затем я мог бы добавить его в класс и написать некоторые компоненты GUI, которые извлекают атрибуты и упорядочивают элементы UI соответствующим образом.

public class DisplayWrapper
{
    private UnderlyingClass underlyingObject;

    public DisplayWrapper(UnderlyingClass u)
    {
        underlyingObject = u;
    }

    [DisplayOrder(1)]
    public int SomeInt
    {
        get
        {
            return underlyingObject .SomeInt;
        }
    }

    [DisplayOrder(2)]
    public DateTime SomeDate
    {
        get
        {
            return underlyingObject .SomeDate;
        }
    }
}

Таким образом, гарантируя, что SomeInt всегда отображается перед SomeDate при работе с моими пользовательскими компонентами GUI.

Однако вы увидите, что они чаще всего используются вне среды прямого кодирования. Например, конструктор Windows широко использует их, поэтому он знает, как работать с заказными объектами. Используя BrowsableAttribute вот так:

[Browsable(false)]
public SomeCustomType DontShowThisInTheDesigner
{
    get{/*do something*/}
}

Например, указывает конструктору не указывать это в списке доступных свойств в окне свойств во время разработки.

Вы также можете использовать их для генерации кода, предварительная компиляция операции (например, после резкого) или во время выполнения таких операций, как Reflection.Emit. Например,вы можете написать немного кода для профилирования, который прозрачно обертывает каждый вызов, выполняемый вашим кодом, и умножает его. Вы можете "opt-out" из времени с помощью атрибута, который вы размещаете на определенных методах.

public void SomeProfilingMethod(MethodInfo targetMethod, object target, params object[] args)
{
    bool time = true;
    foreach (Attribute a in target.GetCustomAttributes())
    {
        if (a.GetType() is NoTimingAttribute)
        {
            time = false;
            break;
        }
    }
    if (time)
    {
        StopWatch stopWatch = new StopWatch();
        stopWatch.Start();
        targetMethod.Invoke(target, args);
        stopWatch.Stop();
        HandleTimingOutput(targetMethod, stopWatch.Duration);
    }
    else
    {
        targetMethod.Invoke(target, args);
    }
}

Объявить их легко, просто создайте класс, который наследует атрибут.

public class DisplayOrderAttribute : Attribute
{
    private int order;

    public DisplayOrderAttribute(int order)
    {
        this.order = order;
    }

    public int Order
    {
        get { return order; }
    }
}

И помните,что при использовании атрибута вы можете опустить суффикс "attribute", который компилятор добавит для вас.

NOTE: атрибуты сами по себе ничего не делают - должен быть какой-то другой код, который их использует. Иногда этот код был написан для вас, но иногда вы должны написать его сами. Например, компилятор C# заботится о некоторых и некоторые фреймворки используют некоторые фреймворки (например, NUnit ищет [TestFixture] в классе и [Test] в методе тестирования при загрузке assembly).
Поэтому, создавая свой собственный пользовательский атрибут, имейте в виду, что он никак не повлияет на поведение вашего кода. Вам нужно будет написать другую часть, которая проверяет атрибуты (через отражение) и действует на них.

Многие люди ответили, но никто не упомянул об этом до сих пор...

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

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

Также неплохо было бы рассмотреть, где уместно было бы использовать место такого атрибута, и приписать свой атрибут (!) чтобы указать это через AttributeUsage . Список доступных способов использования атрибутов может вас удивить:

• Assembly
• Модуль
• Класс
• Структура
• Перечисление
• Конструктор
• Метод
• Собственность
• Поле
• Событие
• Взаимодействие
• Параметр
• Делегат
• ReturnValue
• GenericParameter
• Все

Также здорово, что атрибут AttributeUsage является частью сигнатуры атрибута AttributeUsage. Ух ты для круговых зависимостей!

[AttributeUsageAttribute(AttributeTargets.Class, Inherited = true)]
public sealed class AttributeUsageAttribute : Attribute

Атрибуты - это своего рода метаданные для тегирования классов. Это часто используется в WinForms, например, чтобы скрыть элементы управления с панели инструментов, но может быть реализовано в вашем собственном приложении, чтобы позволить экземплярам различных классов вести себя определенным образом.

Начните с создания атрибута:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
public class SortOrderAttribute : Attribute
{
    public int SortOrder { get; set; }

    public SortOrderAttribute(int sortOrder)
    {
        this.SortOrder = sortOrder;
    }
}

Все классы атрибутов должны иметь суффикс "Attribute", чтобы быть допустимыми.
После этого создайте класс, который использует этот атрибут.

[SortOrder(23)]
public class MyClass
{
    public MyClass()
    {
    }
}

Теперь вы можете проверить конкретный класс' SortOrderAttribute (если он есть), выполнив следующие действия:

public class MyInvestigatorClass
{
    public void InvestigateTheAttribute()
    {
        // Get the type object for the class that is using
        // the attribute.
        Type type = typeof(MyClass);

        // Get all custom attributes for the type.
        object[] attributes = type.GetCustomAttributes(
            typeof(SortOrderAttribute), true);

        // Now let's make sure that we got at least one attribute.
        if (attributes != null && attributes.Length > 0)
        {
            // Get the first attribute in the list of custom attributes
            // that is of the type "SortOrderAttribute". This should only
            // be one since we said "AllowMultiple=false".
            SortOrderAttribute attribute = 
                attributes[0] as SortOrderAttribute;

            // Now we can get the sort order for the class "MyClass".
            int sortOrder = attribute.SortOrder;
        }
    }
}

Если вы хотите узнать больше об этом, вы всегда можете проверить MSDN , который имеет довольно хорошее описание.
Надеюсь, это Вам помогло!

Атрибут-это класс, содержащий некоторые функциональные возможности, которые можно применить к объектам в коде. Чтобы создать его, создайте класс, наследующий от System.Attribute.

Что касается того, для чего они хороши... их применение практически безгранично.

http://www.codeproject.com/KB/cs/dotnetattributes.aspx

Атрибуты подобны метаданным, применяемым к классам, методам или сборкам.

Они хороши для любого количества вещей (визуализация отладчика, маркировка вещей как устаревших, маркировка вещей как сериализуемых, список бесконечен).

Создавать свои собственные пользовательские модели легко, как пирог. Начать здесь:

http://msdn.microsoft.com/en-us/library/sw480ze8(VS.71).aspx

В проекте, над которым я сейчас работаю, есть набор из UI объектов различных вкусов и редактор для assembly этих объектов для создания страниц для использования в главном приложении, немного похожий на конструктор форм в DevStudio. Эти объекты существуют в своем собственном assembly, и каждый объект является классом, производным от UserControl , и имеет пользовательский атрибут. Этот атрибут определяется следующим образом:

[AttributeUsage (AttributeTargets::Class)]
public ref class ControlDescriptionAttribute : Attribute
{
public:
  ControlDescriptionAttribute (String ^name, String ^description) :
    _name (name),
    _description (description)
  {
  }

  property String ^Name
  {
    String ^get () { return _name; }
  }

  property String ^Description
  {
    String ^get () { return _description; }
  }

private:
  String
    ^ _name,
    ^ _description;
};

и я применяю его к такому классу, как этот:

[ControlDescription ("Pie Chart", "Displays a pie chart")]
public ref class PieControl sealed : UserControl
{
  // stuff
};

именно об этом говорили предыдущие плакаты.

Чтобы использовать атрибут, редактор имеет Generic::List <Type> , содержащий типы элементов управления. Существует окно списка, которое пользователь может перетащить на страницу, чтобы создать экземпляр элемента управления. Чтобы заполнить поле списка, я получаю ControlDescriptionAttribute для элемента управления и заполняю запись в списке:

// done for each control type
array <Object ^>
  // get all the custom attributes
  ^attributes = controltype->GetCustomAttributes (true);

Type
  // this is the one we're interested in
  ^attributetype = ECMMainPageDisplay::ControlDescriptionAttribute::typeid;

// iterate over the custom attributes
for each (Object ^attribute in attributes)
{
  if (attributetype->IsInstanceOfType (attribute))
  {
    ECMMainPageDisplay::ControlDescriptionAttribute
      ^description = safe_cast <ECMMainPageDisplay::ControlDescriptionAttribute ^> (attribute);

    // get the name and description and create an entry in the list
    ListViewItem
      ^item = gcnew ListViewItem (description->Name);

    item->Tag = controltype->Name;
    item->SubItems->Add (description->Description);

    mcontrols->Items->Add (item);
    break;
  }
}

Примечание: выше указано C++/CLI, но его нетрудно преобразовать в C# (да, я знаю, C++/CLI-это мерзость, но это то, с чем мне приходится работать :-( )

Вы можете поместить атрибуты на большинство вещей, и есть целый ряд предопределенных атрибутов. Редактор, упомянутый выше, также ищет пользовательские атрибуты в свойствах, которые описывают свойство и способы его редактирования.

Как только вы поймете всю идею, вы будете удивляться, как вы вообще жили без них.

Как уже было сказано, атрибуты относительно легко создавать. Другая часть работы-это создание кода, который его использует. В большинстве случаев вы будете использовать отражение во время выполнения для изменения поведения на основе наличия атрибута или его свойств. Есть также сценарии, в которых вы будете проверять атрибуты в скомпилированном коде, чтобы сделать какой-то статический анализ. Например, параметры могут быть помечены как не-null, и инструмент анализа может использовать это как подсказку.

Использование атрибутов и знание соответствующих сценариев их использования составляет основную часть работы.

Атрибуты-это, по сути, биты данных, которые вы хотите прикрепить к своим типам (классам, методам, событиям, enums и т. д.).)

Идея заключается в том, что во время выполнения какой-то другой type/framework/tool запросит у вашего типа информацию в атрибуте и будет действовать в соответствии с ней.

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

Атрибуты также могут использоваться в аспектно-ориентированном программировании для внедрения / манипулирования объектами во время выполнения на основе атрибутов, которые их украшают и добавляют проверку, ведение журнала и т. д. к объектам, не затрагивая бизнес-логику объекта.

Вы можете использовать пользовательские атрибуты как простой способ определения значений тегов в подклассах без необходимости писать один и тот же код снова и снова для каждого подкласса. Я наткнулся на хороший краткий пример Джона Уотерса о том, как определить и использовать пользовательские атрибуты в своем собственном коде.

Есть учебник по адресу http://msdn.microsoft.com/en-us/library/aa288454(VS.71).aspx

Чтобы приступить к созданию атрибута, откройте исходный файл C#, введите attribute и нажмите [TAB]. Он расширится до шаблона для нового атрибута.

Атрибуты также обычно используются для аспектно-ориентированного программирования. Для примера рассмотрим проект PostSharp .