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



Answers

Les variables déclarées avec var sont implicitement mais statiquement typées. Les variables déclarées avec dynamic sont typées dynamiquement. Cette fonctionnalité a été ajoutée au CLR afin de prendre en charge les langages dynamiques tels que Ruby et Python.

Je dois ajouter que cela signifie que les déclarations dynamiques sont résolues au moment de l'exécution, les déclarations var sont résolues au moment de la compilation.

Question

J'avais lu une tonne d'articles sur ce nouveau mot-clé qui sera livré avec C # v4, mais je ne pouvais pas faire la différence entre un "dynamique" et "var".

Cet article m'a fait réfléchir, mais je ne vois toujours pas de différence.

Est-ce que vous pouvez utiliser "var" seulement comme une variable locale, mais dynamique comme local et global?

Je suis désolé pour mon ignorance, mais pourriez-vous montrer du code sans mot-clé dynamique et ensuite montrer le même code avec mot-clé dynamique?




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




Voici un exemple simple qui montre la différence entre Dynamic (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




Voici les différences

  • var est statiquement typé (temps de compilation), dynamique est typé dynamiquement (temps d'exécution)

  • Une variable déclarée comme var ne peut être utilisée que localement, les variables dynamiques peuvent être passées en params pour fonctionner (la signature de la fonction peut définir un param comme dynamic mais pas var).

  • avec dynamic la résolution des propriétés se produit à l'exécution et ce n'est pas le cas avec var ce qui signifie qu'à la compilation toute variable déclarée dynamique peut appeler une méthode qui peut ou non exister et ainsi le compilateur ne lancerait pas une erreur.

  • Le type cast avec var n'est pas possible mais avec dynamic c'est possible (vous pouvez lancer un objet comme dynamique mais pas comme var).

Arun Vijayraghavan




var implique que la vérification de type statique (liaison anticipée) est appliquée. dynamique implique que la vérification de type dynamique (liaison tardive) est appliquée. En termes de code, considérez 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 inspectez les résultats avec ILSpy, vous constaterez que le compilateur a ajouté un code de liaison tardif qui gérera l'appel à Hello () de b, alors que la liaison anticipée a été appliquée à a, a est capable d'appeler Hello () directement.

par exemple (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 que vous pouvez faire pour découvrir la différence est de vous écrire une petite console comme celle-ci et de la tester vous-même avec ILSpy.




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 au moment de l'exécution.




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

Le compilateur n'a aucune information sur le type de variable 'dynamique'. var est compilateur, c'est-à-dire que le compilateur a toutes les informations sur la valeur stockée, de sorte qu'il ne provoque aucun problème au moment de l'exécution.

Le type dynamique peut être transmis en tant qu'argument de fonction et la fonction peut également le renvoyer. Le type Var ne peut pas être transmis en tant qu'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ù elle a été définie.

Dans le cas de Casting 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 lancer car le compilateur a toutes les informations pour effectuer l'opération.

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

var: Utile lors de l'obtention du résultat des requêtes linq. Dans le cadre 3.5, il introduit la fonctionnalité Linq.

Référence: Counsellingbyabhi






Links