Main() et arguments de ligne de commande

Article
01/31/2025

La méthode Main est le point d’entrée d’une application C#. Lorsque l’application est démarrée, la méthode Main est la première méthode appelée.

Il ne peut y avoir qu’un seul point d’entrée dans un programme C#. Si plusieurs classes ont une méthode Main, vous devez compiler votre programme avec l’option de compilateur StartupObject pour spécifier quelle méthode Main utiliser comme point d’entrée. Pour plus d’informations, consultez StartupObject (Options du compilateur C#).
Voici l’exemple où la première ligne exécutée affiche le nombre d’arguments de ligne de commande :

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. Tout comme la méthode Main, les instructions de niveau supérieur peuvent également 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 foreach pour afficher les arguments de ligne de commande à l’aide de la variable args, et à la fin du programme retourne un code de réussite (0) :

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;

Vue d’ensemble

La méthode Main est le point d’entrée d’un programme exécutable ; c’est l’endroit où le contrôle du programme commence et se termine.
Main doit être déclarée dans une classe ou un struct. La marque englobante class peut être static.
Main doit être static.
Main peut avoir lemodificateur d’accès de votre choix (à l’exception de file).
Main peut avoir le type de retour void, int, Task, ou Task<int>.
Si et seulement si Main retourne un Task ou Task<int>, la déclaration de Main peut inclure le modificateur async. Cela exclut spécifiquement une méthode async void Main.
La méthode Main peut être déclarée avec ou sans paramètre string[], 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 bien utiliser la méthode GetCommandLineArgs() pour obtenir les arguments de ligne de commande. Les paramètres sont lus comme des arguments de ligne de commande avec index de base zéro. Contrairement à C et C++, le nom du programme n’est pas traité comme le premier argument de ligne de commande du tableau args, mais il s’agit du premier élément de la méthode GetCommandLineArgs().

La liste suivante présente les déclarations Main 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 private par défaut. Ceci est typique, mais il vous est possible de spécifier les modificateurs d’accès explicites de votre choix.

Conseil

L’ajout des types de retour async et Task, Task<int> simplifie le code de programme lorsque les applications de console doivent démarrer et await des opérations asynchrones dans Main.

Valeurs de retour Main()

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

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

Si la valeur de retour de Main n’est pas utilisée, retourner void ou Task permet d’avoir un code un peu plus simple.

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

Cependant, retourner int ou Task<int> 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 les outils de ligne de commande .NET Core. Si vous ne connaissez pas les outils de ligne de commande .NET Core, vous pouvez les découvrir dans cet article Bien démarrer.

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

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

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

Quand un programme est exécuté dans Windows, toute valeur retournée par la fonction Main est stockée dans une variable d’environnement. Cette variable d’environnement peut être récupérée à l’aide de ERRORLEVEL dans un fichier de commandes ou de $LastExitCode dans PowerShell.

Vous pouvez générer l’application à l’aide de la commande dotnet CLIdotnet build.

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 test.ps1 dans le dossier qui contient le projet. Exécutez le script PowerShell en tapant test.ps1 à l’invite de PowerShell.

Comme le code retourne zéro, le fichier de commandes indique la réussite. Toutefois, si vous modifiez MainReturnValTest.cs pour qu’il retourne une valeur différente de zéro, puis que vous recompilez le programme, l’exécution suivante du script PowerShell indique un é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 async valeur renvoyée pour Main, le compilateur génère le code réutilisable pour appeler des méthodes asynchrones dans Main. Si vous ne spécifiez pas le mot clé async, vous devez écrire ce code vous-même, comme illustré dans l’exemple suivant. Le code de l’exemple garantit que votre programme s’exécute jusqu’à ce que l’opération asynchrone soit terminée :

class AsyncMainReturnValTest
{
    public static int Main()
    {
        return AsyncConsoleWork().GetAwaiter().GetResult();
    }

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

Ce code réutilisable peut être remplacé par :

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 AsyncConsoleWork().

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

Quand le point d’entrée de l’application retourne Task ou Task<int>, 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é $GeneratedMain, le compilateur génère le code suivant pour ces points d’entrée :

static Task Main() permet au compilateur d’émettre l’équivalent de private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) permet au compilateur d’émettre l’équivalent de private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() permet au compilateur d’émettre l’équivalent de private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) permet au compilateur d’émettre l’équivalent de private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Notes

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

Arguments de ligne de commande

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

Déclaration `Main`	Code de la méthode `Main`
`static void Main(string[] args)`	Aucune valeur renvoyée, aucune utilisation de `await`
`static int Main(string[] args)`	Valeur renvoyée, aucune utilisation de `await`
`static async Task Main(string[] args)`	Aucune valeur renvoyée, utilise `await`
`static async Task<int> Main(string[] args)`	Valeur renvoyée, utilise `await`

Si les arguments ne sont pas utilisés, vous pouvez omettre args de la déclaration de la méthode pour simplifier légèrement le code :

Déclaration `Main`	Code de la méthode `Main`
`static void Main()`	Aucune valeur renvoyée, aucune utilisation de `await`
`static int Main()`	Valeur renvoyée, aucune utilisation de `await`
`static async Task Main()`	Aucune valeur renvoyée, utilise `await`
`static async Task<int> Main()`	Valeur renvoyée, utilise `await`

Notes

Vous pouvez également utiliser Environment.CommandLine ou Environment.GetCommandLineArgs pour accéder aux arguments de ligne de commande à partir de n’importe quel emplacement d’une application console ou 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 Windows Forms crée Main sans paramètre d’entrée.

Le paramètre de la méthode Main est un tableau String qui représente les arguments de ligne de commande. En général, vous déterminez s’il existe des arguments en testant la propriété Length, par exemple :

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

Conseil

Le tableau args ne peut pas être null. Par conséquent, il est sûr d’accéder à la propriété Length 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 Convert ou de la méthode Parse. Par exemple, l’instruction suivante convertit string en nombre long en utilisant la méthode Parse :

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

Il est également possible d’utiliser le type C# long, qui sert d’alias à Int64 :

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

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

long num = Convert.ToInt64(s);

Pour plus d’informations, consultez Parse et Convert.

Conseil

L’analyse des arguments de ligne de commande peut être complexe. Envisagez d’utiliser la bibliothèque System.CommandLine (actuellement en version bêta) 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 :

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 Main, le programme teste si les arguments d’entrée n’ont pas été fournis en comparant la longueur de args argument à 0 et affiche l’aide si aucun argument n’est trouvé.
Si des arguments sont fournis (args.Length est supérieur à 0) programme tente de convertir les arguments d’entrée en nombres. Cela lève une exception si l’argument n’est pas un nombre.
Une fois la factorielle calculée (stockée dans une variable result de type long), le résultat détaillé est imprimé en fonction de la variable result.

Dans l’écran Démarrer ou le menu Démarrer, ouvrez une fenêtre Invite de commandes développeur Visual Studio, puis accédez au dossier qui contient le fichier que vous avez créé.
Entrez la commande suivante pour compiler l’application.

dotnet build

Si votre application ne contient pas d’erreurs de compilation, un fichier exécutable nommé Factorial.exe est créé.
Entrez la commande suivante pour calculer la factorielle de 3 :

dotnet run -- 3
Si 3 est entré sur la ligne de commande en tant qu’argument du programme, la sortie lit : The factorial of 3 is 6.

Notes

Quand vous exécutez une application dans Visual Studio, vous pouvez spécifier des arguments de ligne de commande dans la page Déboguer du Concepteur de projet.

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.

Partager via

Main() et arguments de ligne de commande

Vue d’ensemble

Valeurs de retour Main()

Valeurs de retour d’Async Main

Arguments de ligne de commande

spécification du langage C#

Voir aussi

Ressources supplémentaires