c зачем нужны атрибуты

Что такое атрибуты в C++?

Начиная со стандарта c++11 в языке появились так называемые «атрибуты», что это такое и зачем они нужны?

1 ответ 1

Атрибуты позволяют задавать дополнительную информацию для различных конструкций языка, таких как типы, переменные, имена, блоки и единицы трансляции. Данная информация в частности может быть использована компилятором для генерации более эффективного кода и предоставления (или наоборот, подавления) предупреждающих сообщений пользователю на уровне конкретных участков кода, а не целой программы или компилируемого файла, как это обеспечивается ключами компиляции.

Атрибуты появились в c++11 и впоследствии были несколько расширены. На данный момент существуют следующие стандартные атрибуты:

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

Атрибут всегда обрамляется двойными квадратными скобками:

[[carries_dependency]]

[[deprecated]]

Позволяет отметить сущность устаревшей или небезопасной, но тем не менее пока ещё разрешённой к использованию. Может применяться к объявлению класса, typedef-имени, переменной, нестатическому члену данных, функции, пространству имён, перечислению, элементу перечисления или специализации шаблона. Атрибут может быть снабжен аргументом, заданным строковым литералом. Например:

Текстовое сообщение будет использовано как подсказка при выводе соответствующего предупреждения.

[[fallthrough]]

[[likely]] и [[unlikely]]

Атрибуты могут быть добавлены к меткам case или операторам (statement) для подсказки компилятору, что тот или иной участок кода ожидается наиболее вероятным (likely) или, наоборот, менее вероятным (unlikely) при выполнении программы. Пример:

[[maybe_unused]]

Используется для уведомления компилятора о том, что сущность может быть не использована в программе и следует подавлять соответствующее предупреждение. Может применяться к объявлению класса, typedef-имени, переменной, нестатическому члену данных, функции, пространству имён, перечислению или элементу перечисления. Атрибут может быть полезен при наличии отладочного кода, который не будет включён в бинарник при сборке в release режиме. Пример:

Ранее приходилось использовать приведение к void для подавления возможных предупреждений.

[[nodiscard]]

Указывает на обязательность использования результата при возврате из функции. Может быть применим как к типу (при объявлении класса или перечисления), так и непосредственно к возвращаемому типу функции. Пример:

Явное приведение результата к void подавляет действие атрибута:

Альтернативно можно использовать присваивание std::ignore :

[[noreturn]]

Говорит о том, что функция не возвращает управление. Может быть применим к объявлению функции. Актуально для функций, которые заканчивают свою работу выкидыванием исключения, выполняют вечный цикл или прерывают выполнение всей программы. Пример:

[[no_unique_address]]

Указывает на то, что нестатический член данных класса является потенциально-перекрываемым (potentially-overlapping) подобъектом (не может применяться к битовым полям). Это значит что член может иметь общий адрес с другим нестатическим членом данных этого или базового класса, а заполнители, которые обычно вставляются в конец объекта, могут быть использованы для хранения других членов. Пример:

Источник

Атрибуты C#: обо всех аспектах

Здравствуй, читатель. В этой статье описаны атрибуты со всех сторон — начиная от спецификации, смысла и определения атрибутов, создания собственных и работе с ними, заканчивая добавлением атрибутов на рантайме и наиболее полезными и интересными существующими атрибутами. Если вам интересна тема атрибутов в C#, то добро пожаловать под кат.

Содержание

Введение

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

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

Пример

Как видно StructLayoutAttribute имеет специальный синтаксис, так как в IL он представлен как «explicit». ObsoleteAttribute использует общий синтаксис — в IL начинается с «.custom». SecurityPermissionAttribute как атрибут безопасности превратился в «.permissionset assert».

Пользовательские атрибуты добавляют пользовательскую информацию к метаданным. Этот механизм может использоваться для хранения специфичной для приложения информации во время компиляции и для доступа к ней во время выполнения или для чтения и анализа другим инструментом. Хотя любой определенный пользователем тип может быть использован в качестве атрибута, для соответствия CLS необходимо, чтобы атрибуты наследовались от System.Attribute. CLI предопределяет некоторые атрибуты и использует их для управления поведением во время выполнения. Некоторые языки определяют атрибуты для представления возможностей языка, не представленных непосредственно в CTS.

Как уже упоминалось, атрибуты хранятся в метаданных, которые, в свою очередь, формируются на этапе компиляции, т.е. вносятся в PE файл (как правило *.dll). Таким образом, добавить во время выполнения атрибут можно только модифицируя исполняемый файл во время выполнения (но времена самоизменяющихся программ уже давно в прошлом). Отсюда следует, что на этапе выполнения их добавить нельзя, но это не совсем точно. В случае, если мы формируем свою сборку, определяем в ней типы, то мы можем на этапе выполнения создать новый тип и вешать атрибуты на него. Так что формально, мы все же можем добавлять атрибуты на этапе выполнения (пример будет в самом низу).

А теперь немного об ограничениях

Если по каким-то причинам в одной сборке существует 2 атрибута с именами Name и NameAtribute, то становится невозможным поставить первый из них. При использовании [Name] (т.е. без суффикса) компилятор говорит, что видит неопределенность. При использовании [NameAttribute] мы поставим NameAttribute, что логично. Для такой мистической ситуации с недостатком воображения при именовании существует специальный синтаксис. Чтобы поставить первую версию без суффикса можно указать знак собаки (т.е. [Name] — шутка, так не надо) перед именем атрибута [@Name].

Пользовательские атрибуты могут быть добавлены к чему угодно, кроме пользовательских атрибутов. Имеется в виду метаданные, т.е. если мы ставим в C# атрибут над классом атрибута, то в метаданных он будет относиться к классу. А вот добавить атрибут к «public» нельзя. Зато можно к сборкам, модулям, классам, типам значений, перечислениям (enum), конструкторам, методам, свойствам, полям, событиям, интерфейсам, параметрам, делегатам, возвращаемым значениям или обобщенным параметрам. В примере ниже приведены очевидные и не очень примеры того, как можно поставить атрибут на ту или иную конструкцию.

Атрибуты имеют 2 типа параметров — именованные и позиционные. К позиционным относятся параметры конструктора. К именованным — публичные свойства с доступным сеттером. При этом это не просто формальные названия, все параметры можно указывать при объявлении атрибута в скобках после его названия. Именованные не являются обязательными.

Допустимые параметры (обоих видов) для атрибута должны быть одного из перечисленных типов:

Существует два вида пользовательских атрибутов: подлинные пользовательские атрибуты (genuine custom attributes) и псевдо-пользовательские (pseudo-custom).
В коде они выглядят одинаково (указываются над конструкцией языка в квадратных скобках), но обрабатываются по-разному:

Большинство пользовательских атрибутов введены на уровне языка. Они хранятся и возвращаются рантаймом, при этом рантайм не знает ничего о значении этих атрибутов. Но все псевдо-пользовательские атрибуты плюс некоторые пользовательские атрибуты представляют особый интерес для компиляторов и для CLI. Таким образом мы переходим к следующему разделу.

Атрибуты с поддержкой рантайма

Данный раздел носит чисто информативный характер, если интереса к тому, что использует рантайм нет, то можно скролить к следующему разделу.

В таблице ниже перечислены псевдо-пользовательские атрибуты и специальные пользовательские атрибуты (CLI или компиляторы обрабатывают их специальным образом).

Псевдо-пользовательские атрибуты (их нельзя получить через рефлексию).
CLI Атрибуты:

CLS Атрибуты — языки должны поддерживать их:

Полезные атрибуты

Неотъемлемой частью разработки программного продукта является отладка. И зачастую в большой и сложной системе требуется десятки и сотни раз запускать один и тот же метод и наблюдать за состоянием объектов. При этом на раз 20 уже начинает конкретно бесить необходимость разворачивать один объект вглубь раз 400, чтоб увидеть значение одной переменной и перезапустить метод заново.
Для более спокойной и быстрой отладки можно использовать атрибуты, модифицирующие поведение отладчика.

DebuggerDisplayAttribute указывает, как отображается тип или его член в окне переменных отладчика (ну и не только).

Единственным аргументом конструктора является строка с форматом отображения. То, что будет находиться между фигурными скобками, будет вычислено. Формат как у интерполированной строки, только без доллара. Нельзя использовать указатели в вычисляемом значении. Кстати, если у вас есть переопределенный ToString, то его значение будет показываться как если бы оно было в этом атрибуте. Если есть и ToString и атрибут, то значение берется из атрибута.

DebuggerBrowsableAttribute определяет способ отображения поля или свойства в окне переменных отладчика. Принимает DebuggerBrowsableState, который имеет 3 опции:

DebuggerTypeProxy — если объект просматривается в отладчике сотни раз в день, то можно заморочиться и потратить минуты 3 на создание прокси объекта, который отобразит исходный объект как надо. Обычно прокси объект для отображения — внутренний класс. Собственно, он и будет отображаться вместо целевого объекта.

Другие полезные атрибуты

ThreadStatic — атрибут позволяющий сделать статическую переменную своей для каждого потока. Для этого надо поставить атрибут над статическим полем. Стоит помнить важный нюанс — инициализация статическим конструктором будет выполнена только один раз, и переменная поменяется в том потоке, который выполнит статический конструктор. В остальных она останется дефолтной. (ЗЫ. Если вам необходимо такое поведение, советую взглянуть в сторону класса ThreadLocal).

InternalsVisibleTo — позволяет указать сборку, которой будут видны элементы, помеченные internal. Может показаться, что если какой-то сборке нужны определенные типы и их члены, можно просто пометить их public и не париться. Но хорошая архитектура подразумевает сокрытие деталей имплементации. Тем не менее они могут понадобиться для каких-нибудь инфраструктурных вещей, например, тестовых проектов. С помощью этого атрибута можно поддерживать и инкапсуляцию, и требуемый процент покрытия тестами.

HandleProcessCorruptedStateExceptions — позволяет отпугивать робких программистов и ловить исключения поврежденного состояния. По умолчанию для таких исключений CLR не выполняет отловки. В общем случае лучшим выходом будет как раз позволить приложению упасть. Это опасные исключения, показывающие, что память процесса повреждена, так что использование данного атрибута — идея очень плохая. Но возможно в некоторых случаях, для локальной разработки будет полезно на некоторое время поставить данный атрибут. Чтобы словить исключение поврежденного состояния, достаточно просто поставить этот атрибут над методом. И если уже дошло до использования этого атрибута, то рекомендуется (впрочем, как и всегда) отлавливать какое-то конкретное исключение.

DisablePrivateReflection — делает все приватные члены сборки недосягаемыми для рефлексии. Атрибут ставиться на сборку.

Определение своего атрибута

Не просто так этом раздел стоит последним. Ведь лучший способ понять, в каких случаях будет выгодно использовать атрибут — посмотреть на уже используемые. Сложно сказать формализованное правило, когда следует задуматься о собственном атрибуте. Зачастую их используют как дополнительную информацию о типе/его члене или другой конструкции языка, которая бывает общей у совершенно разных сущностей. Как пример — все атрибуты, используемые для сериализации/ОРМ/форматирования и тд. Из-за обширного применения данных механизмов к совершенно разным типам, зачастую не известным разработчикам соответствующего механизма, использование атрибутов — отличный способ дать пользователю возможность предоставлять декларативную информацию для данного механизма.

Использование своих атрибутов можно разделить на 2 части:

Создание атрибута и его использование

Для создания своего атрибута достаточно наследоваться от System.Attribute. При этом желательно придерживаться упомянутого стиля именования — заканчивать имя класса на Attribute. При этом никакой ошибки не будет, если опустить этот суффикс. Как упоминалось ранее, атрибуты могут иметь 2 типа параметров — позиционные и именованные. Логика их применения такая же, как и со свойствами и параметрами конструктора у класса — значения, необходимые для создания объекта, для которых не существует разумного «дефолта» выносятся в позиционные (т.е. конструктор). То, чему можно поставить какой-то разумный дефолт, который будет зачастую использован, лучше выделить в именованный (т.е. свойство).

Немаловажным в создании атрибута является ограничение мест его применения. Для этого используется AttributeUsageAttribute. Обязательным параметром (позиционным) является AttributeTarget, определяющий место использования атрибута (метод, сборка и тд). Необязательными (именованными) параметрами являются:

Метод (функция) — тоже информация и тоже может описывать конструкцию. И используя полиморфизм в атрибутах можно предоставить весьма мощный и удобный инструмент, где пользователь сможет влиять как на информацию, используемую вашим инструментом, так и на определенные этапы выполнения и обработки. При этом ему не надо будет плодить классы, внедрять зависимости, стоить фабрики и их интерфейсы, которые будут создавать эти классы. Достаточно будет создать единственный класс-наследник, который инкапсулирует в себе детали работы с элементом, к которому он относится. Но, как правило, достаточно обычного «РОСО» атрибута с парой свойств.

Получение и обработка атрибута

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

Получение атрибутов во время выполнения осуществляется с помощью рефлексии. Для получения атрибута с определенного элемента существуют различные способы.

Но все берет начало от интерфейса ICustomAttributeProvider. Его реализуют такие типы как Assembly, MemberInfo, Module, ParameterInfo. В свою очередь наследниками MemberInfo являются Type, EventInfo, FieldInfo, MethodBase, PropertyInfo.

Интерфейс имеет лишь 3 функции, и они не очень удобные. Они работают с массивами (даже если мы знаем, что атрибут может быть лишь один) и не параметризованы типом (используют object). Поэтому напрямую к функциям этого интерфейса придется обращаться редко (не сказал никогда, потому что не хочу быть категоричным). Для удобства использования существует класс CustomAttributeExtensions, в котором собрано множество методов расширения для всевозможных типов, выполняющих несложные операции по приведению типов, выборке единственного значения и так далее, тем самым освобождая разработчика от данной необходимости. Также эти методы доступны как статические в классе Attribute с полезнейшей функцией игнорирования параметра inherit (для нонконформистов).

Основные используемые функции приведены ниже. Первый параметр, указывающий какой тип расширяет метод, я опустил. Также везде, где указан параметр bool inherit существует перегрузка без него (со значением по умолчанию true). Этот параметр указывает, нужно ли учитывать при выполнении метода атрибуты родительского класса или базового метода (если используется на переопределенном методе). В случае, если в атрибуте inherit = flase, то даже установка его в true не поможет учитывать атрибуты базового класса

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

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

Источник

Атрибуты в C#

Достаточно много времени до меня не доходило что же за такая штука эти Атрибуты.

Сел, разобрался, прочитал непонятные определения и предлагаю полученное мной понимание о том что же это такое.

Атрибут — это класс, унаследованный от базового класса Attribute.
Суть атрибута в том, что он используется для генерации описаний. Создав атрибут вы можете наделить его своими свойствами которыми вы желаете наградить класс, поле, свойство или метод, Атрибут не влияет на значение полей и свойств и на выполнение методов класса, если в теле метода не учитывается информация хранящаяся в атрибуте. Но есть очень важный момент — Значение атрибута невозможно изменять в процессе выполнения кода, так как значения их свойств хранятся в виде констант в скомпилированном модуле

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

И некий класс который мы наградим описанным атрибутом и будем использовать его значение для формирования результата функции GetArray:

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

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

Данная статья даёт только общее и скудное описание атрибутов, но используя его, можно понять, что это такое.

Источник

Использование атрибутов в C#

Атрибуты предоставляют возможность декларативно связать информацию с кодом. Также этот элемент можно многократно использовать повторно для разнообразных целевых объектов.

Предварительные требования

Создание приложения

dotnet new console

Команду dotnet restore по-прежнему удобно использовать в некоторых сценариях, где необходимо явное восстановление, например в сборках с использованием непрерывной интеграции в Azure DevOps Services или системах сборки, где требуется явно контролировать время восстановления.

Добавление атрибутов к коду

Когда вы отмечаете класс как устаревший, желательно предоставить некоторые сведения о том, почему он устарел и (или) что можно использовать вместо него. Для этого передайте в атрибут Obsolete строковый параметр.

В конструкторе атрибута можно использовать в качестве параметров только простые типы и литералы bool, int, double, string, Type, enums, etc и массивы этих типов. Нельзя использовать переменные или выражения. Но вы можете свободно использовать позиционные или именованные параметры.

Как создать собственный атрибут

Добавив такой код, вы сможете использовать [MySpecial] (или [MySpecialAttribute] ) в качестве атрибута в любом месте кода.

Здесь есть один подвох, которого следует остерегаться. Как упоминалось выше, в качестве аргументов при использовании атрибутов можно передавать только некоторые определенные типы. Но компилятор C# не помешает вам указать другие параметры при создании типа атрибута. В следующем примере кода я создаю атрибут с конструктором, который отлично компилируется.

Но объект с таким конструктором вы не сможете использовать в роли атрибута.

Такой код вызовет ошибку компиляции, например такую: Attribute constructor parameter ‘myClass’ has type ‘Foo’, which is not a valid attribute parameter type

Как ограничить использование атрибута

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

Когда вы создаете класс атрибута, C# по умолчанию позволяет использовать этот атрибут для любого из допустимых целевых объектов. Если вы хотите, чтобы атрибут можно было использовать только для некоторых из целевых объектов, используйте AttributeUsageAttribute в классе атрибута. Да-да, именно так, атрибут для атрибута!

Если вы попробуете применить описанный выше атрибут для сущности, которая не является классом или структурой, вы получите ошибку компиляции такого рода: Attribute ‘MyAttributeForClassAndStructOnly’ is not valid on this declaration type. It is only valid on ‘class, struct’ declarations

Как использовать атрибуты, прикрепленные к элементу кода

Атрибуты выполняют роль метаданных. Без применения внешних сил они по сути ничего не делают.

Чтобы находить атрибуты и реагировать на них, обычно используется отражение. Мы не будем здесь подробно описывать отражения, ограничимся лишь основной идеей: отражение позволяет написать на C# код, который проверяет другой код.

Например, с помощью отражения можно получить сведения о классе (добавьте using System.Reflection; в начало кода):

Этот код выведет такие данные: The assembly qualified name of MyClass is ConsoleApplication.MyClass, attributes, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

Ниже вы видите пример использования GetCustomAttributes для экземпляра MemberInfo класса MyClass (как мы продемонстрировали ранее, он имеет атрибут [Obsolete] ).

Популярные атрибуты в библиотеке базовых классов (BCL)

Сводка

Атрибуты позволяют реализовать в C# возможности декларативного синтаксиса. Но они являются разновидностью метаданных и сами по себе не выполняют действия.

Источник