我已经阅读了大量关于c# v4附带的新关键字的文章,但我无法区分“dynamic”和“var”之间的区别。

这篇文章让我思考了一下,但我还是看不出有什么不同。

你是否只能将“var”用作局部变量,但同时用作局部变量和全局变量?

你能显示一些代码没有动态关键字,然后显示相同的代码与动态关键字吗?


当前回答

我会解释dynamic和var的区别。

dynamic d1;
d1 = 1;
d1 = "http://mycodelogic.com";

这是可行的。编译器可以重新创建动态变量的类型。 首先,它创建类型为整数,然后编译器将重新创建类型为字符串,但在var的情况下

var v1;  // Compiler will throw error because we have to initialized at the time of declaration  
var v2 = 1; // Compiler will create v1 as **integer**
v2 = "Suneel Gupta"; // Compiler will throw error because, compiler will not recreate the type of variable 

When using the ‘var’ keyword, the type is decided by the compiler at compile time, whereas when using the ‘dynamic’ keyword, the type is decided by the runtime. ‘var’ keyword, a strongly implicitly typed local variable for which the compiler is able to determine the type from the initialization expression - very useful when doing LINQ programming. Compiler doesn't have any information about the dynamic type of variable. so compiler will not show any intelligence .compiler has all information about the stored value of var type so compiler will show intelligence.dynamic type can be passed as function argument and function also can return object typeButvar type can not be passed as function argument and function can not return object type. This type of variable can work in the scope where it defined.

其他回答

Var(隐式类型局部变量)关键字用于定义局部变量。对于Var,底层数据类型是在编译时根据初始赋值确定的。一旦使用Var类型进行了初始赋值,那么它将成为强类型。如果您试图存储与Var类型不兼容的值,则会导致编译时错误。

例子:

Var strNameList=new List<string>(); By using this statement we can store list of names in the string format. 
strNameList.add("Senthil");
strNameList.add("Vignesh");

strNameList.add(45); // This statement will cause the compile time error.

但在动态类型中,底层类型仅在运行时确定。在编译时不检查动态数据类型,也不是强类型。我们可以为动态类型分配任何初始值,然后可以在其生命周期内将其重新分配给任何新值。

例子:

dynamic test="Senthil";
Console.Writeline(test.GetType())  // System.String

test=1222;
Console.Writeline(test.GetType())  // System.Int32

test=new List<string>();
Console.Writeline(test.GetType())  //System.Collections.Generic.List'1[System.String]

它也不提供智能感知支持。当我们使用linq工作时,它也没有提供更好的支持。因为它不支持lambda表达式、扩展方法和匿名方法。

下面是一个简单的例子,演示了动态(4.0)和Var之间的差异

dynamic  di = 20;
dynamic ds = "sadlfk";
var vi = 10;
var vsTemp= "sdklf";

Console.WriteLine(di.GetType().ToString());          //Prints System.Int32
Console.WriteLine(ds.GetType().ToString());          //Prints System.String
Console.WriteLine(vi.GetType().ToString());          //Prints System.Int32
Console.WriteLine(vsTemp.GetType().ToString());      //Prints System.String

**ds = 12;**   //ds is treated as string until this stmt now assigning integer.

Console.WriteLine(ds.GetType().ToString());          **//Prints System.Int32**

**vs = 12**; //*Gives compile time error* - Here is the difference between Var and Dynamic. var is compile time bound variable.

湿婆Mamidi

一个很大的不同——你可以有一个动态返回类型。

dynamic Foo(int x)
{
    dynamic result;

    if (x < 5)
      result = x;
    else
      result = x.ToString();

    return result;
}

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自己测试它。

我会解释dynamic和var的区别。

dynamic d1;
d1 = 1;
d1 = "http://mycodelogic.com";

这是可行的。编译器可以重新创建动态变量的类型。 首先,它创建类型为整数,然后编译器将重新创建类型为字符串,但在var的情况下

var v1;  // Compiler will throw error because we have to initialized at the time of declaration  
var v2 = 1; // Compiler will create v1 as **integer**
v2 = "Suneel Gupta"; // Compiler will throw error because, compiler will not recreate the type of variable 

When using the ‘var’ keyword, the type is decided by the compiler at compile time, whereas when using the ‘dynamic’ keyword, the type is decided by the runtime. ‘var’ keyword, a strongly implicitly typed local variable for which the compiler is able to determine the type from the initialization expression - very useful when doing LINQ programming. Compiler doesn't have any information about the dynamic type of variable. so compiler will not show any intelligence .compiler has all information about the stored value of var type so compiler will show intelligence.dynamic type can be passed as function argument and function also can return object typeButvar type can not be passed as function argument and function can not return object type. This type of variable can work in the scope where it defined.