Main() et arguments de ligne de commande

La méthode Main est le point d’entrée d’une application C#. (Les bibliothèques et les services ne requièrent pas de Main méthode comme point d’entrée.) Lorsque l’application est démarrée, la Main méthode 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 vous avez plusieurs classes qui ont une Main méthode, vous devez compiler votre programme avec l’option du compilateur StartupObject pour spécifier Main la méthode à utiliser comme point d’entrée. Pour plus d’informations, consultez StartupObject (options du compilateur C#).

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        Console.WriteLine(args.Length);
    }
}

À compter de C# 9, vous pouvez omettre la Main méthode et écrire des instructions C# comme si elles se trouvaient dans la Main méthode, comme dans l’exemple suivant :


using System.Text;

StringBuilder builder = new();
builder.AppendLine("Hello");
builder.AppendLine("World!");

Console.WriteLine(builder.ToString());

Pour plus d’informations sur la façon d’écrire du code d’application avec une méthode de point d’entrée implicite, consultez instructions de niveau supérieur.

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 est déclaré à l’intérieur d’une classe ou d’un struct. Main doit être static et n’a pas besoin d’être public . (Dans l’exemple précédent, il reçoit l’accès par défaut de private .) La classe ou le struct englobant ne doit pas obligatoirement être statique.
  • Main peut avoir un type de retour void, int ou, à partir de C# 7.1, 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 async void Main méthode.
  • 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 utiliser la GetCommandLineArgs() méthode 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 dans le args tableau, mais il s’agit du premier élément de la GetCommandLineArgs() méthode.

La liste suivante répertorie les signatures valides Main :

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

Les exemples précédents utilisent tous le public modificateur d’accesseur. C’est par défaut, mais pas obligatoire.

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 retourner un int à partir de la Main méthode en définissant la méthode de l’une des manières suivantes :

Main Code de méthode Main signature
Aucune utilisation de args ou await static int Main()
Utilise args , sans utiliser await static int Main(string[] args)
Aucune utilisation de args , utilise await static async Task<int> Main()
Utilise args et await static async Task<int> Main(string[] args)

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

Main Code de méthode Main signature
Aucune utilisation de args ou await static void Main()
Utilise args , sans utiliser await static void Main(string[] args)
Aucune utilisation de args , utilise await static async Task Main()
Utilise args et await static async Task Main(string[] args)

Toutefois, le fait de retourner int ou Task<int> d’autoriser le programme à 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 en ligne de commande .net Core . Si vous n’êtes pas familiarisé avec les outils en ligne de commande .NET Core, vous pouvez en savoir plus à ce sujet dans cet article de prise en main.

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

// Save this program as MainReturnValTest.cs.
class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

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 ERRORLEVEL de à partir d’un fichier de commandes ou $LastExitCode de PowerShell.

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

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 retourner une valeur différente de zéro, puis recompilez le programme, l’exécution suivante du script PowerShell signalera 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

Quand vous déclarez une async valeur de retour 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é, vous devez écrire le async code vous-même, comme indiqué dans l’exemple suivant. Le code dans l’exemple vérifie que votre programme s’exécute jusqu’à ce que l’opération asynchrone soit terminée :

public static void Main()
{
    AsyncConsoleWork().GetAwaiter().GetResult();
}

private static async Task<int> AsyncConsoleWork()
{
    // Main body here
    return 0;
}

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

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

L’un des avantages de la Déclaration Main en async est que le compilateur génère toujours le 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 :

Main Code de méthode Main signature
Aucune valeur de retour, aucune utilisation de await static void Main(string[] args)
Valeur de retour, aucune utilisation de await static int Main(string[] args)
Aucune valeur de retour, utilise await static async Task Main(string[] args)
Valeur de retour, utilise await static async Task<int> Main(string[] args)

Si les arguments ne sont pas utilisés, vous pouvez omettre args la signature de la méthode pour obtenir un code légèrement plus simple :

Main Code de méthode Main signature
Aucune valeur de retour, aucune utilisation de await static void Main()
Valeur de retour, aucune utilisation de await static int Main()
Aucune valeur de retour, utilise await static async Task Main()
Valeur de retour, utilise await static async Task<int> Main()

Notes

vous pouvez également utiliser Environment.CommandLine ou Environment.GetCommandLineArgs pour accéder aux arguments de ligne de commande à partir de n’importe quel point dans une console ou Windows Forms application. pour activer des arguments de ligne de commande dans la Main signature de méthode dans une application Windows Forms, vous devez modifier manuellement la signature de Main . le code généré par le concepteur de 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 args tableau ne peut pas être null. Par conséquent, il est possible d’accéder à la Length propriété sans vérification de 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 ToInt64 de la classe Convert pour obtenir le même résultat :

long num = Convert.ToInt64(s);

Pour plus d’informations, consultez Parse et Convert.

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 avec 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)
        {
            // Test if input arguments were supplied.
            if (args.Length == 0)
            {
                Console.WriteLine("Please enter a numeric argument.");
                Console.WriteLine("Usage: Factorial <num>");
                return 1;
            }
    
            // Try to convert the input arguments to numbers. This will throw
            // an exception if the argument is not a number.
            // num = int.Parse(args[0]);
            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;
            }
    
            // Calculate factorial.
            long result = Functions.Factorial(num);
    
            // Print result.
            if (result == -1)
                Console.WriteLine("Input must be >= 0 and <= 20.");
            else
                Console.WriteLine($"The Factorial of {num} is {result}.");
    
            return 0;
        }
    }
    // If 3 is entered on command line, the
    // output reads: The factorial of 3 is 6.
    
  2. dans l’écran d' accueil ou le menu démarrer , ouvrez une fenêtre Visual Studio Invite de commandes développeur , puis accédez au dossier qui contient le fichier que vous avez créé.

  3. Entrez la commande suivante pour compiler l’application.

    dotnet build

    Si votre application n’a pas d’erreurs de compilation, un fichier exécutable nommé Factorial.exe est créé.

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

    dotnet run -- 3

  5. Cette commande génère la sortie suivante : 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.

Voir aussi