Возможные фичи C# 5

Никто толком не знает что будет в следующей версии языка C#. Даже люди в C# Insiders (я в их числе) понятия не имеют, что там Microsoft придумает. Тем не менее, в сети есть очень много действительно хороших предложений, несколько из которых я решил представить ниже. Надеюсь получится хорошая дискуссия.

Замена для IEnumerable<T> — тут идея в том, что мы слишком много букв пишем, и что лучше, как это сделано в Boo, заменить IEnumerable одной буквой, чтобы можно были писать T* или T~. К сожалению, звездочка вполне может запутать тех, кто знает что такое указатель, так что придется поискать другой оператор.

Синтакcический сахар для dependency property. Идея простая – реализация DP на данный момент невменяема, т.е. выглядит как “код с известного полуострова” и мейнтейнить такие нагромождения не хочется. Уж лучше написать следующее:

public Message
{
  get; set;
  default { return "No message"; }
  assign { Console.WriteLine("Just changed message!"); }
}

И так далее. Соответственно, реализации INotifyPropertyChanged, IDataErrorInfo, IEditableObject и так далее тоже хочется получать автоматически, а не через нагромождения, как это делается сейчас.

NonNullable типы, то есть типы которые не могут быть null в принципе. Помечаем тип как T! (дуальная аналогия T?, что соответствует Nullable<T>) и всё! Некоторым правда этого мало – они хотят чтобы все типы были ! by default.

yield из анонимных функций – думаю тут все понятно. От себя добавлю, что было бы круто если бы можно было использовать var вместо полного описания прототипа. Например:

var z = (int [] x => { foreach (var y in x.Where(x % 2 == 0)) yield return y; }

Также была бы полезна поддержка yield foreach, т.е. возможность делать рекурсивный yield без двойного обхода. Вот что имеется ввиду:

public IEnumerable<Person> OldPeople(this Person person)
{
  if (person.Age > 80) yield return person;
  // instead of this
  foreach (var result in OldPeople(person.Children))
    foreach (var p in result)
      return p;
  // we write this
  foreach yield OldPeople(person.Children);
}

Sequence-инициализация, чтобы например 1..10 производило то же самое, что Enumerable.Range(1, 10).

Правильная инициализация кортежей. Сейчас метод может вернуть два значения в Tuple<T,U>, но получать их нужно через .Item1 и .Item2. Это нечитабельно, и лучше делать вот так:

(sex,death) = GetMeaningOf(life);

Хотя лучше всего наверное использовать struct-тип для возврата, т.к. иначе подсказки о том что возвращается можно получить только из документации.

Как альтернатива – возможность возвращать анонимные именованые типы, примерно вот так:

public static new { T X, T Y } Vector2<T>(this T k)
{
    return new { X = k, Y = k };
}

Оператор цепочной проверки на null. Например, если один из элементов person.Address.PostCode является null, мы получим исключение, а проверять их все—лень. Поэтому хочется получить оператор а-ля ?. чтобы написал вот так person?.Address?.PostCode мы получили null если любой из элементов null.

Extension properties — у нас уже есть методы, а если еще будут свойства (как в F#), то легче будет делать примеси. Это некий аналог multiple inheritance который, насколько я понимаю, есть например в Scala.

Скрытая ленивость — иначе говоря, обертка вокруг Lazy<T> которая позволить переменной быть ленивой без всяких .Value и так далее. Например:

class C
{
  yield int Z;
  public C()
  {
    Z = SomeLazyComputation(); // only done when asked
  }
}

Приватные поля для свойств — еще одна идея как инкапсулировать поля когда объект не является POCO:

class C
{
  public int N
  {
    int n = 0;
    get { return n; }
    set { if (value != n) {
      n = value;
      NotifyPropertyChanged("n");
    } }
  }
}

Если у вас есть еще какие-то идеи насчет новой версии языка – пишите!