Quelle est la différence entre dynamique (C# 4) et var?

Variables déclarées avec var sont implicitement mais statiquement typé. Les Variables déclarées avec dynamique sont dactylographiées dynamiquement. Cette capacité a été ajoutée au CLR afin de prendre en charge des langages dynamiques comme Ruby et Python.

j'ajoute que cela signifie que déclarations" dynamiques sont résolues à l'exécution, var déclarations sont résolu à la compilation.

je vais expliquer la différence entre dynamique et var .

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

ça va marcher. le compilateur peut recréer le type de variable dynamique .

tout d'abord, il crée le type comme entier et après que le compilateur va recréer le type comme chaîne de caractères

mais dans le cas de 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 

lorsque l'on utilise le mot-clé ‘ var ’, le type est décidé par le compilateur au moment de la compilation, alors que lorsque l'on utilise le mot-clé ‘ dynamique ’, le type est décidé par l'exécution.

---

‘ var ’ mot-clé, une variable locale fortement implicitement typée pour laquelle le compilateur est capable de déterminer le type à partir de la expression d'initialisation - très utile lors de la programmation LINQ.

---

compilateur n'a aucune information sur le dynamique type de variable. si le compilateur n'affiche aucun renseignement .

compilateur a toutes les informations sur la valeur stockée de var type ainsi compilateur montrera l'intelligence.

---

dynamique type peut être passé comme argument de fonction et la fonction peut également retourner le type d'objet

mais

var le type ne peut pas être passé comme argument de fonction et la fonction ne peut pas retourner le type d'objet. Ce type de variable peut fonctionner dans la portée où il a défini.

var implique que le contrôle de type statique (liaison précoce) est appliqué. la dynamique implique que la vérification de type dynamique (liaison tardive) est appliquée. En ce qui concerne le code, considérer ce qui suit:

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

si vous compilez ceci et que vous inspectez les résultats avec ILSpy, vous constaterez que le compilateur a ajouté du code de liaison en retard qui gérera L'appel à Hello() de b, alors que beuase early binding a été appliqué à a, a est capable d'appeler Hello() directement.

p.ex. (démontage 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);
        }
    }
}

la meilleure chose à faire pour découvrir la différence est de vous écrire une petite application de console comme celle-ci, et de la tester vous-même avec ILSpy.

une grande différence - vous pouvez avoir un type de retour dynamique.

dynamic Foo(int x)
{
    dynamic result;

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

    return result;
}

voici un exemple simple qui montre la différence entre dynamique (4.0) et 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 est juste un raccourci pour une déclaration de type normale, où vous laissez le compilateur deviner le type correct.

dynamic est un nouveau type (statique), où tous les contrôles sont effectués à l'exécution, pas par le compilateur.

le type d'une variable déclarée avec var est déterminé par le compilateur, c'est un raccourci pour spécifier le nom du type, rien de plus.

cependant la dynamique est déterminée à l'exécution, le compilateur n'a aucune idée du type réel, et tous les accès méthode/champ/propriété avec cette variable seront élaborés à l'exécution.

Ce est une belle vidéo sur youtube qui parle de var VS Dynamic avec démonstration pratique.

ci-Dessous est une explication plus détaillée avec photo.

Var est liée tôt (statically checked) tandis que la dynamique est liée tard (dynamically assessed).

Var regarde vos données du côté droit et pendant la compilation il décide du type de données de la main gauche.En autres le mot-clé words var vous évite de taper beaucoup de choses. Regardez l'image ci-dessous où lorsque nous avons donné des données de chaîne et la variable x montre le type de données de chaîne dans ma pointe d'outil.

d'autre part le mot-clé dynamique est pour le but complètement différent. Les objets dynamiques sont évalués pendant l'exécution. Par exemple, dans le code ci-dessous, la propriété "Length" existe ou non est évaluée pendant l'exécution.J'ai volontairement tapé un petit "l", donc ce programme compilé très bien, mais quand il a réellement exécuté il lance une erreur quand la propriété" length "a été appelé ( petit"l").

variable dynamique et variable var toutes deux peuvent stocker n'importe quel type de valeur mais son nécessaire pour initialiser 'var' au moment de la déclaration.

compilateur n'a aucune information sur le type de variable "dynamique". var is compiler safe I. le compilateur a toutes les informations sur la valeur stockée, de sorte qu'il ne cause aucun problème à l'exécution.

type dynamique peut être passé comme argument de fonction et la fonction peut également le retourner. Type Var can ne pas passer comme argument de fonction et la fonction ne peut pas retourner le type d'objet. Ce type de variable peut fonctionner dans la portée où il a défini.

en cas de coulée dynamique n'est pas nécessaire , mais vous devez connaître la propriété et les méthodes liées au type stocké, tandis que pour var pas besoin de mouler parce que compilateur a toutes les informations pour effectuer le fonctionnement.

dynamique: utile pour coder en utilisant la réflexion ou le support dynamique du langage ou avec les objets COM, parce que nous avons besoin d'écrire moins de code.

var: utile pour obtenir le résultat des requêtes linq. Dans le cadre 3.5 il introduit pour soutenir la fonctionnalité linq.

Référence: Counsellingbyabhi

1. Var et de la dynamique de définir le type.
2. var au moment de la compilation alors que dynamic est au moment de l'exécution.
3. dans la déclaration var et l'initialisation sont toutes deux obligatoires comme variable constante tandis que
4. dans l'initialisation dynamique peut être à la durée d'exécution comme les variables readonly.
5. dans le type var quel que soit le type décidé au moment de l'initialisation ne peut pas changer ensuite, mais
6. dynamique peut adopter n'importe quel type même l'utilisateur définit type de données aussi.

ne pas confondre dynamic et var. Déclarer une variable locale en utilisant var est juste un raccourci syntaxique qui a le compilateur inferant le type de données spécifique à partir d'une expression. Le mot-clé var ne peut être utilisé que pour déclarer des variables locales dans une méthode tandis que le mot-clé dynamique peut être utilisé pour les variables locales, les champs et les arguments. Vous ne pouvez pas convertir une expression de var, mais vous pouvez lancer une expression dynamique. Vous devez initialiser explicitement une variable déclarée en utilisant var alors que vous n'avez pas à initialiser une variable déclarée avec dynamique.

1. le mot-clé Var(implicite typed local variable) est utilisé pour définir les variables locales.Dans le cas de Var, le type de données sous-jacent est déterminé au moment de la compilation elle-même sur la base de l'assignation initiale.Une fois que la tâche initiale a été effectuée avec le type Var , elle sera fortement tapée.Si vous essayez de stocker une valeur incompatible avec le type Var, il en résultera une erreur de temps de compilation.

exemple:

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.

mais en type dynamique, le type sous-jacent n'est déterminé qu'au moment de l'exécution.Le type de données dynamique n'est pas vérifié au moment de la compilation et n'est pas non plus fortement tapé.Nous pouvons assigner n'importe quelle valeur initiale pour le type dynamique et ensuite il peut être réassigné à n'importe quelle nouvelle valeur pendant sa durée de vie.

exemple:

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]

il ne fournit pas le soutien D'IntelliSense aussi.Il ne donne pas un meilleur soutien lorsque nous donnons du travail avec linq aussi.Parce qu'il n'a pas soutenez les expressions lambda, les méthodes d'extension et les méthodes anonymes.

Voici les différences

• var est de type statique (à la compilation), dynamique est dynamiquement typés (temps d'exécution)

• une variable déclarée var ne peut être utilisée que localement, dynamique les variables peuvent être passées en tant que paramètres de la fonction (fonction signature pouvez définir un paramètre dynamique mais pas var).

• avec dynamique la résolution des propriétés se produit lors de l'exécution et ce n'est pas le cas avec var qui signifie au moment de la compilation n'importe quelle variable déclaré comme dynamique peut appeler une méthode qui peut ou ne peut pas exister et donc le compilateur ne lançait pas d'erreur.

• type moulage avec var pas possible mais avec dynamique son possible (vous pouvez mouler un objet aussi dynamique mais pas comme var).

Arun Vijayraghavan