Do not confuse dynamic and var. Declaring a local variable using var is just a syntactical shortcut that has the compiler infer the specific data type from an expression. The var keyword can be used only for declaring local variables inside a method while the dynamic keyword can be used for local variables, fields, and arguments. You cannot cast an expression to var, but you can cast an expression to dynamic. You must explicitly initialize a variable declared using var while you do not have to initialize a variable declared with dynamic.

用var声明的变量是隐式的，但是是静态类型的。使用dynamic声明的变量是动态类型的。CLR添加此功能是为了支持Ruby和Python等动态语言。

我应该补充一点，这意味着动态声明在运行时解析，var声明在编译时解析。

Var意味着应用静态类型检查(早期绑定)。Dynamic意味着应用动态类型检查(后期绑定)。在代码方面，考虑以下内容:

class Junk
{
    public void Hello()
    {
        Console.WriteLine("Hello");
    }
}

class Program
{
    static void Main(String[] args)
    {
        var a = new Junk();
        dynamic b = new Junk();

        a.Hello();

        b.Hello();
    }
}

如果您编译它并使用ILSpy检查结果，您将发现编译器添加了一些后期绑定代码，这些代码将处理从b对Hello()的调用，而由于早期绑定应用于a, a能够直接调用Hello()。

例如(ILSpy拆卸)

using System;
namespace ConsoleApplication1
{
    internal class Junk
    {
        public void Hello()
        {
            Console.WriteLine("Hello");
        }
    }
}

using Microsoft.CSharp.RuntimeBinder;
using System;
using System.Runtime.CompilerServices;
namespace ConsoleApplication1
{
    internal class Program
    {
        [CompilerGenerated]
        private static class <Main>o__SiteContainer0
        {
            public static CallSite<Action<CallSite, object>> <>p__Site1;
        }
        private static void Main(string[] args)
        {
            Junk a = new Junk();      //NOTE: Compiler converted var to Junk
            object b = new Junk();    //NOTE: Compiler converted dynamic to object
            a.Hello();  //Already Junk so just call the method.

                          //NOTE: Runtime binding (late binding) implementation added by compiler.
            if (Program.<Main>o__SiteContainer0.<>p__Site1 == null)
            {
                Program.<Main>o__SiteContainer0.<>p__Site1 = CallSite<Action<CallSite, object>>.Create(Binder.InvokeMember(CSharpBinderFlags.ResultDiscarded, "Hello", null, typeof(Program), new CSharpArgumentInfo[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
                }));
            }
            Program.<Main>o__SiteContainer0.<>p__Site1.Target(Program.<Main>o__SiteContainer0.<>p__Site1, b);
        }
    }
}

你能做的最好的事情是发现差异是自己写一个小的控制台应用程序，像这样，并用ILSpy自己测试它。

动态变量和var变量都可以存储任何类型的值，但需要在声明时初始化'var'。

编译器没有关于变量的“动态”类型的任何信息。 Var是编译器安全的，即编译器拥有关于存储值的所有信息，因此它不会在运行时引起任何问题。

动态类型可以作为函数参数传递，函数也可以返回它。 Var类型不能作为函数参数传递，函数不能返回对象类型。这种类型的变量可以在其定义的范围内工作。

在动态类型转换的情况下，不需要，但你需要知道与存储类型相关的属性和方法，而对于var不需要类型转换，因为编译器有执行操作的所有信息。

dynamic:在使用反射或动态语言支持或COM对象编码时很有用，因为我们需要编写更少的代码。

var:在从linq查询中获取结果时有用。在3.5框架中引入了对linq特性的支持。

参考:咨询byabhi

Var是静态类型的——编译器和运行时知道它的类型——它们只是为你节省了一些输入…以下是100%相同的:

var s = "abc";
Console.WriteLine(s.Length);

and

string s = "abc";
Console.WriteLine(s.Length);

所发生的一切只是编译器发现s必须是一个字符串(来自初始化式)。在这两种情况下，它都知道(在IL中)s.l end意味着(实例)字符串。长度属性。

动态是一种非常不同的野兽;它与object最相似，但具有动态调度:

dynamic s = "abc";
Console.WriteLine(s.Length);

这里，s的类型是动态的。它不知道字符串。长度，因为它在编译时不知道s的任何信息。例如，下面的代码也可以编译(但不能运行):

dynamic s = "abc";
Console.WriteLine(s.FlibbleBananaSnowball);

在运行时(仅)，它将检查flibb黎巴嫩asnowball属性-未能找到它，并爆炸在一个火花淋浴。

使用dynamic，属性/方法/操作符等在运行时根据实际对象解析。非常方便地与COM(可以具有仅运行时属性)、DLR或其他动态系统(如javascript)通信。

Var只是普通类型声明的简写，让编译器猜测正确的类型。

Dynamic是一种新的(静态)类型，其中所有检查都在运行时完成，而不是由编译器完成。