Commentaires

Une note dans le programme Pine est pour la personne qui lit le fichier. L’écran reste pine. Console.WriteLine("pine"); est encore la ligne qui écrit ce mot. Cette page place la note sous deux formes, montre que pine est encore la seule ligne, puis montre le seul placement qui enlève pine. Vous ne réinstallez pas le SDK. Vous ne relisez pas quelle ligne est Main. Gardez la classe publique nommée Pine et gardez la commande d’écriture active dans le fichier que vous gardez.

Une note n’est pas une commande

Une commande est une ligne que C# exécute. Console.WriteLine("pine"); est une commande. Elle écrit pine et termine la ligne. Une note est un texte que vous laissez dans le fichier pour que vous, ou le prochain lecteur, vous souveniez de quelque chose. Le compilateur et le runtime passent une note. Passer signifie que la note n’est pas exécutée, et qu’elle n’est pas écrite à l’écran. Les lettres de la note restent dans le fichier après l’exécution. Vous pouvez ouvrir le fichier et les lire. Vous ne les trouvez pas à l’écran. L’écran a encore une ligne, et cette ligne est pine, tant que la commande d’écriture elle-même n’est pas la note.

Il y a deux formes. Une note de ligne commence par deux barres obliques, //. C# ignore depuis ces deux barres jusqu’à la fin de cette même ligne. La ligne suivante est de nouveau une ligne normale. Une note de bloc commence par /* et se termine au premier */. C# ignore tout entre ces deux marques, y compris les retours à la ligne. Une note de bloc peut tenir sur une ligne ou sur plusieurs. Les deux formes sont des notes. Aucune des deux n’écrit l’écran. Les barres ne s’impriment pas. Les étoiles ne s’impriment pas. Les mots que vous mettez entre elles ne s’impriment pas.

Le fichier que vous gardez

Gardez cette forme d’enseignement. Elle a une note de ligne au-dessus de la commande d’écriture, une autre note de ligne sur la ligne même de la commande, et une note de ligne près de Main. La commande d’écriture est toujours là, et elle n’est pas derrière une barre.

Lisez-le depuis le haut, et décidez pour chaque ligne si l’écran la reçoit. La ligne using System; prépare des noms courts et n’écrit pas l’écran. La ligne de classe est encore public class Pine. Cette ligne nomme le type et n’écrit pas l’écran. La ligne suivante est // the teaching type is Pine. Les deux barres commencent une note, donc ces mots sont pour vous. L’écran ne les montre pas. Il ne montre pas non plus les barres. La ligne public static void Main() est l’endroit où le runtime démarre, et aucun de ces mots n’est à l’écran. Cela n’a pas changé depuis First Program.

À l’intérieur de Main, la ligne // a note for the reader n’est qu’une note. Le runtime l’atteint, la passe, et va à la ligne suivante. La ligne suivante est celle qui compte : Console.WriteLine("pine"); // the screen is this word. Lisez cette ligne comme deux parties séparées par les barres. Avant les barres, la commande est Console.WriteLine("pine");. Cette commande écrit pine et termine la ligne. Après les barres, les mots the screen is this word sont une note. Ils sont sur la même ligne que la commande, et ils sont quand même ignorés. Une note n’a pas besoin d’occuper une ligne à elle seule. Si // apparaît après une commande terminée, la commande s’exécute et le reste de la ligne non. Le point-virgule est ce qui termine la commande. Les barres après le point-virgule commencent la note. Laissez ce point-virgule où il est. L’écran montre pine. Il ne montre pas the screen is this word. Il ne montre pas une deuxième ligne.

Exécutez-le de la même façon qu’après l’installation. Dans le dossier du projet, tapez dotnet run. L’écran montre pine. Une ligne. Sans guillemets. Sans barres. Sans deuxième ligne. Le mot pine est encore le mot entre les guillemets. Ce n’est pas un mot que vous avez tapé dans la commande, et ce n’est pas un mot que vous avez tapé dans une note. Les notes ne font pas échouer la construction, et elles ne s’impriment pas elles-mêmes.

Une note de bloc

Une note de bloc est l’autre forme. Vous l’utilisez quand la note est plus longue qu’une ligne, ou quand vous voulez que la fin de la note soit une marque que vous choisissez, pas la fin de la ligne. La marque d’ouverture est /*. La marque de fermeture est */. C# ignore de l’ouverture jusqu’à la fermeture, et le premier */ est la fin. Un */ plus tard ne fait pas partie de cette note, parce que la note est déjà terminée. Cette page utilise une note de bloc, donc vous verrez une ouverture et une fermeture.

Remplacez les notes de ligne à l’intérieur de Main par une note de bloc, et laissez la commande d’écriture en place. L’écran ne change pas. C’est le deuxième fichier. Vous regardez à quoi ressemble la note. Le fichier que vous gardiez utilisait des notes de ligne. Celui-ci utilise une note de bloc. Les deux écrivent pine.

La note de bloc commence sur la ligne qui commence par /*. Les mots a note sont à l’intérieur. La ligne suivante, across two lines, y est aussi, parce que le */ de fermeture n’est pas encore apparu. Le */ à la fin de cette deuxième ligne termine la note. C# exécute ensuite Console.WriteLine("pine"); parce que cette commande est hors de la note, sous la marque de fermeture. L’écran montre pine. Les mots a note et across two lines ne sont pas à l’écran. Les étoiles et les barres ne sont pas à l’écran. Si vous montez le */ pour qu’il soit sur la première ligne, juste après a note, alors la deuxième ligne n’est plus dans la note. Cette deuxième ligne devrait être une vraie ligne C#, et across two lines n’est pas une commande. La construction écrirait une erreur au lieu de rester silencieuse. Sur cette page le */ reste à la fin de la deuxième ligne, donc toute la note est ignorée et la construction reste silencieuse.

N’essayez pas de mettre une note de bloc à l’intérieur d’une autre. Le premier */ termine la note, même si vous vouliez que ce */ termine une note intérieure. Après cette première marque de fermeture, C# lit à nouveau des commandes. Cette page n’imbrique pas les notes. Une ouverture, une fermeture, puis la commande d’écriture.

L’erreur qui enlève pine

La note et la commande d’écriture sont des lignes différentes, ou des parties différentes d’une même ligne, dans les fichiers ci-dessus. L’erreur est de mettre les deux barres devant la commande d’écriture, de sorte que la commande devient la note. Gardez cette troisième forme seulement assez longtemps pour voir l’écran vide, puis remettez la commande d’écriture. Ce n’est pas le fichier que vous gardez.

dotnet run n’écrit alors rien d’utile à l’écran pour ce contrôle d’enseignement. Il n’y a pas de pine. Il n’y a pas de mot entre guillemets vide. Il n’y a pas de deuxième ligne. L’écran est vide parce que la commande qui écrivait pine est derrière //. Les lettres Console.WriteLine("pine") sont encore dans le fichier, et vous pouvez les lire, mais elles sont une note maintenant. Les guillemets ne les sauvent pas. Les guillemets marquent un mot à l’intérieur d’une commande. Ils ne retransforment pas une note en commande. Les deux barres devant décident, et elles décident que le reste de la ligne est pour le lecteur.

Remettez le fichier à celui que vous gardez. La ligne d’écriture doit être Console.WriteLine("pine"); avec la note, si vous en voulez une, après le point-virgule. Alors dotnet run écrit pine à nouveau. Si l’écran est vide, cherchez // avant Console. C’est tout le contrôle. Vous ne réinstallez pas le SDK .NET pour un écran vide causé par une note. Gardez les habitudes Java restantes avec System.out.println hors de cette page quand vous pratiquez la ligne d’écriture C#. Gardez l’invention de routes ASP.NET hors de cette page.

L’écran est encore pine

Vous pouvez maintenant mettre une note dans le fichier Pine sans changer l’écran. Une note de ligne commence par //. Une note de bloc commence par /* et se termine au premier */. L’écran du fichier que vous gardez est pine, écrit par Console.WriteLine("pine");. Si // se place devant cette commande, l’écran n’a pas de ligne. Une note peut contenir n’importe quels mots, y compris Pine, Main, et pine. Ces mots ne sont toujours pas à l’écran. La page suivante change la façon d’écrire les lignes de sortie, pour que l’écran puisse montrer plus d’une courte habitude. Les notes de cette page restent des notes.