Entrée

Tapez leaf après le démarrage du programme, et l’écran montre leaf. Ce mot n’est pas dans le fichier. Le fichier Pine crée un nom, plant, et attend. Vous tapez leaf et pressez Enter. Console.WriteLine(plant) écrit leaf. Jusqu’ici un autre écran voulait dire éditer la ligne de rangement, parce que le mot était dans le fichier entre guillemets. Gardez la classe publique nommée Pine. Vous ne réinstallez pas le SDK.

Le fichier attend une ligne tapée

Ouvrez le fichier Pine. Le nom de la classe reste Pine. Cette page ne renomme pas le type. À l’intérieur de Main, remplacez l’ancienne ligne de rangement qui tenait des guillemets. La nouvelle ligne de rangement est string plant = Console.ReadLine();. Le mot-clé string dit encore que ce nom tient des lettres. plant commence encore par un petit p. Le signe = range encore des lettres dans ce nom. Ce qui est nouveau, c’est le côté droit. Console.ReadLine() n’a pas de guillemets. Il n’y a pas de leaf sur cette ligne. La ligne demande à la console une ligne tapée. Le programme attend là jusqu’à ce que vous pressiez Enter. Quand vous pressez Enter, ReadLine range les lettres que vous avez tapées avant cet Enter. Il ne range pas Enter lui-même. Ensuite la ligne se termine au point-virgule. Ranger n’est toujours pas écrire. Le programme n’a pas encore écrit sa propre ligne.

La ligne d’écriture reste le nom nu, la même forme que le fichier que vous gardiez à la page précédente : Console.WriteLine(plant);. Sans guillemets. C# lit le nom plant, écrit les lettres que ce nom tient, et termine la ligne. Ces lettres sont ce que ReadLine vient de ranger. Si vous avez tapé leaf, le programme écrit leaf. Si vous avez tapé stem, le programme écrit stem. Le fichier n’a pas changé entre ces deux exécutions. Enregistrez le fichier.

Le fichier que vous gardez

Gardez cette forme d’enseignement. Le mot que vous allez taper n’est pas dans le fichier. Cherchez dans le fichier les lettres l, e, a, f. Elles n’y sont pas. La ligne rangée s’appelle plant. La ligne d’écriture utilise plant et ne contient pas de guillemets.

Lisez le fichier depuis le haut et décidez ce qui peut atteindre l’écran. using System; prépare les noms courts. public class Pine nomme le type. public static void Main() est l’endroit où le runtime démarre. Aucun de ces mots n’est une lettre pour l’écran. string plant = Console.ReadLine(); range une ligne tapée dans plant. Elle n’écrit rien par elle-même. Console.WriteLine(plant); est la seule ligne d’écriture. Elle écrit les lettres rangées et termine la ligne. Le nom plant n’est pas écrit. Console n’est pas écrit. Le point-virgule n’est pas écrit.

Ce que vous tapez et ce que le programme écrit

Exécutez avec dotnet run. Après cette commande, le programme attend sur Console.ReadLine(). Il n’a pas fini, et il n’a pas écrit leaf, parce que vous ne lui avez pas encore donné de ligne. Le curseur est sur une ligne neuve. Tapez les lettres l, e, a, f. Le terminal montre ces lettres pendant que vous pressez les touches. Cet affichage, c’est le terminal qui répète vos touches. Ce n’est pas Console.WriteLine. Puis pressez Enter.

Enter termine l’attente. ReadLine range leaf dans plant et ne range pas Enter. WriteLine écrit ensuite leaf et termine la ligne. Vous voyez leaf, et en dessous leaf encore. Le premier leaf est les touches que le terminal a montrées. Le second leaf est le programme. La ligne du programme n’a pas de guillemets. Ce sont quatre lettres, puis la ligne se termine. Le programme se termine après cette ligne d’écriture. Si le seul leaf que vous voulez juger est la ligne du programme, jugez la ligne qui apparaît après que vous avez pressé Enter.

Si la ligne du programme est plant, la ligne d’écriture a des guillemets autour de plant. Le fichier que vous gardez n’en a pas. Si dotnet run écrit leaf tout de suite et n’attend jamais, le fichier range encore un mot entre guillemets, comme string plant = "leaf";, et il n’appelle jamais ReadLine. Cherchez des guillemets autour de leaf. Le fichier que vous gardez n’en a aucun. Vous ne réinstallez pas le .NET SDK pour un écran qui montre le mauvais mot.

Les majuscules sont copiées telles que vous les tapez. Si vous tapez Leaf avec un L majuscule et pressez Enter, la ligne du programme est Leaf. Le fichier ne contient toujours pas ces lettres. Un Enter vide est aussi une vraie ligne. Pressez Enter sans taper de lettres. ReadLine ne range aucune lettre dans plant. WriteLine écrit une ligne sans lettres. Le programme a tourné. L’attente s’est terminée parce qu’Enter est arrivé. Le fichier que vous gardez est celui que vous essayez avec leaf, quatre petites lettres.

Un espace reste dans la ligne

ReadLine lit jusqu’à Enter, pas jusqu’à un espace. Tapez leaf, puis un espace, puis stem, puis Enter. Les lettres rangées dans plant sont leaf, un espace, et stem. Console.WriteLine(plant) écrit leaf stem. L’espace est un caractère rangé, de la même façon qu’un espace entre guillemets était rangé quand le mot vivait dans le fichier. Cette page ne coupe pas la ligne à l’espace. Le fichier que vous gardez est toujours le lecteur d’une seule ligne. Vous changez seulement ce que vous tapez, pas le fichier, quand vous voulez l’espace à l’écran.

Deux lignes tapées, deux Enter

Un programme peut prendre une deuxième ligne. Sous la première ligne d’écriture, rangez une nouvelle ligne dans le même nom, puis écrivez le nom encore. La nouvelle ligne de rangement est plant = Console.ReadLine();. Elle ne commence pas par string. plant existe déjà, donc cette ligne remplace seulement les lettres que le nom tient. La ligne d’écriture suivante est encore Console.WriteLine(plant);. Le programme attend maintenant deux fois. Chaque ReadLine attend son propre Enter.

Ceci est le second fichier. Ce n’est pas le fichier que vous gardez. Le fichier que vous gardez attend une fois et écrit une fois. Utilisez cette seconde forme quand vous voulez deux lignes tapées, puis remettez le seul ReadLine et le seul WriteLine.

Lancez dotnet run. Le programme attend. Tapez leaf et pressez Enter. Le terminal montre leaf, et le programme écrit leaf en dessous. Le programme attend encore. Il n’a pas fini. Tapez stem et pressez Enter. Le terminal montre stem, et le programme écrit stem en dessous. Les lignes du programme sont leaf, puis stem. Les touches en écho se placent au-dessus de chacune de ces lignes. Si les deux lignes du programme disent leaf, le second ReadLine n’a jamais tourné, ou vous avez tapé leaf les deux fois. Si le programme écrit stem avant que vous ayez tapé une seconde ligne, le second WriteLine n’est pas sous un second ReadLine. L’écran suit l’ordre des lignes dans le fichier, et chaque attente suit le ReadLine qui n’a pas encore reçu Enter.

N’écrivez pas string une seconde fois pour le même nom. string plant = Console.ReadLine();, placé sous une ligne qui a déjà créé plant, est une autre erreur. Cette ligne essaie de créer plant encore. Le build écrit une erreur et ne reste pas silencieux. La réparation est de supprimer le second string et de laisser plant = Console.ReadLine();. Le nom est créé une fois. Les lignes suivantes changent seulement les lettres qu’il tient. Sur le fichier que vous gardez, il n’y a pas de second ReadLine du tout.

Des guillemets autour du nom écrivent le nom

La ligne d’écriture dans le fichier que vous gardez est Console.WriteLine(plant); sans guillemets. Si vous mettez des guillemets autour du nom après une vraie ligne tapée, la ligne est Console.WriteLine("plant");. Ces guillemets marquent des lettres pour l’écran. Les lettres entre eux sont p, l, a, n, t. C# ne cherche pas le nom. Vous pouvez taper leaf et presser Enter, et ReadLine peut ranger leaf dans plant, et la ligne du programme montre encore plant. Le mot tapé n’est pas écrit, parce que la ligne d’écriture n’a jamais utilisé le nom.

Ceci est le troisième fichier. Ce n’est pas le fichier que vous gardez. Gardez-le assez longtemps pour voir la seule ligne du programme plant après avoir tapé leaf, puis retirez les guillemets de la ligne d’écriture.

Le nom doit exister après ReadLine

C# lit le fichier depuis le haut. La ligne qui remplit plant doit être au-dessus de la ligne qui écrit plant. Si vous mettez d’abord Console.WriteLine(plant);, et seulement ensuite string plant = Console.ReadLine();, la ligne d’écriture nomme plant avant que plant existe. Le build écrit une erreur. Il ne reste pas silencieux. Il n’y a pas d’écran à croire pendant que le build écrit une erreur. La réparation est de remonter la ligne ReadLine au-dessus de la ligne d’écriture.

Ce quatrième fichier est l’ordre cassé. Ce n’est pas le fichier que vous gardez. Gardez-le seulement jusqu’à ce que le build écrive l’erreur, puis remettez la ligne ReadLine en haut.

WriteLine ne range pas une ligne tapée

La ligne de rangement doit appeler ReadLine, pas WriteLine. Si la ligne est string plant = Console.WriteLine();, le build écrit une erreur. WriteLine écrit à l’écran et ne rend pas de lettres à un nom. Ce n’est pas un rangement qui attend. Il n’y a pas de leaf tapé à croire pendant que le build écrit une erreur. La réparation est de remettre Console.ReadLine() à droite de =.

Ce cinquième fichier est le mauvais appel de rangement. Ce n’est pas le fichier que vous gardez. Gardez-le seulement jusqu’à ce que le build écrive l’erreur, puis remettez ReadLine.

L’écran est la ligne que vous avez tapée

Vous pouvez maintenant remplir un nom depuis le clavier et écrire cette ligne sans mettre le mot entre guillemets dans le fichier. string plant = Console.ReadLine(); attend Enter et range les lettres tapées. Console.WriteLine(plant); écrit ces lettres et termine la ligne. Un second ReadLine attend encore. Des guillemets autour du nom écrivent les lettres du nom à la place. La ligne ReadLine doit être au-dessus de la première ligne qui utilise le nom. WriteLine du côté rangement n’est pas un rangement. La page suivante commence Value Types, pour qu’un nom puisse tenir un nombre avec un type autre que string, tandis que cette page reste sur une ligne tapée de lettres.