O uso de 'var' afetará o desempenho?

Anteriormente, fiz uma pergunta sobre por que vejo tantos exemplos usando a varpalavra - chave e obtive a resposta de que, embora seja necessário apenas para tipos anônimos, ela é usada para tornar o código de escrita 'mais rápido' / mais fácil e 'apenas porque'.

Seguindo este link ("C # 3.0 - Var Isn't Objec") , vi que ele varé compilado no tipo correto na IL (você verá este artigo no meio do caminho).

Minha pergunta é quanto mais, se é que existe algum, código IL usando a varpalavra - chave, e seria mesmo perto de ter um nível mensurável no desempenho do código se ele fosse usado em qualquer lugar?

Não há código de IL extra para a varpalavra-chave: o IL resultante deve ser idêntico para tipos não anônimos. Se o compilador não puder criar essa IL porque não consegue descobrir qual tipo você pretendia usar, você receberá um erro do compilador.

O único truque é varinferir um tipo exato em que você pode ter escolhido um tipo de interface ou pai, se definir o tipo manualmente.

Atualização 8 anos depois

Preciso atualizar isso, pois meu entendimento mudou. Agora acredito que pode ser possível varafetar o desempenho na situação em que um método retorna uma interface, mas você usaria um tipo exato. Por exemplo, se você tiver este método:

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

Considere estas três linhas de código para chamar o método:

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

Todos os três compilam e executam conforme o esperado. No entanto, as duas primeiras linhas não são exatamente iguais, e a terceira linha corresponderá à segunda, e não à primeira. Como a assinatura de Foo()é retornar um IList<int>, é assim que o compilador criará a bar3variável.

Do ponto de vista do desempenho, principalmente você não notará. No entanto, há situações em que o desempenho da terceira linha pode não ser tão rápido quanto o desempenho da primeira . À medida que você continua a usar a bar3variável, o compilador pode não conseguir despachar as chamadas de método da mesma maneira.

Observe que é possível (provavelmente até) o jitter será capaz de apagar essa diferença, mas isso não é garantido. Geralmente, você ainda deve considerar varum fator não em termos de desempenho. Certamente não é como usar uma dynamicvariável. Mas dizer que nunca faz diferença pode estar exagerando.

Como Joel diz, o compilador calcula em tempo de compilação o tipo var, efetivamente é apenas um truque que o compilador executa para salvar pressionamentos de tecla, por exemplo, por exemplo

var s = "hi";

é substituído por

string s = "hi";

pelo compilador antes de qualquer IL ser gerada. O IL gerado será exatamente o mesmo que se você tivesse digitado a string.

Como ninguém mencionou refletor ainda ...

Se você compilar o seguinte código C #:

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

Então use o refletor nele, você obtém:

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

Portanto, a resposta é claramente sem desempenho de tempo de execução atingido!

Para o seguinte método:

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

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

A saída IL é esta:

        {
          .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

O compilador C # infere o tipo verdadeiro da varvariável em tempo de compilação. Não há diferença na IL gerada.

Portanto, para deixar claro, é um estilo de codificação preguiçoso. Eu prefiro tipos nativos, dada a escolha; Vou usar esse "ruído" extra para garantir que estou escrevendo e lendo exatamente o que acho que estou no momento do código / depuração. * dar de ombros *

Acho que você não entendeu direito o que leu. Se ele é compilado para o tipo correto, então não é nenhuma diferença. Quando eu faço isso:

var i = 42;

O compilador sabe que é um int e gera código como se eu tivesse escrito

int i = 42;

Como diz a postagem que você vinculou, ela é compilada para o mesmo tipo. Não é uma verificação de tempo de execução ou qualquer outra coisa que exija código extra. O compilador apenas descobre qual deve ser o tipo e o usa.

Não há custo de desempenho de tempo de execução no uso de var. No entanto, eu suspeitaria que haja um custo de desempenho de compilação, pois o compilador precisa inferir o tipo, embora isso provavelmente seja insignificante.

Se o compilador puder fazer inferências automáticas de tipo, não haverá nenhum problema com o desempenho. Ambos irão gerar o mesmo código

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

no entanto, se você estiver construindo o tipo dinamicamente (LINQ ...), então varé sua única pergunta e há outro mecanismo para comparar, a fim de dizer qual é a penalidade.

Eu sempre uso a palavra var em artigos da web ou orienta escritos.

A largura do editor de texto do artigo online é pequena.

Se eu escrever isso:

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

Você verá que o texto do código pré renderizado acima é muito longo e sai da caixa; ele fica oculto. O leitor precisa rolar para a direita para ver a sintaxe completa.

É por isso que eu sempre uso a palavra-chave var nos escritos de artigos da web.

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

Todo o código pré renderizado se encaixa na tela.

Na prática, para declarar objetos, raramente uso var, confio no intellisense para declarar objetos mais rapidamente.

Exemplo:

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

Mas, para retornar objetos de um método, uso var para escrever código mais rapidamente.

Exemplo:

var coolObject = GetCoolObject(param1, param2);

"var" é uma daquelas coisas que as pessoas amam ou odeiam (como regiões). Embora, diferentemente das regiões, var seja absolutamente necessário ao criar classes anônimas.

Para mim, var faz sentido quando você está atualizando um objeto diretamente como:

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

Dito isto, você pode facilmente fazer:

Dictionary<string, string> dict = O novo e o intellisense preencherão o resto para você aqui.

Se você deseja trabalhar apenas com uma interface específica, não poderá usar var, a menos que o método que você está chamando retorne a interface diretamente.

O compartilhador parece estar do lado de usar "var" por toda parte, o que pode levar mais pessoas a fazer dessa maneira. Mas eu meio que concordo que é mais difícil ler se você está chamando um método e não é óbvio o que está sendo retornado pelo nome.

O var não reduz a velocidade das coisas, mas há uma ressalva sobre isso que muitas pessoas não pensam. Se você fizer var result = SomeMethod();isso, o código a seguir espera algum tipo de resultado, onde você chamaria vários métodos ou propriedades ou qualquer outra coisa. Se você SomeMethod()mudou sua definição para outro tipo, mas ainda cumpriu o contrato que o outro código esperava, você acabou de criar um bug muito desagradável (se não houver testes de unidade / integração, é claro).

Depende da situação, se você tentar usar, este código abaixo.

A expressão é convertida em "OBJECT" e diminui muito o desempenho, mas é um problema isolado.

CÓDIGO:

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

Resultados acima com 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();
}

Se você deseja executar este código, use o código abaixo e obtenha a diferença de tempos.

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

Saudações