Explication détaillée de Hello World en C# qui peut être écrite sans IDE (photo)

Il est très facile d'écrire Hello World en C# en utilisant un IDE tel que Visual Studio, mais pouvez-vous imprimer Hello World sans IDE. Cela ne signifie pas travailler sans IDE, mais apprendre le modèle d'exécution de CLR.

Bonjour tout le monde

1. Créez un nouveau bloc-notes, entrez le code suivant et enregistrez-le sous HelloWorld.txt.

using System;
namespace HelloWorld
{
   class Program
   {
        static void Main(string[] args) {
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }
    }
}

2. Ouvrez le programme d'invite de commande Visual Studio 2008 (2005, 2010)

3. Basculez vers le répertoire de HelloWorld.txt

4. Exécutez la commande : csc /out:Hello.exe HelloWorld.txt

Si rien d’inattendu ne se produit, Hello.exe sera compilé et Hello World pourra être imprimé.

Modèle d'exécution CLR - temps de compilation

Le processus d'exécution d'un programme CLR est grossièrement divisé en deux étapes, la période de compilation et la période d'exécution. Le processus de la période de compilation est grossièrement comme indiqué ci-dessous :

.

La période de compilation peut aussi être logiquement divisée en deux étapes :

1. Le compilateur CLR (C#) accepte les fichiers de code source et les compile en modules gérés. Le module géré comprend le code IL, les métadonnées, l'en-tête CLR et d'autres composants. Dans l'exemple ci-dessus, HelloWorld.txt est compilé dans un module géré.

2. Généralement, un assembly contiendra de nombreux fichiers de code source (ici il n'y a que HelloWorld.txt) et des fichiers de ressources. La deuxième étape consiste à fusionner les résultats de compilation correspondants de chaque fichier de code source et fichier de ressources dans un assembly.

Effectuez les deux étapes ci-dessus pour obtenir un assembly XX.dll ou XX.exe, tout comme le Hello.exe ci-dessus.

Comment le compilateur sait-il s'il doit compiler dans un module géré ou dans un fichier de ressources ? En fait, il faut indiquer explicitement au compilateur comment compiler chaque fichier. Cela correspond à l'opération de génération des attributs de fichier de Visual Studio

. Cliquez avec le bouton droit sur le fichier de n'importe quelle solution de ressource de solution Visual Studio-->Propriétés-->Opération de génération :

Spécifiez Class1 comme ressource intégrée. Si vous le vérifiez avec ILSpy, vous constaterez que Class1 est uniquement intégré dans l'assembly, avec le nom : nom de fichier :

.

Vous pouvez même définir une Explication détaillée de Hello World en C# qui peut être écrite sans IDE (photo) à compiler et laisser le compilateur essayer de la compiler, mais il signalera une erreur.

Période de fonctionnement

L'assembly est généré ci-dessus. L'assembly contient du code IL, qui n'est pas encore du code exécutable. IL est un langage machine indépendant du CPU qui est compilé en code natif (instructions CPU) par un compilateur JIT (Just-in-Time) jusqu'à ce que l'assembly soit appelé. Au moment de l'exécution, le CLR effectue les étapes suivantes :

1. Vérifiez les caractéristiques de sécurité de l'assemblage

2. Allouez de l'espace en mémoire

3. Envoyez le code exécutable de l'assembly au compilateur JIT et compilez-en une partie en code natif (instructions CPU).

Le code exécutable de l'assembly est compilé par le compilateur JIT lorsque cela est nécessaire, puis le code natif (instructions CPU) est mis en cache pour une exécution ultérieure dans le programme. Une fois l'application terminée, le code natif compilé est également supprimé.

Par exemple, si vous modifiez le code ci-dessus en :

static void Main(string[] args) {
    Console.WriteLine("Hello");
    Console.WriteLine("World!");
    Console.ReadKey();
}

La première WriteLine doit d’abord être compilée JIT, puis exécutée. Puisque le code WriteLine a été compilé, le deuxième WriteLine exécutera directement le code dans le bloc mémoire, en ignorant la compilation JIT.

En raison de l'allocation de mémoire, du processus de compilation JIT, etc., le programme entraînera une certaine perte de performances lors de sa première exécution. Ce sentiment est particulièrement évident lors de l'écriture d'ASP.NET. Après avoir appuyé sur F5, cela prendra beaucoup de temps. la page d'accueil s'affiche.

Simulons et expérimentons ce processus ci-dessous. Utilisez un tas de classes pour prolonger le temps d'allocation de mémoire, reportez-vous à ce fichier HelloWorld.cs :

Exécutez à nouveau la commande : csc /out:Hello.exe HelloWorld.txt pour obtenir Hello.exe Lors de l'exécution, on constate qu'il y a un certain délai avant l'impression de Hello World.

Générer du code natif

À l'aide de NGen.exe fourni par .NET, le code IL peut être compilé en code natif, ce qui peut résoudre les problèmes ci-dessus. NGen.exe a deux fonctions :

1. Accélérez la vitesse de démarrage des applications. Étant donné que le code est compilé en code natif, il n’est pas nécessaire de consacrer du temps à la compilation au moment de l’exécution.

2. Réduisez l'assemblage de l'application. Si un assembly est chargé par plusieurs processus en même temps, NGen.exe compile l'IL en code natif et l'enregistre dans un fichier séparé. De cette manière, il peut être mappé sur plusieurs processus en même temps grâce au « mappage mémoire », afin que le code puisse être partagé et éviter que chaque processus ait une copie du code.

Exécutez à nouveau le programme d'invite de commande Visual Studio 2008 (2005, 2010)

Exécutez la commande suivante : ngen install Hello.exe :

　

Une fois la commande terminée (cela prend environ 10 secondes sur ma machine, elle ne sera terminée que lorsque la commande pourra être saisie à nouveau), exécutez Hello.exe et vous constaterez que Hello World peut être imprimé immédiatement sans aucun délai.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!