Будущее C#

var name = user.NoNull(x => x.Company)
  .NoNull(x => x.ParentCompany)
  .NoNull(x => x.Name, "N/A");

var total = user.NoNull(x => x.Company)
  .DefaultForNull(x => x.Users)
  .SelectMany(x => x.Email)
  .Where(x => x.EndsWith("@gmail.com"))
  .Count();

    public static TResult NoNull<TObject, TResult>(this TObject obj, Func<TObject, TResult> accessor, TResult defaultingTo = default(TResult)) {
        if (ReferenceEquals(obj, null))
            return defaultingTo;
        return accessor.Invoke(obj);
    }

    public static IEnumerable<TResult> DefaultForNull<TObject, TResult>(this TObject obj, Func<TObject, IEnumerable<TResult>> accessor, IEnumerable<TResult> defaultingTo = null) {
        if (ReferenceEquals(obj, null))
            return defaultingTo ?? Enumerable.Empty<TResult>();
        return accessor.Invoke(obj);
    }

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

public int X { get; private set;} = 100;

private int _x = 100;
public int X { get{ return _x; }; set { _x = value; } }

public int X { get; } = 100;

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

public void Test(params int[] arr)
{

}
...
int[] arr1 = new int{1,2,3};
int[] arr2 = new int{3,4,5};
Test(arr1,arr2);//ошибка

class TestClass(int x, int y)
{
int _x = x;
int _y = y;
}

Получается какой-то уход от объектно-ориентированного программирования к функциональному.

А вдруг метод будет иметь 5-6-7 параметров? Тогда пол часа будешь искать где же объявлена переменная (если не тыкать F12)

import static com.foo.myMethod;

myMethod();

var @switch = new TypeSwitch()
    .Case<string>(x => ProcessString(x, ...))
    .Case<int>(x => Process(int, ...));
@switch.On(value);

class Base {
    public void Foo() {
        Console.WriteLine("Base.Foo");
    }
}
class Derived : Base {
    public new void Foo() {
        Console.WriteLine("Derived.Foo");
    }
}

Base x = new Derived();
if (x is Derived) {
    x.Foo(); // вызываем сокрытый Base.Foo, но только если x - Derived
}

interface A
{
    void A();
}

interface B
{
    void B();
}

//...

A x = new Smth();
x.A(); //работает;
if (x is B)
{
    x.B(); //работает
    x.A(); //ошибка компиляции
}

public static T CastAs<T> (this object obj, out T value) {
  if (obj is T) {
    value = (T)obj;
    return true;
  } else {
    value = default(T);
    return false;
  }
}

public class Point3(int x, int y, int z) : Point(x, y)
{

}