Partager via

Main() et arguments de ligne de commande

Le runtime appelle la méthode lorsque vous démarrez une application C#. La méthode est le point d’entrée d’une application C#.

Un programme C# ne peut avoir qu’un seul point d’entrée. Si vous avez plusieurs classes avec une méthode, vous devez utiliser l’option du compilateur StartupObject lorsque vous compilez votre programme pour spécifier la méthode qui sert de point d’entrée. Pour plus d’informations, consultez StartupObject (Options du compilateur C#). L’exemple suivant affiche le nombre d’arguments de ligne de commande comme première action :

class TestClass
{
    static void Main(string[] args)
    {
        Console.WriteLine(args.Length);
    }
}

Vous pouvez également utiliser des instructions de niveau supérieur dans un fichier comme point d’entrée pour votre application. Comme la méthode, les instructions de niveau supérieur peuvent retourner des valeurs et accéder aux arguments de ligne de commande. Pour plus d’informations, consultez Instructions de niveau supérieur. L’exemple suivant utilise une boucle pour afficher les arguments de ligne de commande à l’aide de la variable, et à la fin du programme retourne un code de réussite () :

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;

À 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 commande , ou en utilisant la directive comme première ligne (shells Unix uniquement).

Vue d’ensemble

  • La méthode est le point d’entrée d’un programme exécutable. C’est là que le contrôle de programme démarre et se termine.
  • Vous devez déclarer à l’intérieur d’une classe ou d’un struct. L'élément englobant peut être .
  • doit être .
  • peut avoir n’importe quel modificateur d’accès.
  • peut retourner , ou .
  • Si et seulement si retourne une ou , la déclaration de peut inclure le modificateur. Cette règle exclut spécifiquement une méthode.
  • Vous pouvez déclarer la méthode avec ou sans paramètre qui contient des arguments de ligne de commande. Lorsque vous utilisez Visual Studio pour créer des applications Windows, vous pouvez ajouter le paramètre manuellement ou utiliser la méthode GetCommandLineArgs() pour obtenir les arguments de ligne de commande. Les paramètres sont des arguments de ligne de commande indexés zéro. Contrairement à C et C++, le nom du programme n’est pas traité comme le premier argument de ligne de commande dans le tableau, mais il s’agit du premier élément de la méthode.

La liste suivante présente les déclarations les plus courantes :

static void Main() { }
static int Main() { }
static void Main(string[] args) { }
static int Main(string[] args) { }
static async Task Main() { }
static async Task<int> Main() { }
static async Task Main(string[] args) { }
static async Task<int> Main(string[] args) { }

Les exemples précédents ne spécifient pas de modificateur d’accès. Ils sont donc implicitement par défaut. Vous pouvez spécifier n’importe quel modificateur d’accès explicite.

Conseil

En utilisant et ou en retournant des types, vous simplifiez le code du programme lorsque les applications console doivent démarrer et effectuer des opérations asynchrones dans .

Valeurs de retour Main()

Vous pouvez renvoyer un à la méthode en définissant la méthode de l’une des manières suivantes :

Déclaration Code de la méthode
static int Main() Aucune utilisation de ou
static int Main(string[] args) Utilise , mais pas
static async Task<int> Main() Utilise , mais pas
static async Task<int> Main(string[] args) Utilise et

Si la valeur de retour de n’est pas utilisée, retourne ou autorise un code légèrement plus simple.

Déclaration Code de la méthode
static void Main() Aucune utilisation de ou
static void Main(string[] args) Utilise , mais pas
static async Task Main() Utilise , mais pas
static async Task Main(string[] args) Utilise et

Cependant, retourner ou permet au programme de communiquer des informations d’état à d’autres programmes ou scripts qui appellent le fichier exécutable.

L’exemple suivant montre comment accéder au code de sortie du processus.

Cet exemple utilise .NET Core outils en ligne de commande. Si vous n'êtes pas familiarisé avec les outils en ligne de commande .NET Core, vous pouvez en savoir plus dans cet article de démarrage.

Créez une application en exécutant . Modifiez la méthode dans Program.cs comme suit :

class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

N’oubliez pas d’enregistrer ce programme en tant que MainReturnValTest.cs.

Lorsque vous exécutez un programme dans Windows, le système stocke n’importe quelle valeur retournée par la fonction Main dans une variable d’environnement. Vous pouvez récupérer cette variable d’environnement à l’aide d’un fichier batch ou de PowerShell.

Vous pouvez générer l’application à l’aide de la commande CLI .

Ensuite, créez un script PowerShell pour exécuter l’application et afficher le résultat. Collez le code suivant dans un fichier texte et enregistrez-le sous dans le dossier qui contient le projet. Exécutez le script PowerShell en tapant à l’invite de PowerShell.

Étant donné que le code retourne zéro, le fichier batch signale la réussite. Toutefois, si vous modifiez MainReturnValTest.cs pour retourner une valeur différente de zéro, puis recompiler le programme, l’exécution ultérieure du script PowerShell signale l’échec.

dotnet run
if ($LastExitCode -eq 0) {
    Write-Host "Execution succeeded"
} else
{
    Write-Host "Execution Failed"
}
Write-Host "Return value = " $LastExitCode

Execution succeeded
Return value = 0

Valeurs de retour d’Async Main

Lorsque vous déclarez une valeur de retour pour , le compilateur génère le code réutilisable pour appeler des méthodes asynchrones dans :

class Program
{
    static async Task<int> Main(string[] args)
    {
        return await AsyncConsoleWork();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        return 0;
    }
}

Dans les deux exemples, le corps principal du programme se trouve dans le corps de la méthode.

L’avantage de déclarer comme est que le compilateur génère toujours un code correct.

Quand le point d’entrée de l’application retourne ou , le compilateur génère un nouveau point d’entrée qui appelle la méthode de point d’entrée déclarée dans le code d’application. En supposant que ce point d’entrée est appelé , le compilateur génère le code suivant pour ces points d’entrée :

  • aboutit au compilateur qui émet l’équivalent de .
  • aboutit au compilateur qui émet l’équivalent de .
  • aboutit au compilateur qui émet l’équivalent de .
  • aboutit au compilateur qui émet l’équivalent de .

Remarque

Si les exemples utilisent le modificateur sur la méthode, le compilateur génère le même code.

Arguments de ligne de commande

Vous pouvez envoyer des arguments à la méthode en définissant la méthode de l’une des manières suivantes :

Déclaration Code de la méthode
static void Main(string[] args) Aucune valeur de retour ou
static int Main(string[] args) Retourne une valeur, mais n’utilise pas
static async Task Main(string[] args) Utilise mais ne retourne pas de valeur
static async Task<int> Main(string[] args) Retourner une valeur et utiliser

Si vous n’utilisez pas les arguments, vous pouvez omettre la déclaration de méthode pour un code légèrement plus simple :

Déclaration Code de la méthode
static void Main() Aucune valeur de retour ou
static int Main() Retourne une valeur, mais n’utilise pas
static async Task Main() Utilise mais ne retourne pas de valeur
static async Task<int> Main() Retourne une valeur et utilise

Remarque

Vous pouvez également utiliser Environment.CommandLine ou Environment.GetCommandLineArgs pour accéder aux arguments de ligne de commande à partir de n’importe quel point d’une console ou d’une application Windows Forms. Pour activer les arguments de ligne de commande dans la déclaration de méthode Main dans une application Windows Forms, vous devez modifier manuellement la déclaration de Main. Le code généré par le concepteur Windows Forms crée Main sans paramètre d’entrée.

Le paramètre de la méthode est un tableau qui représente les arguments de ligne de commande. En règle générale, vous déterminez si des arguments existent en testant la propriété, par exemple :

if (args.Length == 0)
{
    System.Console.WriteLine("Please enter a numeric argument.");
    return 1;
}

Conseil

Le tableau ne peut pas être null. Par conséquent, il est sûr d’accéder à la propriété sans vérification de la valeur Null.

Vous pouvez également convertir les arguments de chaîne en types numériques à l’aide de la classe ou de la méthode . Par exemple, l’instruction suivante convertit en nombre en utilisant la méthode  :

long num = Int64.Parse(args[0]);

Il est également possible d’utiliser le type , qui est un alias de .

long num = long.Parse(args[0]);

Vous pouvez également utiliser la méthode de la classe pour obtenir le même résultat :

long num = Convert.ToInt64(s);

Pour plus d’informations, consultez et .

Conseil

L’analyse des arguments de ligne de commande peut être complexe. Envisagez d’utiliser la bibliothèque System.CommandLine pour simplifier le processus.

L’exemple suivant montre comment utiliser des arguments de ligne de commande dans une application console. L’application prend un argument au moment de l’exécution, le convertit en entier, puis calcule la factorielle du nombre. Si aucun argument n’est fourni, l’application affiche un message pour expliquer comment le programme doit être utilisé.

Pour compiler et exécuter l’application à partir d’une invite de commandes, procédez comme suit :

  1. Collez le code suivant dans un éditeur de texte, puis enregistrez le fichier en tant que fichier texte sous le nom Factorial.cs.
public class Functions
{
    public static long Factorial(int n)
    {
        // Test for invalid input.
        if ((n < 0) || (n > 20))
        {
            return -1;
        }

        // Calculate the factorial iteratively rather than recursively.
        long tempResult = 1;
        for (int i = 1; i <= n; i++)
        {
            tempResult *= i;
        }
        return tempResult;
    }
}

class MainClass
{
    static int Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        int num;
        bool test = int.TryParse(args[0], out num);
        if (!test)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        long result = Functions.Factorial(num);

        if (result == -1)
            Console.WriteLine("Input must be >= 0 and <= 20.");
        else
            Console.WriteLine($"The Factorial of {num} is {result}.");

        return 0;
    }
}

Au début de la méthode , le programme teste si les arguments d'entrée n'ont pas été fournis en comparant la longueur de l'argument à , et affiche l'aide si aucun argument n'est trouvé.
Si des arguments sont fournis ( est supérieur à 0), le programme tente de convertir les arguments d’entrée en nombres. Cet exemple lève une exception si l’argument n’est pas un nombre.
Une fois la factorielle calculée (stockée dans une variable de type ), le résultat détaillé est imprimé en fonction de la variable .

  1. À partir de l’écran Start ou du menu Start, ouvrez une fenêtre Visual Studio Invite de commandes développeur, puis accédez au dossier qui contient le fichier que vous avez créé.

  2. Pour compiler l’application, entrez la commande suivante :

    dotnet build

    Si votre application n’a aucune erreur de compilation, le processus de génération crée un fichier binaire nommé Factorial.dll.

  3. Entrez la commande suivante pour calculer la factorielle de 3 :

    dotnet run -- 3

  4. Si vous entrez 3 sur la ligne de commande en tant qu’argument du programme, la sortie lit :

Remarque

Lors de l’exécution d’une application dans Visual Studio, spécifiez des arguments de ligne de commande dans la page Debug, Concepteur de projets.

spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

  • Last updated on