foreach (var x from collection with i)

word = 'HelpA'

>>> word[2:4]
'lp'

>>> word[:2]
'He'

>>> word[2:]
'lpA'

>>> word[-1]     # The last character
'A'
>>> word[-2]     # The last-but-one character
'p'
>>> word[-2:]    # The last two characters
'pA'
>>> word[:-2]    # All but the last two characters
'Hel'

AVK>Поэтому у меня есть желание сформировать некий документ со списком фич и отдать его дизайнерам шарпа. Гарантии, что хоть что то из него будет реализовано нет никакой, но шансы этого высоки как никогда

• Строгий типизированный "объектный" enum, как в Java 1.5. Здорово решают проблему хранение некоего "регистра" того или иного набора данных. В отличии от примитивных целочисленных констант в шарпе, в Java можно не хило так "полиморфировать" enum-константы, наделяя их реализациями интерфейсов, абстрактных методов, не говоря уже об обычных полях и методах. Небезысвестный Jon Skeet уже как семь лет назад говорил о таком. Компилятор справился бы с перечислениями, я думаю, без изменения CLR.
  
• Возможно, пересмотреть всеобъемлющую директиву using, которая открывает иногда слишком много. В этом контексте я бы пересмотрел также импорт методов расширения, которые не пойми откуда появляются, а также добавил бы "статический импорт": после Java, с её возможностью импортирования статических методов и полей, Console.WriteLine() выглядит уродливо. И если с первыми двумя уже, скорее всего, уже ничего не поделать, то третье можно привинтить было бы.
  
• Возможно, виртуальные методы расширения, как в Java 8 (единственное поведение по умолчанию для интерфейсов как бы "встраивается" без необходимости открывать методы расширения, реализация поведения которых зависит, в принципе, от того, что открыто). Но, наверно, это сомнительное пожелание в контексте уже существующих методов-расширений C#.
  
• После анонимных классов в Java руки автоматически тянутся писать такое же и в C#-коде. Можно, конечно, часто обойтись делегатами, но анонимные классы в Java позволяют инкапсулировать состояние.
  
• Сигнатурные ограничения для конструкторов обобщённых типов: не просто конструктор по умолчанию, а возможность указать желаемую сигнатуру конструктора объекта. Например, для инджектирования объекта через конструктор, а не через свойства -- раз и до конца жизни объекта.
  
• Лично мне "as" не очень нравится. Может быть, такое:
  

  cast ( oldVar as Type newVar ) { ... }

  
  вместо
  

  var newVar = oldVar as Type;
  if ( newVar != null ) {
      ...
  }

  
  
• Часто работаю с рефлексией на Java, но и там самая крутая возможность ссылаться на что-то без строки с именем, а по имени напрямую -- Type.class (typeof(Type) в C#). Иногда очень хочется такого и для методов (делегаты делают нечто похожее), полей и свойств. Таким образом рефакторинг таких вещей происходил бы менее болезненно.
  
• И всякие плюшки в виде интерполированных строк, литералы для регулярок, этц, хотя это уже на любителя...

AVK>Поэтому у меня есть желание сформировать некий документ со списком фич и отдать его дизайнерам шарпа. Гарантии, что хоть что то из него будет реализовано нет никакой, но шансы этого высоки как никогда

public static void AssertFileExists(string filePath, [ArgExpression("filePath")] argName = "")
{
  if (!File.Exists(filePath))
    throw new ArgumentException(argName, "...");
}

// ...
  AssertFileExists(someClass.SomePath); // throws ArgumentException, argument name = "someClass.SomePath"

  class A { SomeMethod(); } // Чужая сборка.
  interface IB { SomeMethod(); }

// ...
  var a = new A()
  var b = a mapas IB; // синтаксис - первый пришедший в голову. Всё разруливается в compile time - генерится обёртка, строчка превращается в b = new <>c__Wrapper_A_IB(a).

var i = 10;
$"Int = $i";

TResult Method<TArg, TResult>(TArg arg)  { return default(TResult); }
...
var res = Method<, string>(10); // TArg выведется.

var list = new List<>{10};

var x = 5;
Console.WriteLine("x = #{x}"));

Expression<Func<int?, string>> ToStr = i => i.HasValue ? i.ToString() : "null";
var q = db.MyTables.Select(rec => rec.StrField + ToStr(rec.IntField));

r = a.?b.?c;

if (a != null && a.b != null)
    r = a.b.c;
else
    r = null;

interface IFoobar { void DoWork(); }
...
object value;
if(value is IFoobar) {
  value.DoWork(); // не надо делать "cast" или "as"
}

var o = container.Resolve<MyObject>() 
   {
      Field1 = 7,
      Field2 = "hello world"
   };

K>interface IFoobar { void DoWork(); }
K>...
K>object value;
K>if(value is IFoobar) {
K>  value.DoWork(); // не надо делать "cast" или "as"
K>}
K>

interface IMyIntf 
{
    void IntfMethod();
}
class MyClass: IMyIntf
{
   public void ClassMethod() {}
   void IMyIntf.IntfMethod() {}
}


IMyIntf o = ...;
if (o is MyClass)
{
    o.IntfMethod(); // сейчас работает, а если o скастится к MyClass, то перестанет компилиться.
}

public enum LengthUnit
{
    Millimeter = 1,
    Meter = 1000,
    Inch = 25400;

    public static LengthUnit Parse(string text)
    {
        if (text == "mm") return LengthUnit.Millimeter;
        if (text == "m") return LengthUnit.Meter;
        if (text == "\"") return LengthUnit.Inch;
    }

    public string GetSystem()
    {
        switch (value)
        {
            case LengthUnit.Millimeter:
            case LengthUnit.Meter:
                return "Metric";
            case LengthUnit.Inch:
                return "US";
            default: return string.Empty;
        }
    }
}

...

var system = LengthUnit.Parse("mm").GetSystem();

T Calc<T>(T a, T b) where T : simple // позразумеваются int, byte, double, etc
{
    T result = a + b; // разрешено использовать + - * /

    return result;
}

1. Авто-инициализация авто-проперти:

   int a {get;set;} = 7;

   Это мелочи, но без них ШАРП БЕСИТ!
   
2. Автопроперть тоже сократить до: prop int a; // паблик проперть для r/w; куча приложений идёт именно с таким дефолтом, почему б его не сократить? Заодно ускорится компиляция.
   
3. Мультиприсвоение: var (a, b) = GetCoords(); // в a и b попадают отдельные числа. Т.е. типа кортежа, но без кортежа. Перл это умеет на раз-два. Сишарп ждём уже 10 лет....
   
4. Ещё один вид мультистрочных каментов (а-ля D): /+ это отладочный коммент /* скрывающий рабочий коммент */ и нужный только временно +/
   
5. Раз уж строки являются "немного встроенным" и широко используемым типом, нельзя ли упростить дебилизм типа if (!string.IsNullOrWhiteSpace(бла-бла...)) на что-то типа if (^string_var) — это сократило бы целую кучу кода.
   
6. Вывод типов для филдов: var SomeField = 6; // знаю, есть проблемы, но они трясут в 0.000001% случаев — так не лучше ли сделать жизнь большинства легче?!
   
7. Если тип переменной уже известен, пересоздавать её простым способом:

   File f; ...где-то позже... f = new();

   — бенефит очевиден при использовании всяких трёхэтажных генериков.
   
8. .ToString() бесит. Можно как в Руби: obj.ToS ? (заметьте — без скобок)
   
9. Синонимы функций. Console.WriteLine задолбал — хочу типа так:

   using Out = Console.WriteLine; Out(bzbz);

   
   
10. Зачем в switch(SomeEnumVar) пишут в case SomeDamnBigEnumName.EnumValue: ? нельзя ли просто switch(SomeEnumVar) case EnumValue: — тип-то везде один и тот же!
    
11. Приведение типов неуклюжее. Вместо

    double z = (double)IntVar;

    можно было б писать

    double z := IntVar;

    , т.е. := — это "присвоить с приведением типа к lvalue". Словесный понос надо искоренять — пусть паскалисты его тыркают.

• Сиськи!
  
• Expression Substitution вместо string.Format
  
• Синтаксис для кортежей с поддержкой везде: foreach(var (x, y) in seq)

1. Упрощённая работа с атрибутами. Какой смысл рассуждать об их пользе, если работа с ними осущ. через анус? Хочется изящной простоты, типа: foreach(PropInfo pi in WindowType.class.GetProperties(Attr1, attr2, ..)); Или PropInfo.HasAttribute(AttrClass); Вообще, у C# довольно помоечный синтаксис работы с классами: вместо элегантных конструкций с именами типов приходится влезать чуть ли не в ассемблер: Класс.ДайСвойТип().ШаманскиеФункции.... отстой полнейший. Нужен синтаксис сразу на уровне "Класс", типа "Класс.ДайПропертиСАтрибутом(Атрибут)". Это мелочи, но без них код загромождается фуфлом — хорошо бы девелоперам сишарпа заботиться не только "предоставить доступ к фиче", но и о элегантности кода с этими фичами.
   
2. Оператор .?
   
3. Улучшить оператор AS: нечасто, но изрядно упрощает бойлерплэйт a = b as SomeType; if (a != null) ....; Вариант: when(b = a as SomeType) { юзаем b }
   
4. Упрощ. иниц. объекта помимо new: var z = GetObject() <= { filed = 4, field2 = 5 }
   
5. Duck typing ака MapAs: приводить объект к интерфейсу, если он совместим по методам. Уж лучше в рантайме всё **нётся, зато в коде можно очень элегантно обруливать всякое гетерогенное фуфло из разных иерархий.

with (node)
{
   .name = "QQ";
   .index = 10;
   .DoSome();
}

public static IEnumerable<PropInfo> GetProperties<A1, A2>(this Type type) where A1: Attribute, A2: Attribute { ... }
public static bool HasAttribute<A1>(this PropInfo pi) where A: Attribute {...};
foreach(var pi in typeof(WindowType).GetProperties<Attr1, attr2>())
  if (pi.HasAttribute<Attr1>())
    ...

public static void WhenIs<T>(this object o, Action<T> action) { 
  if (Typeof(T).IsAssignableFrom(o.GetType()))
    action((T)o);
}
a.WhenIs<SomeType>{b=>юзаем b }

    class A
    {
        private readonly Dictionary<Type, Action> helpers;

        public A()
        {
            this.helpers = new Dictionary<Type, Action>
            {
                // инициализация какими-то значениями
            };
        }

        public void Foo()
        {
            var type = someObject.GetType();

            helpers[type]();
        }
    }

    class A
    {
        public void Foo()
        {
            var someVar = //...
            var type = someObject.GetType();

            switch (type)
            {           
                case typeof(string):
                    break;
                case typeof(A):
                    break;
                case someVar.GetType():
                    break;
            }
        }
    }

        [PropertyChanging]
        [PropertyChanged]
        public int MyProperty { get; set; }

        private readonly Lazy<string> someLazy = new Lazy<string>(SomeLazyFactory);

        private string SomeLazyFactory()
        {
            return string.Empty;
        }

    class A 
    {
        public A(int i)
        {
        }
    }

    class B : A
    {
        public B()
            : base(Foo())
        {
        }

        private int Foo()
        {
            return 0;
        }
    }

            var value = 1;
            var a = new A
            {
                MyIntProperty = value,
                MyStringProperty = value.ToString()
            };

            var a = new A
            {
                MyIntProperty = 1,
                MyStringProperty = MyIntProperty.ToString()
            };

Tuple<int,string> F();

var (a, s) = F();

class F<TArg>
{
 void Method1(TArg arg1);
}
...
var info = typeOf(new F<string>()).Method1.arg1.Type.Name; // здесь генерится структура компилятором, в которой будет вся инфа о классе

Assert.AreEqual("string",info);

Expression<Func<IEnumerable<int>>> array = GetValues();

Expression e = `foreach(var item in #array) { DoSomething(item)}`;

e.Compile().Invoke();

var b = true;
using(var f = new IDisposable { void Dispose { b = false; } } )
{

}

struct Foobar {
  public string Name {get; set;}
  public Foobar(string name) {
    Name = name;
  }
}

class CollectionItem {}
class Collection 
{
    protected virtual CollectionItem CreateItem() {...}
}



class MyCollectionItem: CollectionItem {}
class MyCollection 
{
    protected override MyCollectionItem CreateItem() {...}
}

struct Foobar {
  public string Name {get; set;}
  public Foobar(string name): this() {
    Name = name;
  }
}

object obj = 1;

object[] = new int[] { 1 };

S>object obj = 1;
S>

S>object[] = new int[] { 1 };
S>

object[] x = new int[] { 1 };
x[0] = new object(); //Ахтунг

double z = (double)IntVar;

double z := IntVar;

double z = intVar;

foreach (var x in myEnum with i)
{
    if (i == 0)
        // ...
    else
        // ...
}

foreach (var x in myEnum with i)
    Console.WriteLine("{0,-2}: {1}", i + 1, x);

foreach (var x in myEnumwith i)
    DoSomething(x, myArray[i]);

class CollectionItem {}
class Collection<T> 
{
    protected virtual T CreateItem() {...}
}