מדריך NET. – ניהול חריגים – Exception Handling

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

מנגנון תפיסת השגיאות

המנגנון כולל 2 בלוקים עיקריים:

• try – בלוק בו נכתוב את הקוד שעלול לזרוק חריגה
• catch – בלוק לתפיסת השגיאה וטיפול בה

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

      try
      {
        Console.Write("Enter number:");
        int num = int.Parse(Console.ReadLine());
        num = num + 5;
        Console.WriteLine(num);
      }
      catch
      {
        Console.WriteLine("Error");
      }

נקודות חשובות לגבי מנגנון תפיסת השגיאות:

• כאשר תגרם שגיאה בבלוק ה- try, התוכנית מיד תעבור לבלוק ה- catch ולא תמשיך את בלוק ה- try
• בלוק ה- catch יופעל רק במידה ואכן תהיה חריגה
• בשימוש במנגנון, בין אם תהיה שגיאה ובין אם לא התוכנית תמשיך אח"כ לקוד המופיע לאחר בלוק ה- catch

המחלקה Exception

מחלקה זו מייצגת חריגה ומכילה מידע לגבי החריגה שהתעוררה. אחד המאפיינים החשובים במחלקה זו הוא Message אשר מכיל את הודעת השגיאה כפי שכתב אותה זורק השגיאה (מיד נראה מה זה אומר "זורק השגיאה").

למחלקה זו המון מחלקות נגזרות (יורשות) אשר כל אחת מהן מייצגת חריגה מסויימת. דוגמא לכמה נפוצות:

• DivideByZeroException – מתעורר בחלוקת מספר כלשהו ב- 0
• IndexOutOfRangeException – חריגה באינדקס מערך (יציאה מגבולות המערך)
• FormatException – חריגה בפורמט (סוג) המידע
• ArgumentException – פרמטר לא נכון שהועבר לפונקציה

כאשר נתפוס חריגה נוכל לבקש לתפוס רק חריגה מסוג מסוים או לתפוס מספר סוגי חריגות ולכל סוג חריגה נבצע טיפול אחר. אם נתפוס את החריגה הכללית – Exception יתפסו כל סוגי החריגות ולכן נהוג תמיד להוסיף גם תפיסה של חריגה זו (בסוף) למקרה של שגיאה שלא ציפינו לה.

בדוגמא הבאה:

• אם המשתמש יזין ערך שאינו מספרי החריגה תיתפס ב- catch הראשון
• אם המשתמש יזין ערך 0 החריגה תיתפס ב- catch השני
• אם תהיה שגיאה אחרת, למשל מספר שיותר גדול מגודל של int החריגה תיתפס ב- catch האחרון
• ניתן גם לראות שבמקרה האחרון השתמשנו בהודעת השגיאה שכתב זורק השגיאה

      try
      {
        Console.Write("Enter number:");
        int num = int.Parse(Console.ReadLine());
        num = 10 / num;
        Console.WriteLine(num);
      }
 
      catch (FormatException)
      {
        Console.WriteLine("The value must be numeric");
      }
 
      catch (DivideByZeroException)
      {
        Console.WriteLine("Can't divide by zero:");
      }
 
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
      }

בלוק finally

בלוק זה ניתן להוסיף לאחר ה- catch האחרון. בלוק זה יתבצע בכל מקרה גם אם תהיה שגיאה וגם אם לא תהיה שגיאה. בלוק זה מיועד לפעולות סגירה כגון: סגירת קבצים, חיבור ל- DB, התנתקות מסודרת וכד'. היתרון בבלוק זה הוא שאנו בטוחים שהוא יתבצע בכל מקרה, אפילו אם תהיה שגיאה ב- catch או שלא תפסנו את השגיאה המתאימה (הוא יתבצע גם במקרה ויש בלוק try אך כלל אין בלוקים של catch).

דוגמא ל- finally:

      try
      {
          ...
      }
      catch (Exception ex)
      {
          ...
      }
      finally
      {
        Console.WriteLine("finally code");
      }

זריקת שגיאות

לעיתים נרצה ליזום שגיאות משלנו בכדי "להודיע" למי שהפעיל את הקוד שלנו שהוא עשה טעות. במקרה כזה נשתמש במילה throw אשר תפקידה לזרוק אובייקט Exception כלשהו. מי שמפעיל את הקוד הזה צריך להשתמש במבנה של try…catch כדי לתפוס את השגיאה.

בדוגמא הבאה פונקציה Sqrt מחזירה שורש ריבועי של מספר, אך אם המספר הוא שלילי הפונקציה זורקת שגיאה מסוג ArgumentException. בכדי לתפוס אותה נשתמש ב – try…catch:

    static void Main(string[] args)
    {
      try
      {
        Sqrt(-5);
      }
      catch (Exception ex)
      {
        Console.WriteLine(ex.Message);
      }
    }
 
    static int Sqrt(int num)
    {
      if (num < 0)
        throw new ArgumentException(
            "The number must be positive");
 
      ...
    }