Arguments de ligne de commande dans les applications C# en 10 minutes ou moins

Qu'est-ce que les arguments de la ligne de commande ?

Au début, Tim explique pourquoi les arguments de la ligne de commande sont importants. Il les compare à la façon dont nous lançons des outils tels que Docker, où nous spécifions des commandes telles que l'image à charger ou la tâche à effectuer. De même, dans les applications de ligne de commande C#, vous pouvez passer des paramètres qui définissent le comportement du programme au moment de l'exécution.

Par exemple, si vous exécutez une application console pour traiter des fichiers, vous voudrez peut-être spécifier le chemin d'accès ou le mode du fichier via la ligne de commande - au lieu de modifier le code.

Mise en place du projet de console

Tim commence dans Visual Studio avec un projet de base d'application console .NET 8. Le code par défaut se contente d'imprimer un message du type "Press return to exit", en utilisant une instruction Console.ReadLine() pour attendre l'entrée de l'utilisateur avant de fermer.

Maintenant, pour gérer l'entrée de la ligne de commande, Tim introduit le tableau args, qui stocke les arguments transmis à l'application lors de l'exécution. Bien que les apps de console C# modernes utilisent des déclarations de premier niveau, en coulisses, elles ont toujours un point d'entrée défini comme suit :

static void Main(string[] args)

static void Main(string[] args)

ou parfois :

static int Main(string[] args)

static int Main(string[] args)

Ces signatures représentent la méthode principale - le point d'entrée où l'exécution commence. Le paramètre args est un tableau de chaînes de caractères (string\N[\N]), contenant tous les arguments fournis par la ligne de commande.

Tim fait une démonstration de l'itération sur le tableau args à l'aide d'une boucle foreach :

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

Ici, var arg représente chaque argument de type chaîne dans le tableau args, et le programme les affiche sur des lignes séparées dans la sortie de la console.

Tim fait remarquer que si les déclarations de premier niveau cachent le code standard, comme la classe Program et la méthode Main, tout fonctionne de la même manière : le tableau args est toujours disponible et prêt à capturer les arguments de la ligne de commande.

Exécution de l'application console

Ensuite, Tim montre comment tester cette fonctionnalité. L'exécution normale du programme dans Visual Studio ne montrera rien de différent, puisqu'aucune entrée de ligne de commande n'a été fournie.

Pour tester correctement, il modifie manuellement le processus d'exécution : il ouvre l'explorateur de fichiers, navigue jusqu'au dossier bin → Debug → net8.0 du projet et lance une fenêtre de terminal à partir de ce chemin.

Il utilise ensuite la commande suivante :

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

Cette commande démontre plusieurs points clés :

• L'expression "hello world" entre guillemets est traitée comme un seul argument de chaîne, et non comme deux mots distincts.

• L'indicateur -t et le mot timing sont traités comme deux arguments supplémentaires.

Lorsqu'elle est exécutée, la sortie de la console indique :

hello world  
-t  
timing

hello world  
-t  
timing

Chaque argument de ligne représente un élément du tableau args. Tim explique que cela confirme l'utilisation correcte des arguments de ligne de commande - l'application console a reçu et affiché avec succès tous les arguments transmis pendant l'exécution.

Il mentionne que les développeurs peuvent également utiliser dotnet run au lieu du chemin d'accès à l'exécutable lorsqu'ils travaillent à partir d'un répertoire de projet :

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

Le double tiret (--) indique à .NET de traiter tout ce qui suit comme des paramètres de ligne de commande pour votre programme, et non pour l'interface de programmation .NET elle-même.

Gestion et analyse des arguments de la ligne de commande

Maintenant que nous savons lire les arguments, Tim aborde la question de la gestion intelligente des arguments de la ligne de commande.

Par exemple, si -t est un drapeau qui attend une valeur, le programme doit savoir qu'il doit traiter la chaîne de caractères suivante comme sa valeur. Tim montre qu'il est possible d'analyser manuellement ce fichier en vérifiant les index dans le tableau args :

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

Cette approche vous permet de gérer les arguments nommés, les types numériques et même les drapeaux du mode verbeux. Tim note que les développeurs utilisent souvent une instruction switch ou même de la documentation et des bibliothèques externes pour une analyse plus avancée des arguments, mais que l'espace de noms System et le tableau args fournissent déjà tout ce qui est nécessaire pour les cas de base.

Extension à une application Windows Forms

Après la démonstration des applications en mode console, Tim passe à une application Windows Forms (WinForms).

Dans le code généré, le fichier Program.cs contient une méthode statique void Main(), mais elle n'accepte pas encore de paramètres. Pour activer les arguments de ligne de commande, Tim modifie manuellement la méthode Main afin d'inclure le paramètre args :

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

Il explique que args.FirstOrDefault() récupère le premier paramètre d'entrée du tableau args (ou renvoie "default" si aucun argument n'est fourni).

Ensuite, dans la classe Form1, Tim met à jour le constructeur pour qu'il accepte un argument de type chaîne :

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

Ici, displayName est un label défini dans le Windows Forms Designer, et il affiche maintenant l'argument passé par la ligne de commande.

Lorsqu'il exécute le programme sans arguments, l'étiquette affiche "default" Lorsqu'il l'exécute à nouveau avec :

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

la fenêtre du formulaire affiche "Hello World"

Tim explique que cette technique permet aux applications Windows Forms de prendre en charge les arguments de ligne de commande tout comme les applications de console, ce qui donne aux utilisateurs la possibilité de modifier le comportement de démarrage de manière dynamique.

Utilisations pratiques des arguments de ligne de commande (7:18)

Tim conclut en expliquant à quel point les outils de ligne de commande peuvent devenir polyvalents grâce à cette fonctionnalité. Les développeurs peuvent utiliser des arguments de ligne de commande pour :

Lancer des applications dans différents modes (par exemple, mode sombre vs mode lumineux*).

• Fournir des chemins d'accès aux fichiers ou des options de configuration au démarrage.

• Activez le mode verbeux ou les fonctions de débogage à l'aide de simples commutateurs tels que -v ou --debug.

• Créer des raccourcis qui transmettent des arguments spécifiques pour différents flux de travail.

En concevant la méthode principale de manière à ce qu'elle accepte des arguments de type chaîne, vous pouvez facilement étendre la flexibilité et l'adaptabilité de votre application, sans avoir besoin de boîtes de dialogue ou de fichiers de configuration supplémentaires.

Conclusion (8:15)

Son explication fondée sur des exemples montre que la gestion des arguments de ligne de commande en C# n'est pas compliquée - il s'agit simplement de comprendre que chaque application a un point d'entrée (Main) où les arguments transmis depuis la ligne de commande arrivent sous la forme d'un tableau de chaînes de caractères.

Que vous travailliez avec des applications de console ou des applications Windows Forms, ce concept permet à vos programmes de répondre dynamiquement aux commandes, valeurs et paramètres spécifiés au démarrage.

Témoignage final

La vidéo de Tim Corey propose un guide clair et pratique sur l'utilisation correcte des arguments de ligne de commande en C#. En comprenant le fonctionnement du paramètre args dans la méthode Main, les développeurs peuvent facilement créer, analyser et utiliser des arguments pour des applications plus robustes et configurables.

Ainsi, la prochaine fois que vous construirez un projet C#, n'oubliez pas que vos arguments de ligne de commande ne sont pas qu'une simple syntaxe technique - ils constituent le pont entre votre programme et ses utilisateurs, donnant à votre code plus de puissance, de flexibilité et de facilité d'utilisation dans le monde réel.