C# 14: поддержка nameof для несвязанных универсальных типов

C# 14 вводит несколько небольших, но полезных улучшений языка. Одно из этих новых нововведений касается выражения nameof: теперь оно поддерживает несвязанные универсальные типы. Проще говоря, вам больше не нужно подставлять фиктивный аргумент типа только для того, чтобы получить имя универсального типа. Это обновление устраняет небольшое неудобство, с которым разработчики на C# сталкивались годами, и делает код, использующий nameof, чище и проще в поддержке.

Что такое несвязанные универсальные типы

В C# универсальный тип — это класс или структура, имеющие параметры типа (например, List<T> или Dictionary<TKey, TValue>). Несвязанный универсальный тип — это сама определение универсального типа, без указания конкретных аргументов типа. Распознать несвязанный универсальный тип можно по пустым угловым скобкам (как List<>) или по запятым внутри угловых скобок, обозначающим число параметров типа (как Dictionary<,> для двух параметров типа). Он представляет универсальный тип в общем виде, не уточняя, чем являются T или TKey/TValue. Создать экземпляр несвязанного универсального типа напрямую нельзя, поскольку он не полностью специфицирован, но его можно использовать в определённых контекстах (например, при использовании reflection через typeof). Например, typeof(List<>) возвращает объект System.Type для открытого универсального типа List.

До C# 14 язык не позволял использовать несвязанные универсальные типы в большинстве выражений. Они встречались главным образом в сценариях reflection или атрибутов. Если вы хотели сослаться на универсальный тип по имени в коде, обычно приходилось указывать конкретные аргументы типа, делая его закрытым универсальным типом. Например, List<int> или Dictionary<string, int> — это закрытые универсальные типы, поскольку все их параметры типа заданы. До этого момента разработчики на C# часто выбирали произвольный тип (например, object или int) только ради того, чтобы удовлетворить синтаксис, хотя на самом деле им требовалось лишь имя универсального типа.

Как nameof работал до C# 14

Выражение nameof — это возможность времени компиляции, которая возвращает имя переменной, типа или члена в виде строки. Оно широко используется, чтобы избежать жёсткой привязки идентификаторов к строкам (например, для проверки аргументов или уведомлений об изменении свойств). До C# 14 у nameof было ограничение при работе с универсальными типами: вы не могли использовать несвязанный универсальный тип в качестве аргумента. Аргументом nameof должно было быть допустимое выражение или идентификатор типа в коде, а значит, универсальные типы требовали конкретных аргументов типа. На практике это означало, что для получения имени универсального типа приходилось предоставлять фиктивный параметр типа.

Например, предположим, вы хотели получить строку "List" (имя универсального класса List<T>). В C# 13 или ранее пришлось бы написать что-то вроде:

string typeName = nameof(List<int>);  // evaluates to "List"

Здесь мы использовали List<int> с произвольным аргументом типа (int), хотя выбор типа никак не влияет на результат. Если попытаться использовать несвязанную форму вроде List<> без аргумента типа, код не скомпилировался бы. Компилятор выдал бы ошибку о “несвязанном универсальном имени” или подобной, поскольку это не допускалось в контексте, ожидающем выражение. Иначе говоря, вам приходилось указывать параметр типа, чтобы выражение было допустимым для nameof, хотя nameof в итоге игнорирует аргумент типа и заботится только об имени "List".

Это требование было лишь особенностью правил языка. Оно могло приводить к неуклюжему или хрупкому коду. Например, разработчики часто использовали заполнитель вроде object или int для параметра типа только для использования nameof. Если позже у универсального типа появлялось новое ограничение (например, T должен быть ссылочным типом или наследоваться от определённого класса), использование nameof могло сломаться, поскольку фиктивный тип уже не удовлетворял ограничениям. В некоторых сложных случаях подобрать подходящий тип было нетривиально (например, если T был ограничен внутренним классом или интерфейсом, который не реализовывал ни один существующий тип, приходилось создавать фиктивный класс только для удовлетворения универсального параметра, чтобы воспользоваться nameof). Всё это было лишней нагрузкой ради того, что, по сути, не влияет на результат nameof.

nameof с несвязанными универсальными типами в C# 14

C# 14 устраняет эту проблему, разрешая напрямую использовать несвязанные универсальные типы в выражениях nameof. Теперь аргументом nameof может быть определение универсального типа без указания его параметров типа. Результат именно тот, который вы и ожидаете: nameof возвращает имя универсального типа. Это значит, что наконец можно написать nameof(List<>) и получить строку "List" без фиктивного аргумента типа.

Чтобы проиллюстрировать изменение, сравним, как мы получали бы имя универсального типа до и после C# 14:

До C# 14:

// Using a closed generic type (with a type argument) to get the name:
Console.WriteLine(nameof(List<int>));    // Output: "List"

// The following was not allowed in C# 13 and earlier – it would cause a compile error:
// Console.WriteLine(nameof(List<>));    // Error: Unbound generic type not allowed

В C# 14 и позднее:

// We can use an unbound generic type directly:
Console.WriteLine(nameof(List<>));       // Output: "List"
Console.WriteLine(nameof(Dictionary<,>)); // Output: "Dictionary"

Как показано выше, nameof(List<>) теперь даёт "List", а nameof(Dictionary<,>) — "Dictionary". Больше не нужно подставлять поддельный аргумент типа только для использования nameof с универсальным типом.

Это улучшение не ограничивается получением имени самого типа. Его также можно использовать для получения имён членов несвязанного универсального типа, как и для обычного типа. Например, nameof(List<>.Count) теперь является допустимым выражением в C# 14 и даёт строку "Count". В прежних версиях пришлось бы написать nameof(List<int>.Count) или подставить какой-то конкретный тип вместо <int>, чтобы получить тот же результат. C# 14 позволяет опускать аргументы типа и в таких контекстах. В целом везде, где вы использовали nameof(SomeGenericType<...>.MemberName), теперь можно оставлять универсальный тип несвязанным, если у вас нет конкретного типа или вы не хотите его выбирать.

Стоит отметить, что это нововведение касается исключительно удобства и ясности кода. Результат выражения nameof не изменился — это всё то же имя идентификатора. Изменились правила языка: теперь они допускают более широкий набор входных данных для nameof. Это приводит nameof в соответствие с typeof, который уже поддерживал открытые универсальные типы. По сути, язык C# признаёт, что необходимость указывать параметр типа в этих случаях изначально была излишней.

Чем это полезно

Разрешение несвязанных универсальных типов в nameof может показаться небольшой настройкой, но даёт ряд практических преимуществ:

• Чище и понятнее код: Больше не нужно вставлять нерелевантные аргументы типа в код только ради компилятора. nameof(List<>) ясно выражает: “мне нужно имя универсального типа List”, тогда как nameof(List<int>) может на мгновение заставить читателя задуматься: “а почему int?”. Удаление шума делает намерение кода очевиднее.
• Больше никаких фиктивных типов и обходных решений: В коде до C# 14 разработчики часто использовали типы-заполнители вроде object или создавали фиктивные реализации, чтобы применять nameof с универсальными типами. Теперь это не требуется. Ваш код может напрямую ссылаться на имя универсального типа без обходных решений, уменьшая беспорядок и странные зависимости.
• Лучшая поддерживаемость: Использование несвязанных универсальных типов в nameof делает код менее хрупким при изменениях. Если у универсального типа появятся новые ограничения параметра типа или другие модификации, вам не придётся пересматривать каждое использование nameof, чтобы убедиться, что выбранный аргумент типа всё ещё подходит. Например, если у вас был nameof(MyGeneric<object>), а позднее MyGeneric<T> получит ограничение where T : struct, этот код перестанет компилироваться. С nameof(MyGeneric<>) он продолжит работать независимо от подобных изменений, поскольку не зависит от конкретного аргумента типа.
• Согласованность с другими возможностями языка: Это изменение делает nameof более согласованным с тем, как работают другие средства метапрограммирования, такие как typeof. Поскольку typeof(GenericType<>) уже позволял отражать открытый универсальный тип, интуитивно ожидаемо, что и nameof(GenericType<>) должен давать его имя. Теперь язык воспринимается как более последовательный и логичный.
• Небольшое удобство в сценариях reflection или кодогенерации: Если вы пишете библиотеки или фреймворки, работающие с типами и именами (например, генерируют документацию, сообщения об ошибках или выполняют привязку моделей с журналированием имён типов), теперь имена универсальных типов можно получать напрямую. Удобство небольшое, но оно может упростить код, который собирает строки с именами типов или использует nameof для журналирования и исключений, связанных с универсальными классами.

Что меняется для вашего кода

Поддержка несвязанных универсальных типов в выражении nameof — это приятное улучшение в C# 14, которое делает язык чуть более удобным для разработчика. Разрешая такие конструкции, как nameof(List<>), C# устраняет давнее неудобство и позволяет разработчикам выражать своё намерение без лишнего шаблонного кода. Это изменение полезно всем пользователям C#: новички избегут путаницы при использовании nameof с универсальными типами, а опытные разработчики получат более лаконичный код, устойчивый к будущим изменениям. Это отличный пример того, как команда C# устраняет “papercut” в языке и улучшает согласованность. Переходя на C# 14, помните об этой возможности всякий раз, когда вам нужно имя универсального типа, и наслаждайтесь написанием более чистого и сжатого кода.

Источники

1. What’s new in C# 14 | Microsoft Learn
2. Generics and attributes – C# | Microsoft Learn
3. The nameof expression – evaluate the text name of a symbol – C# reference | Microsoft Learn
4. Unbound generic types in nameof – C# feature specifications (preview) | Microsoft Learn
5. What’s new in C# 14 | StartDebugging.NET