Про новинки в .NET 5 и C# 9.0

В C# и .NET одновременно добавили нативные типы

Добавили?! Они же там с рождения были! Максимум, что могли добавить в язык — так это короткие псевдонимы и арифметические операции (которые и раньше были, но не языковые, а перегруженные).

Частичные классы в C# есть уже давно, их изначальная цель — отделять код, сгенерированный неким дизайнером от кода, написанного программистом. В C# 9.0 подогнали частичные методы.

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

Частичные методы точно так же есть уже давно, и их именно для генераторов кода и делали. Их ещё дизайнер Linq2Sql использовал как возможные точки расширения...

Новые тут разве что out-параметры.

В нашей компании .NET используется с самого его рождения

Как вы относитесь к перенагромождению C# фичами? Помните, каким простым был C# 2? Ощущение, что фичи добавляются ради фич, чтобы имитировать деятельность. Напр., не вижу никакого смысла в новом обратном синтаксисе MyType t = new() Или, например, кому было худо от отсутствия маппинга System.IntPtr как nint?

Сейчас мне больше импонирует подход Go, где каждое новое изменение языка/стандартной библиотеки тщательно выверяется ("а стоит ли оно того?")

Прямо какой-то пролог получается

Из всего перечисленного конечно радуют ковариантные типы у виртуальных методов, адекватный вывод типа у ? : тернарного оператора, ну и паттерн not.

Недавно смотрел обсуждение с, если не изменяет память, Мадсом Торгерсеном (ведущий дизайнер языка), разговор был кажется с ЮАР-коммъюнити. Там самый популярный вопрос был — почему with не завезли для кастомных типов. И ответ был очень интересный — они планируют ввести некий то ли аттрибут то ли еще какой-то флаг для методов, который будет указывать, что метод конструирует объект. Работает например для фабрик. Благодаря этому можно избавиться от внутренней магии, которая сейчас существует в record, и реализовать адекватную поддержку with для типов, ну и добавить немного оптимизаций. Я конечно разделяю энтузиазм полноценных DTO на классах с наследованием и вот этим всем, но условный struct record, или даже ручной readonly struct с get/init свойствами и поддержкой with очень сильно пойдет на пользу при работе с immutable типами, особенно сейчас, когда везде Span, ref, stackalloc и вот это вот все. Можно будет заводить var otherRectangle = thisRectangle with {Width = 10}. Придется ждать 10 версии языка.

Отсутствие необходимости писать полное название типа при перечислении элементов коллекции делает код чуть-чуть чище.

Здорово (как и всё остальное). Но немножко жалко что всё ещё приходится писать полное имя класса при определении конструкторов и деструкторов, вместо лаконичного this (как в D):

class SomeClass {
  this() {...}
  ~this() {...}
}

Вот совершенно непонятно зачем нужны для них полные имена. Хотя современные IDE позволяют на лету всё это рефакторить, но всё равно это кажется избыточным.

Как обычно, решарпер подскажет что там нового подвезли

Я прям удивлён: завезли всё то, что я так давно хотел видеть в языке.
Больше не надо писать Dictionary<SomeLongKeyType, SomeComplexType<ParamName1, ParamName1>> dictionaryName = new Dictionary<SomeLongKeyType, SomeComplexType<ParamName1, ParamName1>>();
Больше не надо писать if (!(someVariable is null)) ...
Больше не надо самому писать рекорды, костыли вместо нормальных инициализаторов, явное приведение к типу в тернарных операторах.

Единственное, чего не хватает — ну сделайте уже типы-перечисления реализующими IEquatable, наконец. Надоело EqualityComparer<>.Default.Equals использовать.

Спасибо за статью, громадное количество текста)

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

По пунктам

• Новые нативные и просто новые типы — ок, пусть будут
• Атрибуты у локальных функций — ок, пусть будут
• GetEnumerator как метод расширения — шаг в правильном направлении, но как всегда видин "сахарозный" подход. форыч вызвать на таких можно, а вот написать какой-нибудь where T : IStaticEnumerable не выйдет. Решилось бы тайпклассами
• Discard pattern — вот это очень хорошо, давно пора. Надеюсь, они везде работают, а не как обычно, в частности в ду нотац… простите, linq-синтаксисе.
• Инструкции верхнего уровня в C# — идея ок, реализация конеш такая. Сколько они костылей воткнули ради этих глобальных Args и остального — с ума сойти. Могли бы просто поти по принципу раста/linqpad — потребовать просто void Main() написать, от 8 буковок разработчики бы не обломались, зато вся магия исчезла бы.
• if (vehicle is not Car car) — если за пределами if можно будет воспользоваться переменной car то фича годная, иначе — не заменяет того варианта с if (!(vehicle is Car car))
• if (context is {Length: > 0 and (< 10 or 25) }) — а вот это уже пушка. Мне просто жаль ребят из команды парсера и компилятора, которые впиливали вот этот новый dsl. Плюс вот лично мне тут ваще непонятно, в какой момент мы работаем с контекстом, а в какой момент начинаем считать его элементы. То что в языке появляются and и or которые как && и ||, но не совсем. В итоге эта фича для меня идет просто со знаком минус.
• Улучшенный pattern matching в swtich expression — как выше уже вроде писали, это уже в текущей версии присутствует. В целом, полезная штука. Давно пора было вместо бесполезного свитча сделать паттерн матчер.
• Новый new, а также в принципе улучшенный target typing — опять же, фича с триллионом ограничений, и в реальности почти всегда ненужная потому что используется var. Поможет только в инициализаторах полей и тестах без AutoData. В целом ничег вредного, но и ничего особо полезного
• Target typed операторы ?? и ?: — ну, тут ничего не скажешь, наконец-то научили их не тупить в очевидных сценариях. Фича со знаком плюс, хотя и сахар, и маленькая
• Переопределение возвращаемого типа методов — тоже полезная штука, ценна в частности для реализация какого-нибудь Clone() который должен возвращать This — то есть для абстрактной фигуры — фигуру, но для треугольника — треугольник. Одна из двух несахарных фичей, однозначно плюс
• init-свойства — это не совсем readonly-члены — отлично пункт назван. У нас уже есть ридонли поля, ридонли свойства, свойства с приватным сеттером, теперь добавляются еще инит-свойства. Зачем они нужны для меня до сих пор загадка, особенно если учитывать что добавили нормальные рекорды. Предлагаю шараду: угадайте, какой из вариантов инициализации что означает:
  

  public class Person(string FirstName, string LastName)
  public class Person { string FirstName; string LastName; }
  public data class Person { string FirstName; string LastName; }
  public class Person { string FirstName {get;set;} string LastName {get;set;} }
  public class Person { string FirstName {get;init;} string LastName {get;init;} }
  public class Person(string firstName, string LastName)

• Record — это узаконенная DTO'шка — ну, это хорошая штука. Хотя с полноценными генераторами делать целую языковую фичу под это было бы необязательно. В целом, плюсовая фича. Но опять сахарная

• .NET Source Generators — а вот это вторая несахарная фича, но как всегда, майкрософт пошел на кучу компромиссов. Один из важных кейсв — сурс генераторы не могут быть вложенными. то есть сгенерировать код из которого будет сгенерирован код нельзя. В частности, в это точно упираются ребята из asp.net которые планировали рейзор перевести на сурс генераторы (а пока останутся на рефлекшне как и раньше), ну и в целом, это кажется блажью только пока не попишешь немного макросов, а там сразу становится понятно, что без этого фича так же ограничена, как ООП с наследованием только одного интерфейса. Во-вторых сурс генераторы не могут менять сигнатуры. Что это означает? Ну, что например атрибут "добавить неявный CancellationToken и прокинуть во все вложенные методы" (этакий АОП) сделать не выйдет. Но что важнее, не выйдет сделать юзерские рекорды. Возьмем раст, там рекорд это обычная структурка на которую навешана пара сорсгенераторов:

  
  

  #[derive(Clone, Eq, PartialEq, Hash)]
  struct Person {
      first_name: String,
      last_name: String
  }

  
  

  которое раскрывается примерно в Person : Clone, Eq, PartialEq, Hash { ... }. То есть меняется сигнатура (добавляются реализации интерфейсов). В шарповых сорсгенераторах такого не будет.

  
  
• Частичные методы (partial method) — сахар, особо не нужен (кроме как в контексте предыдущей фичи)
• Методы-инициализаторы (module initializers) — вредная магия, но без которой генераторы видимо совсем плохие.

Ну и какой итог отсюда можно сделать? Добавили ли в язык полезных фичей? Ну, добавили. Стал ли он удобнее в использовании и т.п.? — Да, стал. Стал ли он удобнее пропорционально добавленной сложности? — однозначнно нет. Сахар, который плох именно тем, что не добавляет ортогональности и не позволяет комбинировать его, фичи с кучей оговорок, и прочее — язык очень сильно усложняется, а вот полезного к сожалению не очень. Нужные вещи вроде полноценных макросов, шейпов, типов высших порядков — откладываются из релиза в релиз. Простейшие рекорды которые наверное единственное стоящее нововведение новой версии языка обещали с 6(!) версии больше пяти лет.

Всегда очень нравился сишарп. Но чем дальше, тем больше понимаю, что для продуктивной разработки он мне все меньше и меньше подходит. И не потому что он становится хуже, нет, конечно же нет. Но как говорила Алиса, тут нужно бежать, чтобы оставаться на месте, а чтобы куда-то попасть нужно бежать ещё сильнее. Другие языки бегута куда лучше, даже Java на которую мне всегда было больно смотреть без слез с каждым релизом выглядит все более и более достойно. Увы, на мой взгляд сишарп бежит едва достаточно чтобы просто оставаться на этом самом месте. А жаль.

На метод накладываются некоторые ограничения:
он не должен работать с обобщениями (generics);

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

Статья супер, спасибо! Кажется, самая подробная из всех, что я видел — на английском в том числе.

спасибо! очень люблю C# а теперь люблю ещё больше <3