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