//primary constructors - 
public class Point(int x, int y) { }
//read only auto-properties - 
public int X { get; } = x;
//static type using statements - 
using System.Math;
//property expressions - 
public double Distance => Sqrt(X * X + Y * Y);
//method expressions - 
public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
//params for enumerables - 
public Point Average(params IEnumerable<Point> points) { }
//monadic null checking - 
if (points?.FirstOrDefault()?.X ?? -1) { }
//constructor type parameter inference - 
var t = new Tuple(1,2); // infers Tuple<T1, T2>
//inline declarations for out params - 
public void Foo(out var x, out var y) { }

class A
{
 public X : int { get; }
 
 public this()
 {
  X = 1; // Транслируется в hidden_field_X = 1;
  F(ref X); // F(ref hidden_field_X)
 }
}

class A
{
 public X : int { get; default 1 }
 public Y : int { get; set; default 2 }
}

public F(params int[] x) { }

F(1,2,3) // F(new [] {1,2,3})

public class Point
{
  private int x;
  private int y;

  public Point(int x, int y)
  {
    this.x = x;
    this.y = y;
  }  
}

А>Больше говнокода! Даёшь жабоскрипт!

private int _x = x;
public int X { get { return x; } }

var a = (var x = Foo(); var y = Bar(x); FooBar(y));

var x = Foo(out var x, out var y);

AVK>var a = (var x = Foo(); var y = Bar(x); FooBar(y));
AVK>

public noreturn int X { get { 1 } }

AVK>var x = Foo(out var x, out var y);
AVK>

mutable x, y;
def z = Foo(out x, out y);

public int X { get; } = x
// при наличии
public int X { get { return x; } }

S>public int X { get; } = x
S>// при наличии
S>public int X { get { return x; } }
S>

S>?

public int X { get; } = x

public int X { get { return _x; } }
private readonly int _x = x;

public int X { readonly x; get; }

S>и то логичнее смотрится

class Q
{
  public X : int { get; } // Создаем поля для чтения
  public Y : int { get; default 1 } // Создаем поля для чтения + инициализация
  public Z : int { get; set; default 2 } // Создаем поля для чтения и записи + инициализация
 
  public this()
  {
    F(out X); // out применяется к внутреннему полю
  }
  
  F(out x : int) { x = 1; }
}

var q = if(true)=> 1 else 2;

S>public int X { get; } = x
S>// при наличии
S>public int X { get { return x; } }
S>

S>?

public int X { get; } = x

// при наличии
private int _x = x;
public int X { get { return _x; } }

S>>>и то логичнее смотрится

public int X {get;} = CalculateX();

if ((var y = x as SomeClass) != null)
    Foo(y);
else
  Bar();

_NN>>Что тело 'then' и 'else' будет выражением а не просто блоком кода, т.е. что-то возвращает и тогда это можно будет использовать справа от присваивания

Это сломает совместимость. Впрочем, кое что на эту тему, возможно, будет:
var a = (var x = Foo(); var y = Bar(x); FooBar(y));

var a = true 
    ? (var x = Foo(); var y = Bar(x); FooBar(y)) 
    : (var x = FooBar(10); var y = Bar(x - 5); FooBar(y));

var x = y as X;
if (x != null)
...

var (a, b, c) = new Tuple(42, "a", 2.3);

_NN>mutable x, y;
_NN>def z = Foo(out x, out y);
_NN>

var x = !map.TryGetValue(42, out var value) ? value : -1;

public class Point(int x, int y)
{
  public int X => x;
  public int Y => y;
  public int Dist { get; } = Math.Sqrt(x * x + y * y);
}

VD>var (a, b, c) = new Tuple(42, "a", 2.3);
VD>

public var F()
{
  return new { Name = "A", Age = 10 };
}

<int a; string b;> Foo()
{
  return new { a=42, b="text" };
}

int Prop1 { get; default 42; }
int Prop2 { get x * y; default 42; }
int Prop3 { get { x * y; } default 42; }
int Prop3 { get { return x * y; } default 42; }

int Foo() = 42;

ЕА>public var F()
ЕА>{
ЕА>  return new { Name = "A", Age = 10 };
ЕА>}
ЕА>

public <string Name, int Age> F()
{
  return new { Name = "A", Age = 10 };
}

X : int { get; } = 42;