Exercițiul - Revizuirea și testarea unei aplicații consolă C# utilizând date eșantion

20 minute

În acest exercițiu, revizuiți și testați codul din proiectul Starter, izolați și remediați o problemă logică, apoi verificați dacă aplicația actualizată funcționează așa cum vă așteptați.

Efectuați următoarele activități în timpul acestui exercițiu:

Revizuire cod: revizuiți conținutul fișierului Program.cs.

Program.cs include următoarele secțiuni de cod:
- Declarații de nivel superior: declarațiile de nivel superior simulează o serie de tranzacții utilizând o matrice de testData tranzacții sau un număr mai mare de tranzacții generate aleator.
- LoadTillEachMorning: LoadTillEachMorning metoda este utilizată pentru a configura registrul de numerar până cu un număr predefinit de facturi în fiecare denumire.
- MakeChange: MakeChange metoda este utilizată pentru a gestiona banii până la efectuarea tranzacțiilor.
- LogTillStatus: LogTillStatus metoda este utilizată pentru a afișa numărul de facturi pentru fiecare valoare nominală în prezent în până.
- TillAmountSummary: TillAmountSummary metoda este utilizat afișează un mesaj care afișează suma de bani în până.
Testare inițială: verificați că MakeChange balansează cu succes banii până când se utilizează matricea testData pentru a simula tranzacții.
Depanare cod: izolați și corectați o problemă logică expusă atunci când utilizați date generate aleator.
Test de verificare: efectuați un test de verificare pentru codul pe care îl dezvoltați în acest exercițiu.

Revizuirea conținutului fișierului Program.cs

În această activitate, finalizați o prezentare a codului de proiect Starter. Fișierul Program.cs conține o aplicație care simulează condițiile pentru tranzacțiile zilnice. Aplicația MakeChange apelează metoda de gestionare a banilor până la fiecare tranzacție. Alte metode sunt utilizate pentru a inițializa până la și de a genera mesaje de raportare.

Asigurați-vă că folderul GuidedProject este deschis în Visual Studio Code.
În vizualizarea EXPLORER, extindeți folderele GhidProject și Starter .

Folderul Starter conține aplicația eșantion pentru acest modul de proiect ghidat.
Deschideți fișierul Program.cs în Visual Studio Code Editor.
În meniul Vizualizare, selectați Paletă de comenzi.
În linia de comandă, introduceți .net: g , apoi selectați .NET: Generare active pentru compilare și depanare.
În solicitarea Selectați proiectul de lansat , selectați proiectul Starter .

Fișierul launch.json creat va include o configurație pentru proiectul Starter.

Așteptați câteva minute pentru a revizui instrucțiunile de nivel superior pentru această aplicație:

/*
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);

Codul instrucțiunilor de nivel superior finalizează următoarele activități:

Configurează datele aplicației și variabilele de mediu utilizate pentru a testa MakeChange metoda.
Apelează , LoadTillEachMorning()LogTillStatus()și TillAmountSummary() metodele pentru a pregăti banii până la și imprima mesaje de stare pe consolă.
Utilizează o while buclă pentru a simula o serie de tranzacții.
Apelează MakeChange metoda din interiorul blocului de cod al buclei while .
Raportează starea banilor până după fiecare tranzacție.

Notă

Instrucțiunile de nivel superior includ o Console.ReadLine() instrucțiune. Fișierul launch.json va trebui actualizat înainte de depanare.

Treceți un moment pentru a revizui LoadTillEachMorning() metoda.

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];
}

Citiți câteva minute pentru a MakeChange() revizui metoda.
```
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;
}
```
Metoda MakeChange gestionează banii până în timpul fiecărei tranzacții de achiziție. Procesul de tranzacție se bazează pe următoarele resurse și condiții:
- Tranzacție în numerar: MakeChange Metoda acceptă o plată în numerar de la client, apoi determină câte facturi de fiecare valoare nominală trebuie returnate clientului în schimbare. MakeChange trebuie să se asigure mai întâi că clientul a furnizat suficienți bani pentru a acoperi tranzacția. Dacă plata este suficientă, procesul de "modificare" începe cu cea mai mare valoare nominală a facturii și funcționează până la cea mai mică valoare nominală. În fiecare etapă, MakeChange se asigură că denumirea curentă este mai mică decât modificarea datorată. MakeChange asigură, de asemenea, că o factură de denumire necesară este disponibilă în până înainte de a o adăuga la modificarea returnată clientului.
- Parametri de intrare: Metoda MakeChange utilizează următorii parametri de intrare:
  - Un număr întreg care reprezintă costul achiziției articolului: itemCost
  - Este o matrice întreagă care conține numărul de facturi din până la fiecare denumire: cashTill
  - Plata oferită de client, unde numărul de facturi pentru fiecare denumire este specificat separat: paymentTwenties, paymentTens, paymentFivespaymentOnes
- Numerar disponibil în până la: facturile oferite ca plată de către client trebuie să fie incluse în facturile de fiecare valoare nominală care sunt disponibile pentru a face modificări.
- Modificare datorată clientului: Modificarea datorată clientului este calculată utilizând suma plătită de client minus costul articolului.
- Subplată: dacă clientul nu a furnizat o plată suficientă, MakeChange returnează un mesaj descriptiv și tranzacția este anulată.
- Insuficientă până când: Dacă până nu poate face modificări exacte, MakeChange returnează un mesaj descriptiv, iar tranzacția este anulată.

Treceți un moment pentru a revizui LogTillStatus() metoda.

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();
}

Metoda LogTillStatus utilizează matricea cashTill pentru a raporta conținutul curent al până.

Treceți un moment pentru a revizui TillAmountSummary() metoda.
```
static string TillAmountSummary(int[] cashTill)
{
    return $"The till has {cashTill[3] * 20 + cashTill[2] * 10 + cashTill[1] * 5 + cashTill[0]} dollars";

}
```
Metoda TillAmountSummary utilizează matricea cashTill pentru a calcula soldul curent de numerar care este disponibil în până.

Aceasta finalizează revizuirea proiectului de cod existent.

Verificați dacă `MakeChange` gestionați cu succes banii atunci când utilizați matricea `testData`

În această sarcină, simula tranzacții folosind matricea testData și verificați că MakeChange soldul cu succes banii până la.

În meniul Rulare cod Visual Studio, selectați Pornire depanare.
Observați că apare o IOException eroare.

CONSOLA DEBUG nu acceptă Console.Clear() sau Console.ReadLine() metode. Trebuie să actualizați fișierul launch.json înainte de depanare.
Pe bara de instrumente Depanare, selectați Oprire.
Utilizați vizualizarea EXPLORER pentru a deschide fișierul launch.json.
În fișierul launch.json, actualizați atributul console după cum urmează:
```
// For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
"console":"integratedTerminal",
```
Valoarea implicită pentru console atribut este internalConsole, care se aliniază la panoul CONSOLĂ DEBUG. Din păcate, panoul CONSOLĂ DEBUG nu acceptă unele metode de consolă. integratedTerminal Setarea se aliniază la panoul TERMINAL, care acceptă intrarea și ieșirea consolei.
Salvați modificările în fișierul launch.json.
În meniul Rulare cod Visual Studio, selectați Pornire depanare.
Revizuiți ieșirea generată de aplicație în panoul TERMINAL.

Comutați de la panoul CONSOLĂ DEBUG la panoul TERMINAL pentru a revizui ieșirea.
Observați că MakeChange echilibrează cu succes până când se utilizează matricea testData pentru a simula tranzacții.

Ar trebui să vedeți următoarele linii listate în partea de jos a rezultatului raportat:
```
The till has 551 dollars
Expected till value: 551


Press the Enter key to exit
```
Observați că valorile raportate și așteptate până la 551 sunt ambele 551.
Pentru a ieși din aplicație, apăsați pe Enter.

Identificarea și remedierea problemelor logice

În această activitate, utilizați tranzacții simulate pentru a expune o problemă de logică de cod, apoi utilizați instrumentele de depanare Visual Studio Code pentru a izola și a remedia problema.

Pentru a rula codul utilizând tranzacții generate aleator, modificați valoarea atribuită lui useTestDatafalse.

Puteți găsi variabila useTestData lângă partea de sus a instrucțiunilor de nivel superior.
Salvați fișierul Program.cs, apoi rulați aplicația în depanator.
Examinați ieșirea în panoul TERMINAL.
Observați discrepanța în balanță până la balanță.

Soldul final până la MakeChange calculul și soldul menținut în declarațiile de nivel superior sunt raportate în partea de jos a rezultatului. De exemplu:
```
Transaction successfully completed.
The till has 379 dollars
Expected till value: 434


Press the Enter key to exit
```
Notă

Aplicația generează aleator costul articolelor de achiziție. Prin urmare, valorile raportate în rezultatul dvs. sunt diferite.
Pentru a ieși din aplicație, apăsați pe Enter.
Închideți panoul TERMINAL.

Depanarea codului

În această activitate, utilizați instrumentele de depanare Visual Studio Code pentru a izola, apoi remediați problema logică.

Lângă sfârșitul instrucțiunilor de nivel superior, găsiți următoarea linie de cod:
```
Console.WriteLine();
```
Setați un punct de întrerupere pentru linia de cod selectată.
În meniul Rulare cod Visual Studio, selectați Pornire depanare.
Observați că executarea codului se întrerupe asupra punctului de întrerupere.
Pe bara de instrumente Depanare controale , selectați Depanați.
Examinați ieșirea în panoul TERMINAL.
Dacă valorile raportate și așteptate până când sunt egale, selectați Continuare pe bara de instrumente Controale depanare .
Repetați pasul anterior până când vedeți o discrepanță între valorile raportate și cele așteptate.
După ce vedeți o discrepanță, examinați detaliile tranzacției.
Observați că sumele primite și modificările raportate sunt corecte, dar până este scurt cu cinci dolari.

Această lipsă sugerează că matricea cashTill este actualizată incorect, chiar dacă raportarea este corectă.
Opriți sesiunea de depanare și închideți panoul TERMINAL.
Defilați în partea de jos a metodei MakeChange .

Instrucțiunile while utilizate pentru "a efectua modificări" se află la sfârșitul metodei MakeChange .
Revizuiți blocurile de cod de while instrucțiune utilizate pentru a efectua modificări.

Deoarece până este dezactivată cu cinci dolari, problema este probabil să fie în blocul while de cod care este utilizat pentru a returna cinci dolari facturi.
Observați următorul cod:
```
while ((changeNeeded > 4) && (cashTill[1] > 0))
{
    cashTill[2]--;
    changeNeeded -= 5;
    Console.WriteLine("\t A five");
}    
```
Matricea cashTill[] este utilizată pentru a stoca numărul de facturi pentru fiecare valoare nominală disponibilă în prezent. Elementul 1 matrice este utilizat pentru a gestiona numărul de cinci dolari facturi în până. Expresia din while instrucțiune se referă cashTill[1] corect. Cu toate acestea, instrucțiunea din interiorul blocului de cod decrementează cashTill[2] în loc de cashTill[1]. Specificarea unei valori index de 2 înseamnă că o factură de zece dolari este eliminată din până în loc de o factură de cinci dolari.

Actualizați blocul de while cod după cum urmează:

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

Salvați fișierul Program.cs.

Verificați-vă activitatea

În această activitate, rulați aplicația și verificați dacă funcționează codul actualizat așa cum doriți.

În meniul Rulare cod Visual Studio, selectați Eliminare toate punctele de întrerupere.
În meniul Executare , selectați Pornire depanare.
Examinați ieșirea în panoul TERMINAL.
Verificați dacă valoarea raportată până la valoarea este egală cu valoarea așteptată până la:

Soldul final până la MakeChange calculul și soldul menținut în declarațiile de nivel superior sunt raportate în partea de jos a rezultatului. De exemplu:
```
Transaction successfully completed.
The till has 452 dollars
Expected till value: 452


Press the Enter key to exit
```
Aplicația generează aleator costul articolelor de achiziție. Prin urmare, valorile raportate în rezultatul dvs. sunt diferite. Atât timp cât cele două valori sunt egale, ați reușit să remediați problema logică.

Feedback

Această pagină a fost utilă?