Exercice - Passer en revue et tester une application console C# à l’aide d’exemples de données

20 minutes

Dans cet exercice, vous passez en revue et testez le code dans le projet Starter, vous isolez et corrigez un problème de logique, puis vous vérifiez que votre application mise à jour fonctionne comme prévu.

Pendant cet exercice, vous effectuez les tâches suivantes :

Révision du code : passez en revue le contenu du fichier Program.cs.

Le fichier Program.cs comprend les sections de code suivantes :
- Instructions de niveau supérieur : les instructions de niveau supérieur simulent une série de transactions à l’aide d’un tableau de testData ou d’un plus grand nombre de transactions générées de manière aléatoire.
- LoadTillEachMorning : la méthode LoadTillEachMorning est utilisée pour configurer la caisse enregistreuse avec un nombre prédéfini de billets pour chaque dénomination.
- MakeChange : la méthode MakeChange est utilisée pour gérer le tiroir-caisse pendant des transactions d’achat.
- LogTillStatus : la méthode LogTillStatus permet d’afficher le nombre de billets de chaque valeur se trouvant actuellement dans la caisse.
- TillAmountSummary : la méthode TillAmountSummary est utilisée pour afficher un message indiquant le montant en espèces se trouvant dans la caisse.
Test initial : vérifiez que MakeChange équilibre correctement le tiroir-caisse lors de l’utilisation du tableau testData pour simuler des transactions.
Débogage du code : isolez et corrigez un problème de logique qui est exposé lors de l’utilisation de données générées de manière aléatoire.
Test de vérification : effectuez un test de vérification sur le code que vous développez dans cet exercice.

Passer en revue le contenu du fichier Program.cs

Dans cette tâche, vous effectuez une procédure pas à pas du code du projet Starter. Le fichier Program.cs contient une application qui simule les conditions des transactions quotidiennes. L’application appelle la méthode MakeChange pour gérer l’argent pendant chaque transaction. D’autres méthodes sont utilisées pour initialiser le tiroir-caisse et générer des messages de rapport.

Vérifiez que le dossier GuidedProject est ouvert dans Visual Studio Code.
Dans la vue EXPLORATEUR, développez les dossiers GuidedProject et Starter.

Le dossier Starter contient l’exemple d’application pour ce module de projet guidé.
Ouvrez le fichier Program.cs dans l’éditeur Visual Studio Code.
Dans le menu Affichage, sélectionnez Palette de commandes.
À l’invite de commandes, entrez .net: g, puis sélectionnez .NET : Générer des ressources pour la compilation et le débogage.
À l’invite Sélectionner le projet à lancer, sélectionnez le projet Starter.

Le fichier launch.json créé inclut une configuration pour le projet Starter.

Prenez quelques minutes pour passer en revue les instructions de niveau supérieur pour cette application :

/*
This application manages transactions at a store check-out line. The
check-out line has a cash register, and the register has a cash till
that is prepared with a number of bills each morning. The till includes
bills of four denominations: $1, $5, $10, and $20. The till is used
to provide the customer with change during the transaction. The item 
cost is a randomly generated number between 2 and 49. The customer 
offers payment based on an algorithm that determines a number of bills
in each denomination. 

Each day, the cash till is loaded at the start of the day. As transactions
occur, the cash till is managed in a method named MakeChange (customer 
payments go in and the change returned to the customer comes out). A 
separate "safety check" calculation that's used to verify the amount of
money in the till is performed in the "main program". This safety check
is used to ensure that logic in the MakeChange method is working as 
expected.
*/

string? readResult = null;
bool useTestData = true;

Console.Clear();

int[] cashTill = new int[] { 0, 0, 0, 0 };
int registerCheckTillTotal = 0;

// registerDailyStartingCash: $1 x 50, $5 x 20, $10 x 10, $20 x 5 => ($350 total)
int[,] registerDailyStartingCash = new int[,] { { 1, 50 }, { 5, 20 }, { 10, 10 }, { 20, 5 } };

int[] testData = new int[] { 6, 10, 17, 20, 31, 36, 40, 41 };
int testCounter = 0;

LoadTillEachMorning(registerDailyStartingCash, cashTill);

registerCheckTillTotal = registerDailyStartingCash[0, 0] * registerDailyStartingCash[0, 1] + registerDailyStartingCash[1, 0] * registerDailyStartingCash[1, 1] + registerDailyStartingCash[2, 0] * registerDailyStartingCash[2, 1] + registerDailyStartingCash[3, 0] * registerDailyStartingCash[3, 1];

// display the number of bills of each denomination currently in the till
LogTillStatus(cashTill);

// display a message showing the amount of cash in the till
Console.WriteLine(TillAmountSummary(cashTill));

// display the expected registerDailyStartingCash total
Console.WriteLine($"Expected till value: {registerCheckTillTotal}\n\r");

var valueGenerator = new Random((int)DateTime.Now.Ticks);

int transactions = 10;

if (useTestData)
{
    transactions = testData.Length;
}

while (transactions > 0)
{
    transactions -= 1;
    int itemCost = valueGenerator.Next(2, 20);

    if (useTestData)
    {
        itemCost = testData[testCounter];
        testCounter += 1;
    }

    int paymentOnes = itemCost % 2;                 // value is 1 when itemCost is odd, value is 0 when itemCost is even
    int paymentFives = (itemCost % 10 > 7) ? 1 : 0; // value is 1 when itemCost ends with 8 or 9, otherwise value is 0
    int paymentTens = (itemCost % 20 > 13) ? 1 : 0; // value is 1 when 13 < itemCost < 20 OR 33 < itemCost < 40, otherwise value is 0
    int paymentTwenties = (itemCost < 20) ? 1 : 2;  // value is 1 when itemCost < 20, otherwise value is 2

    // display messages describing the current transaction
    Console.WriteLine($"Customer is making a ${itemCost} purchase");
    Console.WriteLine($"\t Using {paymentTwenties} twenty dollar bills");
    Console.WriteLine($"\t Using {paymentTens} ten dollar bills");
    Console.WriteLine($"\t Using {paymentFives} five dollar bills");
    Console.WriteLine($"\t Using {paymentOnes} one dollar bills");

    // MakeChange manages the transaction and updates the till 
    string transactionMessage = MakeChange(itemCost, cashTill, paymentTwenties, paymentTens, paymentFives, paymentOnes);

    // Backup Calculation - each transaction adds current "itemCost" to the till
    if (transactionMessage == "transaction succeeded")
    {
        Console.WriteLine($"Transaction successfully completed.");
        registerCheckTillTotal += itemCost;
    }
    else
    {
        Console.WriteLine($"Transaction unsuccessful: {transactionMessage}");
    }

    Console.WriteLine(TillAmountSummary(cashTill));
    Console.WriteLine($"Expected till value: {registerCheckTillTotal}\n\r");
    Console.WriteLine();
}

Console.WriteLine("Press the Enter key to exit");
do
{
    readResult = Console.ReadLine();

} while (readResult == null);

Le code des instructions de niveau supérieur effectue les tâches suivantes :

Configure les données d’application et les variables d’environnement utilisées pour tester la méthode MakeChange.
Appelle les méthodes LoadTillEachMorning(), LogTillStatus() et TillAmountSummary() pour préparer le tiroir-caisse et imprimer les messages d’état sur la console.
Utilise une boucle while pour simuler une série de transactions.
Appelle la méthode MakeChange à partir du bloc de code de la boucle while.
Signale l’état du le tiroir-caisse après chaque transaction.

Remarque

Les instructions de niveau supérieur incluent une instruction Console.ReadLine(). Le fichier launch.json doit être mis à jour avant le débogage.

Prenez un moment pour passer en revue la méthode LoadTillEachMorning().

static void LoadTillEachMorning(int[,] registerDailyStartingCash, int[] cashTill)
{
    cashTill[0] = registerDailyStartingCash[0, 1];
    cashTill[1] = registerDailyStartingCash[1, 1];
    cashTill[2] = registerDailyStartingCash[2, 1];
    cashTill[3] = registerDailyStartingCash[3, 1];
}

Prenez quelques minutes pour passer en revue la méthode MakeChange().
```
static string MakeChange(int cost, int[] cashTill, int twenties, int tens = 0, int fives = 0, int ones = 0)
{
    string transactionMessage = "";

    cashTill[3] += twenties;
    cashTill[2] += tens;
    cashTill[1] += fives;
    cashTill[0] += ones;

    int amountPaid = twenties * 20 + tens * 10 + fives * 5 + ones;
    int changeNeeded = amountPaid - cost;

    if (changeNeeded < 0)
        transactionMessage = "Not enough money provided.";

    Console.WriteLine("Cashier Returns:");

    while ((changeNeeded > 19) && (cashTill[3] > 0))
    {
        cashTill[3]--;
        changeNeeded -= 20;
        Console.WriteLine("\t A twenty");
    }

    while ((changeNeeded > 9) && (cashTill[2] > 0))
    {
        cashTill[2]--;
        changeNeeded -= 10;
        Console.WriteLine("\t A ten");
    }

    while ((changeNeeded > 4) && (cashTill[1] > 0))
    {
        cashTill[2]--;
        changeNeeded -= 5;
        Console.WriteLine("\t A five");
    }

    while ((changeNeeded > 0) && (cashTill[0] > 0))
    {
        cashTill[0]--;
        changeNeeded--;
        Console.WriteLine("\t A one");
    }

    if (changeNeeded > 0)
        transactionMessage = "Can't make change. Do you have anything smaller?";

    if (transactionMessage == "")
        transactionMessage = "transaction succeeded";

    return transactionMessage;
}
```
La méthode MakeChange gère le tiroir-caisse pendant chaque transaction d’achat. Le processus de transaction s’appuie sur les ressources et conditions suivantes :
- Transaction en espèces : la méthode MakeChange accepte un paiement en espèces du client, puis détermine combien de billets de chaque valeur doivent être rendus au client comme monnaie. MakeChange doit d’abord vérifier que le client a fourni la somme nécessaire pour couvrir la transaction. Si le paiement est suffisant, le processus « rendre la monnaie » commence par la valeur de billet la plus importante et descend jusqu’à la plus petite valeur faciale. À chaque étape, MakeChange vérifie que la coupure actuelle est inférieure à la monnaie à rendre. MakeChange vérifie également qu’un billet de la valeur requise est disponible dans la caisse avant de l’ajouter à la monnaie rendue au client.
- Paramètres d’entrée : la méthode MakeChange utilise les paramètres d’entrée suivants :
  - Entier représentant le coût de l’article acheté : itemCost
  - Tableau d’entiers contenant le nombre de billets présent dans le tiroir-caisse pour chaque coupure : cashTill
  - Paiement remis par le client, où le nombre de billets de chaque valeur est spécifié séparément : paymentTwenties, paymentTens, paymentFives, paymentOnes
- Espèces disponibles dans le tiroir-caisse : Les billets remis comme paiement par le client doivent être inclus dans les billets de chaque coupure qui sont disponibles pour rendre la monnaie.
- Monnaie due au client : la monnaie due au client est calculée à l’aide de la somme payée par le client moins le prix de l’article.
- Paiement non effectué : si le client n’a pas remis une somme suffisante pour le paiement, MakeChange retourne un message descriptif et la transaction est annulée.
- Tiroir-caisse insuffisant : Si la caisse ne permet pas de rendre la monnaie exacte, MakeChange retourne un message descriptif et la transaction est annulée.

Prenez un moment pour passer en revue la méthode LogTillStatus().

static void LogTillStatus(int[] cashTill)
{
    Console.WriteLine("The till currently has:");
    Console.WriteLine($"{cashTill[3] * 20} in twenties");
    Console.WriteLine($"{cashTill[2] * 10} in tens");
    Console.WriteLine($"{cashTill[1] * 5} in fives");
    Console.WriteLine($"{cashTill[0]} in ones");
    Console.WriteLine();
}

La méthode LogTillStatus utilise le tableau cashTill pour indiquer le contenu actuel du tiroir-caisse.

Prenez un moment pour passer en revue la méthode TillAmountSummary().
```
static string TillAmountSummary(int[] cashTill)
{
    return $"The till has {cashTill[3] * 20 + cashTill[2] * 10 + cashTill[1] * 5 + cashTill[0]} dollars";

}
```
La méthode TillAmountSummary utilise le tableau cashTill pour calculer le solde actuel disponible dans la caisse.

Cela termine votre examen du projet de code existant.

Vérifier que `MakeChange` gère correctement l’argent lors de l’utilisation du tableau `testData`

Dans cette tâche, vous simulez des transactions à l’aide du tableau testData et vous vérifiez que MakeChange équilibre correctement la caisse.

Dans le menu Exécuter de Visual Studio Code, sélectionnez Lancer le débogage.
Notez qu’une erreur IOException se produit.

La CONSOLE DE DÉBOGAGE ne prend pas en charge les méthodes Console.Clear() ou Console.ReadLine(). Vous devez mettre à jour le fichier launch.json avant le débogage.
Dans la barre d’outils de débogage, sélectionnez Arrêter.
Utilisez la vue EXPLORATEUR pour ouvrir le fichier launch.json.
Dans le fichier launch.json, mettez à jour l’attribut console comme suit :
```
// For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
"console":"integratedTerminal",
```
La valeur par défaut de l’attribut console est internalConsole, qui s’aligne sur le panneau CONSOLE DE DÉBOGAGE. Malheureusement, le panneau CONSOLE DE DÉBOGAGE ne prend pas en charge certaines méthodes de console. Le paramètre integratedTerminal s’aligne sur le panneau TERMINAL, qui prend en charge l’entrée et la sortie de la console.
Enregistrez les changements apportés au fichier launch.json.
Dans le menu Exécuter de Visual Studio Code, sélectionnez Lancer le débogage.
Passez en revue la sortie générée par l’application dans le panneau TERMINAL.

Basculez de la fenêtre CONSOLE DE DÉBOGAGE vers la fenêtre TERMINAL pour examiner la sortie.
Notez que MakeChange équilibre correctement la caisse lors de l’utilisation du tableau testData pour simuler des transactions.

Vous devez voir les lignes suivantes listées en bas de la sortie indiquée :
```
The till has 551 dollars
Expected till value: 551


Press the Enter key to exit
```
Notez que les valeurs de tiroir-caisse indiquées et attendues sont toutes les deux 551.
Pour quitter l’application, appuyez sur Entrée.

Identifier et corriger les problèmes de logique

Dans cette tâche, vous utilisez des transactions simulées pour exposer un problème de logique de code, puis vous utilisez les outils du débogueur Visual Studio Code pour isoler et résoudre le problème.

Pour exécuter le code à l’aide de transactions générées de manière aléatoire, remplacez la valeur affectée à useTestData par false.

Vous trouverez la variable useTestData en haut des instructions de niveau supérieur.
Enregistrez le fichier Program.cs, puis exécutez l’application dans le débogueur.
Passez en revue la sortie dans le panneau TERMINAL.
Notez la divergence concernant le solde du tiroir-caisse.

Le solde de caisse final calculé par MakeChange et le solde maintenu dans les déclarations de haut niveau sont indiqués en bas du rapport. Par exemple :
```
Transaction successfully completed.
The till has 379 dollars
Expected till value: 434


Press the Enter key to exit
```
Remarque

L’application génère de manière aléatoire le prix des éléments acheté. Par conséquent, les valeurs de tiroir-caisse indiquées dans votre sortie sont différentes.
Pour quitter l’application, appuyez sur Entrée.
Fermez le panneau TERMINAL.

Déboguer le code

Dans cette tâche, vous utilisez les outils du débogueur Visual Studio Code pour isoler puis résoudre le problème de logique.

Vers la fin des instructions de niveau supérieur, recherchez la ligne de code suivante :
```
Console.WriteLine();
```
Définissez un point d’arrêt sur la ligne de code sélectionnée.
Dans le menu Exécuter de Visual Studio Code, sélectionnez Lancer le débogage.
Notez que l’exécution du code s’interrompt sur le point d’arrêt.
Dans la barre d’outils Contrôles de débogage, sélectionnez Effectuer un pas à pas détaillé.
Passez en revue la sortie dans le panneau TERMINAL.
Si les valeurs de caisse indiquées et attendues sont égales, sélectionnez Continuer dans la barre d’outils Contrôles de débogage.
Répétez l’étape précédente jusqu’à ce que vous voyiez une divergence entre les valeurs de tiroir-caisse indiquées et celles attendues.
Une fois que vous voyez une divergence, prenez le temps d’examiner les détails de la transaction.
Notez que la somme reçue et la monnaie rendue indiquées sont correctes, mais il manque cinq dollars dans la caisse.

Ce manque suggère que la mise à jour du tableau cashTill est incorrecte, même si le rapport est correct.
Arrêtez la session de débogage et fermez le panneau TERMINAL.
Faites défiler l’écran jusqu’en bas de la méthode MakeChange.

Les instructions while utilisées pour « rendre la monnaie » se trouvent à la fin de la méthode MakeChange.
Passez en revue les blocs de code d’instruction while utilisés pour apporter des modifications.

Étant donné qu’il manque cinq dollars dans la caisse, le problème se trouve probablement dans le bloc de code while qui est utilisé pour rendre des billets de cinq dollars.
Notez le code suivant :
```
while ((changeNeeded > 4) && (cashTill[1] > 0))
{
    cashTill[2]--;
    changeNeeded -= 5;
    Console.WriteLine("\t A five");
}    
```
Le tableau cashTill[] est utilisé pour stocker le nombre de billets de chaque valeur actuellement disponibles. L’élément 1 du tableau est utilisé pour gérer le nombre de billets de cinq dollars se trouvant dans la caisse. L’expression dans l’instruction while fait correctement référence à cashTill[1]. Toutefois, l’instruction à l’intérieur du bloc de code décrémente cashTill[2] au lieu de cashTill[1]. La spécification de 2 comme valeur d’index signifie qu’un billet de dix dollars est supprimé de la caisse au lieu d’un billet de cinq dollars.

Mettez à jour le bloc de code while comme suit :

while ((changeNeeded > 4) && (cashTill[1] > 0))
{
    cashTill[1]--;
    changeNeeded -= 5;
    Console.WriteLine("\t A five");
}

Enregistrez le fichier Program.cs.

Vérifier votre travail

Dans cette tâche, vous exécutez votre application et vous vérifiez que votre code mis à jour fonctionne comme prévu.

Dans le menu Exécuter de Visual Studio Code, sélectionnez Supprimer tous les points d’arrêt.
Dans le menu Exécuter, sélectionnez Démarrer le débogage.
Passez en revue la sortie dans le panneau TERMINAL.
Vérifiez que la valeur de tiroir-caisse signalée est égale à la valeur de tiroir-caisse attendue :

Le solde de caisse final calculé par MakeChange et le solde maintenu dans les déclarations de haut niveau sont indiqués en bas du rapport. Par exemple :
```
Transaction successfully completed.
The till has 452 dollars
Expected till value: 452


Press the Enter key to exit
```
L’application génère de manière aléatoire le prix des éléments acheté. Par conséquent, les valeurs de tiroir-caisse indiquées dans votre sortie sont différentes. Dès lors que les deux valeurs sont égales, vous avez réussi à résoudre le problème logique.

Commentaires

Cette page a-t-elle été utile ?