Download presentation
Presentation is loading. Please wait.
1
Exceptions and Object Lifetime
Chapter - 5 Exceptions and Object Lifetime
2
Chapter Objectives What is an Exception? – basics
System.Exception Class Catching an Exception System Level Exceptions Building Customized Exceptions Multiple Exceptions Garbage Collection - basics What is "finally"? Building Finallizable and Disposable Types
3
Introduction An exception is any error condition or unexpected behavior encountered by an executing program. These are run time anomalies. In the .NET Framework, an exception is an object that inherits from the System.Exception class An exception is thrown from an area of code where a problem has occurred .NET base class libraries define: OutOfMemoryException, IndexOutOfRangeException, FileNotFoundException, and so on
4
.NET Exceptions A type that represents the details of the exceptional circumstance A method that throws the exception to the caller A block of code that will invoke the exception-ready method A block of code that will process or catch the exception
5
.NET Exceptions … The CLR supports an exception handling model based on the concepts of exception objects and protected blocks of code The runtime creates an object to represent an exception when it occurs. You can also create your own exception classes by deriving classes from the appropriate base exception Each language uses a form of try/catch/finally structured exception handling
6
Why Exceptions? Code that uses exceptions are clearer and more robust than other methods bool RemoveFromAccount(string AcctID, decimal Amount) { bool Exists = VerifyAmount(AcctID); if (Exists) bool CanWithDraw = CheckAv(AcctID, Amount); if (CanWithDraw) { return WithDraw(AcctID, Amount); } } return false;
7
Disadvantages of Traditional Methods
Code that depends on return value – must provide additional error parameters or call other functions (e.g. Win32 API) Returning error code – must be handled properly Error codes are difficult to extend and update. The entire source code must be updated for any new error codes C# uses rich Exception object which contains info about failure condition
8
Handling Exceptions To handle an exception you must protect with a try block and have at least one catch block try { Employee e; e.GiveBonus(); // null reference } catch // Handle any exception
9
How Exceptions are Executed?
To catch an exception the try-catch block must be used A try block is a section of the code that looks for an exception When an exception is raised, or thrown, within a try block, an exception object is created and a search begins in the catch block When an exception occurs within that scope, the control goes to the appropriate catch block (handler) If no exception occurs, obviously the catch block is never executed After the catch block code is executed the rest of the code in the program continues (is it OK?) Catch block can also rethrow the exception
10
Catching Specific Exceptions
try { Employee e; e.GiveBonus(); // null reference } catch (NullReferenceException ex) // Log the error throw(ex); If the catch block can recover from the error that caused the exception, execution can continue after catch block. If it can't, then it must rethrow (shown in red color). If an exception is rethrown, the next catch block will be checked. The check may continue in the call stack until a proper handler is found. If none found, terminate!
11
throw statement The throw statement is used to signal the occurrence of an anomalous situation /exception and to send the error object back to the caller (raising an exception) throw [expression]; expression is an exception object Usually the throw statement is used with try-catch or try-finally statements. When an exception is thrown, the program looks for the catch statement that handles this exception
12
The following exception occurs: System.ArgumentNullException
Example (throw) using System; public class ThrowTest { public static void Main() string s = null; if (s == null) throw(new ArgumentNullException()); } // not executed Console.Write("The string s is null"); Output: The following exception occurs: System.ArgumentNullException
13
Example (try - catch) using System; class AddInts {
static void Main(string[] args) int a, b; int c, d = 0; Console.Write("Enter the first number (a): "); a = System.Int32.Parse(Console.ReadLine()); Console.Write("Enter the second number (b): "); b = System.Int32.Parse(Console.ReadLine()); c = a + b;
14
Console.WriteLine("Method: {0}", e.TargetSite);
try { d = a / b; } catch(Exception e) Console.WriteLine("Method: {0}", e.TargetSite); Console.WriteLine("Message: {0}", e.Message); Console.WriteLine("Source: {0}", e.Source); return; Console.WriteLine("a + b = {0}", c); Console.WriteLine("a / b = {0}", d); Enter the first number (a): 28 Enter the second number (b): 0 Method: Void Main(System.String[]) //which method threw the exception Message: Attempted to divide by zero. Source: AddInts
15
System.Exception Base Class
Most of the memebers defined by System.Exception are read-only Property Meaning HelpLink URL to a help file InnerException details of previous exceptions that caused the current exception Message returns the text describing the error Source name of the assembly that threw the exception StackTrace sequence of calls that triggered the exception TargetSite returns the MethodBase type
16
Example-2 : StackTrace StackTrace: Displays sequence of calls that resulted in throwing the exception. We can follow the flow of the error's origin catch(Exception e) { Console.WriteLine("Stack: {0}",e.StackTrace); }
17
Example-3 : HelpLink try {
// create a new Exception object, passing a string Exception myException = new Exception("myException"); // set the HelpLink and Source properties myException.HelpLink = "See the Readme.txt file"; myException.Source = "My HelpLink Program"; // throw the Exception object throw myException; } catch (Exception e) // display the exception object's properties Console.WriteLine("HelpLink = " + e.HelpLink); Console.WriteLine("Source = " + e.Source); HelpLink = See the Readme.txt file Source = My HelpLink
18
Building Custom Exceptions
Though the System level exceptions are useful, sometimes it is necessary to build user defined exceptions Define a new user defined class derived from System.Exception You may override any virtual members defined in the parent class
19
۩ Square Root using System; namespace CustomException {
class NegNumException : ApplicationException public NegNumException() : base("SNG: Negative Number Exception") { } public NegNumException(string msg) : base(msg) public NegNumException(string msg, Exception inner) : base(msg, inner) }
20
Square Root… class CustomException { public double SqRoot(double n)
if (n < 0) // calls 1-arg ctor. // throw new NegNumException ("SNG: Negative Number not allowed"); // calls default ctor. throw new NegNumException(); return Math.Sqrt(n); }
21
Square Root… public void SqRootTest() { double n; try
Console.Write("Enter a number: "); n = System.Double.Parse(Console.ReadLine()); double result = SqRoot(n); Console.WriteLine("Sq Root = {0}", result); } catch(FormatException ex) Console.WriteLine(ex.Message); catch(NegNumException ex)
22
Square Root… static void Main(string[] args) {
CustomException e = new CustomException(); e.SqRootTest(); }
23
Multiple Exceptions The code in the try block may trigger more than one exception. Under these circumstances you can have more than one catch block Exception will be processed by the nearest available catch block (Below example is wrong!) Ex: try { … } catch (Exception e) {…} catch (NegNumException e) {…} catch (ArgumentOutOfRangeException e) {…} Unreachable
24
Other types of Exception Handling
Generic catch try {…} catch { … } Rethrowing Exceptions catch (NegNumException e) { // handle the error and pass the buck throw e; } The finally Block - The optional finally block will get executed always - Useful for cleaning up process or close the database files No argument rethrow the same exception
25
When the application shuts down, object c may be destroyed.
Garbage Collection C# Programmers never directly deallocate an object from memory – so no 'delete' keyword Rule: Allocate an object on to a managed heap using 'new' and forget about it! How does .NET determine that an object is no longer needed? When it is unreachable by the current application Example: public static int Main(string[] args) { Car c = new Car( ); …. } When the application shuts down, object c may be destroyed.
26
Garbage Collector CIL emits newobj for new
.NET garbage collector maintains a new object pointer which indicates where the next object should be placed in the heap Assume c1, c2, and c3 are objects of type Car c3 c2 c1 Unused heap next object pointer
27
Garbage Collector… If the managed heap does not have enough memory, CLR does garbage collection. It frees the memory to accommodate the new object Which object memory is to be removed – "no longer needed" basis Objects that have been recently allocated are most likely to be freed Objects that have lived the longest are least likely to be become free Objects allocated together will be used together To get this idea CLR uses an object graph to know whether the objects are still in use. The other objects which are no longer used – "severed roots" or unreachable objects are reclaimed and the memory is compacted with necessary object pointer adjustment
28
Garbage Collector… The Garbage Collector in .NET is known as generational garbage collector. Allocated objects are sorted into three groups or generations: generation 0: objects allocated most recently generation 1: Objects that survive a garbage collection pass are moved into generation 1 generation 2: Objects that survive in generation 1 are moved into generation 2 If no memory is available after compaction, an OutOfMemoryException is thrown
29
Finalizing a Type The garbage collection process is nondeterministic
To release the memory in a timely manner, one possible solution is to override System.Object.Finalize() method. We go for this only when C# types are using unmanaged types (Win32 APIs) Unmanaged resources: database connections and GDI Note that you can't override this method directly: public class FinalizedCar { protected override void Finalize() { } // Wrong } protected void Finalize() // don't expose this method base.Finalize(); Do not define both a destructor and Finalize method in the same class
30
Indirectly Invoking Finalize()
When an Application domain is unloaded by CLR, the Finalize() method is invoked for all finalizable objects class FinalizedCar { ~FinalizedCar() { Console.WriteLine("Finalizing"); } // 3 class FinalizeApp static void Main(string[] args) Console.WriteLine("Object creation"); // 1 FinalizedCar fc = new FinalizedCar(); Console.WriteLine("Exiting Main"); // 2 } Instead of using a finalizer (because it is costly), you can expose the Dispose() method
31
Dispose with using With the presence of the using statement, which opens a scope at the end of which a given object will be disposed, regardless of whether the scope is exited normally or via an exception. using( Pen myPen = new Pen(Color.Red) ) { // Do stuff with myPen } When objects are of the same type, you may put them all inside the same using statement: using( Pen myRedPen = new Pen(Color.Red), myBluePen = new Pen(Color.Blue) ) // Do stuff with both pens
32
Dispose with using For instance, you'll need a Font and a Brush if you want to use the Graphics.DrawString method to paint some text. Unfortunately, here's where the using statement starts to break down, because the following code generates a compile error: using( Font myFont = new Font("Arial", 16), SolidBrush myBrush = new SolidBrush(Color.Blue) ) { // COMPILE ERROR! } That snippet doesn't compile because C# doesn't let you have more than one type in a single using statement. So, your next alternative is to nest using statements like this: using( Font myFont = new Font("Arial", 16) ) using( SolidBrush myBrush = new SolidBrush(Color.Blue) ) // Do stuff with a font and a brush
33
Dispose with using But use of more than a couple of levels of nesting, and your code gets ugly pretty quickly Hence, we must search for a better solution………………..
34
Implementing IDisposable
Creating and properly disposing of an object requires several lines of correctly written code. C# provides an automated solution based on IDispose interface IDispose interface provided in .NET is for symmetry among all objects that supports an explicit destruction
35
IDispose Implementation Flow
36
Implementing IDisposable…
public class MyClass : IDisposable { public void Dispose() Console.WriteLine("Custom cleaning process"); } public class IDisposeApp public static void Main(string[] args) MyClass m = new MyClass(); m.Dispose();
37
Example public class ClassBeingTested : IDisposable {
private bool disposed=false; private Image img=null; public Image Image get {return img;} } // the constructor public ClassBeingTested() Trace.WriteLine("ClassBeingTested: Constructor"); // the destructor ~ClassBeingTested() Trace.WriteLine("ClassBeingTested: Destructor"); // call Dispose with false. Since we're in the // destructor call, the managed resources will be // disposed of anyways. Dispose(false);
38
{ } public void Dispose()
Trace.WriteLine("ClassBeingTested: Dispose"); // dispose of the managed and unmanaged resources Dispose(true); // tell the GC that the Finalize process no longer needs // to be run for this object. GC.SuppressFinalize(this); }
39
protected virtual void Dispose(bool disposeManagedResources)
{ // process only if mananged and unmanaged resources have not been disposed of. if (!this.disposed) Trace.WriteLine("ClassBeingTested: Resources not disposed"); if (disposeManagedResources) Trace.WriteLine("ClassBeingTested: Disposing managed resources"); // dispose managed resources if (img != null) img.Dispose(); img=null; } // dispose unmanaged resources Trace.WriteLine("ClassBeingTested: Disposing unmanaged resouces"); disposed=true; else Trace.WriteLine("ClassBeingTested: Resources already disposed");
40
End of Chapter - 5 For more details on IDispose implementation, please refer to: C# How to Program by DEITEL & DEITEL
Similar presentations
© 2025 SlidePlayer.com Inc.
All rights reserved.