Повлияет ли использование var на производительность?

Ранее я задал вопрос о том, почему я вижу, что во многих примерах используется varключевое слово, и получил ответ, что, хотя это необходимо только для анонимных типов, оно, тем не менее, используется для того, чтобы сделать написание кода «быстрее» / проще и «просто потому что».

По этой ссылке («C # 3.0 - Var Is Not Objec») я увидел, что он varскомпилирован в правильный тип в IL (вы увидите его в середине статьи).

Мой вопрос заключается в том, насколько больше, если таковой имеется, IL-кода использует varключевое слово take, и будет ли оно даже близко к измеряемому уровню производительности кода, если бы он использовался повсеместно?

Для varключевого слова нет дополнительного кода IL : полученный IL должен быть идентичным для неанонимных типов. Если компилятор не может создать этот IL, потому что он не может определить, какой тип вы намеревались использовать, вы получите ошибку компилятора.

Единственная хитрость в том, что вы varполучите точный тип, в котором вы, возможно, выбрали интерфейс или родительский тип, если вам нужно было установить тип вручную.

Обновление 8 лет спустя

Мне нужно обновить это, так как мое понимание изменилось. Теперь я считаю, что это может varповлиять на производительность в ситуации, когда метод возвращает интерфейс, но вы бы использовали точный тип. Например, если у вас есть этот метод:

IList<int> Foo()
{
    return Enumerable.Range(0,10).ToList();
}

Рассмотрим эти три строки кода для вызова метода:

List<int> bar1 = Foo();
IList<int> bar = Foo();
var bar3 = Foo();

Все три компилируются и выполняются, как и ожидалось. Однако первые две строки не совсем совпадают, а третья строка будет соответствовать второй, а не первой. Поскольку подпись Foo()должна возвращать IList<int>, именно так компилятор будет создавать bar3переменную.

С точки зрения производительности, в основном вы не заметите. Однако существуют ситуации, когда производительность третьей строки может быть не такой быстрой, как производительность первой . Поскольку вы продолжаете использовать bar3переменную, компилятор может не иметь возможности отправлять вызовы методов одинаково.

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

Как говорит Джоэл, компилятор работает при компиляции , что должно быть тип вар, эффективно это просто трюк выполняет компилятор , чтобы сохранить нажатия клавиш, так, например ,

var s = "hi";

заменяется

string s = "hi";

компилятором до того, как будет сгенерирован любой IL. Сгенерированный IL будет точно таким же, как если бы вы набрали строку.

Как никто еще не упомянул отражатель ...

Если вы компилируете следующий код C #:

static void Main(string[] args)
{
    var x = "hello";
    string y = "hello again!";
    Console.WriteLine(x);
    Console.WriteLine(y);
}

Затем, используя отражатель, вы получите:

// Methods
private static void Main(string[] args)
{
    string x = "hello";
    string y = "hello again!";
    Console.WriteLine(x);
    Console.WriteLine(y);
}

Таким образом, ответ явно не влияет на производительность во время выполнения!

Для следующего метода:

   private static void StringVsVarILOutput()
    {
        var string1 = new String(new char[9]);

        string string2 = new String(new char[9]);
    }

Выход IL это:

        {
          .method private hidebysig static void  StringVsVarILOutput() cil managed
          // Code size       28 (0x1c)
          .maxstack  2
          .locals init ([0] string string1,
                   [1] string string2)
          IL_0000:  nop
          IL_0001:  ldc.i4.s   9
          IL_0003:  newarr     [mscorlib]System.Char
          IL_0008:  newobj     instance void [mscorlib]System.String::.ctor(char[])
          IL_000d:  stloc.0
          IL_000e:  ldc.i4.s   9
          IL_0010:  newarr     [mscorlib]System.Char
          IL_0015:  newobj     instance void [mscorlib]System.String::.ctor(char[])
          IL_001a:  stloc.1
          IL_001b:  ret
        } // end of method Program::StringVsVarILOutput

Компилятор C # определяет истинный тип varпеременной во время компиляции. Там нет разницы в сгенерированном IL.

Итак, чтобы быть ясным, это ленивый стиль кодирования. Я предпочитаю нативные типы, учитывая выбор; Я возьму этот лишний «шум», чтобы убедиться, что я пишу и читаю именно то, что, как мне кажется, находится во время кода / отладки. * пожимает плечами *

Я не думаю, что вы правильно поняли, что вы читаете. Если он компилируется к правильному типу, то нет никакой разницы. Когда я делаю это:

var i = 42;

Компилятор знает, что это int, и генерирует код, как если бы я написал

int i = 42;

Как говорится в сообщении, на которое вы ссылаетесь, скомпилировано в тот же тип. Это не проверка во время выполнения или что-то еще, требующее дополнительного кода. Компилятор просто выясняет, каким должен быть тип, и использует его.

Нет никаких затрат производительности при использовании var. Тем не менее, я подозреваю, что производительность компиляции будет снижена, поскольку компилятор должен определить тип, хотя это, скорее всего, будет незначительным.

Если компилятор может делать автоматическое определение типа, то с производительностью проблем не будет. Оба из них будут генерировать один и тот же код

var    x = new ClassA();
ClassA x = new ClassA();

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

Я всегда использую слово var в веб-статьях или руководствах.

Ширина текстового редактора онлайн-статьи невелика.

Если я напишу это:

SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName coolClass = new SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName();

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

Вот почему я всегда использую ключевое слово var в записях веб-статей.

var coolClass = new SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName();

Весь представленный предварительный код просто помещается на экране.

На практике для объявления объекта я редко использую var, я полагаюсь на intellisense для более быстрого объявления объекта.

Пример:

SomeCoolNamespace.SomeCoolObject coolObject = new SomeCoolNamespace.SomeCoolObject();

Но для возврата объекта из метода я использую var, чтобы быстрее написать код.

Пример:

var coolObject = GetCoolObject(param1, param2);

«var» - это одна из тех вещей, которые люди либо любят, либо ненавидят (например, регионы). Хотя, в отличие от регионов, var абсолютно необходим при создании анонимных классов.

Для меня var имеет смысл, когда вы обновляете объект, например:

var dict = new Dictionary<string, string>();

При этом, вы можете легко сделать:

Dictionary<string, string> dict = new и intellisense заменит вам все остальное здесь.

Если вы хотите работать только с определенным интерфейсом, вы не можете использовать var, если только метод, который вы вызываете, не возвращает интерфейс напрямую.

Resharper, кажется, на стороне использования «var» повсюду, что может подтолкнуть больше людей, чтобы сделать это таким образом. Но я согласен, что читать сложнее, если вы вызываете метод, и неясно, что возвращает имя.

Сам по себе var не тормозит, но есть одна оговорка, о которой не многие думают. Если вы это сделаете, var result = SomeMethod();то код после этого ожидает некоторого результата назад, где вы будете вызывать различные методы или свойства или что-то еще. Если вы SomeMethod()изменили свое определение на какой-то другой тип, но все равно выполнили контракт, которого ожидал другой код, вы просто создали действительно неприятную ошибку (если, конечно, нет модульных / интеграционных тестов).

Это зависит от ситуации, если вы попробуете использовать этот код ниже.

Выражение преобразуется в «ОБЪЕКТ» и сильно снижает производительность, но это отдельная проблема.

КОД:

public class Fruta
{
    dynamic _instance;

    public Fruta(dynamic obj)
    {
        _instance = obj;
    }

    public dynamic GetInstance()
    {
        return _instance;
    }
}

public class Manga
{
    public int MyProperty { get; set; }
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
    public int MyProperty3 { get; set; }
}

public class Pera
{
    public int MyProperty { get; set; }
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
}

public class Executa
{
    public string Exec(int count, int value)
    {
        int x = 0;
        Random random = new Random();
        Stopwatch time = new Stopwatch();
        time.Start();

        while (x < count)
        {
            if (value == 0)
            {
                var obj = new Pera();
            }
            else if (value == 1)
            {
                Pera obj = new Pera();
            }
            else if (value == 2)
            {
                var obj = new Banana();
            }
            else if (value == 3)
            {
                var obj = (0 == random.Next(0, 1) ? new Fruta(new Manga()).GetInstance() : new Fruta(new Pera()).GetInstance());
            }
            else
            {
                Banana obj = new Banana();
            }

            x++;
        }

        time.Stop();
        return time.Elapsed.ToString();
    }

    public void ExecManga()
    {
        var obj = new Fruta(new Manga()).GetInstance();
        Manga obj2 = obj;
    }

    public void ExecPera()
    {
        var obj = new Fruta(new Pera()).GetInstance();
        Pera obj2 = obj;
    }
}

Выше результатов с ILSPY.

public string Exec(int count, int value)
{
    int x = 0;
    Random random = new Random();
    Stopwatch time = new Stopwatch();
    time.Start();

    for (; x < count; x++)
    {
        switch (value)
        {
            case 0:
                {
                    Pera obj5 = new Pera();
                    break;
                }
            case 1:
                {
                    Pera obj4 = new Pera();
                    break;
                }
            case 2:
                {
                    Banana obj3 = default(Banana);
                    break;
                }
            case 3:
                {
                    object obj2 = (random.Next(0, 1) == 0) ? new Fruta(new Manga()).GetInstance() : new Fruta(new Pera()).GetInstance();
                    break;
                }
            default:
                {
                    Banana obj = default(Banana);
                    break;
                }
        }
    }
time.Stop();
return time.Elapsed.ToString();
}

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

        static void Main(string[] args)
    {
        Executa exec = new Executa();            
        int x = 0;
        int times = 4;
        int count = 100000000;
        int[] intanceType = new int[4] { 0, 1, 2, 3 };

        while(x < times)
        {                
            Parallel.For(0, intanceType.Length, (i) => {
                Console.WriteLine($"Tentativa:{x} Tipo de Instancia: {intanceType[i]} Tempo Execução: {exec.Exec(count, intanceType[i])}");
            });
            x++;
        }

        Console.ReadLine();
    }

С уважением