//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) { }

<int x, int y> -> <string name, bool isMale>

<int, int> -> <string, bool>

S>public var X() { return new { A = 1, B = 2 }; }
S>public var Y() { return X(); }
S>

<int index> IndexOf(T value);

var a = 5;

if (condition)
  a = 10;

// и

var a = if (condition) 5 else 10;

var x = using (var db = new Db())
{
  (from a in db.Table1
  from b in db.Table2
  from c in db.Table3
  select new {a.X, b.Y, c.Relation1.GroupBy(x => x.Z)}).ToArray();
}
CallMethodWithArgument(x);

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

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

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

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

Ты, видимо, о чем то о своем, а не про razor.
...
Не розлин, а razor.

using LacalNameForRecord = <string Name, int Age>;

public <string Name, int Age> F(<string Name, int Age> param) // через параметры как-то так, но это на практике не нужно
{
  return param;
}

public LacalNameForRecord F() // через параметры как-то так, но это на практике не нужно
{
  return new { Name="A", Age=42 };
}

<string Name, int Age>

void Foo(int a, strind b);

void Foo(strind b, int a);

<int a, strind b> Foo();

<strind b? int a>  Foo();

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

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

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;

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

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;

var x = src.Count(i => try { CanThrowException(i) } catch { defaultValue });
var y = src.Sum(i => using(var rc = GetDisposableResource()) rc.Foo(i));

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

public int X { readonly x; get; }

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

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

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