C # est-il partiellement interprété ou vraiment compilé?
Il y a beaucoup d'informations contradictoires à ce sujet. Alors que certains disent que C # est compilé (car il est compilé en IL puis en code natif lors de son exécution), d'autres disent qu'il est interprété comme il a besoin de .NET. EN Wiki dit:
De nombreux langages interprétés sont d'abord compilés en une certaine forme de code de machine virtuelle, qui est ensuite interprété ou compilé au moment de l'exécution en code natif.
Je suis donc assez confus. Quelqu'un pourrait-il expliquer cela clairement?
C # est compilé en IL, par le compilateur c #.
Cet IL est ensuite compilé juste à temps (JIT) selon les besoins, dans le langage d'assemblage natif de la machine hôte. Il serait cependant possible d'écrire un runtime .NET qui interpréterait l'IL à la place. Même si cela a été fait, je dirais toujours que c # est un langage compilé.
Un langage purement compilé présente certains avantages. La vitesse, en règle générale, et la taille de l'ensemble de travail. Un langage purement interprété présente certains avantages. Flexibilité de ne pas avoir besoin d'une étape de compilation explicite qui nous permet d'éditer sur place, et portabilité souvent plus facile.
Une langue jitted s'inscrit dans un juste milieu dans ce cas.
C'est une seule raison pour laquelle nous pourrions penser à un langage ignoré comme étant compilé ou interprété selon la position sur quelle métrique nous nous soucions d'atteindre, et nos préjugés pour et contre l'un ou l'autre.
C # peut également être compilé lors de la première exécution, comme cela se produit dans ASP.NET, ce qui le rend proche d'être interprété dans ce cas (bien qu'il soit toujours compilé en IL puis jitted dans ce cas). Certes, il a à peu près tous les avantages d'interprété dans ce cas (comparer avec VBScript ou JScript utilisé dans ASP classique), ainsi que la plupart des avantages de compilé.
Strictement, aucune langue n'est jitted, interprétée ou compilée en tant que langue. Nous pouvons NGen C # en code natif (bien que s'il fait quelque chose comme charger dynamiquement un Assembly, il utilisera toujours IL et jitting). Nous pourrions écrire un interprète pour C ou C++ (plusieurs personnes l'ont fait). Dans son cas d'utilisation le plus courant cependant, C # est compilé en IL qui est ensuite jitted, ce qui n'est pas tout à fait la définition classique d'interprété ni de compilé.
Trop de sémantique et de déclarations basées sur l'opinion.
Tout d'abord: C # n'est pas un langage interprété; le CLR et la JVM sont considérés comme "runtimes" ou "middleware", mais le même nom s'applique à des choses comme Perl. Cela crée beaucoup de confusion parmi les personnes concernées par les noms.
Le terme "interprète" faisant référence à un runtime signifie généralement que le code existant interprète du code non natif. Il existe deux grands paradigmes: l'analyse syntaxique lit le code source brut et prend des actions logiques; L'exécution de bytecode compile d'abord le code en une représentation binaire non native, ce qui nécessite beaucoup moins de cycles CPU à interpréter.
Java initialement compilé en bytecode, est ensuite passé par un interpréteur; maintenant, la JVM lit le bytecode et le compile juste à temps en code natif. CIL fait de même: le CLR utilise une compilation juste à temps en code natif.
Considérez toutes les combinaisons de l'exécution du code source, de l'exécution du bytecode, de la compilation en natif, de la compilation juste à temps, de l'exécution du code source via un compilateur en natif juste à temps, etc. La sémantique de savoir si une langue est compilée ou interprétée devient vide de sens.
Par exemple: de nombreux langages interprétés utilisent une compilation de bytecode juste à temps. C # compile en CIL, que JIT compile en natif; en revanche, Perl compile immédiatement un script en un bytecode, puis exécute ce bytecode via un interpréteur. Vous ne pouvez exécuter qu'un assemblage C # au format CIL bytecode; vous ne pouvez exécuter qu'un script Perl au format de code source brut.
Les compilateurs juste à temps exécutent également un grand nombre d'instruments externes et internes. Le runtime suit l'exécution de diverses fonctions, puis ajuste la disposition du code pour optimiser les branches et l'organisation du code pour son flux d'exécution particulier. Cela signifie que le code JIT peut s'exécuter plus rapidement que le code compilé nativement (comme C++ est généralement, ou comme C # exécuté via IL2CPP), car le JIT ajuste sa stratégie d'optimisation au cas d'exécution réel du code lors de son exécution.
Bienvenue dans le monde de la programmation informatique. Nous avons décidé de le rendre extrêmement compliqué, puis d'attacher des noms non descriptifs à tout. Le but est de créer des guerres enflammées sur la définition de mots qui n'ont aucune signification pratique.
Regardez ici: http://msdn.Microsoft.com/library/z1zx9t92
Le code source écrit en C # est compilé dans un langage intermédiaire (IL) conforme à la spécification CLI.
(...)
Lorsque le programme C # est exécuté, l'assembly est chargé dans le CLR, qui peut effectuer diverses actions en fonction des informations contenues dans le manifeste. Ensuite, si les exigences de sécurité sont remplies, le CLR effectue une compilation juste à temps (JIT) pour convertir le code IL en instructions machine natives.
Si vous sentez, apprenez ou êtes à l'ancienne, qu'un EXE compilé passe du code source au code machine, alors C # est interprété. Si vous pensez que compiler signifie convertir le code source en un autre code tel que le code d'octet, alors oui, il est converti. Pour moi, tout ce qui prend le traitement à l'exécution pour fonctionner dans le système d'exploitation pour lequel il a été conçu est interprété.
Tout d'abord, comprenons les définitions de interprétées et compilées.
"Compiler" (en se référant au code) signifie traduire le code d'une langue à une autre. Typiquement du code source lisible par l'homme au code machine que le processeur cible peut ... traiter.
"Interpréter" (en se référant au code) signifie également traduire le code d'une langue à une autre. Mais cette fois, il est généralement utilisé pour passer du code source lisible par l'homme à un code intermédiaire pris par une machine virtuelle qui l'interprète en code machine.
Juste pour être clair
Code source -> Compilateur -> Code machine
Code source -> Compilateur -> Code octet -> Interprète -> Code machine
Tout langage peut, en théorie, être interprété ou compilé . Typiquement Java est compilé en bytecode qui est interprété par la machine virtuelle Java en code machine. C # est généralement interprété en bytecode qui est compilé par le CLR, le runtime de langage commun, une autre machine virtuelle.
De loin, le tout est un gadget marketing. Le terme "interprété" a été ajouté (ou au moins, augmenté dans l'utilisation) pour aider à montrer à quel point compilation juste à temps était. Mais ils auraient pu simplement utiliser "compilé". La distinction est plus une étude de la langue anglaise et des tendances commerciales que quelque chose de nature technique.
La plupart des langues, sinon toutes, nécessitent un interprète qui traduit leurs scripts en codes machine afin de permettre au processeur de le comprendre et de l'exécuter!
Chaque langue gère le processus de traduction différemment!
Par exemple, "AutoIt" est ce que nous pouvons décrire comme étant un langage 100% interprété!
pourquoi?
Parce que l'interpréteur "AutoIt" est constamment nécessaire pendant l'exécution de son script! Voir l'exemple ci-dessous:
Loop, 1000
Any-Code
L'interprète "AutoIt" devrait traduire 1000 fois "Any-Code" en code machine, ce qui fait automatiquement de "AutoIt" un langage lent!
En revanche, C # gère différemment le processus de traduction, l'interpréteur de C # n'est requis qu'une seule fois, avant l'exécution du script, après quoi il n'est plus nécessaire pendant l'exécution du script!
L'interprète de C # ne devrait traduire "Any-Code" qu'une seule fois en code machine, ce qui fait automatiquement de "C #" un langage rapide!
Donc en gros,
Un langage qui nécessite son interprète pendant l'exécution du script est un "langage interprété"!
Un langage qui ne nécessite son interprète qu'une seule fois (avant l'exécution du script) est un "langage compilé"!
Finalement,
"AutoIt" est un "langage interprété"!
"C #" est un "langage compilé"!
C # est les deux interprété et compilé dans sa durée de vie. C # est compilé dans un langage virtuel qui est interprété par une machine virtuelle.
La confusion provient du concept flou d'un "langage compilé".
"Langage compilé" est un terme impropre, dans un sens, parce que compilé ou interprété n'est pas une propriété du langage mais du runtime.
par exemple. Vous pouvez écrire un interpréteur C, mais les gens l'appellent généralement un "langage compilé", car les implémentations C se compilent en code machine, et le langage a été conçu en pensant à la compilation.
Je pense que c'est un sujet assez ancien.
De mon point de vue, le code interprété passera par un interpréteur, traduction ligne par ligne et exécution en même temps. Comme l'exemple de javascript, il s'agit d'un code interprété, lorsqu'une ligne de javascript rencontre une erreur, le script se casse.
Pendant la compilation du code, il passera par un compilateur, traduira tout le code en une autre forme de code à la fois, sans l'exécuter au préalable. L'exécution est dans un autre contexte.
Si nous sommes d'accord avec la définition d'interprète " En informatique, un interprète est un programme informatique qui exécute directement, c'est-à-dire exécute, des instructions écrites dans un langage de programmation ou de script, sans les obliger à avoir préalablement été compilé dans un programme en langage machine. "il n'y a aucun doute: C # n'est pas un langage interprété.
C #, comme Java, a un processeur de langage hybride. Les processeurs hybrides effectuent les tâches d'interprétation et de compilation.
C # est un langage compilable.
Probablement, je le répète, probablement, comme j'ai rencontré aussi ce genre d'opinions, le fait que quelqu'un pense qu'il y a un interprète pour le langage C #, est dû au genre de projets comme
ou, par exemple, célèbre
où vous pouvez écrire juste des lignes du code et les exécuter, ce qui fait penser que c'est Python comme un langage, qui est pas vrai . Il compile ces lignes et les exécute, comme un langage de programmation compilable ordinaire (du point de vue du workflow).
Puisqu'un ordinateur ne peut exécuter que du code binaire, n'importe quel langage entraînera la production de code binaire à un moment ou à un autre. La question est: le langage vous permet-il de produire un programme en code binaire? Si oui, alors c'est un langage compilé: par définition "compilé" dans "langage compilé" se réfère à la compilation en code binaire, pas à la transformation en un code intermédiaire. Si le langage conduit à la production d'un tel code intermédiaire pour un programme, il aura besoin d'un logiciel supplémentaire pour effectuer la compilation binaire à partir de ce code: il s'agit alors d'un langage interprété. Un programme "compilé" par C # est-il directement exécutable sur une machine sans aucun autre logiciel installé sur cette machine? sinon, c'est un langage interprété. Pour un langage interprété, c'est un interpréteur qui va générer le code binaire sous-jacent, la plupart du temps de manière dynamique puisque ce mécanisme est à la base de la flexibilité de ces langages. rem. : parfois cela ne semble pas évident car l'interpréteur est intégré au système d'exploitation