Error Handling. Exceptions

Size: px

Start display at page:

Download "Error Handling. Exceptions"

Stephanie Black
6 years ago
Views:

1 Error Handling Exceptions Error Handling in.net Old way (Win32 API and COM): MyFunction() error_1 = dosomething(); if (error_1) display error else continue processing if (error_2) display error else continue processing How is Error Handled in.net? It uses Exceptions Exception handling enables programmers to remove error-handling code from the main line of the program s execution. Examples: Without exceptions: DivideByZeroNoExceptionHandling.cs With exceptions: DivideByZeroTest.sln Syntax try // code that requires common cleanup or // exception-recovery operations catch (InvalidOperationException) //code that recovers from an InvalidOperationException // (or any exception type derived from it) catch (SomeOtherException) // code that recovers from an SomeOtherException // (or any exception type derived from it) catch // code that recovers from any kind of exception // when you catch any exception, you usually re-throw throw; finally // code that cleans up any operations started // within the try block. This code ALWAYS executes. try block A try block contains code that requires common cleanup or exception-recovery operations. The cleanup code should be put in a single finally block. The exception recovery code should be put in one or more catch blocks. Create one catchblock for each kind of type you want to handle. A try block must have at least one catchor finally block. catch block A catchblock contains code to execute in response to an exception. If the code in a try block doesn t cause an exception to be thrown, the CLR will never execute the code in any of its catch blocks. You may or may not specify a catch type in parantheses after catch: The catch type must be of type System.Exception or a type that derived from System.Exception If there is no catch type specified, that catch block handles any exception. This is equivalent to having a catch block that specifies System.Exception as a catch type. CLR searches for a matching catch type from top to bottom. If CLR cannot find any catch type that matches the exception, CLR continues searching up the callstack to find a catch type.

2 catch block Once the catchblock that matches the exception is found, you have 3 choices: 1. Re-throw the same exception, notifying the higher-up call stack of the exception 2. Throw a different exception, giving richer exception information to code higher-up in the call stack 3. Let the code continue from the bottom of the catch block In choices 1-2, an exception is thrown and code starts looking for a catch block whose type matches the exception thrown In choice 3, the finally block is executed You can also specify a variable name like catch(exception e)to access information specific to the exception. finally block The CLR does not completely eliminate memory leaks. Why? Even though GC does automatic memory clean-up, it only cleans up if there are no references kept on the object. Even then there may be a delay until the memory is required. Thus, memory leaks can occur if programmers inadvertently keep references to unwanted objects. C# provides the finallyblock, which is guaranteed to execute regardless of whether an exception occurs. If the try block executes without throwing, the finally block executes. If the tryblock throws an exception, the finallyblock still executes regardless of whether the exception is caught. This makes the finallyblock ideal to release resources from the corresponding try block. Example: UsingExceptions.cs finally block Local variables in a tryblock cannot be accessed in the corresponding finallyblock, so variables that must be accessed in both should be declared before the tryblock. Placing the finallyblock before a catchblock is a syntax error. A tryblock does not require a finallyblock, sometimes no clean-up is needed. A tryblock can have no more than one finallyblock. Avoid putting code that might throw in a finally block. Exception handling will still work but the CLR will not keep theinformation about the first exception just thrown in the corresponding try block. using The usingstatement simplifies writing code in which you obtain a resource. The general form of a usingstatement is: using ( ExampleObject e = new ExampleObject() ) e.somemethod(); This using statement code is equivalent to: ExampleObject e = new ExampleObject(); try e.somemethod(); finally if ( e!= null ) ( ( IDisposable ) e ).Dispose(); System.Exception In.NET, only objects of class Exceptionand its derived classes may be thrown and caught. Exceptions thrown in other.net languages can be caught with the general catch clause. Class Exceptionis the base class of.net s exception class hierarchy. A catchblock can use a base-class type to catch a hierarchy of related exceptions. A catchblock that specifies a parameter of type Exception can catch all exceptions. System.Exception Properties Class Exception s properties are used to formulate error messages indicating a caught exception. Property Messagestores the error message associated with an Exception object. Property StackTrace contains a string that represents the methodcall stack. When an exception occurs, a programmer might use a different error message or indicate a new exception type. The original exception object is stored in the InnerException property. Other properties: HelpLinkspecifies the location of a help file that describes the problem. Sourcespecifies the name of the application or object that caused the exception. TargetSitespecifies the method where the exception originated.

Common.NET Exceptions The CLR generates SystemExceptions, derived from class Exception, which can occur at any point during program execution.

3 Common.NET Exceptions The CLR generates SystemExceptions, derived from class Exception, which can occur at any point during program execution. If a program attempts to access an out-of-range array index, the CLR throws an exception of type IndexOutOfRangeException. Attempting to use a nullreference causes a NullReferenceException. FCL-Defined Exceptions System.Exception System.ApplicationException System.SystemException System.AccessViolationException System.ArgumentException System.ArgumentNullException System.ArgumentOutOfRangeException System.FormatException System.IndexOutOfRangeException System.InvalidCastException System.IO.IOException System.IO.FileNotFoundException System.NotImplementedException System.NullReferenceException System.OutOfMemoryException Determining Which Exceptions a FCL Method Throws Example:Convert.ToInt32 Search for Convert.ToInt32 in the Indexof the Visual Studio online documentation. Select the document entitled Convert.ToInt32 Method. In the document that describes the method, click the link ToInt32(String). The Exceptionssection indicates that method Convert.ToInt32 throws two exception types. What are Exceptions? They are not an exceptional event, a rare event that occurs. They are not just errors. They are specific results returned when a method could not complete its task. Example: when should Transfer throw? public class Account public void Transfer(Account from, Account to, decimal amount) When the Transfer method detects any of such possible conditions and cannot transfer the money, then it should notify the caller that it failed by throwing an exception. Choosing the Exception to throw When implementing your own methods, you should throw an exception when the method cannot complete its task. Associating each type of malfunction with an appropriately named exception class improves program clarity. 1. What Exception-derived type are you going to throw? You must select a meaningful type You can select a type defined in FCL that matches your semantics If not, you may need to define your own type Your exception type hierarchy should be shallow and wide: that is, create as few base classes as possible 2. What string message are you going to pass to the exception type s constructor? If the exception is handled, no one will see this exception message. If the exception is unhandled, then the code will probably log this message and a developer would want to understand what went wrong using this message. So the message should give enough detail as possible. Message does not need to be localized. User-Defined Exceptions User-defined exception classesshould derive directly or indirectly from class Exception of namespace System. Exceptions should be documented so that other developers will know how to handle them. User-defined exceptions should define three constructors: a parameterless constructor a constructor that receives a string argument (the error message) a constructor that receives a string argument and an Exception argument (the error message and the inner exception object)

4 User-Defined Exception Example SquareRootTest Benefits of Exceptions The ability to keep cleanup code in a dedicated location and making sure this cleanup code will execute The ability to keep code that deals with exceptional situations in a central place The ability to locate and fix bugs in the code Unified error handling: all.net Framework classes throw exceptions to handle error cases Old Win32 APIs and COM returns a 32-bit error code. Exceptions include a string description of the problem. Exceptions also include a stack trace that tells you the path application took until the error occurred. You can also put any information you want in a user-defined exception of your own. The caller could ignore the error returned by a Win32 API, now the caller cannot continue with exceptions. If the application cannot handle the exception, CLR can terminate the application. Pass by Reference Parameters The parameters we have seen so far are value parameters their arguments are passed by value if you change the value of a parameter in function, corresponding argument does NOT change in the caller function Let s see an example: PassByRef.cs. Pass by Reference (ref & out) Pass by reference: ref Need to assign an initial value to the parameter out No need to assign an initial value to the parameter static void FunctionOutRef(ref int c, out int d) d = c + 1; c = c + 1; static void Main(string[] args) int num3 = 5, num4; FunctionOutRef(ref num3, out num4); Underlying Mechanisms For valueparameters, the arguments values are copied into parameters arguments and parameters have different memory locations double Average (int 10 a, 15 int b) copy value copy value Underlying Mechanisms For referenceparameters, the parameter and the argument share the same memory location parameter is an alias of argument double average (ref int a, int b) 15 refers to the same memory location copy value main function Average(num1, num2) main function average(ref num1, num2)

5 Example: Swap Write a function that swaps the values of its two integer parameters Example: Swap void swap(ref int a, ref int b) int temp; temp = a; a = b; b = temp; How do we use this in main? int a=5, b=8; swap(ref a, ref b); // a becomes 8, b becomes 5 swap(ref a, ref 5); // syntax error, arguments must be variables Passing Arrays as Parameters To pass an array argument to a method, specify the name of the array without any brackets. For a method to receive an array reference through a method call, the method s parameter list must specify an array parameter. When an argument to a method is an entire array or an individual array element of a reference type, the called method receives a copy of the reference. When an argument to a method is an individual array element of a value type, the called method receives a copy of the element s value. To pass an individual array element to a method, use the indexed name of the array as an argument in the method call. Example: ArrayReferenceTest.cs const Sometimes very useful provides self documentation re-use the same value across the class or program avoid accidental value changes Like variables, but their value is assigned at declaration and can never change afterwards declared by using const before the type name (any type is OK) public const double PI = ; const int LENGTH = 6; later you can use their value Console.WriteLine(MathClass.PI * 4 * 4); but cannot change their value MathClass.PI = 3.14; causes a syntax error const Cannot use const with reference types. Exception: string public const string CLASSNAME = IT 528 ; readonly constis set at compile time readonly is set at runtime readonlycan be used for reference types as well Constructor can set readonlyfields but not any other methods public class GradeBook private readonly string coursename = ; public GradeBook(string name) coursename = name;

6 struct (structure) structis very similar to a class Like classes, struct s can have methods and properties with access modifiers. Struct members are accessed via (.) operator similarly. So they are almost the same with one difference: Classis a referencetype whereas structis a valuetype. Example: mystruct.cs

12/14/2016. Errors. Debugging and Error Handling. Run-Time Errors. Debugging in C# Debugging in C# (continued)

12/14/2016. Errors. Debugging and Error Handling. Run-Time Errors. Debugging in C# Debugging in C# (continued) Debugging and Error Handling Debugging methods available in the ID Error-handling techniques available in C# Errors Visual Studio IDE reports errors as soon as it is able to detect a problem Error message