#1session# Day 1.3.2

C#
Session 19
Exception Handling
AAIE - RU
Objectives
Define and describe exceptions
Explain the process of throwing and catching
exceptions
Explain nested try and multiple catch blocks
Define and describe custom exceptions
AAIE - RU
2
Purpose 1-2
Exceptions are abnormal events that prevent
a certain task from being completed
successfully.
Building Applications
Using C# / Session 11
AAIE - RU
3
Purpose 2-2
Example
Consider a vehicle that
halts abruptly due to
some problem in the
engine.
Until this problem is
sorted out, the vehicle
may not move ahead.
Similarly, in C#,
exceptions disrupt the
normal flow of the
program.
AAIE - RU
4
Exceptions in C#
Consider a C# application that is currently being
executed.
Assume that at some point of time, the CLR discovers
that it does not have the read permission to read a
particular file.
The CLR immediately stops further processing of the
program and terminates its execution abruptly.
To avoid this from happening, you can use the
exception handling features of C#.
AAIE - RU
5
Types of Exceptions
statements. in C#
C# can handle different types of exceptions using exception handling
It allows you to handle basically two kinds of exceptions. These are as

follows:
System-level Exceptions: These are the exceptions thrown by the system
that are thrown by the CLR.
For example, exceptions thrown due to failure in database connection or
network connection are system-level exceptions.

Application-level Exceptions: These are thrown by user-created
applications.
For example, exceptions thrown due to arithmetic operations or
referencing any null object are application-level exceptions.
Building
The following figure displays Applications
the types of exceptions in C#:
AAIE - RU
6
Properties of the Exception Class
System.Exception:
Is the base class that allows you to handle all exceptions in
C#.

Is inherited by all exceptions in C# either directly or
indirectly.

Contains public and protected methods that can be
inherited by other exception classes and also contains
properties that are common to all exceptions.
The following table describes the properties of

Properties
Exception class: Descriptions
Message
Displays a message which indicates the reason for the
exception.
Source Provides the name of the application or the object that
caused the exception.
StackTrace Provides exception details on the stack at the time the
exception was thrown.
InnerException Returns the Exception instance that caused the current
exception.
AAIE - RU
7
Commonly Used Exception
Classes class has a number of derived
The System.Exception
exception classes to handle different types of
exceptions.
The hierarchy shown in the following figure displays
the different exception classes in the System
namespace:
AAIE - RU
8
Exception Classes 1-
2
The System namespace contains the different exception
classes that C# provides the type of exception to be
handled depends on the specified exception class.
The following table lists some of the commonly used
exception classes:
Exceptions Descriptions
This exception is thrown for problems that occur
System.ArithmeticException due to arithmetic or casting and conversion
operations.
This exception is thrown when one of the
System.ArgumentException arguments does not match the parameter
specifications of the invoked method.
This exception is thrown when an attempt is made
Building
System.ArrayTypeMismatchException to storeApplications
data in an array whose type is
Using C# / Session
incompatible 11type of the array.
with the
System.DivideByZeroException
to divide a numeric value by zero.
System.IndexOutOfRangeException to store data in an array using an index that is less
than zero or outside the upper bound of the array.
This exception is thrown when an explicit
System.InvalidCastException conversion from the base type or interface type to
another type fails.
This exception is thrown when a null reference is
AAIE - RU
System.ArgumentNullException passed to an argument of a method that does not
9
Exception Classes 2-
The following2table lists additional exception
classes:
Exceptions Descriptions
System.NullReferenceException This exception is thrown when you try to assign a value
to a null object.
System.OutOfMemoryException This exception is thrown when there is not enough
memory to allocate to an object.
System.OverflowException This exception is thrown when the result of an
arithmetic, casting, or conversion operation is too large
to be stored in the destination object or variable.
System.StackOverflowException This exception is thrown when the stack runs out of
space due to having too many pending method calls.
System.Data.DataException This exception is thrown when errors are generated
while using the ADO.NET components.
System.FormatException This exception is thrown when the format of an
argument does not match the format of the parameter
data type of the invoked method.
System.IO.IOException This exception is thrown when any I/O error occurs
while accessing information using streams, files, and
directories.
AAIE - RU
10
InvalidCastException Class 1-
2
The InvalidCastException exception is thrown when an
explicit conversion from a base type to another type fails.
The following code demonstrates the InvalidCastException
exception:
using System;
class InvalidCastError
{
static void Main(string[] args)
{
try
{ Building Applications
Snippet float numOne = 3.14F;
Using
Object objC#= / numOne;
Session 11
int result = (int)obj;
Console.WriteLine("Value of numOne =
{0}", result);
}
catch(InvalidCastException objEx)
{
Console.WriteLine("Message : {0}",
objEx.Message);
Console.WriteLine("Error : {0}", objEx);
} AAIE - RU
catch (Exception objEx) 11
InvalidCastException Class 2-
In the code: 2

A variable numOne is defined as float. When this variable is
boxed, it is converted to type object.
However, when it is unboxed, it causes an
InvalidCastException and displays a message for the same.

This is because a value of type float is unboxed to type int,
which is not allowed in C#.
The figure displays the exception that is generated
when the program is executed.
AAIE - RU
12

ArrayTypeMismatchE
The ArrayTypeMismatchException exception is thrown when
xception Class 1-2
the data type of the value being stored is incompatible with
the data type of the array.
The following code demonstrates the
ArrayTypeMismatchException exception:
using System;
Snippet class ArrayMisMatch

{
{
string[] names = { "James", "Jack", "Peter" };
int[] id = { 10, 11, 12 };
double[] salary = { 1000, 2000, 3000 };
float[] bonus = new float[3];
try Building Applications

{
salary.CopyTo(bonus, 0);
}
catch (ArrayTypeMismatchException objType)
{
Console.WriteLine("Error: " + objType);
}
catch (Exception objEx)
{
Console.WriteLine("Error: " + objEx);
}
}
}
AAIE - RU
13
In the code:
ArrayTypeMismatchE
array is of double dataClass
The salary xception type and the2-2
bonus
array is of float data type.

When copying the values stored in salary array to bonus
array using the CopyTo() method, data type mismatch
occurs.
The following table displays the exception that is
generated when the program is executed:
Figure 11.4: ArrayTypeMismatchException

Generated at Runtime
AAIE - RU
14

NullReferenceExcep
The NullReferenceException exception is thrown when an attempt is made
tion Class 1-2

to operate on a null reference as shown in the following code:
using System;
Snippet class Employee

{
private string _empName;
private int _empID;
public Employee()
{
_empName = "David";
_empID = 101;
}
{
Employee objEmployee = new Employee();
Employee objEmp = objEmployee;
objEmployee = null;
try
Console.WriteLine("Employee Name: " +
objEmployee._empName);
Console.WriteLine("Employee ID: " +
objEmployee._empID);
}
catch (NullReferenceException objNull)
{
Console.WriteLine("Error: " + objNull);
}
{
Console.WriteLine("Error: " + objEx);
}
}
} AAIE - RU
15
In the code:
NullReferenceExcep

tion
A class Employee Class
is defined 2-2
which contains the details
of an employee. Two instances of class Employee are
created with the second instance referencing the first.

The first instance is de-referenced using null. If the first
instance is used to print the values of the Employee
class, a NullReferenceException exception is thrown,
which is caught by the catch block.
The figure displays the exception that is
generated when theBuilding
program is executed.
Applications
AAIE - RU
16
System.Exception
Class 1-5
System.Exception is the base class that handles all exceptions
and contains public and protected methods that can be
inherited by other exception classes.
The following table lists the public methods of the
System.Exception class and their corresponding description:
Method Description
Equals Determines whether objects are equal
GetBaseException Returns a type of Exception class when overridden in a
derived class
GetHashCode Returns a hash function for a particular type
GetObjectData Stores information
Using C# /about serializing
Session 11 or deserializing a
particular object with information about the exception
when overridden in the inheriting class
GetType Retrieves the type of the current instance
ToString Returns a string representation of the thrown exception
AAIE - RU
17
System.Exception
System.ExceptionClass
class: 2-5
The following code demonstrates some public methods of the
using System;
Snippet class ExceptionMethods
{
{
byte numOne = 200;
byte numTwo = 5;
byte result = 0;
try
{
result = checked((byte)(numOne * numTwo));
Console.WriteLine("Result = {0}", result);
}
Console.WriteLine("Error Description : {0}",
objEx.ToString());
Console.WriteLine("Exception : {0}", objEx.GetType());
}
In the code: }
}
The arithmetic overflow occurs because the result of
multiplication of two byte numbers exceeds the range of the
data type of the destination variable, result.
The arithmetic overflow exception is thrown and it is caught by
the catch block. The block uses the ToString() method to
AAIE - RU
retrieve the string representation of the exception.
18
System.Exception
Class
The following table lists the 3-5
protected methods of the class and
their corresponding descriptions:
Name Description
Finalize Allows objects to perform cleanup operations before they
are reclaimed by the garbage collector
MemberwiseClone Creates a copy of the current object
In the following table lists the commonly used public properties in the
class:
Public Property Description
HelpLink Retrieves or sets a link to the help file associated with the
exception
InnerException Retrieves the reference of the object of type Exception that
caused the thrown exception
Message Retrieves the description of the current exception
Source Retrieves or sets the name of the application or the object
that resulted in the error
StackTrace Retrieves a string of the frames on the stack when an
exception is thrown
TargetSite Retrieves the method that throws the exception
AAIE - RU
19
System.Exception
Class
System.Exception class.
using System;
4-5
The code demonstrates the use of some of the public properties of the
Snippet class ExceptionProperties

{
{
byte numOne = 200;
byte numTwo = 5;
byte result = 0;
try Building Applications
{ Using C# / Session 11
result = checked((byte)(numOne *
numTwo));
Console.WriteLine("Result = {0}",
result);
}
catch (OverflowException objEx)
{
Console.WriteLine("Message
AAIE - RU : {0}",
20
System.Exception
In the code: Class 5-5
The arithmetic overflow occurs because the result of
multiplication of two byte numbers exceeds the range of
the destination variable type, result.
The arithmetic overflow exception is thrown and it is
caught by the catch block.
The block uses various properties of the System.Exception
class to display the source and target site of the error.
The following figure displays use of some of the

public properties of the
System.Exception class:
AAIE - RU
21
Throwing and
An exceptionCatching Exceptions
is an error that occurs during program
execution.
An exception arises when an operation cannot be
completed normally. In such situations, the system
throws an error.
AAIE - RU
The error is handled through the process of 22
Purpose of Exception
Example Handlers
Consider a group of boys playing
throwball.
If any of the boys fail to catch the
ball when thrown, the game is
terminated.
Thus, the game goes on till the
boys are successful Building
in catching
Applications
the ball on time. Using C# / Session 11
Similarly, in C#, exceptions that
occur while working on a
particular program need to be
caught by exception handlers.
If the program does not contain
the appropriate exception handler,
AAIE - RU
then the program might be 23
Catching Exceptions
1-3
Exception handling is implemented using the try-
catch construct in C# that consists of the following
two blocks:
It encloses statements that might
generate exceptions.
When these exceptions are thrown, the
The try block required actions are performed using
the catch block.
It consists of the appropriate error-handlers
that handle exceptions.
If the catch block does not contain any
parameter, it can catch any type of
The catch block exception.
The catch block follows the try block and
may or may not contain parameters.
If the catch block contains a parameter, it
catches the type of exception specified by the
parameter.
AAIE - RU
24
Catching Exceptions
The following 2-3
syntax is used for handling errors using the
try and catch blocks:
Syntax
try
{
// program code
}
catch[(<ExceptionClass><objException>)]
{
// error handling code
}
where,
Building
try: Specifies that the block enclosesApplications
statements that may throw exceptions.
program code: Are statementsUsing C#may
that / Session 11exceptions.
generate
catch: Specifies that the block encloses statements that catch exceptions
and carry out the appropriate actions.
ExceptionClass: Is the name of exception class. It is optional.
objException: Is an instance of the particular exception class. It can be
omitted if the ExceptionClass is omitted.
AAIE - RU
25
Catching Exceptions
3-3
The code demonstrates the use of try-catch blocks.
using System;
class DivisionError
{
Snippet static void Main(string[] args)

{
int numOne = 133;
int numTwo = 0;
int result;
try
{
result = numOne / numTwo;
}
catch (DivideByZeroException objDivide)
{
Console.WriteLine(Exception caught: + objDivide);
}
}
In the code:
}

The Main() method of theUsing C#DivisionError
class / Session 11 declares three
variables.
The try block contains the code to divide numOne by numTwo and
store the output in the result variable. As numTwo has a value of
zero, the try block throws an exception.
This exception is handled by the corresponding catch block, which
takes in objDivide as the instance of the DivideByZeroException
Output
class.
The exception is caught bythis
AAIE catch
- RU block and the appropriate
message is displayed as the output. 26
General catch Block
Following
block:
1-2
are the features of a general catch
However, the type of
exception that the
It can handle all types catch block handles
of exceptions. depends on the
specified exception
class.
You can create a

catch block with the A general catch block
base class Exception can handle all types
Building
that are referred to asApplications
of exceptions.
general catchUsing C# / Session 11
blocks.
However, one disadvantage of

the general catch block is that
there is no instance of the
exception and thus, you cannot
know what appropriate action
must be performed for handling
the exception.
AAIE - RU
27
General catch Block
declared:
Snippet
2-2
The following code demonstrates the way in which a general catch block is
using System;
class Students
{
string[] _names = { James, John, Alexander };
{
Students objStudents = new Students();
try
{
objStudents._names[4] = Michael;
}
catch (Exception objException)
{
Console.WriteLine(Error: + objException);
}
}
}
In the code:
A string array called names is initialized. In the try block, there is a
Building
statement trying to reference a Applications
fourth array element.
The array can store onlyUsing
threeC# / Session
values, 11 will cause an
so this
exception. The class Students consists of a general catch block
Output
declared with Exception and this catch block can handle any type
of exception.
Error: System.IndexOutOfRangeException: Index was outside the

bounds of the array at
AAIE - RU
Project_New.Exception_Handling.Students.Main(String[] args) in
28
The throw Statement
1-3
The throw statement in C# allows you to
programmatically throw exceptions using the throw
keyword.
When you throw an exception using the throw keyword,

the exception is handled by the catch block as shown in
the following syntax:
Syntax
throw exceptionObject;
where,
throw: Specifies that the exception is thrown
programmatically.
exceptionObject: Is an instance of a particular exception
class.
AAIE - RU
29
The throw Statement
Snippet
2-3
The following code demonstrates the use of the throw statement:
using System;
class Employee
{
static void ThrowException(string name)
{
if (name == null)
{
throw new ArgumentNullException();
}
}
static void Main(string [] args)
{
Console.WriteLine(Throw Example);
try
{
string empName = null;
ThrowException(empName);
}
catch (ArgumentNullException objNull)
{
Console.WriteLine(Exception caught: + objNull);
}
}
}
In the code: Using C# / Session 11
The class Employee declares a static method called ThrowException that
takes a string parameter called name.
If the value of name is null, the C# compiler throws the exception, which is
caught by the instance of the ArgumentNullException class.
In the try block, the value of name is null and the control of the program goes
back to the method ThrowException, where the exception is thrown for
referencing a null value.
The catch block consists of the error handler, which is executed when the
exception is thrown. AAIE - RU
30
The throw Statement
Output 3-3
Throw Example
Exception caught: System.ArgumentNullException: Value cannot be
null.
at Exception_Handling.Employee.ThrowException(String name) in
D:\Exception Handling\Employee.cs:
line 13
at Exception_Handling.Employee.Main(String[] args) in
D:\Exception Handling\Employee.cs:line 24
AAIE - RU
31
The finally
the catch block isStatement 1-2
In general, if any of the statements in the try block raises an exception,
executed and the rest of the statements in the try
block are ignored.
Sometimes, it becomes mandatory to execute some statements
irrespective of whether an exception is raised or not. In such cases, a
finally block is used.
The finally block is an optional block and it appears after the catch
block. It encloses statements that are executed regardless of whether
an exception occurs.
Syntax
The following syntax demonstrates the use of the finally block:
finally
{
// cleanup code;
}
where,
finally: Specifies that the statements
AAIE - in
RUthe block have to be executed
irrespective of whether or not an exception is raised. 32
The finally
construct: Statement 2-2

The following code demonstrates the use of the try-catch-finally
using System;
class DivisionError
{
Snippet {
int numOne = 133;
int numTwo = 0;
int result;
try
{
result = numOne / numTwo;
}
{
Console.WriteLine(Exception caught: + objDivide);
}
finally
{
Console.WriteLine(This finally block will always be
executed);
}
}
}
In the code: Building Applications

The Main() method of the class DivisionError declares and initializes
two variables.
An attempt is made to divide one of the variables by zero and an
exception is raised.
Output
This exception is caught using the try-catch-finally construct.
The finally block is executed at the end even though an exception is
thrown by the try block.
AAIE - RU
Exception caught: System.DivideByZeroException: Attempted 33
to

Performance 1-7
Exceptions hinder the performance of a program.
There are two design patterns that help in
minimizing the hindrance caused due to
exceptions. These are:
Tester-Doer Pattern:
A call that might throw exceptions is divided into two
parts, tester and doer, using the tester-doer pattern.
The tester part will perform a test on the condition that
might cause the doer part to throw an exception.
This test is then placed just before the code that
throws an exception.
AAIE - RU
34

Performance 2-7
The following code demonstrates the use of the
tester-doer using
pattern:
System;
Snippet class NumberDoer

{
public void Process(int numOne, int numTwo)
{
try
{
if (numTwo == 0)
{
throw new DivideByZeroException("Value of divisor is zero");
}
else
{
Console.WriteLine ("Quotient: " + (numOne / numTwo));
Console.WriteLine ("Remainder: " + (numOne % numTwo));
}
} Using C# / Session 11
{
Console.WriteLine("Error: " + objDivide);
}
}
}
class NumberTester
{
NumberDoer objDoer = new NumberDoer();
NumberDoer objDoer = new NumberDoer();
public void AcceptDetails()
{ AAIE - RU
35
Performance 3-7
int dividend = 0;
int divisor = 0;
Console.WriteLine("Enter the value of dividend");
try {
dividend = Convert.ToInt32(Console.ReadLine());
}
catch (FormatException objForm) {
Console.WriteLine("Error: " + objForm);
}
Console.WriteLine("Enter the value of divisor");
try {
divisor = Convert.ToInt32(Console.ReadLine());
}
catch (FormatException objFormat) {
Console.WriteLine("Error: " + objFormat);
}
if ((dividend > 0) Using C# /> Session
|| (divisor 0)) 11
{
objDoer.Process(dividend, divisor);
}
else
{
Console.WriteLine("Invalid input");
}
}
{
AAIE - RU
NumberTester objTester = new NumberTester();
36
Performance 4-7
In the code:
Two classes, NumberDoer and NumberTester, are defined. In the
NumberTester class, if the value entered is not of int data type, an
exception is thrown.
Next, a test is performed to check if either of the values of dividend
and divisor is greater than 0. If the result is true, the values are passed
to the Process() method of the NumberDoer class. In the
NumberDoer class, another test is performed to check whether the
value of the divisor is equal to 0.
If the condition is true, then the DivideByZero exception is thrown and
caught by the catch block.
The following figure Building
displays the use of tester-
Applications
doer pattern: Using C# / Session 11
AAIE - RU
37

Performance
TryParse Pattern
5-7
There are two different methods to implement the
TryParse pattern. The first method is X, which performs
the operation and throws the exception.
The second method is TryX, which also performs the
operation but does not throw the exception.
Instead, it returns a boolean value that indicates whether
the operation failed or succeeded.
The following code demonstrates the use of the TryParse
pattern:
Snippet
using System;
class Product
private int _quantity;
private float _price;
private double _sales;
string _productName;
public Product()
{
_productName = "Motherboard";
}
public void AcceptDetails()
{
Console.WriteLine("Enter the number of " + _productName +
" sold");
try
AAIE - RU
38
{
Performance 6-7
_quantity = Int32.Parse(Console.ReadLine());
}
catch (FormatException objFormat)
{
Console.WriteLine("Error: " + objFormat);
return;
}
Console.WriteLine("Enter the price of the product");
if (float.TryParse((Console.ReadLine()), out _price) ==
true)
{
_sales = _price * _quantity;
}
else
{
Console.WriteLine("Invalid price inserted");
}
} Building Applications
public void Display()
{
Console.WriteLine("Product Name: " + _productName);
Console.WriteLine("Product Price: " + _price);
Console.WriteLine("Quantity sold: " + _quantity);
Console.WriteLine("Total Sale Value: " + _sales);
}
{
Product objGoods = new Product();
objGoods.AcceptDetails();
objGoods.Display();
}
}
AAIE - RU
39
In the code:
Performance 7-7
A class Product is defined in which the total product sales is
calculated.
The user-defined function AcceptDetails accepts the number of
products sold and the price of each product. The number of
products sold is converted to int data type using the Parse()
method of the Int32 structure.
This method throws an exception if the value entered is not of the
int data type. Hence, this method is included in the try...catch
block.
When accepting the price of the product, the TryParse pattern is
used to verify whether the valueApplications
Building entered is of the correct data
type. Using C# / Session 11
If the value returned by the TryParse() method is true, the sale
price is calculated.
The following figure displays the output of the code when the
user enters a value which is not of int data type:
AAIE - RU
40
Nested try and
Multiple
Exception handling code cancatch Blocks
be nested in a
program. In nested exception handling, a try block
can enclose another
try-catch block.
In addition, a single try block can have multiple

catch blocks that are sequenced to catch and
handle different type of exceptions raised in the
try block.
AAIE - RU
41
Nested try Blocks 1-
Following 4
are the features of the
nested try block:
The nested try block If an exception is

This outer try block
consists of multiple thrown by a nested
contains multiple try
try-catch constructs try block, the control
blocks within it,
that starts with a try passes to its
which are called
block, which is called corresponding nested
inner try blocks.
the outer try block. catch block.
Consider an outer Using
try block However,
C# / Session 11 if the inner
containing a nested try- catch block does not
catch-finally construct. If contain the
the inner try block throws appropriate error
an exception, control is handler, the control
passed to the inner catch is passed to the outer
block. catch block.
AAIE - RU
42
The following4syntax is used to create nested
trycatch blocks:
try
Syntax {
// outer try block
try
{
// inner try block
}
catch
{
// inner catch block
}
// this is optional
finally Building Applications
// inner finally block
}
}
catch
{
// outer catch block
}
// this is optional
finally
{
// outer finally block
} AAIE - RU
43
blocks:
4
The following code demonstrates the use of nested try
Snippet
{
string[] names = {John, James};
int numOne = 0;
int result;
try
{
Console.WriteLine(This is the outer try block);
try
{
result = 133 / numOne;Building Applications
} Using C# / Session 11
catch (ArithmeticException objMaths)
{
Console.WriteLine(Divide by 0 + objMaths);
}
names[2] = Smith;
}
catch (IndexOutOfRangeException objIndex)
{
Console.WriteLine(Wrong number of arguments supplied + objIndex);
}
} AAIE - RU
44
In the code:

4
The array variable called names of type string is initialized to have
two values.
The outer try block consists of another try-catch construct.
The inner try block divides two numbers. As an attempt is made to
divide the number by zero, the inner try block throws an exception,
which is handled by the inner catch block.
In addition, in the outer try block, there is a statement referencing a
third array element whereas, the array can store only two values. So,
the outer try block also throws an exception, which is handled by the
outer catch block.
Output
This is the outer try block
Divide by 0 System.DivideByZeroException: Attempted to
divide by zero.
at Product.Main(String[] args) in
c:\ConsoleApplication1\Program.cs:line 52
Wrong number of arguments supplied
System.IndexOutOfRangeException: Index was outside the
AAIE - RU
bounds of the array. 45
Multiple catch Blocks
1-3
A try block can throw multiple types of exceptions, which need to be
handled by the catch block. C# allows you to define multiple catch
blocks to handle the different types of exceptions that might be raised
by the try block. Depending on the type of exception thrown by the try
block, the appropriate catch block (if present) is executed.
However, if the compiler does not find the appropriate catch block, then
the general catch block is executed.
Once the catch block is executed, the program control is passed to the
finally block (if any) and then the control terminates the try-catch-finally
construct.
The following syntax is used for defining multiple catch blocks:
Syntax
try Using C# / Session 11
{
// program code
}
catch (<ExceptionClass><objException>)
{
// statements for handling the exception
}
AAIE - RU
catch (<ExceptionClass1><objException>) 46
The following2-3
code demonstrates the use of multiple
catch blocks:
Snippet static void Main(string[] args)
{
string[] names = { John, James };
int numOne = 10;
int result = 0;
int index = 0;
try
{
index = 3;
names[index] = Smith;
result = 130 / numOne;
}
{
Console.WriteLine(Divide by 0 + objDivide);
}
catch (IndexOutOfRangeException objIndex)
{
Console.WriteLine(Wrong number of arguments supplied
+ objIndex);
}
catch (Exception objException)
{
Console.WriteLine(Error: + objException);
AAIE - RU
} 47
In the code: 3-3
The array, names, is initialized to two element values and
two integer variables are declared and initialized.

As there is a reference to a third array element, an
exception of type IndexOutOfRangeException is thrown and
the second catch block is executed.

Since the try block encounters an exception in the first
statement, the next statement in the try block is not
executed and the control terminates the try-catch construct.

So, the C# compiler prints the initialized value of the
variable result and not the value
Building obtained by dividing the
Applications
two numbers. Using C# / Session 11

However, if an exception occurs that cannot be caught using
either of the two catch blocks, then the last catch block with
the general Exception class will be executed.
AAIE - RU
48
System.TypeInitial
izationException
The System.TypeInitializationException class is used to handle
Class
to invoke the static
following code:
constructor1-2
exceptions that are thrown when an instance of a class attempts
of the class as shown in the
Snippet
using System;
class TypeInitError
{
static TypeInitError()
{
throw new ApplicationException("This program throws
TypeInitializationException error.");
}
Building
static void Main(string[] args) Applications
try
{
TypeInitError objType = new TypeInitError();
}
catch (TypeInitializationException objEx)
{
Console.WriteLine("Error : {0}",objEx);
}
{
AAIE
Console.WriteLine("Error - RU objEx);
: {0}",
} 49
System.TypeInitial
In the code:
izationException

Class 2-2
A static constructor TypeInitError is defined. Here, only the
static constructor is defined and when the instance of the
class, objType attempts to invoke the constructor, an
exception is thrown.
This invocation of the static constructor is not allowed and
the instance of the TypeInitializationException class is used to
Thedisplay the errorthe
figure displays message in the catch block.
System.TypeInitializationException
generated at runtime:
AAIE - RU
50
Custom Exceptions
Following are the features of custom
exceptions:
They are user-defined
exceptions that allow
Allows you to simplify and
users to recognize the
improve the process of
cause of unexpected
error-handling in a
events in specific
program.
programs and display
custom messages.
Even though C# provides

you with a rich set of Building Applications
Using Custom
exception classes, they do
exceptions
C# / Session 11 can be
created to handle
not address certain
exceptions that are
application-specific and
thrown by the CLR as well
system-specific
as those that are thrown
constraints. To handle
by user applications.
such constraints, you can
define custom exceptions.
AAIE - RU
51
Implementing
Custom Exceptions
Custom exceptions can be created by deriving from the Exception
1-
2
class, the SystemException class, or the ApplicationException class.
However, to define a custom exception, you first need to define a new
class and then derive it from the Exception, SystemException, or
ApplicationException class. Once you have created a custom exception,
you can reuse it in any C# application.
The following demonstrates the implementation of custom exceptions:
Snippet public class CustomMessage : Exception
{
public CustomMessage (string message) : base(message) {
}
}
public class CustomException{
static void Main(string[] args) {
try Using C# / Session 11
{
throw new CustomMessage (This illustrates creation and catching of custom exception);
}
catch(CustomMessage objCustom)
{
Console.WriteLine(objCustom.Message);
}
}
}
AAIE - RU
52
Implementing
Custom Exceptions 2-
In the code:

2
The class CustomMessage
from the class Exception.
is created, which is derived
The constructor of the class CustomMessage is created

and it takes a string parameter.
This constructor, in turn, calls the constructor of the base
class, Exception. The class CustomException consists of
the Main() method.
The try block of the class CustomException throws the
custom exception that passes a string value.
Building Applicationsthrown by the try
The catch block catches the exception
block and prints the message.
Output
This illustrates creation and catching of custom exception
AAIE - RU
53

Exception Assistant
Exception assistant is a new feature for debugging
C# applications. The Exception dialog box feature in
earlier versions of C# is replaced by Exception
assistant.
This assistant appears whenever a run-time exception
occurs.
It shows the type of exception that occurred, the
troubleshooting tips, and the corrective action to be
taken, and can also be used to view the details of an
exception object. Building Applications
Exception assistant provides more information about
an exception than the Exception dialog box.
The assistant makes it easier to locate the cause of
the exception and to solve the problem.
AAIE - RU
54

Summary
Exceptions are errors that encountered at run-time.
Exception-handling allows you to handle methods that are
expected to generate exceptions.
The try block should enclose statements that may generate
exceptions while the catch block should catch these
exceptions.
The finally block is meant to enclose statements that need to
be executed irrespective of whether or not an exception is
thrown by the try block.
Nested try blocks allow you to have a try-catch-finally construct
within a try block. Building Applications
Multiple catch blocks can be implemented
Using C# / Session 11when a try block
throws multiple types of exceptions.
Custom exceptions are user-defined exceptions that allow users
to handle system and application-specific runtime errors.
AAIE - RU
55
Objectives
Define and describe inheritance

Explain method overriding
Define and describe sealed classes
Explain polymorphism
AAIE - RU
56
Definition of Inheritance 1-2
The similarity in physical features of a child to that of

its parents is due to the child having inherited these
features from its parents.
Similarly, in C#, inheritance allows you to create a

class by deriving the common attributes and methods
of an existing class.
The class from which the new class is created is known

as the base class and the created class is known as the
derived class.
The process of creating a new class by extending some

features of an existing class is known as inheritance.
AAIE - RU
57
Definition of Inheritance 2-2
Consider a class called Vehicle that consists of a

variable called color and a method called Speed().
These data members of the Vehicle class can be
inherited by the TwoWheelerVehicle and
FourWheelerVehicle classes.
The following figure illustrates an example of
inheritance:
AAIE - RU
58
Purpose 1-3
The purpose of inheritance is to reuse common

methods and attributes among classes without
recreating them.
Reusability of a code enables you to use the
same code in different applications with little
or no changes.
Example
Consider a class named Animal which defines
attributes and behavior for animals.
If a new class named Cat has to be created, it
can be done based on Animal because a cat is
also an animal.
Thus, you can reuse the code from the
previously-defined class.
AAIE - RU
59
Purpose 2-3
Apart from reusability, inheritance is widely used

for: Inheritance allows you to implement generalization by
Generalizati creating base classes. For example, consider the class

Vehicle, which is the base class for its derived classes
Truck and Bike.
on The class Vehicle consists of general attributes and

methods that are implemented more specifically in the
respective derived classes.
Inheritance allows you to implement specialization by
Specializatio creating derived classes.

For example, the derived classes such as Bike, Bicycle,
Bus, and Truck are specialized by implementing only
n specific methods from its generalized base class Vehicle.
Inheritance allows you to extend the functionalities of a

derived class by creating more methods and attributes that
Extension are not present in the base class. It allows you to provide
additional features to the existing derived class without
modifying the existing code.
AAIE - RU
60
Purpose 3-3
The following figure displays a real-world example

demonstrating the purpose of inheritance:
AAIE - RU
61
Multi-level Hierarchy 1-3
Inheritance allows the programmer to build hierarchies

that can contain multiple levels of inheritance.
Example
Consider three classes Mammal, Animal, and Dog. The
class Mammal is inherited from the base class Animal,
which inherits all the attributes of the Animal class.
The class Dog is inherited from the class Mammal and
inherits all the attributes of both the Animal and Mammal
classes.
The following figure depicts multi-level hierarchy of
related classes:
AAIE - RU
62
The following code demonstrates multiple levels of inheritance:

using System;
class Animal
{
public void Eat()
{
Console.WriteLine(Every animal eats something.);
}
}
class Mammal : Animal
{
public void Feature()
{
Console.WriteLine(Mammals give birth to young ones.);
}
} Snippet
class Dog : Mammal
{
public void Noise()
{
Console.WriteLine(Dog Barks.);
}
{
Dog objDog = new Dog();
objDog.Eat();
objDog.Feature();
objDog.Noise();
}
}
AAIE - RU
63
In the code, the Main()method of the class Dog

invokes the methods of the class Animal, Mammal,
and Dog.
Output
Every animal eats something.

Mammals give birth to young ones.
Dog Barks.
AAIE - RU
64
Implementing Inheritance 1-3
To derive a class from another class in C#, insert a colon

after the name of the derived class followed by the name
of the base class.
The derived class can now inherit all non-private
methods and attributes of the base class.
The following syntax is used to inherit a class in C#:
Syntax
<DerivedClassName>:<BaseClassName>

where,
DerivedClassName: Is the name of the newly created child
class.
BaseClassName: Is the name of the parent class from which
the
currentclass is inherited.
AAIE - RU
65
The following syntax is used to invoke a method of the base

class:
Syntax <objectName>.<MethodName>;

where,
objectName: Is the object of the base class.
MethodName: Is the name of the method of the base class.
The following code demonstrates how to derive a class from another
existing
class
class Animal
{
Animal class and inherit methods from the base class:
public voidEat()
{
Snippet
Console.WriteLine("Everyanimaleatssomething.");
Console.WriteLine("Everyanimaleatssomething.");
}
}
publicvoidDoSomething()
publicvoidDoSomething()
{
Console.WriteLine("Everyanimaldoessomething.");
}
}
}
}
class Cat:Animal
{
static
static voidMain(String[]args)
voidMain(String[]args)
{
{
Cat objCat=new
Cat objCat=new Cat();
Cat();
objCat.Eat();
objCat.DoSomething();
objCat.DoSomething();
}
AAIE - RU
}
66
In the code:
The class Animal consists of two methods, Eat()and
DoSomething(). The class Cat is inherited from the class Animal.
The instance of the class Cat is created and it invokes the two
methods defined in the class Animal.
Even though an instance of the derived class is created, it is the
methods of the base class that are invoked because these
methods are not implemented again in the derived class.
When the instance of the class Cat invokes the Eat()and
DoSomething()methods, the statements in the Eat()and
DoSomething()methods of the base class Animal are executed.
Output
Every animal eats something.

Every animal does something.
AAIE - RU
67
protected Access Modifier 1-3
The protected access modifier protects the data members
that are declared using this modifier.
The protected access modifier is specified using the
protected keyword.
Variables or methods that are declared as protected are
accessed only by the class in which they are declared or by a
class that is derived from this class.
The following figure displays an example of using the
protected access modifier:
AAIE - RU
68
The following syntax declares a protected variable:
Syntax
protected<data_type><VariableName>;
where,
data_type: Is the data type of the data member.
VariableName: Is the name of the variable.
The following syntax declares a protected method:
Syntax
protected<return_type><MethodName>(argument_list);
where,
return_type: Is the type of value the method will return.
MethodName: Is the name of the method.
argument_list: Is the list of parameters.
AAIE - RU
69
The following code demonstrates the use of the protected access
modifier:
Snippet
class Animal
{
protected string Food;
protected string Activity;
}
class Cat:Animal
{
{
cat objCat=newCat();
objCat.Food="Mouse";
objCat.Activity="lazearound";
Console.WriteLine("The Cat loves to eat"+objCat.Food+".");
Console.WriteLine("The Catloves to"+objCat.Activity+".");
}
}
In the code:
Two variables are created in the class Animal with the protected keyword.
The class Cat is inherited from the class Animal.
The instance of the class Cat is created that is referring the two variables defined in the
class Animal using the dot (.) operator.
The protected access modifier allows the variables declared in the class Animal to be
accessed by the derived class Cat.
The Cat loves to eat Mouse.

Output The Cat loves to laze around.
AAIE - RU
70
base Keyword 1-3
The base keyword allows you to do the following:
AAIE - RU
71
base Keyword 2-3
The following syntax shows the use of the base
keyword:
Syntax
class <ClassName>
{
<accessmodifier><returntype><BaseMethod>{}
}
class <ClassName1>:<ClassName>
{
base.<BaseMethod>;
}
where,
<ClassName>: Is the name of the base class.
<accessmodifier>: Specifies the scope of the class or method.
<returntype>: Specifies the type of data the method will return.
<BaseMethod>: Is the base class method.
<ClassName1>: Is the name of the derived class.
base: Is a keyword used to access the base class members.
AAIE - RU
72
base Keyword 3-3
The following figure displays an example of

using the base keyword:
AAIE - RU
73
new Keyword 1-2
The new keyword can either be used as an operator or as a

modifier in C#.
This allows you to redefine the inherited methods or variables in

the derived class.
Since redefining the base class members in the derived class
results in base class members being hidden, the only way you can
AAIE - RU
access these is by using the base keyword. 74
new Keyword 2-2
The following syntax shows the use of the new modifier:

<access modifier>class<ClassName>
{
<access modifier><returntype><BaseMethod>{}
}
<access modifier>class<ClassName1>:<ClassName>
{
new<access modifier>void<BaseMethod>{}
}
where,
<accessmodifier>: Specifies the scope of the class or method.
<returntype>: Specifies the type of data the method will return.
<ClassName>: Is the name of the base class.
<ClassName1>: Is the name of the derived class.
new: Is a keyword used to hide the base class method.
Snippet
The following code creates an object using the new operator:
EmployeesobjEmp=newEmployees();
Here, the code creates an instance called objEmp of the class Employees
and invokes its constructor. AAIE - RU
75
The following code demonstrates the use of the new modifier to redefine
the inherited methods in the base class:
Snippet
class Employees
{
int _empId=1;
string _empName="JamesAnderson";
int _age=25;
Public void Display()
{
Console.WriteLine("EmployeeID:"+_empId);
Console.WriteLine("EmployeeName:"+_empName);
}
}
Class Department:Employees
{
Int _deptId=501;
String _deptName="Sales";
new void Display()
{
base.Display();
Console.WriteLine("DepartmentID:"+_deptId);
Console.WriteLine("DepartmentName:"+_deptName);
}
static void Main(string[]args)
{
Department objDepartment=new Department();
objDepartment.Display();
}
}
AAIE - RU
76
In the code:
The class Employees declares a method called Display().
This method is inherited in the derived class Department and is preceded by
the new keyword.
The new keyword hides the inherited method Display()that was defined in
the base class, thereby executing the Display()method of the derived class
when a call is made to it.
However, the base keyword allows you to access the base class members.
Therefore, the statements in the Display()method of the derived class and
the base class are executed, and, finally, the employee ID, employee name,
department ID, and department name are displayed in the console window.
Output
Employee ID: 1
Employee Name: James Anderson
Department ID: 501
Department Name: Sales AAIE - RU 77
Constructor Inheritance 1-3
In C#, you can:
However, C# cannot inherit constructors similar to how you inherit

methods.
The following figure displays an example of constructor
inheritance:
AAIE - RU
78
The following code explicitly invokes the base class

constructor using the base keyword:
class Animal
{
public Animal()
{
Console.WriteLine("Animal constructor without parameters");
}
public Animal(string name)
{
Console.WriteLine("Animal constructor with a string parameter");
}
}
class Canine:Animal
{
//base()takes a string value calledLion
public Canine():base("Lion")
{
Console.WriteLine("DerivedCanine");
Snippet
}
}
class Details
{
{
Canine objCanine=new Canine();
}
}
AAIE - RU
79
In the code:
The class Animal consists of two constructors, one
without a parameter and the other with a string
parameter.
The class Canine is inherited from the class Animal.
The derived class Canine consists of a constructor that
invokes the constructor of the base class Animal by
using the base keyword.
If the base keyword does not take a string in the
parenthesis, the constructor of the class Animal that
does not contain parameters is invoked.
In the class Details, when the derived class constructor
Output
is invoked,
Animal it will in with
constructor turn invoke
a stringthe parameterized
parameter
constructor of the base class.

Derived Canine
AAIE - RU
80
Invoking Parameterized Base Class Constructors 1-3
The derived class constructor can explicitly invoke

the base class constructor by using the base
keyword.
If a base class constructor has a parameter, the
base keyword is followed by the value of the type
specified in the constructor declaration.
If there are no parameters, the base keyword is
followed by a pair of parentheses.
AAIE - RU
81
The following code demonstrates how parameterized

constructors are invoked in a multi-level hierarchy:
using System;
class Metals
{
Snippet
string _metalType;
public Metals(string type)
{
_metalType=type;
Console.WriteLine("Metal:\t\t"+_metalType);
}
}
class SteelCompany : Metals
{
string_grade;
public SteelCompany(string grade):base("Steel")
{
_grade=grade;
Console.WriteLine("Grade:\t\t"+_grade);
}
}
class Automobiles:SteelCompany
{
string _part;
public Automobiles(string part):base("CastIron")
{
_part=part;
Console.WriteLine("Part:\t\t"+_part);
}
static voidMain(string[]args)
{
AAIE - RU
Automobiles objAutomobiles=new Automobiles("Chassies");
} 82
In the code:
The Automobiles class inherits the SteelCompany class.
The SteelCompany class inherits the Metals class.
In the Main()method, when an instance of the
Automobiles class is created, it invokes the constructor of
the Metals class, followed by the constructor of the
SteelCompany class.
Finally, the constructor of the Automobiles class is invoked.
Output
Metal: Steel
Grade: CastIron
Part: Chassies
AAIE - RU
83
Method Overriding
Method overriding:
Is a feature that allows the derived class to override or
redefine the methods of the base class which changes the
body of the method that was declared in the base class.
Allows the same method with the same name and
signature declared in the base class to be reused in the
derived class to define a new behavior.
Ensures reusability while inheriting classes.
Is implemented in the derived class from the base class is
known as the Overridden Base Method.
The following figure depicts method overriding:
AAIE - RU
84
virtual and override Keywords 1-5
You can override a base class method in the

derived class using appropriate C# keywords
such as:
AAIE - RU
85
The following is the syntax for declaring a virtual method
using the virtual keyword:
Syntax
<access_modifier>virtual<return_type><MethodNam
e>(<parameter-list>);
where,
access_modifier: Is the access modifier of the method, which
can be private, public, protected, or internal.
virtual: Is a keyword used to declare a method in the base class
that can be overridden by the derived class.
return_type: Is the type of value the method will return.
MethodName: Is the name of the virtual method.
parameter-list: Is the parameter list of the method; it is
optional.
AAIE - RU
86
The following is the syntax for overriding a method

using the override keyword:
Syntax
<accessmodifier>override<returntype><MethodName>(
<parameters-list>)
where,
override: Is the keyword used to override a method in the
derived class.
AAIE - RU
87
The following code demonstrates the application of the

virtual and override keywords in the base and derived
classes respectively:
class Animal
{
public virtual void Eat() Snippet
{
Console.WriteLine("Every animal eats something");
}
protected void DoSomething()
{
Console.WriteLine("Every animal does something");
}
}
class Cat:Animal
{
//Class Cat overrides Eat()method of class Animal
public override void Eat()
{
Console.WriteLine("Cat loves to eat the mouse");
}
static void Main(String[]args)
{
Cat objCat = newCat();
objCat.Eat();
} }}
AAIE - RU
88
In the code:
The class Animal consists of two methods, the Eat()method
with the virtual keyword and the DoSomething()method
with the protected keyword. The class Cat is inherited from
the class Animal.
An instance of the class Cat is created and the dot (.) operator
is used to invoke the Eat()and the DoSomething()methods.
The virtual method Eat()is overridden in the derived class
using the override keyword.
This enables the C# compiler to execute the code within the
Eat()method of the derived class.
Output
Cat loves to eat the mouse
AAIE - RU
89
Calling the Base Class Method 1-3
Method overriding allows the derived class to

redefine the methods of the base class.
It allow the base class methods to access the new
method but not the original base class method.
To execute the base class method as well as the
derived class method, you can create an instance of
the base class.
It allows you to access the base class method, and
an instance of the derived class, to access the
derived class method.
AAIE - RU
90
The following code demonstrates how to access a base class method:

class Student
{
string _studentName = James;
string _address = California;
public virtual void PrintDetails()
{
Console.WriteLine(Student Name: + _studentName);

Console.WriteLine(Address: + _address);
}
}
class Grade : Student
{
string _class = Four;
float _percent = 71.25F;
public override void PrintDetails()
{
Console.WriteLine(Class: + _class);
Console.WriteLine(Percentage: + _percent);
}
{
Student objStudent = new Student();
Grade objGrade = new Grade();
objStudent.PrintDetails();
objGrade.PrintDetails();
}
}
AAIE - RU
91
In the code:
The class Student consists of a virtual method called
PrintDetails().
The class Grade inherits the class Student and overrides the base
class method PrintDetails().
The Main()method creates an instance of the base class Student
and the derived class Grade.
The instance of the base class Student uses the dot (.) operator to
invoke the base class method PrintDetails().
The instance of the derived class Grade uses the dot (.) operator
to invoke the derived class method PrintDetails().
Output
Student Name: James
Address: California
Class: Four
Percentage: 71.25
AAIE - RU
92
Sealed Classes 1-3
A sealed class is a class that prevents inheritance. The features of a

sealed class are as follows:
The following syntax is used to declare a sealed class:

Syntax
sealed class<ClassName>
{
//body of the class
}
where,
sealed: Is a keyword used to prevent a class from being inherited.
ClassName: Is the name of the class that needs
AAIE - RU to be sealed.
93
Sealed Classes 2-3
The following code demonstrates the use of a sealed class in C# which will
generate a compiler error:
sealed class Product
{
public int Quantity;
public int Cost; Snippet
}
class Goods
{
static void Main(string [] args)
{
Product objProduct = new Product();
objProduct.Quantity = 50;
objProduct.Cost = 75;
Console.WriteLine(Quantity of the Product: + objProduct. Quantity);
Console.WriteLine(Cost of the Product: + objProduct.Cost);
}
}
class Pen : Product
{
}
In the code:
The class Product is declared as sealed and it consists of two variables.
The class Goods contains the code to create an instance of Product and uses the
dot (.) operator to invoke variables declared in Product.
AAIE - RU
94
Sealed Classes 3-3
The class Pen tries to inherit the sealed class

Product, the C# compiler generates an error, as
shown in the following figure:
AAIE - RU
95
Purpose of Sealed Classes
Consider a class named SystemInformation that

consists of critical methods that affect the working
of the operating system.
You might not want any third party to inherit the

class SystemInformation and override its methods,
thus, causing security and copyright issues.
Here, you can declare the SystemInformation class

as sealed to prevent any change in its variables and
methods.
AAIE - RU
96
Guidelines
Sealed classes are restricted classes that cannot

be inherited where the list depicts the conditions
in which a class can be marked as sealed:
If overriding the methods of a class might result in
unexpected functioning of the class.
When you want to prevent any third party from
modifying your class.
AAIE - RU
97
Sealed Methods 1-3
A sealed class cannot be inherited by any other class.
The following syntax is used to declare an overridden method as sealed:
where,
return_type: Specifies the data type of value returned by the method.
MethodName: Specifies the name of the overridden method.
sealed override <return_type> <MethodName>{} Syntax
AAIE - RU
98
Sealed Methods 2-3
The following code declares an overridden method Print() as

sealed:
using System;
class ITSystem
{
public virtual void Print()
{
Console.WriteLine (The system should be handled carefully);
}
}
class CompanySystem : ITSystem
{
public override sealed void Print()
{
Console.WriteLine (The system information is
confidential);
Console.WriteLine (This information should not be
overridden);
}
}
class SealedSystem : CompanySystem
{
public override void Print()
{
Console.WriteLine (This statement wont get
executed);
}
static void Main (string [] args)
{
SealedSystem objSealed = new SealedSystem();
objSealed.Print ();
}
}
AAIE - RU
99
Sealed Methods 3-3
In the code:
The class ITSystem consists of a virtual function Print().
The class CompanySystem is inherited from the class ITSystem.
It overrides the base class method Print().
The overridden method Print() is sealed by using the sealed
keyword, which prevents further overriding of that method.
The class SealedSystem is inherited from the class
CompanySystem.
When the class SealedSystem overrides the sealed method
Print(), the C# compiler generates an error as shown in the
following figure:
AAIE - RU
100
Polymorphism
Polymorphism is the ability of an entity to behave differently in different situations.

Polymorphism is derived from two Greek words, namely Poly and Morphos, meaning forms.
Polymorphism means existing in multiple forms.
The following methods in a class have the same name but different signatures that perform the
same basic operation but in different ways:
Area(float radius)
Area(float base, float height)
These methods calculate the area of the circle and triangle taking different parameters and
using different formulae.
Example
Polymorphism allows methods to function differently based on the parameters and their data
types. The following figure displays the polymorphism:
AAIE - RU
101
Implementation 1-3
Polymorphism can be implemented in C# through method

overloading and method overriding.
AAIE - RU
102
Implementation 2-3
The following figure displays the implementation:
Figure 7.11: Implementation
AAIE - RU
103
Implementation 3-3
The following code demonstrates the use of method overloading

feature:
class Area
{
static int CalculateArea(int len, int wide)
{
return len * wide;
}
static double CalculateArea(double valOne, double valTwo)
{
Snippet
return 0.5 * valOne * valTwo;
}
{
int length = 10;
int breadth = 22;
double tbase = 2.5;
double theight = 1.5;
Console.WriteLine(Area of Rectangle: + CalculateArea(length, breadth));
Console.WriteLine(Area of triangle: + CalculateArea(tbase, theight));
}
}
In the code:
The class Area consists of two static methods of the same name,
CalculateArea. However, both these methods have different return types
Output
and take different parameters.
Area of Rectangle: 220
AAIE - RU
Area of triangle: 1.875
104
Compile-time and Run-time Polymorphism 1-3
Polymorphism can be broadly classified into the following

categories:
Compile-time polymorphism
Run-time polymorphism
The following table differentiates between compile-time and
run-time polymorphism:
Compile-time Polymorphism Run-time Polymorphism
Is implemented through method Is implemented through method
overloading. overriding.
Is executed at the compile-time since Is executed at run-time since the compiler
the compiler knows which method to does not know the method to be executed,
execute depending on the number of whether it is the base class method that
parameters and their data types. will be called or the derived class method.
Is referred to as static polymorphism. Is referred to as dynamic polymorphism.
AAIE - RU
105
The following code demonstrates the implementation of run-time

polymorphism:
using System;
class Circle
{
protected const double PI = 3.14;
protected double Radius = 14.9;
public virtual double Area()
{
return PI * Radius * Radius;
}
}
class Cone : Circle
{
protected double Side = 10.2;
public override double Area()
{
return PI * Radius * Side;
}
{
Circle objRunOne = new Circle();
Console.WriteLine(Area is: + objRunOne.Area());
Circle objRunTwo = new Cone();
Console.WriteLine(Area is: + objRunTwo.Area());
}
}
AAIE - RU
106
In the code:
The class Circle initializes protected variables and contains a
virtual method Area()that returns the area of the circle.
The class Cone is derived from the class Circle, which
overrides the method Area().
The Area()method returns the area of the cone by
considering the length of the cone, which is initialized to the
value 10.2.
The Main() method demonstrates how polymorphism can
take place by first creating an object of type Circle and
invoking its Area()method and later creating a reference of
type Circle but instantiating it to Cone at runtime and then
calling the Area()method.
In this case, the Area()method of Cone will be called even
Output
though the reference created was that of Circle.
Area is: 697.1114 AAIE - RU

Area is: 477.2172 107
Summary
Inheritance allows you to create a new class from

another class, thereby inheriting its common properties
and methods.
Inheritance can be implemented by writing the derived
class name followed by a colon and the name of the base
class.
Method overriding is a process of redefining the base
class methods in the derived class.
Methods can be overridden by using a combination of
virtual and override keywords within the base and
derived classes respectively.
Sealed classes are classes that cannot be inherited by
other classes.
You can declare a sealed class in C# by using the sealed
AAIE - RU
keyword. 108

#1session# Day 1.3.2

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

#1session# Day 1.3.2

Caricato da

Copyright:

Formati disponibili

C#

It allows you to handle basically two kinds of exceptions. These are as

The following table describes the properties of

Snippet class ArrayMisMatch

try Building Applications

Figure 11.4: ArrayTypeMismatchException

tion Class 1-2

Snippet class Employee

Snippet class ExceptionProperties

The following figure displays use of some of the

Snippet static void Main(string[] args)

You can create a

However, one disadvantage of

Error: System.IndexOutOfRangeException: Index was outside the

When you throw an exception using the throw keyword,

construct: Statement 2-2

In the code: Building Applications

Snippet class NumberDoer

In addition, a single try block can have multiple

The nested try block If an exception is

Even though C# provides

The constructor of the class CustomMessage is created

Define and describe inheritance

The similarity in physical features of a child to that of

Similarly, in C#, inheritance allows you to create a

The class from which the new class is created is known

The process of creating a new class by extending some

Consider a class called Vehicle that consists of a

The purpose of inheritance is to reuse common

Apart from reusability, inheritance is widely used

Generalizati creating base classes. For example, consider the class

on The class Vehicle consists of general attributes and

Inheritance allows you to implement specialization by

Specializatio creating derived classes.

n specific methods from its generalized base class Vehicle.

Inheritance allows you to extend the functionalities of a

The following figure displays a real-world example

Inheritance allows the programmer to build hierarchies

The following code demonstrates multiple levels of inheritance:

In the code, the Main()method of the class Dog

Every animal eats something.

To derive a class from another class in C#, insert a colon

The following syntax is used to invoke a method of the base

Every animal eats something.

The following syntax declares a protected method:

The Cat loves to eat Mouse.

The base keyword allows you to do the following:

The following figure displays an example of

The new keyword can either be used as an operator or as a

This allows you to redefine the inherited methods or variables in

The following syntax shows the use of the new modifier:

In C#, you can:

However, C# cannot inherit constructors similar to how you inherit

The following code explicitly invokes the base class

The derived class constructor can explicitly invoke

The following code demonstrates how parameterized

You can override a base class method in the

The following is the syntax for overriding a method

The following code demonstrates the application of the

Method overriding allows the derived class to

The following code demonstrates how to access a base class method:

Console.WriteLine(Student Name: + _studentName);

A sealed class is a class that prevents inheritance. The features of a