Partager via

Déclarations de haut niveau – programmes sans méthodes Main

Conseil / Astuce

Vous débutez avec le développement de logiciels ? Commencez par commencer par les didacticiels De prise en main . Ces didacticiels utilisent des instructions de niveau supérieur. Vous serez donc déjà familiarisé avec les principes de base.

Vous recherchez une alternative à la méthode Main ? Consultez le point d’entrée de la méthode Main pour une approche méthodologique explicite Main.

Utilisez des instructions de niveau supérieur pour les nouvelles applications. En utilisant des instructions de niveau supérieur, vous pouvez écrire du code exécutable directement à la racine d’un fichier.

Voici un fichier Program.cs qui est un programme C# complet :

Console.WriteLine("Hello World!");

Lorsque vous créez une application console à l’aide de dotnet new console, elle utilise des instructions de niveau supérieur par défaut. Ils fonctionnent bien pour les programmes de toute taille , de petits utilitaires et d’Azure Functions à des applications complètes. Si vous disposez d’une application existante qui utilise une méthode explicite Main , il n’est pas nécessaire de la convertir. Les deux styles sont compilés en code équivalent.

Les sections suivantes expliquent les règles concernant ce que vous pouvez et ne pouvez pas faire avec les instructions de niveau supérieur.

Règles de point d’entrée

Une application doit avoir un seul point d’entrée. Un projet ne peut avoir qu’un seul fichier avec des instructions de niveau supérieur, mais il peut avoir n’importe quel nombre de fichiers de code source qui n’ont pas d’instructions de niveau supérieur. Vous pouvez écrire explicitement une Main méthode, mais elle ne peut pas fonctionner comme point d’entrée. Dans un projet avec des instructions de niveau supérieur, vous ne pouvez pas utiliser l’option -main du compilateur pour sélectionner le point d’entrée, même si le projet a une ou plusieurs Main méthodes.

Le compilateur génère une méthode pour servir de point d’entrée de programme pour un projet comportant des instructions de niveau supérieur. La signature de la méthode varie selon que les instructions de niveau supérieur contiennent le mot clé await ou l’instruction return. Le tableau suivant montre à quoi ressemble la signature de méthode, en utilisant le nom Main de la méthode dans la table pour des raisons pratiques.

Le code de niveau supérieur contient Signature implicite Main
await et return static async Task<int> Main(string[] args)
await static async Task Main(string[] args)
return static int Main(string[] args)
Aucun await ou return static void Main(string[] args)

À compter de C# 14, les programmes peuvent être des applications basées sur des fichiers, où un seul fichier contient le programme. Vous exécutez des applications basées sur des fichiers à l’aide de la commandedotnet <file.cs>, ou directement à l’aide du nom de fichier sur Unix (par exemple). ./file.cs Cette dernière nécessite l’inclusion de la #!/usr/bin/env dotnet directive comme première ligne et la définition de l’autorisation d’exécution (chmod +x <file>).

Directives using

Pour le fichier unique contenant des instructions de niveau supérieur, using les directives doivent être fournies en premier dans ce fichier, comme dans l’exemple suivant :

using System.Text;

StringBuilder builder = new();
builder.AppendLine("The following arguments are passed:");

foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

return 0;

Espaces de noms et définitions de type

Les instructions de niveau supérieur figurent implicitement dans l’espace de noms global. Un fichier avec des instructions de niveau supérieur peut également contenir des espaces de noms et des définitions de type, mais, dans ce cas, ceux-ci doivent figurer après les instructions de niveau supérieur. Par exemple :

MyClass.TestMethod();
MyNamespace.MyClass.MyMethod();

public class MyClass
{
    public static void TestMethod()
    {
        Console.WriteLine("Hello World!");
    }
}

namespace MyNamespace
{
    class MyClass
    {
        public static void MyMethod()
        {
            Console.WriteLine("Hello World from MyNamespace.MyClass.MyMethod!");
        }
    }
}

args

Les instructions de niveau supérieur peuvent référencer la args variable pour accéder aux arguments de ligne de commande passés à l’application au démarrage. La args variable n’est jamais null, mais elle Length est égale à zéro si aucun argument de ligne de commande n’a été fourni. Par exemple :

if (args.Length > 0)
{
    foreach (var arg in args)
    {
        Console.WriteLine($"Argument={arg}");
    }
}
else
{
    Console.WriteLine("No arguments");
}

await et code de sortie

Permet await d’appeler une méthode asynchrone. Lorsque votre code de niveau supérieur contient await, le compilateur génère un point d’entrée qui retourne un Task. Le runtime surveille Task jusqu'à achèvement, gardant le processus actif jusqu'à ce que tous les travaux asynchrones s'achèvent. Par exemple :

Console.Write("Hello ");
await Task.Delay(5000);
Console.WriteLine("World!");

Pour retourner un code de sortie lorsque l’application se termine, utilisez l’instruction return . Le compilateur génère un point d’entrée qui retourne Task<int> lorsque votre code contient à la fois await et return, ou int lorsqu’il contient uniquement return. Par exemple :

string? s = Console.ReadLine();

int returnValue = int.Parse(s ?? "-1");
return returnValue;

Contenu connexe

  • Last updated on