Pourquoi le type dynamic C # est-il statique?

Lors de la lecture et de l’exploration du mot clé dynamic, j’ai trouvé la ligne suivante sur [MSDN] (dans Utilisation du type dynamic (Guide de programmation C #) ):

Le type est un type statique, mais un object de type dynamic ignore la vérification de type statique. Dans la plupart des cas, il fonctionne comme s’il avait un object de type.

Quelle est la signification de statique dans la ligne ci-dessus et comment contourner la vérification de type statique?

Ceci est le typage statique:

 ssortingng foo = "bar"; 

foo est maintenant une chaîne, donc cela provoquera une erreur de compilation:

 foo = 1; 

Même si vous utilisez var , il est toujours typé statiquement:

 var foo = "bar"; // foo is now a ssortingng foo = 1; // still a comstack time error 

En utilisant le mot-clé dynamic, le type ne sera pas statique et pourra être modifié. Vous pouvez maintenant le faire:

 dynamic foo = "bar"; foo = 1; // this is now fine. 

Maintenant, pourquoi on dit “le type est un type statique” parce que dans de nombreux langages dynamics (comme Javascript), vous pouvez faire quelque chose comme ceci:

 var foo = { bar: 1 }; 

Qui crée un object avec une propriété appelée “bar”, et vous pouvez alors faire ceci:

 foo.la = 2; 

Qui ajoute une nouvelle propriété à l’object dans foo . Mais si vous essayez le même tour en C #

 dynamic foo = new SomeClassThatDoesntHaveABarProperty(); foo.bar = 2; // runtime error 

Vous ne pouvez pas non plus supprimer une propriété. Vous pouvez affecter n’importe quel type à une variable dynamic, mais vous ne pouvez pas modifier ces types eux-mêmes.

Si vous avez besoin de ce type de fonctionnalité, alors vous voudrez examiner ExpandoObject

Comme le dit votre description, la dynamic fonctionne comme un object dans de nombreux cas. Vous pourriez faire ceci:

 dynamic foo = new Foo(); foo = new Bar(); 

Aussi bien comme ça:

 object foo = new Foo(); foo = new Bar(); 

Mais la différence entre lorsque vous souhaitez utiliser des propriétés ou des méthodes. Avec dynamic, je peux le faire:

 dynamic foo = new Foo(); foo.FooMethod(); // Note: You WILL get a runtime exception if foo doesn't have a FooMethod 

Mais avec un object, je devrais le faire:

 object foo = new Foo(); ((Foo)foo).FooMethod(); // Note: I HAVE to know the type at comstack time here 

Ce que je ne peux faire que si je sais déjà que je peux convertir le type en foo en un type de Foo au moment de la compilation , et si je le savais déjà, alors je pourrais simplement utiliser Foo comme mon object plutôt que comme object .

Cela signifie qu’une variable déclarée comme dynamic restra de type dynamic et ne peut pas être changée en une variable de type int par exemple. Ce concept est ignoré, car vous pouvez modifier les types d’objects contenus dans la variable.

C # est considéré comme un langage fortement typé car les variables sont typées statiquement. Cela signifie que chaque variable est typée et que le compilateur C # peut vérifier si les bons types sont utilisés dans le code. Dans un langage faiblement typé comme la plupart des langages de script, le type de variable est dynamic. Ils peuvent avoir n’importe quelle valeur.