Övning – Granska och testa ett C#-konsolprogram med hjälp av exempeldata

  • 20 minuter

I den här övningen granskar och testar du koden i Startprojektet, isolerar och åtgärdar ett logikproblem och kontrollerar sedan att det uppdaterade programmet fungerar som förväntat.

Du utför följande uppgifter under den här övningen:

  1. Kodgranskning: granska innehållet i filen Program.cs.

    Program.cs innehåller följande kodavsnitt:

    • Toppnivåinstruktioner: toppnivåinstruktionerna simulerar en serie transaktioner med antingen en matris med testData eller ett större antal slumpmässigt genererade transaktioner.
    • LoadTillEachMorning: LoadTillEachMorning metoden används för att konfigurera kassan till med ett fördefinierat antal fakturor i varje valör.
    • MakeChange: MakeChange metoden används för att hantera kassan under köptransaktioner.
    • LogTillStatus: LogTillStatus metoden används för att visa antalet fakturor för varje valör som för närvarande finns i kassan.
    • TillAmountSummary: metoden TillAmountSummary används visar ett meddelande som visar mängden kontanter i kassan.

  2. Inledande testning: Kontrollera att MakeChange pengarna balanseras tills när matrisen testData används för att simulera transaktioner.

  3. Kodfelsökning: isolera och korrigera ett logikproblem som exponeras när slumpmässigt genererade data används.

  4. Verifieringstest: Utför ett verifieringstest på koden som du utvecklar i den här övningen.

Granska innehållet i filen Program.cs

I den här uppgiften slutför du en genomgång av startprojektkoden. Filen Program.cs innehåller ett program som simulerar villkoren för dagliga transaktioner. Programmet anropar MakeChange metoden för att hantera pengarna till under varje transaktion. Andra metoder används för att initiera kassan och generera rapporteringsmeddelanden.

  1. Kontrollera att mappen GuidedProject är öppen i Visual Studio Code.

  2. I EXPLORER-vyn expanderar du mapparna GuidedProject och Starter .

    Mappen Starter innehåller exempelprogrammet för den här guidade projektmodulen.

  3. Öppna filen Program.cs i Visual Studio Code-redigeraren.

  4. På menyn Visa väljer du Kommandopalett.

  5. I kommandotolken anger du .net: g och väljer sedan .NET: Generate Assets for Build and Debug (Generera tillgångar för build och felsökning).

  6. I kommandotolken Välj projektet som ska startas väljer du Projektet Starter.

    Filen launch.json som skapas innehåller en konfiguration för Starter-projektet.

  7. Det tar några minuter att granska toppnivåinstruktionerna för det här programmet:

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

    Koden för toppnivåinstruktioner slutför följande uppgifter:

    • Konfigurerar programdata och miljövariabler som används för att testa MakeChange metoden.
    • LoadTillEachMorning()Anropar metoderna , LogTillStatus()och TillAmountSummary() för att förbereda pengarna till och skriva ut statusmeddelanden till konsolen.
    • Använder en while loop för att simulera en serie transaktioner.
    • MakeChange Anropar metoden inifrån kodblocket i loopenwhile.
    • Rapporterar status för pengarna till efter varje transaktion.

    Kommentar

    De översta instruktionerna innehåller en Console.ReadLine() -instruktion. Filen launch.json måste uppdateras innan du felsöker.

  8. Ta en stund att granska LoadTillEachMorning() metoden.

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

  9. Det tar några minuter att granska MakeChange() metoden.

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

    Metoden MakeChange hanterar pengarna tills under varje köptransaktion. Transaktionsprocessen förlitar sig på följande resurser och villkor:

    • Kontanttransaktion: Metoden MakeChange accepterar en kontant betalning från kunden och avgör sedan hur många fakturor av varje valör som måste returneras till kunden i förändring. MakeChange måste först se till att kunden har tillhandahållit tillräckligt med pengar för att täcka transaktionen. Om betalningen är tillräcklig börjar processen "gör ändring" med den största fakturabeteckningen och fungerar ner till den minsta valören. I varje steg MakeChange ser du till att den aktuella valören är mindre än den ändring som är skyldig. MakeChange säkerställer också att en faktura för den obligatoriska valören är tillgänglig i kassan innan den läggs till i ändringen som returneras till kunden.

    • Indataparametrar: Metoden MakeChange använder följande indataparametrar:

      • Ett heltal som representerar kostnaden för den artikel som köps: itemCost
      • En heltalsmatris som innehåller antalet fakturor i kassan för varje valör: cashTill
      • Den betalning som erbjuds av kunden, där antalet fakturor för varje valör anges separat: paymentTwenties, paymentTens, paymentFives, paymentOnes

    • Kontanter som är tillgängliga i kassan: De fakturor som erbjuds som betalning av kunden måste ingå i räkningarna för varje valör som är tillgängliga för att göra ändringar.

    • Ändring som kunden är skyldig: Ändringen som kunden är skyldig beräknas med hjälp av det belopp som kunden betalar minus kostnaden för artikeln.

    • Underbetalning: Om kunden inte har tillhandahållit tillräcklig betalning MakeChange returnerar ett beskrivande meddelande och transaktionen avbryts.

    • Otillräckligt till: Om kassan inte kan göra någon exakt ändring MakeChange returnerar du ett beskrivande meddelande och transaktionen avbryts.

  10. Ta en stund att granska LogTillStatus() metoden.

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

    Metoden LogTillStatus använder matrisen cashTill för att rapportera det aktuella innehållet i kassan.

  11. Ta en stund att granska TillAmountSummary() metoden.

    static string TillAmountSummary(int[] cashTill)
{
    return $"The till has {cashTill[3] * 20 + cashTill[2] * 10 + cashTill[1] * 5 + cashTill[0]} dollars";

}

    Metoden TillAmountSummary använder matrisen cashTill för att beräkna det aktuella kontantsaldot som är tillgängligt i till.

Det slutför din granskning av det befintliga kodprojektet.

Kontrollera att MakeChange hanterar pengarna när du använder matrisen testData

I den här uppgiften simulerar du transaktioner med matrisen testData och kontrollerar att MakeChange pengarna har balanserats tills.

  1. På Menyn Kör i Visual Studio Code väljer du Starta felsökning.

  2. Observera att ett IOException fel inträffar.

    FELSÖKNINGSKONSOLen stöder Console.Clear() inte eller Console.ReadLine() metoder. Du måste uppdatera filen launch.json innan du felsöker.

  3. I verktygsfältet Felsök väljer du Stoppa.

  4. Använd EXPLORER-vyn för att öppna filen launch.json.

  5. Uppdatera attributet enligt console följande i filen launch.json:

    // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
"console":"integratedTerminal",

    Standardvärdet för console attributet är internalConsole, som justeras till PANELEN FELSÖKNINGSKONSOL. Tyvärr stöder felsökningskonsolpanelen inte vissa konsolmetoder. Inställningen integratedTerminal justeras mot TERMINAL-panelen, som stöder konsolens indata och utdata.

  6. Spara ändringarna i filen launch.json.

  7. På Menyn Kör i Visual Studio Code väljer du Starta felsökning.

  8. Granska utdata som genererats av programmet i TERMINAL-panelen.

    Växla från panelen FELSÖKNINGSKONSOL till TERMINAL-panelen för att granska utdata.

  9. Observera att MakeChange balanserar kassan när matrisen testData används för att simulera transaktioner.

    Du bör se följande rader längst ned i de rapporterade utdata:

    The till has 551 dollars
Expected till value: 551


Press the Enter key to exit

    Observera att både rapporterade och förväntade till-värden är 551.

  10. Om du vill avsluta programmet trycker du på Retur.

Identifiera och åtgärda logikproblem

I den här uppgiften använder du simulerade transaktioner för att exponera ett kodlogikproblem och använder sedan felsökningsverktygen i Visual Studio Code för att isolera och åtgärda problemet.

  1. Om du vill köra koden med slumpmässigt genererade transaktioner ändrar du värdet som tilldelats till useTestDatafalse.

    Du hittar variabeln useTestData längst upp i toppnivåinstruktionerna.

  2. Spara filen Program.cs och kör sedan programmet i felsökningsprogrammet.

  3. Granska utdata i terminalpanelen.

  4. Observera avvikelsen i kassabalansen.

    Det slutliga till-saldot som beräknas av MakeChange och saldot som upprätthålls i de översta satserna rapporteras längst ned i utdata. Till exempel:

    Transaction successfully completed.
The till has 379 dollars
Expected till value: 434


Press the Enter key to exit

    Kommentar

    Programmet genererar slumpmässigt kostnaden för inköpsartiklar. Därför skiljer sig till-värdena som rapporteras i dina utdata.

  5. Avsluta programmet genom att trycka på Retur.

  6. Stäng terminalpanelen.

Felsöka koden

I den här uppgiften använder du felsökningsverktygen i Visual Studio Code för att isolera och sedan åtgärda logikproblemet.

  1. Leta upp följande kodrad i slutet av de översta satserna:

    Console.WriteLine();

  2. Ange en brytpunkt på den valda kodraden.

  3. På Menyn Kör i Visual Studio Code väljer du Starta felsökning.

  4. Observera att kodkörningen pausar brytpunkten.

  5. I verktygsfältet Felsökningskontroller väljer du Stega in.

  6. Granska utdata i terminalpanelen.

  7. Om de rapporterade och förväntade tills-värdena är lika väljer du Fortsätt i verktygsfältet Felsökningskontroller .

  8. Upprepa föregående steg tills du ser en avvikelse mellan de rapporterade och förväntade till-värdena.

  9. När du ser en avvikelse tar det en minut att undersöka detaljerna i transaktionen.

  10. Observera att de rapporterade kontanter som mottagits och den returnerade ändringen är korrekta, men kassan är kort med fem dollar.

    Den här bristen tyder på att matrisen cashTill uppdateras felaktigt, även om rapporteringen är korrekt.

  11. Stoppa felsökningssessionen och stäng terminalpanelen.

  12. Rulla längst ned i MakeChange metoden.

    De while instruktioner som används för att "göra ändringar" finns i slutet av MakeChange metoden.

  13. Granska de instruktionskodblock while som används för att göra ändringar.

    Eftersom kassan är av med fem dollar är problemet sannolikt i kodblocket while som används för att returnera fem dollarräkningar.

  14. Observera följande kod:

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

    Matrisen cashTill[] används för att lagra antalet fakturor för varje valör som för närvarande är tillgängliga. Matriselementet 1 används för att hantera antalet fem dollarfakturor i kassan. Uttrycket i -instruktionen while refererar till cashTill[1] korrekt. Instruktionen i kodblocket minskar cashTill[2] dock snarare än cashTill[1]. Om du anger ett indexvärde 2 för innebär det att en 10-dollarsedel tas bort från kassan i stället för en femdollarsedel.

  15. Uppdatera kodblocket på while följande sätt:

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

  16. Spara Program.cs-filen.

Kontrollera ditt arbete

I den här uppgiften kör du programmet och kontrollerar att den uppdaterade koden fungerar som den ska.

  1. Välj Ta bort alla brytpunkter på Visual Studio Code Run-menyn.

  2. På menyn Kör väljer du Starta felsökning.

  3. Granska utdata i terminalpanelen.

  4. Kontrollera att det rapporterade till-värdet är lika med det förväntade till-värdet:

    Det slutliga till-saldot som beräknas av MakeChange och saldot som upprätthålls i de översta satserna rapporteras längst ned i utdata. Till exempel:

    Transaction successfully completed.
The till has 452 dollars
Expected till value: 452


Press the Enter key to exit

    Programmet genererar slumpmässigt kostnaden för inköpsartiklar. Därför skiljer sig till-värdena som rapporteras i dina utdata. Så länge de två värdena är lika har du lyckats åtgärda logikproblemet.