Jaka jest różnica między dynamicznym (C # 4) A var?

Zmienne zadeklarowane przez var są niejawne, ale statycznie wpisywane. Zmienne zadeklarowane przez dynamic{[2] } są wpisywane dynamicznie. Ta funkcja została dodana do CLR w celu obsługi dynamicznych języków, takich jak Ruby i Python.

Powinienem dodać, że oznacza to, że deklaracje dynamiczne są rozwiązywane w czasie wykonywania, deklaracje var są rozwiązywane w czasie kompilacji.

Wyjaśnię różnicę pomiędzy dynamicznym i var .

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

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 

Przy użyciu słowa kluczowego ' var ', o typie decyduje kompilator w czasie kompilacji, natomiast przy użyciu Słowo kluczowe ' dynamic ', o typie decyduje runtime.

---

'słowo kluczowe var', silnie wpisana zmienna lokalna, dla której kompilator jest w stanie określić typ z wyrażenia inicjalizacyjnego - bardzo przydatne podczas programowania LINQ.

---

kompilator nie posiada żadnych informacji o typie zmiennej dynamic . więc kompilator nie pokaże żadnej inteligencji .
kompilator posiada wszystkie informacje o przechowywanej wartości var typu so kompilator pokaże inteligencję.

---

Typ dynamiczny może być przekazany jako argument funkcji i funkcja może również zwracać typ obiektu
, Ale
Typ var nie może być przekazany jako argument funkcji i funkcja nie może zwracać typu obiektu. Ten typ zmiennej może pracować w zakresie, w którym została zdefiniowana.

Var oznacza, że stosowane jest statyczne sprawdzanie typu (wczesne Wiązanie). dynamic oznacza, że stosowane jest dynamiczne sprawdzanie typu (późne wiązanie). Pod względem kodu wyróżnia się:

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

Jeśli skompilujesz to i sprawdzisz wyniki za pomocą ILSpy, okaże się, że kompilator dodał kod opóźnionego wiązania, który obsłuży wywołanie Hello() z b, podczas gdy wczesne Wiązanie becuase zostało zastosowane do A, a jest w stanie wywołać Hello() bezpośrednio.

Np. (ILSpy demontaż)

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

Najlepszą rzeczą, jaką możesz zrobić, aby odkryć różnicę, jest napisanie małej aplikacji na konsolę, takiej jak ta i przetestowanie jej samemu za pomocą ILSpy.

Jedna duża różnica - możesz mieć dynamiczny Typ powrotu.

dynamic Foo(int x)
{
    dynamic result;

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

    return result;
}

Oto prosty przykład pokazujący różnicę pomiędzy Dynamic (4.0) i 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.

Shiva Mamidi

var jest tylko skrótem od zwykłej deklaracji typu, gdzie pozwalasz kompilatorowi odgadnąć właściwy typ.

dynamic jest nowym (statycznym) typem, gdzie wszystkie kontrole są wykonywane w czasie wykonywania, a nie przez kompilator.

Typ zmiennej zadeklarowanej przez var jest określony przez kompilator, jest skrótem do określenia nazwy typu, nic więcej.

Jednakże dynamika jest określana w czasie wykonywania, kompilator nie ma pojęcia o rzeczywistym typie, a wszystkie metody/pola/właściwości tej zmiennej zostaną opracowane w czasie wykonywania.

Ten {[4] } jest fajnym filmikiem na youtube, który opowiada o var VS Dynamic z praktyczną demonstracją.

Poniżej znajduje się bardziej szczegółowe wyjaśnienie z migawką.

Var jest wcześnie wiązany (sprawdzany statycznie), podczas gdy dynamiczny jest późno wiązany (dynamicznie oceniany).

Słowo kluczowe Var patrzy na dane z prawej strony, a następnie podczas kompilacji decyduje o danych z lewej strony type.In inne słowa kluczowe var po prostu oszczędza wpisując wiele rzeczy. Spójrz na poniższy obrazek gdzie gdy podaliśmy dane string i zmienna x pokazuje typ danych string w mojej podpowiedzi.

Z drugiej strony dynamiczne słowo kluczowe służy zupełnie innemu celowi. Obiekty dynamiczne są oceniane podczas wykonywania. Na przykład w poniższym kodzie właściwość "Length" istnieje lub nie jest obliczana podczas runtime.Celowo wpisałem małe "l", więc ten program skompilował się dobrze, ale kiedy faktycznie wykonał, wyrzucił błąd podczas wywoływania właściwości "length" ( SMALL "l").

Zmienna dynamiczna i zmienna var mogą przechowywać dowolny typ wartości, ale wymagane do zainicjowania 'var' w momencie deklaracji.

Kompilator nie posiada żadnych informacji o zmiennej typu 'dynamic'. var jest bezpieczny dla kompilatora tzn. kompilator posiada wszystkie informacje o przechowywanej wartości, tak aby nie powodował żadnych problemów w czasie wykonywania.

Typ dynamiczny może być przekazany jako argument funkcji i funkcja może go również zwrócić. Typ Var nie może być przekazany jako argument funkcji i funkcja nie może zwracać typu obiektu. Ten typ zmiennej może pracować w zakresie, w którym została zdefiniowana.

W przypadku dynamicznego odlewania nie jest wymagane, ale trzeba znać właściwość i metody związane z przechowywanym typem, natomiast dla var nie ma potrzeby odlewania, ponieważ kompilator ma wszystkie informacje do wykonania operacji.

Dynamic: przydatne przy kodowaniu przy użyciu reflection lub dynamic language support lub z obiektami COM, ponieważ wymagamy mniejszej ilości kodu.

Var: Przydatne podczas uzyskiwania wyniku z zapytań linq. W 3.5 framework wprowadza obsługę funkcji linq.

Reference: Counsellingbyabhi

1. var i dynamiczne definiowanie typu.
2. var w czasie kompilacji, podczas gdy dynamiczne są w czasie wykonywania.
3. w deklaracji var i inicjalizacji obie są obowiązkowe jak stała zmienna, podczas gdy
4. w dynamicznej inicjalizacji może być w czasie wykonywania jak tylko zmienne readonly.
5. w typie var niezależnie od tego, jaki typ zostanie określony w czasie inicjalizacja nie może się zmienić dalej, ale
6. dynamic może przyjąć dowolny typ danych, nawet zdefiniowany przez użytkownika.

Nie mylić dynamic i var. Deklarowanie zmiennej lokalnej za pomocą var jest tylko skrótem składniowym, który kompilator wywiera określony typ danych z wyrażenia. Słowo kluczowe var może być używane tylko do deklarowania zmiennych lokalnych wewnątrz metody, podczas gdy słowo kluczowe dynamic może być używane do zmiennych lokalnych, pól i argumentów. Wyrażenia nie można oddać do var, ale można je oddać do dynamic. Musisz jawnie zainicjować zmienną zadeklarowaną za pomocą var, gdy to zrobisz nie trzeba inicjalizować zmiennej zadeklarowanej dynamicznie.

1. słowo kluczowe Var (Implicit typed local variable) służy do definiowania lokalnego variables.In w przypadku Var, bazowy typ danych jest ustalany w czasie kompilacji na podstawie początkowego przypisania.Po dokonaniu początkowego przypisania z typem Var, zostanie ono mocno wpisane.Jeśli spróbujesz zapisać niezgodną wartość z typem Var, spowoduje to błąd w czasie kompilacji.

Przykład:

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.

Ale w typie dynamicznym określa się typ bazowy tylko w czasie biegu.Dynamiczny typ danych nie jest sprawdzany podczas kompilacji, a także nie jest mocno wpisywany.Możemy przypisać dowolną wartość początkową dla typu dynamicznego, a następnie można ją przypisać do dowolnej nowej wartości w czasie jej życia.

Przykład:

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]

Nie zapewnia wsparcia IntelliSense also.It nie daje lepszego wsparcia, gdy dajemy pracę z linq również.Ponieważ nie obsługuje wyrażeń lambda, metod rozszerzeń i metod anonimowych.

Oto różnice

• Zmienna jest wpisywana statycznie (czas kompilacji), dynamiczna jest wpisywana dynamicznie (czas wykonania)

• Zmienna zadeklarowana jako var może być używana tylko lokalnie, dynamicznie zmienne mogą być przekazywane jako params do funkcji (podpis funkcji może zdefiniować param jako dynamiczny, ale nie var).

• Z dynamiczną rozdzielczością właściwości dzieje się w czasie wykonywania i tak nie jest w przypadku var, co oznacza w czasie kompilacji dowolną zmienną zadeklarowana jako dynamic może wywołać metodę, która może lub nie istnieje i więc kompilator nie wyrzuci błędu.

• Typ casting z var nie jest możliwe, ale z dynamicznym its możliwe (można oddać obiekt jako dynamiczny, ale nie jako var).

Arun Vijayraghavan