“var”是人们要么喜欢要么讨厌的东西之一(就像区域一样)。不过，与区域不同，var在创建匿名类时是绝对必要的。

对我来说，当你直接像这样更新一个对象时，var是有意义的:

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

话虽如此，你可以很容易地做到:

Dictionary<string, string> dict = new和intellisense将在这里为您填充其余部分。

如果你只想使用一个特定的接口，那么你不能使用var，除非你调用的方法直接返回该接口。

Resharper似乎是在使用“var”的一边，这可能会促使更多人这样做。但我同意，如果你在调用一个方法，并且它的名称返回的是什么并不明显，那就更难读了。

Var本身并没有减慢速度，但有一个警告，很多人都没有想到。如果你执行var result = SomeMethod();之后的代码会期望返回某种结果，你会调用各种方法或属性之类的。如果SomeMethod()将其定义更改为其他类型，但它仍然满足其他代码所期望的契约，那么您就创建了一个非常严重的错误(当然，如果没有单元/集成测试)。

就像Joel说的，编译器在编译时计算出var应该是什么类型，实际上这只是编译器用来节省击键的一个技巧，举个例子

var s = "hi";

被替换为

string s = "hi";

在生成任何IL之前，编译器会调用。生成的IL将完全相同，如果你键入字符串。

使用var没有运行时性能成本。尽管如此，我怀疑编译器需要推断类型会有编译性能成本，尽管这很可能可以忽略不计。

如果编译器可以自动进行类型推断，那么就不会有任何性能问题。这两种方法都会生成相同的代码

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

然而，如果你是动态构造类型(LINQ…)，那么var是你唯一的问题，还有其他的机制来比较，以说明什么是惩罚。

这取决于情况，如果您尝试使用，此代码如下。

表达式被转换为“OBJECT”，性能大大降低，但这是一个孤立的问题。

代码:

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

问候

因此，明确地说，这是一种懒惰的编码风格。如果可以选择，我更喜欢原生类型;我将利用这一点额外的“噪音”来确保我在代码/调试时所编写和阅读的内容完全符合我的想法。耸肩*