Didacticiel : Explorez des idées à l’aide d’instructions de niveau supérieur pour générer du code à mesure que vous en ApprenezTutorial: Explore ideas using top-level statements to build code as you learn

Ce didacticiel vous montre comment effectuer les opérations suivantes :In this tutorial, you'll learn how to:

  • Découvrez les règles qui régissent l’utilisation des instructions de niveau supérieur.Learn the rules governing your use of top-level statements.
  • Utilisez les instructions de niveau supérieur pour explorer les algorithmes.Use top-level statements to explore algorithms.
  • Refactorisez les explorations dans des composants réutilisables.Refactor explorations into reusable components.

PrérequisPrerequisites

Vous devez configurer votre ordinateur pour exécuter .NET 5, qui comprend le compilateur C# 9.You'll need to set up your machine to run .NET 5, which includes the C# 9 compiler. Le compilateur C# 9 est disponible à partir de Visual Studio 2019 version 16,9 Preview 1 ou .net 5,0 SDK.The C# 9 compiler is available starting with Visual Studio 2019 version 16.9 preview 1 or .NET 5.0 SDK.

Ce tutoriel suppose de connaître C# et .NET, y compris Visual Studio ou l’interface CLI .NET Core.This tutorial assumes you're familiar with C# and .NET, including either Visual Studio or the .NET Core CLI.

Commencez à explorerStart exploring

Les instructions de niveau supérieur vous permettent d’éviter la cérémonie supplémentaire requise en plaçant le point d’entrée de votre programme dans une méthode statique dans une classe.Top-level statements enable you to avoid the extra ceremony required by placing your program's entry point in a static method in a class. Le point de départ classique d’une nouvelle application console ressemble au code suivant :The typical starting point for a new console application looks like the following code:

using System;

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

Le code précédent est le résultat de l’exécution de la dotnet new console commande et de la création d’une nouvelle application console.The preceding code is the result of running the dotnet new console command and creating a new console application. Ces 11 lignes contiennent une seule ligne de code exécutable.Those 11 lines contain only one line of executable code. Vous pouvez simplifier ce programme avec la nouvelle fonctionnalité d’instructions de niveau supérieur.You can simplify that program with the new top-level statements feature. Cela vous permet de supprimer toutes les lignes, sauf deux, dans ce programme :That enables you to remove all but two of the lines in this program:

using System;

Console.WriteLine("Hello World!");

Cette action simplifie ce qui est nécessaire pour commencer à explorer de nouvelles idées.This action simplifies what's needed to begin exploring new ideas. Vous pouvez utiliser des instructions de niveau supérieur pour les scénarios de script ou pour explorer.You can use top-level statements for scripting scenarios, or to explore. Une fois les principes de base opérationnels, vous pouvez commencer à refactoriser le code et créer des méthodes, des classes ou d’autres assemblys pour des composants réutilisables que vous avez générés.Once you've got the basics working, you can start refactoring the code and create methods, classes, or other assemblies for reusable components you've built. Les instructions de niveau supérieur permettent d’effectuer des expérimentations rapides et des didacticiels débutants.Top-level statements do enable quick experimentation and beginner tutorials. Ils fournissent également un chemin lisse entre l’expérimentation et les programmes complets.They also provide a smooth path from experimentation to full programs.

Les instructions de niveau supérieur sont exécutées dans l’ordre dans lequel elles apparaissent dans le fichier.Top-level statements are executed in the order they appear in the file. Les instructions de niveau supérieur ne peuvent être utilisées que dans un seul fichier source dans votre application.Top-level statements can only be used in one source file in your application. Le compilateur génère une erreur si vous les utilisez dans plusieurs fichiers.The compiler generates an error if you use them in more than one file.

Créer un ordinateur de réponse Magic .NETBuild a magic .NET answer machine

Pour ce didacticiel, nous allons créer une application console qui répond à une question « oui » ou « non » avec une réponse aléatoire.For this tutorial, let's build a console application that answers a "yes" or "no" question with a random answer. Vous allez créer les fonctionnalités pas à pas.You'll build out the functionality step by step. Vous pouvez vous concentrer sur votre tâche plutôt que sur la cérémonie nécessaire à la structure d’un programme standard.You can focus on your task rather than ceremony needed for the structure of a typical program. Ensuite, une fois que vous êtes satisfait de la fonctionnalité, vous pouvez refactoriser l’application comme vous le souhaitez.Then, once you're happy with the functionality, you can refactor the application as you see fit.

Un bon point de départ consiste à réécrire la question sur la console.A good starting point is to write the question back to the console. Vous pouvez commencer par écrire le code suivant :You can start by writing the following code:

using System;

Console.WriteLine(args);

Vous ne déclarez pas de args variable.You don't declare an args variable. Pour le fichier source unique qui contient vos instructions de niveau supérieur, le compilateur reconnaît args les arguments de ligne de commande.For the single source file that contains your top-level statements, the compiler recognizes args to mean the command-line arguments. Le type des arguments est un string[] , comme dans tous les programmes C#.The type of args is a string[], as in all C# programs.

Vous pouvez tester votre code en exécutant la dotnet run commande suivante :You can test your code by running the following dotnet run command:

dotnet run -- Should I use top level statements in all my programs?

Les arguments qui suivent le -- sur la ligne de commande sont passés au programme.The arguments after the -- on the command line are passed to the program. Vous pouvez voir le type de la args variable, car il s’agit de l’impression sur la console :You can see the type of the args variable, because that's what's printed to the console:

System.String[]

Pour écrire la question dans la console, vous devez énumérer les arguments et les séparer par un espace.To write the question to the console, you'll need to enumerate the arguments and separate them with a space. Remplacez l' WriteLine appel par le code suivant :Replace the WriteLine call with the following code:

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

Désormais, lorsque vous exécutez le programme, la question est correctement affichée sous la forme d’une chaîne d’arguments.Now, when you run the program, it will correctly display the question as a string of arguments.

Répondre avec une réponse aléatoireRespond with a random answer

Après avoir renvoyé la question, vous pouvez ajouter le code pour générer la réponse aléatoire.After echoing the question, you can add the code to generate the random answer. Commencez par ajouter un tableau de réponses possibles :Start by adding an array of possible answers:

string[] answers =
{
    "It is certain.",       "Reply hazy, try again.",     "Don’t count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
};

Ce tableau a 12 réponses positives, six qui ne sont pas valides et six négatives.This array has 12 answers that are affirmative, six that are non-committal, and six that are negative. Ensuite, ajoutez le code suivant pour générer et afficher une réponse aléatoire à partir du tableau :Next, add the following code to generate and display a random answer from the array:

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Vous pouvez réexécuter l’application pour voir les résultats.You can run the application again to see the results. Vous devriez voir une sortie semblable à la suivante :You should see something like the following output:

dotnet run -- Should I use top level statements in all my programs?

Should I use top level statements in all my programs?
Better not tell you now.

Ce code répond aux questions, mais nous allons ajouter une fonctionnalité supplémentaire.This code answers the questions, but let's add one more feature. Vous aimeriez que votre application de question simule une réflexion sur la réponse.You'd like your question app to simulate thinking about the answer. Vous pouvez le faire en ajoutant un peu d’animations ASCII et en interrompant le travail.You can do that by adding a bit of ASCII animation, and pausing while working. Ajoutez le code suivant après la ligne qui renvoie la question :Add the following code after the line that echoes the question:

for (int i = 0; i < 20; i++)
{
    Console.Write("| -");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("/ \\");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("- |");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("\\ /");
    await Task.Delay(50);
    Console.Write("\b\b\b");
}
Console.WriteLine();

Vous devez également ajouter une using instruction en haut du fichier source :You'll also need to add a using statement to the top of the source file:

using System.Threading.Tasks;

Les using instructions doivent être antérieures à toute autre instruction dans le fichier.The using statements must be before any other statements in the file. Dans le cas contraire, il s’agit d’une erreur du compilateur.Otherwise, it's a compiler error. Vous pouvez réexécuter le programme et voir l’animation.You can run the program again and see the animation. Cela offre une meilleure expérience.That makes a better experience. Expérimentez la longueur du délai pour vous adapter à votre goût.Experiment with the length of the delay to match your taste.

Le code précédent crée un ensemble de lignes en rotation séparées par un espace.The preceding code creates a set of spinning lines separated by a space. L’ajout du await mot clé indique au compilateur de générer le point d’entrée du programme en tant que méthode avec le async modificateur et retourne un System.Threading.Tasks.Task .Adding the await keyword instructs the compiler to generate the program entry point as a method that has the async modifier, and returns a System.Threading.Tasks.Task. Ce programme ne retourne pas de valeur, donc le point d’entrée du programme retourne un Task .This program does not return a value, so the program entry point returns a Task. Si votre programme retourne une valeur entière, vous devez ajouter une instruction return à la fin de vos instructions de niveau supérieur.If your program returns an integer value, you would add a return statement to the end of your top-level statements. Cette instruction return spécifie la valeur entière à retourner.That return statement would specify the integer value to return. Si vos instructions de niveau supérieur incluent une await expression, le type de retour devient System.Threading.Tasks.Task<TResult> .If your top-level statements include an await expression, the return type becomes System.Threading.Tasks.Task<TResult>.

Refactorisation à l’avenirRefactoring for the future

Votre programme doit ressembler au code suivant :Your program should look like the following code:

using System;
using System.Threading.Tasks;

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

for (int i = 0; i < 20; i++)
{
    Console.Write("| -");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("/ \\");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("- |");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("\\ /");
    await Task.Delay(50);
    Console.Write("\b\b\b");
}
Console.WriteLine();

string[] answers =
{
    "It is certain.",       "Reply hazy, try again.",     "Don’t count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
};

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Le code précédent est raisonnable.The preceding code is reasonable. Il fonctionne.It works. Mais il n’est pas réutilisable.But it isn't reusable. Maintenant que l’application fonctionne, il est temps de tirer parti des parties réutilisables.Now that you have the application working, it's time to pull out reusable parts.

Un candidat est le code qui affiche l’animation en attente.One candidate is the code that displays the waiting animation. Cet extrait de code peut devenir une méthode :That snippet can become a method:

Vous pouvez commencer par créer une fonction locale dans votre fichier.You can start by creating a local function in your file. Remplacez l’animation actuelle par le code suivant :Replace the current animation with the following code:

await ShowConsoleAnimation();

static async Task ShowConsoleAnimation()
{
    for (int i = 0; i < 20; i++)
    {
        Console.Write("| -");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("/ \\");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("- |");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("\\ /");
        await Task.Delay(50);
        Console.Write("\b\b\b");
    }
    Console.WriteLine();
}

Le code précédent crée une fonction locale à l’intérieur de votre méthode main.The preceding code creates a local function inside your main method. Cela n’est toujours pas réutilisable.That's still not reusable. Ainsi, extrayez ce code dans une classe.So, extract that code into a class. Créez un nouveau fichier nommé Utilities.cs et ajoutez le code suivant :Create a new file named utilities.cs and add the following code:

using System;
using System.Threading.Tasks;

namespace MyNamespace
{
    public static class Utilities
    {
        public static async Task ShowConsoleAnimation()
        {
            for (int i = 0; i < 20; i++)
            {
                Console.Write("| -");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("/ \\");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("- |");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("\\ /");
                await Task.Delay(50);
                Console.Write("\b\b\b");
            }
            Console.WriteLine();
        }
    }
}

Les instructions de niveau supérieur ne peuvent figurer que dans un seul fichier, et ce fichier ne peut pas contenir d’espaces de noms ou de types.Top-level statements can only be in one file, and that file cannot contain namespaces or types.

Enfin, vous pouvez nettoyer le code de l’animation pour supprimer des doublons :Finally, you can clean the animation code to remove some duplication:

foreach (string s in new[] { "| -", "/ \\", "- |", "\\ /", })
{
    Console.Write(s);
    await Task.Delay(50);
    Console.Write("\b\b\b");
}

Vous disposez maintenant d’une application complète et vous avez refactorisé les parties réutilisables pour une utilisation ultérieure.Now you have a complete application, and you've refactored the reusable parts for later use. Vous pouvez appeler la nouvelle méthode utilitaire à partir de vos instructions de niveau supérieur, comme indiqué ci-dessous dans la version finale du programme principal :You can call the new utility method from your top-level statements, as shown below in the finished version of the main program:

using System;
using MyNamespace;

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

await Utilities.ShowConsoleAnimation();

string[] answers =
{
    "It is certain.",       "Reply hazy, try again.",     "Don’t count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
};

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Cela ajoute l’appel à Utilities.ShowConsoleAnimation et ajoute une instruction supplémentaire using .This adds the call to Utilities.ShowConsoleAnimation, and adds an additional using statement.

RésuméSummary

Les instructions de niveau supérieur facilitent la création de programmes simples à utiliser pour explorer les nouveaux algorithmes.Top-level statements make it easier to create simple programs for use to explore new algorithms. Vous pouvez expérimenter des algorithmes en essayant différents extraits de code.You can experiment with algorithms by trying different snippets of code. Une fois que vous avez appris ce qui fonctionne, vous pouvez Refactoriser le code pour qu’il soit plus facile à gérer.Once you've learned what works, you can refactor the code to be more maintainable.

Les instructions de niveau supérieur simplifient les programmes basés sur les applications console.Top-level statements simplify programs that are based on console applications. Il s’agit notamment des fonctions Azure, des actions GitHub et d’autres petits utilitaires.These include Azure functions, GitHub actions, and other small utilities.