Différence entre objet, dynamique et var
J'ai besoin de connaître la différence entre ces trois mots clés Object, Dynamic et var en C #.
J'ai vu cela lien mais je ne comprends pas dans quel cas je dois utiliser chacun.
Pouvez-vous m'expliquer, s'il vous plaît, la différence entre ces mots clés? Quels sont les utilitaires de chaque mot-clé?
Tout est Object c'est un type de base. Chaque type hérite de Object en un instant, une simple variable int peut être boxée vers un object. Par exemple:
object a = 10; // int
object b = new Customer(); // customer object
object c = new Product(); // product object
object d = "Jon"; // string
object e = new { Name = "Felipe", Age = 20 }; // anonymous type
C'est le plus d'abstraction pour tout type et c'est un type de référence. Si vous voulez obtenir le vrai type, vous devez le unbox (en utilisant une stratégie de conversion telle que des méthodes, des transtypages, etc.):
object a = "Some Text";
string text = a.ToString();
// call a string method
text = text.ToUpper();
object i = 10; // declared as object but instance of int
int intValue = (int) i; //declare as an int ... typed
Dynamic est une implémentation d'un aspect dynamique en C #, il n'est pas fortement typé. Par exemple:
dynamic a = new Class();
a.Age = 18;
a.Name = "Jon";
a.Product = new Product();
a.Name; // read a string
a.Age; // read an int
a.Product.Name; // read a property
a.Product.MoveStock(-1); // call a method from Product property.
var est juste un mot-clé du langage C # qui vous permet de définir n'importe quel objet d'un type puisque vous l'initialisez avec une valeur et il déterminera le type à partir de cette valeur, par exemple:
var a = 10; // int
var b = 10d; // double
var c = "text"; // string
var p = new Product(); // Product type
Le compilateur vérifie le type de la valeur que vous avez définie et le définit sur l'objet.
Objet:
Chaque objet en C # est dérivé du type d'objet, directement ou indirectement. Il est variable dans le temps de compilation et nécessite une boxe et unboxing pour la conversion et il le rend lent. Vous pouvez changer le type de valeur en type de référence et vice versa.
public void CheckObject()
{
object test = 10;
test = test + 10; // Compile time error
test = "hello"; // No error, Boxing happens here
}
Var:
Il s'agit d'une variable de temps de compilation et ne nécessite pas de boxe et de déballage. Étant donné que Var est une fonction de compilation, toute vérification de type est effectuée uniquement lors de la compilation. Une fois que Var a été initialisé, vous ne pouvez pas changer le type qui y est stocké.
public void CheckVar()
{
var test = 10; // after this line test has become of integer type
test = test + 10; // No error
test = "hello"; // Compile time error as test is an integer type
}
Dynamique:
Il est variable au moment de l'exécution et ne nécessite pas de boxe et de déballage. Vous pouvez attribuer une valeur à Dynamic et également modifier le type de valeur stocké dans celui-ci. Toutes les erreurs sur Dynamic ne peuvent être découvertes qu'au moment de l'exécution. Nous pouvons également dire que la dynamique est un objet d'exécution qui peut contenir n'importe quel type de données.
public void CheckDynamic()
{
dynamic test = 10;
test = test + 10; // No error
test = "hello"; // No error, neither compile time nor run time
}
1) var est utilisé pour la définition de type implicite. Par exemple, si vous définissez une variable comme celle-ci:
var number = 123;
Le compilateur déduit le type en fonction de la valeur affectée et de votre variable initialisée sous forme d'entier en heure de compilation . Après cette définition, vous ne pouvez pas affecter un string à votre variable car il s'agit d'un entier. Et vous ne pouvez pas utiliser var comme ceci:
var number;
number = 123;
Parce que vous devez attribuer quelque chose à votre variable si vous utilisez le mot clé var pour que le type puisse être déterminé.
2) Object est une classe de base pour toutes les classes. Dans C# toutes les classes héritent de la classe d'objets, vous pouvez donc tout assigner à un objet. Par exemple:
object str = "bla bla bla...";
str = 234;
str = DateTime.Now;
Cela fonctionne parce que lorsque vous faites cela boxe/déballage effectuer automatiquement pour vous. Et contrairement au mot clé var, vous pouvez utiliser object comme ceci:
object myVariable;
myVariable = "bla bla bla..";
3) dynamic est une fonctionnalité intéressante fournie avec C# 4.0, vous pouvez utiliser dynamic si vous ne savez pas retourner le type de votre fonction au moment de la compilation. Votre type sera déterminé dans run-time. Par conséquent, vous ne pouvez pas utiliser intellisense avec des variables dynamiques.
Vous pouvez utiliser dynamique comme ceci:
dynamic myObj = SomeMethod();
myObj.DoSomething();
myObj.Method1();
Mais vous devez être prudent lorsque vous utilisez dynamic.Parce que si vous appelez une méthode ou une propriété qui n'existe pas, vous obtiendrez un RuntimeBinderException lors de l'exécution.
Et la dernière chose que je veux mentionner, dynamic et object peuvent être de type paramètre, mais var ne peut pas. Par exemple, vous pouvez faire ceci:
public void SomeMethod(dynamic arg1)
Mais vous ne pouvez pas faire ça:
public void SomeMethod(var arg1)
Parce que var n'est pas un type mais plutôt un sucre syntaxique pour laisser le compilateur déduire le type pour vous.
Object est la classe racine dont tous les objets .net dérivent.
var est utilisé comme raccourci si vous ne voulez pas écrire dites string x = "a", mais écrivez plutôt var x = "a". Cela ne fonctionne que si le compilateur peut comprendre ce que vous voulez dire.
dynamic implique que ce que vous faites avec l'objet n'est évalué qu'au moment de l'exécution (x.StrangeMethod() ne provoquera pas d'erreur de compilation, même si la méthode n'existe pas), utile lors de l'interaction avec les langages de script.
C’est assez simple…
Object est un type de base dans .NET. Tous les autres types en héritent. La variable de type objet peut donc tout contenir. Mais cela ne devrait être fait que s'il n'y a pas d'autres options, pour les raisons suivantes:
Avant de lire/écrire sur cette variable, nous devons effectuer des opérations de déballage/de boxe, qui sont coûteuses.
Le compilateur ne peut pas effectuer de vérification de type au moment de la compilation, ce qui peut entraîner des bogues et des exceptions au moment de l'exécution. Par exemple, ce code sera compilé avec succès mais lèvera une exception au moment de l'exécution:
object o = "2"; int i = 1 + (int)o;
Var n'est pas un type, mais l'instruction pour le compilateur de conclure un type de variable à partir du contexte du programme. Il était nécessaire pour les méthodes anonymes mais peut également être utilisé partout où vous le souhaitez. Attention seulement votre programme n'est pas devenu difficile à lire. Le compilateur prend sa décision au moment de la compilation de sorte qu'il n'aura aucune influence sur l'efficacité du programme.
Dynamic - est un type spécial pour lequel le compilateur ne vérifie pas le type au moment de la compilation. Le type est spécifié au moment de l'exécution par CLR. Il s'agit d'un type statique (!) Et une fois le type de variable spécifié, il ne peut plus être modifié ultérieurement. Nous devons utiliser ce type uniquement, il n'y a pas d'autres options pour des raisons similaires avec le type d'objet:
Il existe une opération d'addition pour spécifier le type au moment de l'exécution - ce qui réduit l'efficacité du programme.
Le compilateur n'effectue pas de vérification de type qui peut entraîner des bogues et des exceptions au moment de l'exécution.
Voici la différence entre System.Object, dynamic et var.
Tout dans .net est dérivé du type System.Object. Mais si vous cherchez une différence spécifique, les voici.
Différence entre objet et dynamique.
Vous ne pouvez pas implicitement convertir une variable de type Object en un autre type. Le compilateur ne vous laissera pas faire cela. D'un autre côté, vous pouvez implicitement convertir n'importe quel type en dynamique. Le compilateur ne se plaindra pas car le casting sera effectué pendant le temps d'exécution et l'exception, si nécessaire, sera augmentée pendant le temps d'exécution. 2.Parce que dynamique est identique à objet, vous ne pouvez pas écrire des méthodes surchargées qui diffèrent en objet et dynamique en arguments.
Différence entre dynamique et var.
1. La déclaration d'une variable locale comme dynamique ou var n'a qu'une différence syntaxique. 2. Vous ne pouvez pas déclarer une variable de type var sans l'initialiser, mais vous pouvez le faire pour une variable dynamique 3. Vous ne pouvez pas utiliser une variable var pour passer comme argument de méthode ou revenir d'une méthode. 4. Vous ne pouvez pas transtyper une expression en var mais vous pouvez le faire pour une variable dynamique.
Un résumé de la différence entre les types Objet, Var et Dynamique. Dans le cas où vous ne comprenez pas les concepts dans chaque cellule de ligne de tableau, veuillez le référer ailleurs. Source: https://www.dotnettricks.com/learn/csharp/differences-between-object-var-and-dynamic-type
Objet
Objet de base de .net, la plupart du temps, vous n'aurez pas besoin de l'utiliser.
Var
Juste un sucre syntaxique, chaque fois que vous utilisez var, le type de variable est décidé en temps de compilation en fonction de la valeur qui lui est affectée.
Dynamique
Provient de la partie DLR de .net, vous n'en aurez besoin que si vous souhaitez utiliser une saisie de type non forte.
le compilateur indique que var est un mot-clé contextuel utilisé pour la déclaration de variable. c'est pourquoi nous devons attribuer une valeur au moment de la déclaration. le compilateur vérifie ensuite leur type de données et le traite de la même manière. De cette façon, le compilateur sait tout sur cette variable et implique une sécurité de type dessus.