Comment créer une liste de choses à faire en C# ?

Apprendre le C# en créant une application To-do peut être un exercice très utile pour les débutants. Grâce à cette application, un utilisateur peut ajouter des tâches et afficher une liste de tous les éléments de sa liste de tâches. Il peut également choisir de supprimer des éléments de la liste.

Une application To-do couvre de nombreux principes fondamentaux de la programmation. Cela inclut la gestion des entrées utilisateur, le stockage des données dans des tableaux, l’utilisation d’instructions conditionnelles et le travail avec des boucles. Vous pouvez créer une application To-do simple en utilisant une application console C# dans Visual Studio.

Comment créer une nouvelle application console

Vous pouvez consulter le code source complet de ce projet de liste de choses à faire sur GitHub.

Vous pouvez créer une application To-do dans de nombreux langages de programmation différents. Il peut être difficile de décider quel langage choisir, surtout si vous êtes débutant. Cependant, il existe plusieurs raisons pratiques d’apprendre le C#.

Commencez par créer une nouvelle application console Visual Studio C#.

Lire Comment désactiver n'importe quelle tuile vidéo sur Google Meet avec cette option

Ouvrez l’application Visual Studio sur votre ordinateur.
Cliquez sur Créer un nouveau projet:
Choisissez Application Console C#et cliquez sur Suivant:
Donnez un nom au projet et un emplacement pour stocker la solution :
Conserver le Cadre de la cible à la valeur par défaut et cliquez Créer:

Comment ajouter une tâche à la liste des tâches à accomplir ?

Après avoir créé la nouvelle application console, un programme « Hello World » généré apparaîtra par défaut. Modifiez le code pour créer une liste à laquelle vous pouvez ajouter des tâches.

Comme il s’agit d’une application console, vous pouvez utiliser des instructions print pour demander à l’utilisateur quelles informations il souhaite ajouter à la liste des tâches.

En haut du fichier, importez l’espace de nom « System.Collections.Generic ». Cela vous permettra de créer des objets List dans votre programme :
```
 using System.Collections.Generic; 
```
Dans la fonction Main(), supprimez le code « Hello World » par défaut. Déclarez une nouvelle liste pour stocker les tâches de la liste des tâches à faire :
```
 List<string> toDoList = new List<string>(); 
```
Ajoutez une boucle while qui s’exécutera indéfiniment jusqu’à ce que l’utilisateur termine le programme :
```
 while (true) {

} 
```
Au-dessus de la fonction Main(), ajoutez un enum pour la liste des actions possibles de l’utilisateur :
```
 enum UserChoice { 
 AddTask = 1, 
 Exit
} 
```
A l’intérieur de la boucle while de la fonction Main(), affichez la liste des actions possibles parmi lesquelles l’utilisateur peut choisir. L’utilisateur peut alors entrer un numéro pour compléter l’action. Par exemple, l’utilisateur peut appuyer sur « 1 » s’il veut ajouter une nouvelle tâche à la liste.
```
 Console.WriteLine("1. Add task");
Console.WriteLine("2. Exit");
int choice = int.Parse(Console.ReadLine()); 
```
Si l’utilisateur appuie sur « 1 » pour ajouter une tâche, ajoutez une autre invite pour demander à l’utilisateur quel est le nom de la tâche. Ajoutez l’entrée de l’utilisateur dans le tableau des tâches. Au lieu d’une instruction if, vous pouvez également utiliser une instruction switch C#.
```
 if (choice == (int)UserChoice.AddTask) {
 Console.Write("Enter task: "); 
 string task = Console.ReadLine(); 
 toDoList.Add(task); 
 Console.Clear(); 
 Console.WriteLine("Task added successfully!");
} 
```
Si l’utilisateur quitte l’application, sortez de la boucle while :
```
 else if (choice == (int)UserChoice.Exit) { 
 break;
} 
```
Cliquez sur le bouton vert jouer en haut de l’application Visual Studio :
Sélectionnez la première option en saisissant « 1 ». Entrez une tâche dans la liste des tâches à faire :

Comment afficher les tâches dans la liste des tâches ?

Avant de demander à l’utilisateur s’il veut ajouter une tâche, affichez les tâches actuelles dans la liste des tâches.

A l’intérieur de la boucle while de la fonction principale, ajoutez une instruction if pour vérifier si la liste des tâches n’est pas vide :

 while (true) { 
 if (toDoList.Count > 0) { 
 
 } 

 Console.WriteLine("1. Add task"); 
 Console.WriteLine("2. Exit");
}

Si la liste de choses à faire contient des éléments, bouclez sur chaque élément du tableau « toDoList » pour afficher le nom de la tâche sous forme de puces :

 if (toDoList.Count > 0) { 
 Console.WriteLine("To-do List:");

 for (int i = 0; i < toDoList.Count; i++) { 
   Console.WriteLine("- " + toDoList[i]); 
 } 

 Console.WriteLine("");
}

Ajoutez une condition else à l’instruction if. Si la liste est vide, affichez un message différent :

 else { 
 Console.WriteLine("You currently have no tasks in your To-do list."); 
 Console.WriteLine("");
}

Cliquez sur le bouton vert jouer en haut de l’application Visual Studio.
Ajoutez quelques éléments à la liste. Lorsque vous ajoutez un élément, la console se met à jour pour afficher les nouveaux éléments de votre liste de tâches :

Comment supprimer une tâche de la liste des tâches à accomplir ?

Lorsque vous supprimez une tâche, montrez à nouveau la liste des tâches à l’utilisateur et demandez-lui quelle tâche il souhaite supprimer.

Mise à jour de l’enum UserChoice en haut du fichier pour inclure l’action de suppression d’une tâche :
```
 enum UserChoice { 
 AddTask = 1, 
 DeleteTask, 
 Exit
} 
```
Mettez à jour la liste des actions affichées à l’utilisateur pour montrer la nouvelle option de suppression :
```
 Console.WriteLine("1. Add task");
Console.WriteLine("2. Delete task");
Console.WriteLine("3. Exit"); 
```
Dans la boucle while de la fonction Main(), ajoutez une nouvelle condition else-if lorsque l’utilisateur choisit l’option de suppression :
```
 else if (choice == (int)UserChoice.DeleteTask) {

} 
```
A l’intérieur, vérifiez si la liste des tâches est vide. Si ce n’est pas le cas, réaffichez la liste des tâches avec un numéro devant chaque élément. Cela permet à l’utilisateur de saisir le numéro de la tâche qu’il souhaite supprimer :
```
 if (toDoList.Count > 0) { 
 Console.WriteLine("Enter the number of the task you want to delete:");

 for (int i = 0; i < toDoList.Count; i++) { 
   Console.WriteLine("(" + (i + 1) + ") " + toDoList[i]); 
 }
} 
```
Après la boucle for, obtenez l’entrée de l’utilisateur sur l’élément qu’il souhaite supprimer. En utilisant l’entrée, obtenez l’index correspondant de l’élément, et utilisez la fonction RemoveAt() pour supprimer l’élément de la tâche :
```
 int taskNum = int.Parse(Console.ReadLine());
taskNum--;

if (taskNum >= 0 && taskNum < toDoList.Count) { 
 toDoList.RemoveAt(taskNum); 
 Console.Clear(); 
 Console.WriteLine("Task deleted successfully!"); 
 Console.WriteLine("");
} 
```
Ajoutez une condition else à l’énoncé if pour vérifier que l’utilisateur n’a pas entré un numéro de tâche invalide :
```
 else { 
 Console.Clear(); 
 Console.WriteLine("Invalid task number."); 
 Console.WriteLine("");
} 
```
Cliquez sur le bouton vert jouer en haut de l’application Visual Studio.
Cliquez sur l’option « 1 » pour ajouter des éléments dans votre liste de choses à faire.
Cliquez sur l’option « 2 » pour supprimer un élément existant de votre liste de tâches.

Apprendre à programmer en créant des applications simples

Vous devriez avoir réussi à créer une simple application To-do en utilisant la console. Vous pouvez continuer à développer vos connaissances en créant des applications qui nécessitent une interface utilisateur.

Essayez de concevoir et de construire l’interface utilisateur et la logique d’une application C# en utilisant Windows Forms. Un exemple de projet que vous pouvez essayer est une application simple de gestion de fichiers.