Presentation is loading. Please wait.

Presentation is loading. Please wait.

Exception Handling Handling Errors During the Program Execution SoftUni Team Technical Trainers Software University

Similar presentations


Presentation on theme: "Exception Handling Handling Errors During the Program Execution SoftUni Team Technical Trainers Software University"— Presentation transcript:

1 Exception Handling Handling Errors During the Program Execution SoftUni Team Technical Trainers Software University http://softuni.bg

2 2 1.What are Exceptions? 2.Handling Exceptions 3.The System.Exception Class 4.Types of Exceptions and their Hierarchy 5.Raising (Throwing) Exceptions 6.Best Practices 7.Creating Custom Exceptions Table of Contents

3 What are Exceptions? The Paradigm of Exceptions in OOP

4 4  The exceptions in.NET Framework / Java are a classic implementation of the OOP exception model  Deliver powerful mechanism for centralized handling of errors and unusual events  Substitute procedure-oriented approach, in which each function returns error code  Simplify code construction and maintenance  Allow the problematic situations to be processed at multiple levels What are Exceptions?

5 Handling Exceptions Catching and Processing Errors

6 6  In C# exceptions can be handled by the try-catch-finally construction  catch blocks can be used multiple times to process different exception types Handling Exceptions try{ // Do some work that can raise an exception // Do some work that can raise an exception} catch (SomeException) { // Handle the caught exception // Handle the caught exception}

7 7 Handling Exceptions – Example static void Main() { string s = Console.ReadLine(); string s = Console.ReadLine(); try try { int.Parse(s); int.Parse(s); Console.WriteLine( Console.WriteLine( "You entered a valid Int32 number {0}.", s); "You entered a valid Int32 number {0}.", s); } catch (FormatException) catch (FormatException) { Console.WriteLine("Invalid integer number!"); Console.WriteLine("Invalid integer number!"); } catch (OverflowException) catch (OverflowException) { Console.WriteLine( Console.WriteLine( "The number is too big to fit in Int32!"); "The number is too big to fit in Int32!"); }}

8 Handling Exceptions Live Demo

9 9  Exceptions in C# /.NET are objects  The System.Exception class is base for all exceptions in CLR  Contains information for the cause of the error / unusual situation  Message – text description of the exception  StackTrace – the snapshot of the stack at the moment of exception throwing  InnerException – exception caused the current exception (if any)  Similar concept in Java and PHP The System.Exception Class

10 10 Exception Properties – Example class ExceptionsExample { public static void CauseFormatException() public static void CauseFormatException() { { string str = "an invalid number"; string str = "an invalid number"; int.Parse(str); int.Parse(str); } } static void Main() static void Main() { { try try { { CauseFormatException(); CauseFormatException(); } } catch (FormatException fe) catch (FormatException fe) { { Console.Error.WriteLine("Exception: {0}\n{1}", Console.Error.WriteLine("Exception: {0}\n{1}", fe.Message, fe.StackTrace); fe.Message, fe.StackTrace); } } }}

11 11  The Message property gives a brief description of the problem  The StackTrace property is extremely useful when identifying the reason that caused the exception Exception Properties Exception caught: Input string was not in a correct format. at System.Number.ParseInt32(String s, NumberStyles style, NumberFormatInfo info) at System.Number.ParseInt32(String s, NumberStyles style, NumberFormatInfo info) at System.Int32.Parse(String s) at System.Int32.Parse(String s) at ExceptionsTest.CauseFormatException() in c:\consoleapplication1\exceptionstest.cs:line 8 at ExceptionsTest.CauseFormatException() in c:\consoleapplication1\exceptionstest.cs:line 8 at ExceptionsTest.Main(String[] args) in c:\consoleapplication1\exceptionstest.cs:line 15 at ExceptionsTest.Main(String[] args) in c:\consoleapplication1\exceptionstest.cs:line 15

12 Exception Properties Live Demo

13 The Hierarchy of Exceptions

14 14  Exceptions in.NET Framework are organized in a hierarchy Exception Hierarchy in.NET

15 15 .NET exceptions inherit from System.Exception  The system exceptions inherit from System.SystemException  System.ArgumentException  System.FormatException  System.NullReferenceException  System.OutOfMemoryException  System.StackOverflowException  User-defined exceptions should inherit from System.Exception Types of Exceptions

16 16  When catching an exception of a particular class, all its inheritors (child exceptions) are caught too, e.g.  Handles ArithmeticException and its descendants DivideByZeroException and OverflowException Handling Exceptions try{ // Do some work that can cause an exception // Do some work that can cause an exception} catch (System.ArithmeticException) { // Handle the caught arithmetic exception // Handle the caught arithmetic exception}

17 17 Find the Mistake! static void Main() { string str = Console.ReadLine(); string str = Console.ReadLine(); try try { Int32.Parse(str); Int32.Parse(str); } catch (Exception) catch (Exception) { Console.WriteLine("Cannot parse the number!"); Console.WriteLine("Cannot parse the number!"); } catch (FormatException) catch (FormatException) { Console.WriteLine("Invalid integer number!"); Console.WriteLine("Invalid integer number!"); } catch (OverflowException) catch (OverflowException) { Console.WriteLine( Console.WriteLine( "The number is too big to fit in Int32!"); "The number is too big to fit in Int32!"); }} This should be last Unreachable code

18 18  All exceptions thrown by.NET managed code inherit the System.Exception class  Unmanaged code can throw other exceptions  For handling all exceptions (even unmanaged) use the construction: Handling All Exceptions try{ // Do some work that can raise any exception // Do some work that can raise any exception}catch{ // Handle the caught exception // Handle the caught exception}

19 Throwing Exceptions

20 20  Exceptions are thrown (raised) by the throw keyword  Used to notify the calling code in case of error or unusual situation  When an exception is thrown:  The program execution stops  The exception travels over the stack  Until a matching catch block is reached to handle it  Unhandled exceptions display an error message Throwing Exceptions

21 21 How Do Exceptions Work? Main() Method 1 Method 2 Method N 2. Method call 3. Method call 4. Method call … Main() Method 1 Method 2 Method N 8. Find handler 7. Find handler 6. Find handler … 5. Throw an exception.NET CLR 1. Execute the program 9. Find handler 10. Display error message

22 Call Stack Example Live Demo

23 23  Throwing an exception with an error message:  Exceptions can accept message and cause:  Note: if the original exception is not passed, the initial cause of the exception is lost Using throw Keyword throw new ArgumentException("Invalid amount!"); try{ …} catch (SqlException sqlEx) { throw new InvalidOperationException("Cannot save invoice.", sqlEx); throw new InvalidOperationException("Cannot save invoice.", sqlEx);}

24 24  Caught exceptions can be re-thrown again: Re-Throwing Exceptions try{ Int32.Parse(str); Int32.Parse(str);} catch (FormatException fe) { Console.WriteLine("Parse failed!"); Console.WriteLine("Parse failed!"); throw fe; // Re-throw the caught exception throw fe; // Re-throw the caught exception} catch (FormatException) { throw; // Re-throws the last caught exception throw; // Re-throws the last caught exception}

25 25 Throwing Exceptions – Example public static double Sqrt(double value) { if (value < 0) if (value < 0) throw new System.ArgumentOutOfRangeException("value", throw new System.ArgumentOutOfRangeException("value", "Sqrt for negative numbers is undefined!"); "Sqrt for negative numbers is undefined!"); return Math.Sqrt(value); return Math.Sqrt(value);} static void Main() { try try { Sqrt(-1); Sqrt(-1); } catch (ArgumentOutOfRangeException ex) catch (ArgumentOutOfRangeException ex) { Console.Error.WriteLine("Error: " + ex.Message); Console.Error.WriteLine("Error: " + ex.Message); throw; throw; }}

26 Throwing Exceptions Live Demo

27 27  When an invalid parameter value is passed to a method:  ArgumentException, ArgumentNullException, ArgumentOutOfRangeException  When requested operation is not supported  NotSupportedException  When a method is still not implemented  NotImplementedException  If no suitable standard exception class is available  Create own exception class (inherit Exception ) Choosing the Exception Type

28 Using Try-Finally Blocks

29 29  The statement:  Ensures execution of given block in all cases  When exception is raised or not in the try block  Used for execution of cleaning-up code, e.g. releasing resources The try-finally Statement try{ // Do some work that can cause an exception // Do some work that can cause an exception}finally{ // This block will always execute // This block will always execute}

30 30 try-finally – Example static void TestTryFinally() { Console.WriteLine("Code executed before try-finally."); Console.WriteLine("Code executed before try-finally."); try try { string str = Console.ReadLine(); string str = Console.ReadLine(); int.Parse(str); int.Parse(str); Console.WriteLine("Parsing was successful."); Console.WriteLine("Parsing was successful."); return; // Exit from the current method return; // Exit from the current method } catch (FormatException) catch (FormatException) { Console.WriteLine("Parsing failed!"); Console.WriteLine("Parsing failed!"); } finally finally { Console.WriteLine("This cleanup code is always executed."); Console.WriteLine("This cleanup code is always executed."); } Console.WriteLine("This code is after the try-finally block."); Console.WriteLine("This code is after the try-finally block.");}

31 31  In programming we often use the "Dispose" pattern  It ensures that resources are always closed properly  The same can be achieved by the " using " keyword in C#: The "using" Statement using ( ) { // Use the resource. It will be disposed (closed) at the end // Use the resource. It will be disposed (closed) at the end} Resource resource = AllocateResource(); try { // Use the resource here … // Use the resource here … } finally { if (resource != null) resource.Dispose(); if (resource != null) resource.Dispose();}

32 Try-Finally Live Demo

33 33  Read and display a text file line by line: Reading a Text File – Example StreamReader reader = new StreamReader("somefile.txt"); using (reader) { int lineNumber = 0; int lineNumber = 0; string line = reader.ReadLine(); string line = reader.ReadLine(); while (line != null) while (line != null) { lineNumber++; lineNumber++; Console.WriteLine("Line {0}: {1}", lineNumber, line); Console.WriteLine("Line {0}: {1}", lineNumber, line); line = reader.ReadLine(); line = reader.ReadLine(); }}

34 Reading a Text File Live Demo

35 Exceptions: Best Practices

36 36  catch blocks should begin with the exceptions lowest in the hierarchy  And continue with the more general exceptions  Otherwise a compilation error will occur  Each catch block should handle only these exceptions which it expects  If a method is not competent to handle an exception, it should leave it unhandled  Handling all exceptions disregarding their type is a popular bad practice (anti-pattern)! Exceptions – Best Practices

37 37  When raising an exception always pass to the constructor good explanation message  When throwing an exception always pass a good description of the problem  The exception message should explain what causes the problem and how to solve it  Good: "Size should be integer in range [1…15]"  Good: "Invalid state. First call Initialize()"  Bad: "Unexpected error"  Bad: "Invalid argument" Exceptions – Best Practices (2)

38 38  Exceptions can decrease the application performance  Throw exceptions only in situations which are really exceptional and should be handled  Do not throw exceptions in the normal program control flow  CLR could throw exceptions at any time with no way to predict them  E.g. System.OutOfMemoryException Exceptions – Best Practices (3)

39 39  Custom exceptions inherit an exception class (commonly System.Exception )  Are thrown just like any other exception Creating Custom Exceptions public class TankException : Exception { public TankException(string msg) public TankException(string msg) : base(msg) : base(msg) { }} throw new TankException("Not enough fuel to travel");

40 40  Exceptions provide a flexible error handling mechanism  Allow errors to be handled at multiple levels  Each exception handler processes only errors of a particular type (and its child types)  Other types of errors are processed by some other handlers later  Unhandled exceptions cause error messages  Try-finally ensures given code block is always executed (even when an exception is thrown) Summary

41 ? ? ? ? ? ? ? ? ? OOP – Exception Handling httpshttps://softuni.bg/courses/oop/

42 License  This course (slides, examples, demos, videos, homework, etc.) is licensed under the "Creative Commons Attribution- NonCommercial-ShareAlike 4.0 International" licenseCreative Commons Attribution- NonCommercial-ShareAlike 4.0 International 42  Attribution: this work may contain portions from  "OOP" course by Telerik Academy under CC-BY-NC-SA licenseOOPCC-BY-NC-SA

43 Free Trainings @ Software University  Software University Foundation – softuni.orgsoftuni.org  Software University – High-Quality Education, Profession and Job for Software Developers  softuni.bg softuni.bg  Software University @ Facebook  facebook.com/SoftwareUniversity facebook.com/SoftwareUniversity  Software University @ YouTube  youtube.com/SoftwareUniversity youtube.com/SoftwareUniversity  Software University Forums – forum.softuni.bgforum.softuni.bg


Download ppt "Exception Handling Handling Errors During the Program Execution SoftUni Team Technical Trainers Software University"

Similar presentations


Ads by Google