LCR>MyClass c = MyClass(10, 20);
LCR>

MyClass c(10, 20);

LCR>В Джаве new было введено исключительно по политическим причинам, чтобы облегчить переход C++ программистов на Джаве облегчив им узнавание привычных конструкций (создание объектов в куче). В Шарп, вероятно, new было содрано с Джавы, дабы облегчить переход C++ и Джава — программистов на Шарп

LCR>MyClass c = MyClass(10, 20);
LCR>

MyClass MyClass()
{
    return new MyClass();
}

static void Main()
{
    MyClass c = MyClass(10, 20);
}

int[] integers;
foreach (var el in integers) ;
foreach (int el in integers) ;

Ш>>MyClass c(10, 20);
Ш>>

Interface obj = Class(1,2,3) ;

MyClass c = MyClass(10, 20);

var c = new MyClass(10, 20);

#define DEF_VAR(name, expr) typeof(expr) name = expr
// т.е.
DEF_VAR(c,new MyClass(10,20))
// аналогично
typeof(new MyClass(10,20)) c = new MyClass(10,20)

class Test { }

class Program
{
    static Test Test() { return new Test(); }
    
    static void Main(string[] args)
    {
        Test test = Test();
    }
}

return new NotImplementedException();

void f(MyClass mc)
{}

// много кода

f(MyClass(10, 20));

class BaseClass
{}

class MyClass : BaseClass
{}

// ...

BaseClass bc = new MyClass();

public class Test {
    int FunctionName()
    {
        return 1;
    }
    public static void main(String[] args)
    {
        System.out.println("Hello, world");
    }
}

class FunctionName
{
    public void doF()
    {
    }
}

O>>А как же быть, например, с явными реализациями интерфейсов в C#? Т.е. если класс явно реализует несколько интерфейсов с одинаковыми именами членов, например, да вдобавок ещё и имеет собственный член с таким же именем? Или для интерфейсов специально использовать старый синтаксис?

Кё>С трудом понимаю о чём ты — приведи код Да, старый синтаксис обязательно тоже должен остаться, `var` это просто ещё один синтаксический сахар для удобства, чтобы исключить лишнее имя типа в коде. Он просто как макрос, ничего не меняет.

interface I1
{
    string Run();
}

interface I2
{
    string Run();
}

class C1 : I1, I2
{
    public string Run()
    {
        return "C1 is running";
    }
    
    string I1.Run()
    {
        return "I1 is running";
    }
    
    string I2.Run()
    {
        return "I2 is running";
    }
}

// используемый код
C1 x = new C1();
Console.WriteLine(x.Run());        // C1 is running
Console.WriteLine(((I1)x).Run());  // I1 is running
Console.WriteLine(((I2)x).Run());  // I2 is running

// гипотетический код

var x2 = new C1();
Console.WriteLine(x2.Run());  // ну и какой же Run() вызывать?

Кё>var c = new MyClass(10, 20);
Кё>

public class Base
{
    virtual public string Hello()
    {
        return "Hi from Base";
    }
}

public class Derived : Base
{
    new public string Hello()
    {
        return "Hi from Derived";
    }
}

// работающий код
Base x = new Derived();
Console.WriteLine(x.Hello());  // Hi from Base
Console.WriteLine(((Derived)x).Hello());  // Hi from Derived

// гипотетический код
var x2 = new Derived();
Console.WriteLine(x2.Hello());  // опять же, какой Hello вызывать

Base[] array;
foreach (var x in array) {
    Console.WriteLine(x.Hello());
}

Base[] array;
foreach (Base x in array) {
    Console.WriteLine(x.Hello());
}

O>Base[] array;
O>foreach (var x in array) {
O>    Console.WriteLine(x.Hello());
O>}
O>

            ISelectionService selectionService = (ISelectionService) GetService(typeof (ISelectionService));

            auto selectionService = GetService<ISelectionService>();

O>>Base[] array;
O>>foreach (var x in array) {
O>>    Console.WriteLine(x.Hello());
O>>}
O>>

WH>            ISelectionService selectionService = (ISelectionService) GetService(typeof (ISelectionService));
WH>

WH>            auto selectionService = GetService<ISelectionService>();
WH>

ISelectionService selectionService = GetService<ISelectionService>();

MyClass c = a + <подсказка>;

def myVariable = new SomeVeryLongNamespace.SomeVeryBigType();

MyObject myObj;
myObj.Create();

Create(myObj);

VD>def myVariable = new SomeVeryLongNamespace.SomeVeryBigType();
VD>

def myVariable;
myVariable.DoSmth();

public class MyClass: BaseClass
{}

BaseClass bc = new MyClass();

> #define DEF_VAR(name, expr) typeof(expr) name = expr
> // т.е.
> DEF_VAR(c,new MyClass(10,20))
> // аналогично
> typeof(new MyClass(10,20)) c = new MyClass(10,20)
>

auto c = new MyClass(10,20);

Чтобы сократить количество мест где может возникнуть перегрузка.

Т>Ну, можно попробовать let

let a = 1.0 +. float_of_int 1;;