c#: 4 способа написания одного и того же кода. У всех одинаковая производительность?

Question

Все ли эти 4 способа записи 1 + 1 имеют одинаковую производительность?

1.

return 1 + 1;

2.

int x = 1 + 1;
return x;

3.

var x = 1 + 1;
return x;

4.

int getInt()
{ return 1 + 1;}
return getInt();

Answer 1

Когда вы пишете приложение C#, оно компилируется в промежуточный язык, а затем во время выполнения дополнительно компилируется в код процессора. Обе эти ситуации позволяют оптимизировать инструкции программы.

В приведенных вами примерах все они в основном составлены по тем же инструкциям, что и предоставляемая оптимизация, используемая для вашей выгоды.

Учитывая

public int Method1()
{
   return 1 + 1;
}

public int Method2()
{
   int x = 1 + 1; 
   return x;
}

public int Method3()
{
   var x = 1 + 1;   
   return x;
}

int getInt()
{
   return 1 + 1;
}

public int Method4()
{
   return getInt();
}

Ваш код, вероятно, будет преобразован в следующие инструкции

C.Method1()
    L0000: mov eax, 0x2
    L0005: ret

C.Method2()
    L0000: mov eax, 0x2
    L0005: ret

C.Method3()
    L0000: mov eax, 0x2
    L0005: ret

C.getInt()
    L0000: mov eax, 0x2
    L0005: ret

C.Method4()
    L0000: mov eax, 0x2
    L0005: ret

_{Примечание : Выше приведено только представление о том, как все они могут быть преобразованы в один и тот же набор команд, в действительности каждый метод в примере с острым шрифтом io будет вставлен в mov ecx, 0x2, как Пассант Ганса , правильно указанный в комментариях}

Короче говоря (и в этой ситуации) нет заметной разницы с вашими вариантами кода, поэтому все сводится к тому, как вам нравится писать код. Однако в других ситуациях платформа использует сложный набор правил для управления оптимизациями, которые могут быть не такими четкими.

Сказав все это: лучше не беспокоиться о таких оптимизациях преждевременно и сосредоточиться на написании хороших чистый код, который легко читается и поддерживается, и если у вас есть проблемы с производительностью, потратьте время на профилирование. Хотя такой подход кажется расточительным, время, потраченное на преждевременную оптимизацию, теряется впустую (если только у вас нет проблем с производительностью). Есть больше фи sh для жарки и еще больше денег.

Answer 2

В качестве дополнительного примечания, поскольку кажется, что вы не понимаете C# var правильно, эти два примера:

int x = 1 + 1;
return x;

И,

var x = 1 + 1;
return x;

Точно так же. var в C# означает: «Вы, компилятор, самостоятельно выясните тип x, я предоставил вам достаточно информации, чтобы сделать это возможным».

var не специальный тип, который может содержать что угодно (вариант VB). Компилятор выяснит, что var равно int, поскольку 1 + 1 является целочисленной константой. Если вы используете VS (и я уверен, что другие IDE), если вы наведете курсор на var, вы увидите всплывающее окно, сообщающее вам, какой тип компилятор сумел вывести.

Answer 3

Вы получите одинаковые результаты для всех методов в режиме выпуска,

для этого ->

    private static int SimpleAdd()
    {
        return 1 + 1;
    }

    private static int SimpleAddWithInt()
    {
        int x = 1 + 1;
        return x;
    }
    private static int SimpleAddWithVar()
    {
        var x = 1 + 1;
        return x;
    }
    private static int SimpleAddWithFunc()
    {
        int getInt()
        { return 1 + 1; }
        return getInt();
    }

вы получите:

private static int SimpleAdd()
{
    return 2;
}

private static int SimpleAddWithInt()
{
    return 2;
}

private static int SimpleAddWithVar()
{
    return 2;
}

private static int SimpleAddWithFunc()
{
    return <SimpleAddWithFunc>g__getInt|4_0();
}

[CompilerGenerated]
private static int <SimpleAddWithFunc>g__getInt|4_0()
{
    return 2;
}

Джитед:

TestPerformace.Program.SimpleAdd()
L0000: mov eax, 0x2
L0005: ret

TestPerformace.Program.SimpleAddWithInt()
L0000: mov eax, 0x2
L0005: ret

TestPerformace.Program.SimpleAddWithVar()
L0000: mov eax, 0x2
L0005: ret

TestPerformace.Program.SimpleAddWithFunc()
L0000: mov eax, 0x2
L0005: ret

Джитед

SharpLab