foreach (var x from collection with i)

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]);

IEnumerable<Tuple<T, int>> WithIndex(this IEnumerable<T> sequence)
{
    int i = 0;
    foreach (var elem in sequence)
    {
        yield return Tuple.Create(elem, 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#). Иногда очень хочется такого и для методов (делегаты делают нечто похожее), полей и свойств. Таким образом рефакторинг таких вещей происходил бы менее болезненно.
  
• И всякие плюшки в виде интерполированных строк, литералы для регулярок, этц, хотя это уже на любителя...

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();

                             // V - для своего lookupIndexedEnumValue() в ответ на жирный аналог в LengthUnit.Parse
public enum RoleType implements IIndexable<String>, IRoleAuthorizationContextFactory  {

    ADMINISTRATOR("admin") {
        @Override
        public IRoleAuthorizationContext createRoleAuthorizationContext(Request request) {
            return new AdministratorRoleAuthorizationContext();
        }
    },

    EDITOR("editor") {
        @Override
        public IRoleAuthorizationContext createRoleAuthorizationContext(Request request) {
            return new EditorRoleAuthorizationContext(request);
        }
    };

    private final String alias;

    RoleType(String alias) {
        this.alias = alias;
    }

    @Override
    public final String getIndexKey() {
        return alias;
    }

}

public interface IService {

    @Role(ADMINISTRATOR)
    void foo();

    @Role(EDITOR)
    void bar();

}

public enum RoleType
{
    ADMINISTRATOR,
    EDITOR;

    public IRoleAuthorizationContext ToContext(Request request)
    {
        switch (value)
        {
            case ADMINISTRATOR: return new AdministratorRoleAuthorizationContext(); break;
            case EDITOR:        return new EditorRoleAuthorizationContext(request); break;
            default:            throw new Exception("A new role was added with no converting code."); break;
        }
    }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class RoleTypeAttribute : System.Attribute
{
    ...
}

public interface IService
{
    [RoleTypeAttribute(RoleType.ADMINISTRATOR)]
    void foo();

    [RoleTypeAttribute(RoleType.EDITOR)]
    void bar();
}

Well, I can't answer why it's not available, but I can confirm that it's not a CLI issue. The CLI spec doesn't mention it (as far as I can see) and if you use IL directly you can create a generic attribute. The part of the C# 3 spec that bans it — section 10.1.4 "Class base specification" doesn't give any justification.

The annotated ECMA C# 2 spec doesn't give any helpful information either, although it does provide an example of what's not allowed.

My copy of the annotated C# 3 spec should arrive tomorrow... I'll see if that gives any more information. Anyway, it's definitely a language decision rather than a runtime one.

EDIT: Answer from Eric Lippert (paraphrased): no particular reason, except to avoid complexity in both the language and compiler for a use case which doesn't add much value.

public enum RoleType
{
    ADMINISTRATOR,
    EDITOR;

    public IRoleAuthorizationContext ToContext(Request request)
    {
        switch (value)
        {
            case ADMINISTRATOR: return new AdministratorRoleAuthorizationContext(); break;
            case EDITOR:        return new EditorRoleAuthorizationContext(request); break;
            default:            throw new Exception("A new role was added with no converting code."); break;
        }
    }
}

public interface IService
{
    [System.EnumAttribute<RoleType>(RoleType.ADMINISTRATOR)]
    void foo();

    [System.EnumAttribute<RoleType>(RoleType.EDITOR)]
    void bar();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Role { // аналог аттрибута; аналога AllowMultiple не существует

    RoleType value();    // RoleType - само перечесление, которое можно использовать в качестве значения анотации (value можно опускать)

}

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

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

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

...

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

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).

match (RuleSymbol)
{
  | ExtensibleRuleSymbol => ()
  | ExtentionRuleSymbol(BaseRule = RuleRef.Some(baseRuleSymbol), ExtentionType = Prefix) =>
    defineExtentionRuleMethods(baseRuleSymbol)

  | ExtentionRuleSymbol(BaseRule = RuleRef.Some(baseRuleSymbol), ExtentionType = Postfix(bindingPower, _)) =>
    defineExtentionRuleMethods(baseRuleSymbol);
    _descriptorTb.DefineConditional(<[decl: public override BindingPower : int { get { $(bindingPower : int) } } ]>);

  | SimpleRuleSymbol  => defineNewParserMethod(<[ N2.Internal.SimpleRuleParser ]>);
  | RegularRuleSymbol => ()
  | _       => assert(false)
}

class C(int firstField, string secondField)
{
}
...
var c = C(42, "wow");
Console.WriteLine(c.firstField);

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};

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

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

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"
}

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, то перестанет компилиться.
}

when (x is Y as y)
{
  ...
}

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

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

    return result;
}

T* pT1= (T*)Marshal.AllocHGlobal(n*Marshal.SizeOf(typeof(T)));

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)

double z = (double)IntVar;

double z := IntVar;

double z = intVar;

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: приводить объект к интерфейсу, если он совместим по методам. Уж лучше в рантайме всё **нётся, зато в коде можно очень элегантно обруливать всякое гетерогенное фуфло из разных иерархий.

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 }

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

    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()
            };

public class Tester {

    /**
     * @param args
     */
    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        int m = 1024 * 1024;
        Test(100 * m);
        long end = System.currentTimeMillis();
        System.out.println("time" + (end - start));

    }

    static void Test(int limit_) {
        int limit = limit_;
        int sqr_lim;
        boolean[] is_prime = new boolean[limit + 1];
        int x2, y2;
        int i, j;
        int n;

        sqr_lim = (int) Math.sqrt(limit);
        for (i = 0; i <= limit; i++)
            is_prime[i] = false;
        is_prime[2] = true;
        is_prime[3] = true;

        x2 = 0;
        for (i = 1; i <= sqr_lim; i++) {
            x2 += 2 * i - 1;
            y2 = 0;
            for (j = 1; j <= sqr_lim; j++) {
                y2 += 2 * j - 1;

                n = 4 * x2 + y2;
                if ((n <= limit) && (n % 12 == 1 || n % 12 == 5))
                    is_prime[n] = !is_prime[n];

                // n = 3 * x2 + y2;
                n -= x2;
                if ((n <= limit) && (n % 12 == 7))
                    is_prime[n] = !is_prime[n];

                // n = 3 * x2 - y2;
                n -= 2 * y2; //
                if ((i > j) && (n <= limit) && (n % 12 == 11))
                    is_prime[n] = !is_prime[n];
            }
        }

        for (i = 5; i <= sqr_lim; i++) {
            if (is_prime[i]) {
                n = i * i;
                for (j = n; j <= limit; j += n) {
                    is_prime[j] = false;
                }
            }
        }

    }

}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace cappTestPrime
{
    public class Tester
    {


        public static void Main(String[] args)
        {

            var sw = Stopwatch.StartNew();

            int m = 1024 * 1024;

            Test(100 * m);

            var end = sw.ElapsedMilliseconds;
            Console.WriteLine("elapsed=" + end);


        }

        static void Test(int limit_)
        {
            int limit = limit_;
            int sqr_lim;
            bool[] is_prime = new bool[limit + 1];
            int x2, y2;
            int i, j;
            int n;

            sqr_lim = (int)Math.Sqrt(limit);

            for (i = 0; i <= limit; i++)
                is_prime[i] = false;
            is_prime[2] = true;
            is_prime[3] = true;

            x2 = 0;
            for (i = 1; i <= sqr_lim; i++)
            {
                x2 += 2 * i - 1;
                y2 = 0;
                for (j = 1; j <= sqr_lim; j++)
                {
                    y2 += 2 * j - 1;

                    n = 4 * x2 + y2;
                    if ((n <= limit) && (n % 12 == 1 || n % 12 == 5))
                        is_prime[n] = !is_prime[n];

                    // n = 3 * x2 + y2;
                    n -= x2;
                    if ((n <= limit) && (n % 12 == 7))
                        is_prime[n] = !is_prime[n];

                    // n = 3 * x2 - y2;
                    n -= 2 * y2; // 
                    if ((i > j) && (n <= limit) && (n % 12 == 11))
                        is_prime[n] = !is_prime[n];
                }
            }

            for (i = 5; i <= sqr_lim; i++)
            {
                if (is_prime[i])
                {
                    n = i * i;
                    for (j = n; j <= limit; j += n)
                    {
                        is_prime[j] = false;
                    }
                }
            }

        }

    }
}

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;
  }
}

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

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



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

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(); //Ахтунг

void Test(object sender)
{
    if (sender is not Smth1)
    {
    }
}

void Test(object sender)
{
    if (!(sender is Smth1))
    {
    }
}

FE>void Test(object sender)
FE>{
FE>    if (sender is not Smth1)
FE>    {
FE>    }
FE>}
FE>

public static class ObjectExtensions
{
    public static bool IsNot<T>(this object obj)
    {
        return obj is T == false;
    }
}

            list.ForEach((item) =>
                {
                    item.SetValue(1);
                });

            for (int i = 0; i < list._array.Length; i++)
            {
                list._array[i]._value = 1;
            }

id = new Guid("218a8084-1e3d-4afa-8783-41df0147032d")

id = g218a80841e3d4afa878341df0147032d

class MyClass:IDisposableException
{
   public MyClass(Context c){...}
   public void Dispose(){ context.Commit();}
   public void Dispose(Exception e)
   {
    context.Rollback();
    Log.Exception(e);
    throw;
   }
}

void main()
{
   using(new MyClass(new Context()))
   {
/// do something
   }
}

void main()
{
   var myClass=new MyClass(new Context());
   bool bDisposed;
   try
   {
///do something
   }
   catch(Exception e)
   {
      myClass.Dispose(e);
      bDisposed=true;
   }
   finally
   {
      if (!bDisposed)
          myClass.Dispose();
   }

}

switch (myObj)
{
   case typeof(MyClass):....
   case typeof(MyClass2):....
}

    //Base interfaces
    interface IXmlNode
    {
        IList<IXmlNode> Children { get; }
    }

    interface IXmlElement : IXmlNode
    {
    }

    // Simple implementation
    class XmlNodeBase : IXmlNode
    {
        public IList<IXmlNode> Children
        {
            get { return children; }
        }
        IList<IXmlNode> children = new List<IXmlNode>();
    }

    class XmlElementBase : XmlNodeBase, IXmlElement
    {
    }

    //Real Implementation
    class MsXmlNode : XmlNodeBase
    {
    }

    class MsXml : MsXmlNode, XmlElementBase//Error here!
    {
    }

//создаю лексему, которая ведёт себя как тип
    let dictionary = dictionary<KeyType KeyName, ValueType ValueName> : Type
        where KeyType: Type, KeyName: Identifier, ValueType: Type, ValueType: Identifier
    {
        class @item : KeyValuePair<KeyType, ValueType>
        {
            public KeyType KeyName { get { return base.Key; } set { base.Key = value; }}
            public ValueType ValueName { get { return base.Value; } set { base.Value = value; }}
        }
        class @ : IEnumerable<@item>
        {
        }
    }

//В итоге могу писать так:
var test = new dictionary<string passport, string fullname>();
foreach(var i in test)
    Console.WriteLine("{0}->{1}", i.passport, i.fullname);

int _prop;
int Prop
{
   get{ return _prop; }
   set
   {
     if(_prop!=value)
     {
        _prop=value;
        Update();
     }
   }
}

int Prop{ onchange { Update(); } }

public (string a, int b) Function()
{
  return new { a = "text", b  = 1 };
}

string! str = null; //compile time error

  list.Where(it => it < 5);

  list.Where(it < 5);

list where it < 5

[RaisesPropertyChanged]
public string Str {get; set; }

[2, 3, 5].Aggregate(_ * _) // 30

 public static implicit operator IEnumerable<MyOperator<T>>(IEnumerable<T> src)
        {
            return src.Select(a => MyOperator<T>.Create(a));
        }

public class MyOperator<T>
    {

 
using(var res=CreateSomeResource()) {
  // сечас компилятор генерит такой код что возможно вызвать Abort для потока и ресурсу не будет вызван Dispose();
}

class A {
static public [dllimport(.....)] [SomeAttr] ... {
  void fn1() {}
  void fn2() {}
}
или во
#prefixregion static public [Attr1] [Attr2] ...
...
#endregion
}

enum Bits { B0=1,B1=2,B2=4,B3=8 };
...
int r1=(int)( Bits.B0 | Bits.B1 | Bits.B2 | Bits.B3);
int r2=(int) using(Bits) B0|B1|B2;
...
void fn(Bits bits) {...}
...
fn(using(Bits) B0|B1|B2|B3);
или чтоб по умолчанию так было
fn( B0|B1|B2|B3 );

  Action a1;
  if (a1!=null) a1();

  Action<string> trace
  if (trace!=null) trace( prepare_string_for_trace() );

  if (a!=null && a.b!=null && a.b.c!=null && a.b.c.d!=null) a.b.c.d( retrive_some_args() );

  // что бы было примерно так
  call a1();
  call trace( prepare_string_for_trace );
  call a.b.c.d( retrive_some_args() );

  bool enable=true;
  after_each_line(enable, source_file => trace( "{0}:{1}", source_file.Name, source_file.Line ), ()=> {
     fn1();
     fn2();
     fn3();
     fn4();
  });
  ...
  bool enable=true;
  Action<SourceFile> fn=!enable ? null : source_file => trace( "{0}:{1}", source_file.Name, source_file.Line);
  fn1(); if (fn!=null) fn(new SourceFile() { Name="src.cs", Line=100, ... });
  fn2(); if (fn!=null) fn(new SourceFile() { Name="src.cs", Line=101, ... });
  fn3(); if (fn!=null) fn(new SourceFile() { Name="src.cs", Line=102, ... });
  fn4(); if (fn!=null) fn(new SourceFile() { Name="src.cs", Line=103, ... });

...
public int value=5 { get;set;modify; }
...
value.modify+=()=>{ ... };
или так
onchange(value)+=()=> {...};

for(int a=0;i<N;++a) {
case first: {}
case last: {}
case odd: {}
case even: {}
case enter: {}
case leave: {}
case if (a%3==2) {}
// every step
}
...
foreach(var it in list) {
case first: {}
case last: {}
case odd: {}
case even: {}
case enter: {}
case leave: {}
case if (cond(it)) {}
// ordinary
}

class A {
   public event void dyn_fn(object prm) { ... }
}
...
class A {
   Action<object> dyn_fn=dyn_fn_default;
   void dyn_fn_default(object prm) { ... }
}

class A {
  void fn(int x) switch;
  void fn(int x) case x=0 { ... }
  void fn(int x) case (x>10 && x<100) { ... }
  void fn(int x) case default { ... }
}
class B : public A {
  void fn(int x) case (x>200 && x<214) { ... }
}

   class A {
     public switch cases;
     void fn(int cmd) {
        switch(cases(cmd)) {
          case 0: { ... } break;
          case 1: { ... } break;
          default: { ... } break;
        }
     }
   }
   class B : public A {
     void fn(int cmd) {
        switch(cases(cmd)) {
          case 2: { ... } break;
          case 3: { ... } break;
        }
     }
   }
   ...
   var b=new B();
   b.cases.add(4, cmd=> { ... });
   b.cases.add(5, cmd=> { ... });

   class A {
     public static void fn(string msg) { var ctx=ThreadContext::GetCurrentThreadContext(); var recorder=ctx.Resolve<IRecorder>();  recorder.Record(msg); }
     int x;
     public int X { 
       get { 
         #if AUTOMATIC_DEBUG
         var ctx=ThreadContext::GetCurrentThreadContext(); var bp=ctx.Resolve<IBreakPoints>(); 
         bp.NotifyReadAccess(this,"A.get_X",x)
         #endif
         return x; 
       } 
       set { 
         #if AUTOMATIC_DEBUG
         var ctx=ThreadContext::GetCurrentThreadContext(); var bp=ctx.Resolve<IBreakPoints>(); 
         bp.NotifyWriteAccess(this,"A.set_X",value);
         #endif
         x=value;
       }
   }

  interface A {
    void f1(int x,int y);
    string f2(int x,int y,param object[] args);
    int X { get;set; }
    ...
  }
  class AWrapper : public A() {
    public A a;
    public void f1(int x,int y) { a.f1(x,y); }
    public string f2(int x,int y,param object[] args) { return a.f2(x,y,args); };
    public int X { get { return a.X; } set { a.X=value; } }
    ...
  }

  int ret=0;
  assume (res>0) or throw new Exception(GetErrorMessage(res)) {
     ret=DoOp1();
     ret=DoOp2();
     ret=DoOp3();
  }
  ...
  Action<string> action=null;
  ...
  assume (action!=null) or skip {
     ...
     action("some message");
     ...
     action("some message");
     ...
  }
  assume possible or skip {
     a.b.c.d.e.f=1; // проверять возможно ли выполнить такое действие если да то выполнить и ничего не делать если не возможно например a.b.c.d=null
  }
  assume no return {
     ...
     return 1; // ошибку компиляции если встретился return
     ...
  }
  object a=...;
  assume a is Control or skip {
    a.Name="name";
  }
  ...

  int res=0;
  {
     ret=DoOp1(); if (!(res>0)) throw new Exception(GetErrorMessage(res));
     ret=DoOp2(); if (!(res>0)) throw new Exception(GetErrorMessage(res));
     ret=DoOp3(); if (!(res>0)) throw new Exception(GetErrorMessage(res));
  }
  Action<string> action=null;
  ...
  {
    if (action!=null) action("some message");
    ... 
    if (action!=null) action("some message");
    ...
  }
  // no return - на уровне компилятора (чтоб рефакторить длиныые портянки if-ов или switch-ей)
  {
     if (a!=null && a.b!=null && a.b.c!=null && a.b.c.d!=null && a.b.c.d.e!=null) a.b.c.d.e.f=1;
     // try { a.b.c.d.e.f=1; } catch {}
  }

  object a=...;
  if (a is Control) { Control local_a=(Control)a;
    local_a.Name="name";
  }

   void Foo(int x) {
     int Bar(int a) { ... }
     Bar(x);
   }
   // а не только так
   void Foo(int x) {
     Func<int,int> Bar=(a)=>{ ... };
     Bar(x);
   }

int Property { get; initonly set; }

class C
{
  private Cl2 _member;
  ...
  wrappers(_member)
  {
     int Prop1{get;set;}
     int Func1(int p1, ref int p2);
     ...
  }
}

class C
{
  private Cl2 _member;
  public Prop1{ get{return _member.Prop1;} set{_member.Prop1=value;} }
  public int Func1(int p1, ref int p2){ return member.Func1(p1, ref p2); }
  ...
}