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





objet dynamiquement (13)


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

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?




  1. Le Var (variable locale implicite) est utilisé pour définir les variables locales. Dans le cas de Var, le type de données sous-jacent est déterminé à la compilation lui-même en fonction de l'affectation initiale. Une fois l'affectation initiale effectuée avec le type Var, deviendra fortement typé. Si vous essayez de stocker une valeur incompatible avec le type Var, cela entraînera une erreur 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 dans le type dynamique, le type sous-jacent est déterminé uniquement au moment de l'exécution. Le type de données dynamiques n'est pas vérifié à la compilation et n'est pas fortement typé. Nous pouvons assigner n'importe quelle valeur initiale pour le type dynamique. 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 non plus de support IntelliSense. Il ne donne pas un meilleur support lorsque nous travaillons avec linq aussi. Parce qu'il ne supporte pas les expressions lambda, les méthodes d'extension et les méthodes anonymes.




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




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



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



var est juste un raccourci pour une déclaration de type normal, où vous laissez le compilateur deviner le type correct.

dynamic est un nouveau type (statique), où toutes les vérifications sont effectuées au moment de l'exécution, et non par le compilateur.




var est typé statique - le compilateur et l'exécution connaissent le type - ils vous épargnent juste un peu de frappe ... les éléments suivants sont identiques à 100%:

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

et

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

Tout ce qui s'est passé est que le compilateur a compris que s doit être une chaîne (à partir de l'initialiseur). Dans les deux cas, il sait (dans l'IL) que s.Length signifie la propriété (instance) string.Length .

dynamic est une bête très différente; il est le plus similaire à l' object , mais avec une répartition dynamique:

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

Ici, s est typé dynamique . Il ne connaît pas string.Length , car il ne sait rien de s au moment de la compilation. Par exemple, les éléments suivants compileraient (mais ne fonctionneraient pas):

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

Au moment de l'exécution (seulement), il vérifie la propriété FlibbleBananaSnowball - ne parvient pas à la trouver, et explose dans une pluie d'étincelles.

Avec dynamic , les propriétés / methods / opérateurs / etc sont résolues au moment de l'exécution , en fonction de l'objet réel. Très pratique pour parler à COM (qui peut avoir des propriétés d'exécution seulement), le DLR, ou d'autres systèmes dynamiques, comme javascript .




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.




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




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.




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.




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

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

Cela fonctionnera. le compilateur peut recréer le type de variable dynamique .
d'abord, il crée un type en tant qu'entier et après que le compilateur recréera le type en tant que chaîne
mais en 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 

Lors de l'utilisation du mot-clé ' var ', le type est décidé par le compilateur au moment de la compilation, tandis que lors de l'utilisation du mot-clé ' dynamic ', le type est déterminé par le runtime. Le mot clé ' var ', une variable locale fortement implicitement typée pour laquelle le compilateur est capable de déterminer le type à partir de l'expression d'initialisation - très utile lors de la programmation LINQ. Le compilateur n'a aucune information sur le type dynamique de la variable. donc le compilateur ne montrera aucune intelligence.
compilateur a toutes les informations sur la valeur stockée de type var donc le compilateur montrera l'intelligence. type dynamique peut être passé en argument de fonction et la fonction peut également retourner le type d'objet
Mais
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.




explication: avec des analogies. J'espère que cela vous aidera.

Le contexte

Je travaille au 21ème étage d'un immeuble. Et je suis paranoïaque à propos du feu. De temps en temps, quelque part dans le monde, un feu brûle dans un gratte-ciel. Mais heureusement, nous avons un manuel d'instructions quelque part ici sur ce qu'il faut faire en cas d'incendie:

Escalier de secours()

  1. Ne pas recueillir d'effets personnels
  2. Marcher pour échapper à l'incendie
  3. Sortez du bâtiment

Ceci est essentiellement une méthode virtuelle appelée FireEscape ()

Méthode virtuelle

Ce plan est plutôt bon dans 99% des cas. C'est un plan de base qui fonctionne. Mais il y a 1% de chance que l'issue de secours soit bloquée ou endommagée auquel cas vous êtes complètement foutu et vous deviendrez grillé à moins que vous ne preniez des mesures drastiques. Avec les méthodes virtuelles, vous pouvez faire exactement cela: vous pouvez remplacer le plan FireEscape () de base avec votre propre version du plan:

  1. Courir à la fenêtre
  2. Sauter par la fenêtre
  3. Parachute en toute sécurité vers le bas

En d'autres termes, les méthodes virtuelles fournissent un plan de base qui peut être remplacé si nécessaire . Les sous-classes peuvent remplacer la méthode virtuelle de la classe parente si le programmeur le juge approprié.

Méthodes abstraites

Toutes les organisations ne sont pas bien forées. Certaines organisations ne font pas d'exercices d'incendie. Ils n'ont pas de politique globale d'évasion. Chaque homme est pour lui-même. La direction n'est intéressée que par une telle politique existante.

En d'autres termes, chaque personne est obligée de développer sa propre méthode FireEscape (). Un gars va sortir de l'escalier de secours. Un autre gars va parachuter. Un autre type utilisera la technologie de propulsion de fusée pour s'envoler du bâtiment. Un autre gars va descendre en rappel. La direction ne se soucie pas de savoir comment vous échapper, tant que vous avez un plan FireEscape () de base - si ce n'est pas le cas, vous pouvez être assuré que la santé et la sécurité au travail descendront sur l'organisation comme une tonne de briques. C'est ce que l'on entend par une méthode abstraite.

Quelle est la différence entre les deux?

Méthode abstraite: les sous-classes sont obligées d'implémenter leur propre méthode FireEscape. Avec une méthode virtuelle, vous avez un plan de base qui vous attend, mais vous pouvez choisir d'implémenter le vôtre si ce n'est pas suffisant.

Ce n'était pas si difficile, n'est-ce pas?







c# dynamic