תרגיל - סקירה ובדיקה של אפליקציית קונסולת C# באמצעות נתונים לדוגמה

  • 20 דקות

בתרגיל זה, אתה סוקר ובדוק את הקוד בפרוייקט Starter, מבודד ופותר בעיה לוגית ולאחר מכן מוודא שהיישום המעודכן פועל כצפוי.

עליך להשלים את המשימות הבאות במהלך תרגיל זה:

  1. סקירת קוד: סקור את תוכן Program.cs הקובץ.

    המקטע Program.cs את מקטעי הקוד הבאים:

    • משפטים ברמה העליונה: testData המשפטים ברמה העליונה מדמה סידרת טרנזקציות באמצעות מערך של טרנזקציות שנוצרות באופן אקראי או גדול יותר.
    • LoadTillEachMorning: LoadTillEachMorning השיטה משמשת לקביעת התצורה של קופה עד עם מספר מוגדר מראש של חשבונות בכל מכנה.
    • MakeChange: השיטה משמשת MakeChange לניהול המזומנים עד במהלך עסקאות רכישה.
    • LogTillStatus: LogTillStatus השיטה משמשת להצגת מספר החשבונות של כל מכנה הנמצאים בשלבי התשלום.
    • TillAmountSummary: TillAmountSummary השיטה משמשת להצגת הודעה המציגה את סכום המזומנים בתשלום.

  2. בדיקה ראשונית: ודא כי MakeChange מאזן בהצלחה את הכסף עד לשימוש במערך testData כדי לדמות עסקאות.

  3. איתור באגים בקוד: בידוד ותיקון של בעיה לוגית שנחשף בעת שימוש בנתונים שנוצרו באופן אקראי.

  4. בדיקת אימות: בצע בדיקת אימות על הקוד שפיתת בתרגיל זה.

סקירת התוכן של Program.cs שלך

בפעילות זו, עליך להשלים הדרכה של קוד הפרוייקט של Starter. קובץ Program.cs מכיל יישום המדמה את התנאים עבור טרנזקציות יומיות. היישום קורא לשיטה MakeChange לנהל את הכסף עד לכל עסקה. שיטות אחרות משמשות לאתחל את ההודעות לדיווח וליצור בהן הודעות דיווח.

  1. ודא שהתיקיה GuidedProject פתוחה ב- Visual Studio Code.

  2. בתצוגת EXPLORER, הרחב את התיקיות GuidedProjectו- Starter .

    התיקיה Starter מכילה את היישום לדוגמה עבור מודול פרוייקט מונחה זה.

  3. פתח את Program.cs בעורך הקוד של Visual Studio.

  4. בתפריט תצוגה, בחר לוח פקודה.

  5. בשורת הפקודה, הזן .net: g ולאחר מכן בחר .NET: צור נכסים עבור גירסת Build ו-איתור באגים.

  6. בהנחיה בחר את הפרוייקט להפעלה , בחר את הפרוייקט Starter .

    קובץ launch.json שנוצר יכלול תצורה עבור פרוייקט Starter.

  7. תימשך כמה דקות כדי לסקור את המשפטים ברמה העליונה עבור יישום זה:

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

    קוד המשפטים ברמה העליונה משלים את המשימות הבאות:

    • קביעת התצורה של נתוני היישום ומשתנה הסביבה המשמשים לבדיקת MakeChange השיטה.
    • קורא ל LoadTillEachMorning()- , LogTillStatus()ולשיטות TillAmountSummary() כדי להכין את הכסף עד ולהדפיס הודעות מצב לקונסולה.
    • שימוש בלולאה while כדי לדמות סידרת עסקאות.
    • קריאה לשיטה MakeChange מתוך בלוק הקוד של הלולאה while .
    • מדווח על מצב הכסף עד לאחר כל עסקה.

    הערה

    המשפטים ברמה העליונה כוללים Console.ReadLine() משפט. יהיה launch.json צורך לעדכן את הקובץ לפני איתור באגים.

  8. קח כמה רגעים כדי לסקור את 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];
}

  9. תימשך כמה דקות כדי לסקור את 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;
}

    השיטה MakeChange מנהלת את הכסף עד לכל עסקה ברכישה. תהליך הטרנזקציה מסתמך על המשאבים והתנאים הבאים:

    • עסקה במזומן: MakeChange השיטה מקבלת תשלום במזומן מהלקוח ולאחר מכן קובעת כמה חשבונות של כל ערך יש להחזיר ללקוח בשינוי. MakeChange תחילה עליך לוודא שהלקוח סיפק מספיק כסף כדי לכסות את העסקה. אם התשלום מספיק, התהליך של "לבצע שינוי" מתחיל עם ההפחתה הגדולה ביותר של החשבון, והוא פועל עד לערך הקטן ביותר. בכל שלב, MakeChange מבטיחה שהערך הנוכחי יהיה קטן מהשינוי המנורש. MakeChange כמו כן מבטיחה שחייב של המכנה הנדרש יהיה זמין ב- עד לפני הוספתו לשינוי המוחזר ללקוח.

    • פרמטרי קלט: פעולת MakeChange השירות משתמשת בפרמטרי הקלט הבאים:

      • מספר שלם המייצג את העלות של הפריט שנרכש: itemCost
      • מערך מספר שלם המכיל את מספר החשבונות ב- עד עבור כל ערך: cashTill
      • התשלום המוצע על-ידי הלקוח, שבו מספר החשבונות עבור כל מכנה מצוין בנפרד: paymentTwenties, paymentTens, paymentFives, , paymentOnes

    • מזומנים זמינים עד: יש לכלול את החשבונות המוצעים כתשלום על-ידי הלקוח בשטרות של כל ערך הזמין לביצוע שינויים.

    • שינוי חייב ללקוח: השינוי המנורש ללקוח מחושב באמצעות הסכום ששולם על-ידי הלקוח פחות עלות הפריט.

    • תשלום תחתון: אם הלקוח לא סיפק מספיק תשלום, MakeChange מחזיר הודעה תיאורית והטרנזקציה מבוטלת.

    • אין די עד: אם ל- till אין אפשרות לבצע שינוי מדויק, MakeChange מחזירה הודעה תיאורית והטרנזקציה מבוטלת.

  10. קח כמה רגעים כדי לסקור את 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();
}

    פעולת LogTillStatus השירות משתמשת במערך cashTill כדי לדווח על התוכן הנוכחי של השורה.

  11. קח כמה רגעים כדי לסקור את TillAmountSummary() השיטה.

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

}

    פעולת TillAmountSummary השירות משתמשת cashTill במערך לחישוב יתרת המזומנים הנוכחית הזמינה עד.

פעולה זו משלים את הסקירה של פרוייקט הקוד הקיים.

ודא שמנהל MakeChange בהצלחה את הכסף בעת השימוש במערך testData

במשימה זו, אתה מדמה עסקאות באמצעות המערך testData ואמת MakeChange כי מאזן בהצלחה את הכסף עד.

  1. בתפריט הפעלת קוד של Visual Studio , בחר התחלאיתור באגים.

  2. שים לב שמתרחשת IOException שגיאה.

    מסוף איתור הבאגים אינו תומך בפעולות Console.Clear()Console.ReadLine() שירות או בפעולות שירות. עליך לעדכן את הקובץ launch.json לאיתור באגים.

  3. בסרגל הכלים איתור באגים, בחר עצור.

  4. השתמש בתצוגה EXPLORER כדי לפתוח את launch.json הקובץ.

  5. בקובץ launch.json, עדכן את console התכונה באופן הבא:

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

    ערך ברירת המחדל עבור console התכונה הוא internalConsole, המיושר לחלונית DEBUG CONSOLE. למרבה הצער, החלונית 'מסוף איתור באגים' אינה תומכת בשיטות מסוימות של המסוף. ההגדרה integratedTerminal מיושרת לחלונית TERMINAL, התומכת בקלט ובפלט של הקונסולה.

  6. שמור את השינויים שביצעת בקובץ launch.json הקובץ.

  7. בתפריט הפעלת קוד של Visual Studio , בחר התחלאיתור באגים.

  8. סקור את הפלט שנוצר על-ידי היישום בלוח TERMINAL.

    עבור מהלוח 'מסוף איתור באגים' לחלונית TERMINAL כדי לסקור את הפלט.

  9. שים לב MakeChange כי מאזן בהצלחה את ה- till בעת שימוש במערך testData כדי לדמות עסקאות.

    אתה אמור לראות את השורות הבאות בחלק התחתון של הפלט שדווח:

    The till has 551 dollars
Expected till value: 551


Press the Enter key to exit

    שים לב כי ערכי ה- till שדווחו והצפוי הם שניהם 551.

  10. כדי לצאת מהאפליקציה, הקש Enter.

זיהוי ופתרון של בעיות לוגיקה

במשימה זו, עליך להשתמש בטרנזקציות מדומה כדי לחשוף בעיה בלוגיקה של קוד ולאחר מכן להשתמש בכלי מאתר הבאגים של קוד Visual Studio כדי לבודד ולפתור את הבעיה.

  1. כדי להפעיל את הקוד באמצעות טרנזקציות שנוצרו באופן אקראי, שנה את הערך שהוקצה ל- useTestDatafalse.

    באפשרותך למצוא את המשתנה useTestData בסמוך לחלק העליון של המשפטים ברמה העליונה.

  2. שמור את Program.cs הקובץ ולאחר מכן הפעל את היישום במאתר הבאגים.

  3. סקור את הפלט בלוח המסוף.

  4. שים לב לפער בין היתרה.

    יתרת החוב הסופית המחושבת MakeChange על-ידי והיתרה המנוהרת במשפטים ברמה העליונה מדווחת בחלק התחתון של הפלט. לדוגמה:

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


Press the Enter key to exit

    הערה

    היישום יוצר באופן אקראי את העלות של פריטי רכישה. לכן, ערכי ה- till שדווחו בפלט שלך הם שונים.

  5. כדי לצאת מהאפליקציה, הקש Enter.

  6. סגור את לוח המסוף.

איתור באגים בקוד

במשימה זו, עליך להשתמש בכלי מאתר הבאגים של קוד Visual Studio כדי לבודד ולאחר מכן לפתור את הבעיה הלוגית.

  1. סמוך לסוף המשפטים ברמה העליונה, אתר את שורת הקוד הבאה:

    Console.WriteLine();

  2. הגדר נקודת עצירה בשורת הקוד שנבחרה.

  3. בתפריט הפעלת קוד של Visual Studio , בחר התחלאיתור באגים.

  4. שים לב שביצוע קוד מושהה בנקודות עצירה.

  5. בסרגל הכלים של פקדי איתור באגים , בחר צעד לתוך.

  6. סקור את הפלט בלוח המסוף.

  7. אם ערכי עד שדווחו והצפויים שווים, בחר המשך בסרגל הכלים של פקדי איתור באגים .

  8. חזור על השלב הקודם עד שתראה אי-התאמה בין ערכי עד שדווחו וצפויים.

  9. לאחר שתראה אי-התאמה, קח דקה כדי לבחון את פרטי העסקה.

  10. שים לב שהמזומנים המדווחים שהתקבלו והשינוי המוחזרים נכונים, אך קופה קצרה בחמישה דולר.

    חסרונות אלה מצביעים על cashTill כך שמערך זה מתעדכן באופן שגוי, למרות שהדיווח נכון.

  11. הפסק את הפעלת איתור הבאגים וסגור את לוח המסוף.

  12. גלול לחלק התחתון של השיטה MakeChange .

    המשפטים while המשמשים ל"ביצוע שינוי" ממוקמים בסוף MakeChange פעולת השירות.

  13. סקור את while בלוקי קוד המשפט המשמשים כדי לבצע שינויים.

    מאחר שהתשואה מבוטלת בחמישה דולר, while ייתכן שהבעיה נמצאת בבלוק הקוד שמשמש להחזרת 5 דולר.

  14. שים לב לקוד הבא:

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

    המערך cashTill[] משמש לאחסון מספר החשבונות של כל מכנה הזמין כעת. רכיב מערך 1 משמש לניהול מספר חמשת השטרות בדולרים. הביטוי במשפט while מתייחס כראוי cashTill[1] . עם זאת, המשפט בתוך בלוק הקוד נפרש cashTill[2] במקום cashTill[1]. ציון ערך אינדקס של 2 אמצעים להוסרה של איגרת חיוב של 10 דולר מחשבון ה-עד במקום מחשבון של חמישה דולר.

  15. עדכן את while בלוק הקוד באופן הבא:

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

  16. שמור את Program.cs הקובץ.

בדוק את העבודה שלך

במשימה זו, אתה מפעיל את היישום שלך ואמת שהקוד המעודכן פועל כצפוי.

  1. בתפריט הפעלת קוד של Visual Studio, בחר הסר את כל נקודות החלוקה.

  2. בתפריט הפעלה , בחר התחל איתור באגים.

  3. סקור את הפלט בלוח המסוף.

  4. ודא שערך ה- till שדווח שווה לערך ה- till הצפוי:

    יתרת החוב הסופית המחושבת MakeChange על-ידי והיתרה המנוהרת במשפטים ברמה העליונה מדווחת בחלק התחתון של הפלט. לדוגמה:

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


Press the Enter key to exit

    היישום יוצר באופן אקראי את העלות של פריטי רכישה. לכן, ערכי ה- till שדווחו בפלט שלך הם שונים. כל עוד שני הערכים שווים, הצלחת לפתור את הבעיה הלוגית.