Pourquoi C # statiquement typé?

Question

Je suis un programmeur web PHP qui essaie d'apprendre le C #.

Je voudrais savoir pourquoi C # me demande de spécifier le type de données lors de la création d'une variable.

Class classInstance = new Class();

Pourquoi avons-nous besoin de connaître le type de données devant une instance de classe?

Answer 1

Comme d'autres l'ont dit, C # est statique / fortement typé. Mais je prends votre question plus à être « Pourquoi voudriez-vous voulez C # pour être statique / fortement typé comme ça? Quels sont les avantages que cela a sur les langages dynamiques? »

Avec cela à l'esprit, il y a beaucoup de bonnes raisons:

• Stabilité Certains types d'erreurs sont maintenant pris automatiquement par le compilateur, avant que le code jamais fait nulle part proche de la production.

• Lisibilité / maintenabilité Vous êtes maintenant fournit plus d'informations sur la façon dont le code est censé travailler pour les futurs développeurs qui l'ont lu. Vous ajoutez des informations qu'une variable spécifique est destinée à maintenir un certain type de valeur, et qui aide à raison de programmeurs à ce que le but de cette variable est.

  Ceci est probablement la raison pour laquelle, par exemple, les directives de style de Microsoft ont recommandé que les programmeurs VB6 mettre un préfixe de type avec des noms variables, mais que les programmeurs VB.Net ne le font pas.

• Performance Ceci est la plus faible raison, mais la liaison tardive / frappe de canard peut être plus lent. En fin de compte, une variable fait référence à la mémoire qui est structuré d'une manière spécifique. Sans types forts, le programme devra faire la vérification de type supplémentaire ou de conversion dans les coulisses lors de l'exécution que vous utilisez la mémoire qui est structuré d'une manière physique comme si elle était structurée d'une autre manière logique.

  Je hésite à inclure ce point, parce que finalement vous avez souvent à faire les conversions dans un langage fortement typé aussi bien. Il est juste que le langage fortement typé laisse le moment exact et l'étendue de la conversion au programmeur, et ne fait pas de travail supplémentaire à moins qu'il doit être fait. Il permet également au programmeur de forcer un type de données plus avantageux. Mais ce sont vraiment des attributs du programmeur , plutôt que la plate-forme.

  Ce serait elle-même une faible raison d'omettre le point, sauf qu'une bonne langue dynamique souvent faire de meilleurs choix que le programmeur. Cela signifie un langage dynamique peut aider beaucoup de programmeurs écrivent des programmes plus rapides. Pourtant, pour bon les programmeurs, les langues ont fortement typées potentiel pour être plus rapide.

• Une meilleure Dev Tools Si votre IDE sait ce type d'une variable devrait être, il peut vous donner une aide supplémentaire sur ce genre de choses que variable peut faire. Cela est beaucoup plus difficile pour l'IDE à faire si elle doit déduire le type pour vous. Et si vous obtenez plus d'aide avec l'API minuties d'une de l'IDE, vous en tant que développeur sera en mesure d'obtenir votre tête autour d'une plus grande, plus riche API et y arriver plus rapidement.

Ou peut-être vous demandez juste pourquoi vous devez spécifier le nom de classe deux fois pour la même variable sur la même ligne? La réponse est double:

1. Souvent, vous ne le faites pas. En C # 3.0 et versions ultérieures, vous pouvez utiliser le mot-clé au lieu du var nom du type dans de nombreux cas. Les variables créées de cette manière sont toujours typés statiquement mais le type est maintenant inférée pour vous par le compilateur.
2. Merci à l'héritage et les interfaces parfois le type sur le côté gauche ne correspond pas au type sur le côté droit.

Answer 2

Il est tout simplement la façon dont la langue a été conçu. C # est un langage de style C et suit dans le motif d'avoir des types sur la gauche.

En C # 3.0 et jusqu'à vous pouvez sorte de contourner ce dans de nombreux cas avec l'inférence de type local.

var variable = new SomeClass();

Mais en même temps, vous pouvez aussi faire valoir que vous déclarez toujours un type LHS. Juste que vous voulez que le compilateur de choisir pour vous.

EDIT

S'il vous plaît lire ceci dans le contexte de la question initiale des utilisateurs

  

Pourquoi avons-nous besoin [nom de la classe] avant un nom de variable?

Je voulais faire des commentaires sur plusieurs autres réponses dans ce fil. Beaucoup de gens donnent « C # est de type statique » comme une réponse. Bien que l'énoncé est vrai (C # est statiquement typé), il est presque sans aucun rapport avec la question. Le typage statique ne nécessite pas un nom de type étant à la gauche du nom de la variable. Bien sûr, il peut aider, mais qui est un choix de concepteur de langage et non une caractéristique nécessaire des langages typés statiques.

C'est facilement démontrable en considérant d'autres langues statiquement typés comme le F #. Types de F # apparaissent à droite d'un nom de variable et très souvent peuvent être tout à fait omises. Il y a aussi plusieurs contre-exemples. PowerShell, par exemple, est extrêmement dynamique et met tout son type, si elle est incluse, à gauche.

Answer 3

L'une des principales raisons est que vous pouvez spécifier différents types aussi longtemps que le type sur le côté gauche de l'affectation est un type de parent du type à gauche (ou une interface qui est mis en œuvre sur ce type).

Par exemple, compte tenu des types suivants:

class Foo { }
class Bar : Foo { }
interface IBaz { }
class Baz : IBaz { }

C # vous permet de faire ceci:

Foo f = new Bar();
IBaz b = new Baz();

Oui, dans la plupart des cas, le compilateur peut déduire le type de la variable de l'affectation (comme avec var mot-clé) mais il n'a pas le raison pour laquelle je l'ai montré ci-dessus.

Modifier En tant que point de l'ordre - en C # est fortement typé la distinction importante (dans la mesure où cette discussion est concerné) est qu'il est en fait statiquement typé langue. Autrement dit, le compilateur C # ne type statique vérification à la compilation.

Answer 4

C # est un statiquement typé, fortement typé langage comme C ou C ++. Dans ces langues toutes les variables doivent être déclarées d'un type spécifique.

Answer 5

En fin de compte, car Anders Hejlsberg a dit ...

Answer 6

Vous avez besoin [nom de la classe] devant parce qu'il ya beaucoup de situations dans lesquelles le premier [nom de la classe] est différente de la seconde, comme:

 IMyCoolInterface obj = new MyInterfaceImplementer();
 MyBaseType obj2 = new MySubTypeOfBaseType();

etc. Vous pouvez également utiliser le mot « var » si vous ne voulez pas spécifier le type explicitement.

Answer 7

  

Pourquoi avons-nous besoin de connaître le type de données    avant une instance de classe?

Vous ne le faites pas! Lire de droite à gauche. Vous créez la variable puis vous stockez dans un type de variable sûre de sorte que vous savez quel type cette variable est pour une utilisation ultérieure.

Considérons l'extrait suivant, ce serait un cauchemar pour déboguer si vous ne recevez pas les erreurs avant l'exécution.

 void FunctionCalledVeryUnfrequently()
 {
   ClassA a = new ClassA();
   ClassB b = new ClassB();
   ClassA a2 = new ClassB(); //COMPILER ERROR(thank god)

   //100 lines of code

   DoStuffWithA(a);
   DoStuffWithA(b);      //COMPILER ERROR(thank god)
   DoStuffWithA(a2);
 }

Quand you'r pensant que vous pouvez remplacer le avec un nouveau numéro de classe () ou une chaîne et la syntaxe sera beaucoup plus logique. L'exemple suivant est peut-être un peu bavard, mais pourrait aider à comprendre pourquoi il a été conçu comme ça.

   string s = "abc";
   string s2 = new string(new char[]{'a', 'b', 'c'});
   //Does exactly the same thing

   DoStuffWithAString("abc");
   DoStuffWithAString(new string(new char[]{'a', 'b', 'c'}));
   //Does exactly the same thing

Answer 8

C #, comme d'autres l'ont souligné, est un fort, statiquement typé.

En indiquant à l'avance ce que le type que vous avez l'intention de créer est, vous recevrez à la compilation des avertissements lorsque vous essayez d'attribuer une valeur illégale. En déclarant à l'avance quel type de paramètres que vous acceptez dans les méthodes, vous recevez ces mêmes avertissements de compilation lorsque vous passez accidentellement un non-sens dans une méthode qui ne s'y attend pas. Il élimine les frais généraux de la paranoïa en votre nom.

Enfin, et plutôt bien, C # (et beaucoup d'autres langues) n'a pas le même ridicule, « convertir quoi que ce soit à quoi que ce soit, même quand il n'a pas de sens » mentalité que PHP ne, qui peut tout à fait franchement vous trébucher en plus de fois que ça aide.

Answer 9

Parce que C # est un langage fortement typé

Answer 10

c # est un langage fortement typé, comme C ++ ou Java. Par conséquent, il a besoin de connaître le type de la variable. vous pouvez truquer un peu en c # 3.0 via le mot-clé var. Cela permet au compilateur de déduire le type.

Answer 11

C'est la différence entre un langage fortement typé et faiblement typé. C # (et C, C ++, Java, la plupart des langues plus puissantes) Vous devez donc fortement typée déclarer le type de variable.

Answer 12

Lorsque nous définissons des variables pour contenir les données que nous avons pour spécifier le type de données que ces variables détiendront. Le compilateur vérifie alors que ce que nous faisons avec les données sens à elle, à savoir les règles suit. Nous ne pouvons pas par exemple stocker du texte dans un numéro -. Le compilateur ne le permettrons pas

int a = "fred"; // Not allowed. Cannot implicitly convert 'string' to 'int' 

La variable a est de type int, et en lui attribuant la valeur « fred » qui est une chaîne de texte brise le -Règlement le compilateur ne peut pas faire une sorte de conversion de cette chaîne.

Answer 13

En C # 3.0, vous pouvez utiliser le mot-clé « var » - utilise cette inférence de type statique pour travailler ce que le type de la variable est au moment de la compilation

var foo = new ClassName();

variable 'foo' sera de type 'ClassName' à partir de là.

Answer 14

Une chose qui n'a pas été mentionné est que C # est un CLS (Common Language Specification) langue conforme. Ceci est un ensemble de règles qu'un langage .NET doit respecter afin d'être interopable avec d'autres langages .NET.

Alors, vraiment C # est juste garder à ces règles. Pour citer cet article MSDN :

  

Le CLS permet d'améliorer et d'assurer   l'interopérabilité des langues en définissant   un ensemble de fonctionnalités que les développeurs peuvent   compter pour être disponible dans un large   variété de langues. Le CLS aussi   fixe les exigences concernant CLS   conformité; ceux-ci vous aider à déterminer   si votre code managé est conforme à   la CLS et dans quelle mesure une donnée   outil prend en charge le développement de   code managé qui utilise des fonctionnalités CLS.

     

Si votre composant utilise uniquement CLS   fonctionnalités de l'API qu'elle expose à   un autre code (y compris les dérivés   classes), le composant est garanti   être accessible de toute la programmation   langue qui prend en charge la CLS.   Les composants qui adhèrent à la CLS   règles et utiliser uniquement les caractéristiques   inclus dans les CLS sont dites   composants conformes CLS

Une partie de la CLS est le CTS système Type commun .

Si ce n'est pas assez d'acronymes pour vous, alors il y a une tonne de plus en .NET telles que la CLI, ilasm / MSIL, CLR, BCL, FCL,

Answer 15

Le typage statique permet également le compilateur de prendre de meilleures optimisations, et sauter certaines étapes. Prenez la surcharge par exemple, où vous avez des méthodes ou des opérateurs multiples avec le même nom ne diffèrent que par leurs arguments. Avec un langage dynamique, le moteur d'exécution aurait besoin au grade chaque version afin de déterminer quelle est la meilleure correspondance. Avec un langage statique comme celui-ci, le code final indique simplement directement à la surcharge appropriée.

Le typage statique contribue également à la maintenance du code et refactoring. Mon exemple préféré étant la fonction Renommer de plusieurs IDEs haut de gamme. Merci à typage statique, l'IDE peut trouver avec certitude toutes les occurrences de l'identifiant dans votre code, et laisser des identifiants non reliés avec le même nom intact.

Je n'ai pas remarqué si elle était encore mentionné ou non, mais C # 4.0 introduit la vérification dynamique via le mot-clé dynamic. Bien que je suis sûr que vous voulez éviter quand il est pas nécessaire.

Answer 16

  

Pourquoi C # me demande de spécifier le type de données lors de la création d'une variable.

     

Pourquoi avons-nous besoin de connaître le type de données devant une instance de classe?

Je pense une chose que la plupart des réponses ne sont pas référencés est le fait que C # était à l'origine signifié et conçu comme « géré », la langue « sûr » entre autres et beaucoup de ces objectifs sont est arrivé à via statique / compilation vérifiabilité de temps. Connaissant le type de données variables fait explicitement ce problème beaucoup plus facile à résoudre. Ce qui signifie que l'on peut faire plusieurs évaluations automatisées (C # compilateur, pas JIT) sur les erreurs possibles / comportement indésirable sans jamais permettre l'exécution.

Ce vérifiabilité comme un effet secondaire vous donne également une meilleure lisibilité, outils de développement, la stabilité, etc., parce que si un algorithme automatisé peut mieux comprendre ce que le code fera quand il fonctionne en fait, vous aussi:)

Answer 17

statiquement typé signifie que le compilateur peut effectuer une sorte de contrôles au moment de la compilation pas au moment de l'exécution. Chaque variable est de type particulier ou forte dans le type statique. C # est fortement certainement fortement typé.