UNIT V

Interfaces

 Interfaces define properties, methods, and

events, which are the members of the interface.
 Interfaces contain only the declaration of the
members.
 It is the responsibility of the deriving class to
define the members.

EXAMPLE

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceApplication
{
publicinterfaceITransaction
{
void showTransaction();
double getAmount();
Transaction(string c, string d, double a);
}
publicclassTransaction : ITransaction
{
privatestring tcode;
privatestring date;
privatedouble amount;
public Transaction(string c, string d, double a)
{
tcode = c;
date = d;
amount = a;
}
publicdouble getAmount()

1
 {
return amount;
}
publicvoid showTransaction()
{
Console.WriteLine("Transaction: {0}",tcode);
Console.WriteLine("Date: {0}", date);
Console.WriteLine("Amount: {0}", getAmount());
}
}
classTester
{
staticvoid Main(string[] args)
{
Transaction t1 =
newTransaction("001","8/2/2019",78900.00);
Transaction t2 = new Transaction ("002", "9/2/2019" ,

451900.00);
t1.showTransaction();
t2.showTransaction();
Console.ReadKey();
}
}
}

Operator Overloading

 Overloaded operators are functions with special

names the keyword operator followed by the symbol
for the operator being defined.
 similar to any other function, an overloaded
operator has a return type and a parameter list.

EXAMPLE

2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace overloading
{
classCalculate
{
publicint n1, n2;
public Calculate(int no1, int no2)
{
n1 = no1;
n2 = no2;
}

publicstaticCalculateoperator + (Calculate c1,Calculate

c2)
{
c1.n1=+c2.n1;
c1.n2=+c2.n2;
return c1;
}
publicvoid print()
{
Console.WriteLine("Number 1: " +n1);
Console.WriteLine("Number 2: " +n2);
Console.ReadKey();
}
}
classover
{
staticvoid Main(string[] args)
{
Calculate c = newCalculate(20,-40);
c.print();
Calculate c3 = newCalculate();
c3 = +c;
c3.print();
Console.ReadKey();

3
 }
}
}
OUTPUT

Number 1:20

Number 2: -40

Delegates

 A delegate is a reference type variable that

holds the reference to a method.
 The reference can be changed at runtime.
 All delegates are implicitly derived from
the System.Delegate class

Declaring Delegates

 Delegate declaration determines the methods that

can be referenced by the delegate

Syntax for delegate declaration is:

delegate<return type><delegate-name><parameter
list>

public delegate intMyDelegate (string s);

Instantiating Delegates

 Once a delegate type is declared, a delegate

object must be created with thenew keyword and be
associated with a particular method.

4
EXAMPLE

public delegate void printString(string s); ...

printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

Multicasting of a Delegate

 Delegate objects can be composed using the "+"

operator. A composed delegate calls the two
delegates it was composed from
 Using this property of delegates you can create
an invocation list of methods that will be called
when a delegate is invoked. This is
called multicasting of a delegate
 delegate intNumberChanger(int n);

EXAMPLE

namespaceDelegateAppl
{
classTestDelegate
{
staticintnum = 10;
public static intAddNum(int p)
{
num += p;
returnnum;

5
}
public static intMultNum(int q)
{
num *= q;
returnnum;
}
public static intgetNum()
{
returnnum;
}
static void Main(string[] args)
{
//create delegate instances
NumberChangernc;
NumberChanger nc1 = newNumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;
//calling multicast
nc(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
Result

Value of Num: 75
6
Using Delegates

 The delegateprintString can be used to reference

method that takes a string as input and returns
nothing.

Events

• Events are user actions such as key press, clicks,

mouse movements, etc.

• Applications need to respond to events when they

occur

Using Delegates with Events

• A publisher is an object that contains the

definition of the event and the delegate

• A subscriber is an object that accepts the event

and provides an event handler

Declaring Events

• To declare an event inside a class, first a

delegate type for the event must be declared

syntax

– public delegate string MyDel(string str);

– event MyDelMyEvent;

7
public delegate string MyDel(string str);

EXAMPLE
classEventProgram
{
eventMyDelMyEvent;
publicEventProgram()
{
this.MyEvent += new MyDel(this.WelcomeUser);
}
public string WelcomeUser(string username)
{
return "Welcome " + username;
}
static void Main(string[] args)
{
EventProgram obj1 = new EventProgram();
string result = obj1.MyEvent("Tutorials Point");
Console.WriteLine(result);
} }}
Output

Welcome Tutorials Point

Exception Handling

8
 • C# exception handling is built upon four
keywords: try, catch, finally, and throw.

• try: A try block identifies a block of code for

which particular exceptions is activated. It is
followed by one or more catch blocks.

• catch: A program catches an exception with an

exception handler at the place in a program where
you want to handle the problem. The catch keyword
indicates the catching of an exception.

• finally: The finally block is used to execute a

given set of statements, whether an exception is
thrown or not thrown. For example, if you open a
file, it must be closed whether an exception is
raised or not.

• throw: A program throws an exception when a problem

shows up. This is done using a throw keyword.

Syntax

try
{
// statements causing exception
}
catch(ExceptionName e1 )
{
// error handling code

9
 }
catch(ExceptionName e2 )
{
// error handling code
}
catch(ExceptionNameeN )
{
// error handling code
}
Finally
{
// statements to be executed
}
Nested try
try
{
//do something
Try
{
//do something
if exception is thrown, don't go to parent catch
}
catch(Exception ex) {...} }
catch(Exception ex) { .... }
Exception Classes in C#

10
 • The System.ApplicationException class supports
exceptions generated by application programs

• The System.SystemException class is the base class

for all predefined system exception

Exception Class Description

System.IO.IOException Handles I/O errors.

System.IndexOutOfRangeException Handles errors generated

when a method refers to an
array index out of range.

System.ArrayTypeMismatchException Handles errors generated

when type is mismatched
with the array type.

System.NullReferenceException Handles errors generated

from deferencing a null
object.

System.DivideByZeroException Handles errors generated

from dividing a dividend
with zero.

System.InvalidCastException Handles errors generated

during typecasting.

11
System.OutOfMemoryException Handles errors generated
from insufficient free
memory.

System.StackOverflowException Handles errors generated

from stack overflow.

Handling Exceptions

• These error handling blocks are implemented using

the try, catch, and finallykeywords

classDivNumbers
{
int result;
DivNumbers()
{
result = 0;
}
public void division(int num1, int num2)
{
try
{
result = num1 / num2;
}
catch (DivideByZeroException e)

12
{
Console.WriteLine("Exception caught: {0}", e);
}
Finally
{
Console.WriteLine("Result: {0}", result);
}
}
static void Main(string[] args)
{
DivNumbers d = new DivNumbers();
d.division(25, 0);
Console.ReadKey();
}
}
Throwing Objects

• You can throw an object if it is either directly or

indirectly derived from theSystem.Exception class.

• Catch(Exception e) { ... Throw e }

Classification of Errors

13
Logic Errors

• Your code may compile and run without any Syntax

Errors or Run-time Errors, but the output of an
operation may produce unwanted or unexpected
results in response to user actions.

• These types of errors are called Logic Errors. That

means, Logic errors are those that appear once the
application is in use.

• These are generally the hardest type to fix, since

it is not always clear where they originate.

• Also the development environment does not see

anything wrong in the document and therefore cannot
point out a problem

Run-time Errors

• Run-time errors are those that appear only after

you compile and run your code. It will occur when
your program attempts an operation that is

14
 impossible to carry out. You can fix most run-time
errors by rewriting the faulty code, and then
recompiling and running it.

• Ex: A program error may result from an attempt to

divide by zero

• int a = 5; int b = 0; int c = a /b;

• When you compile this program, compiler won't show

any Syntax Error. But when you run this code, the
compiler show "Attempted to divide by zero".

Syntax Errors

• Syntax Errors, also known as Compilation errors are

the most common type of errors. Most Syntax errors
are caused by mistakes that you make when writing
code. If you are using the coding environment like
Visual Studio, it is able to detect them as soon as
you write them, also you can fix them easily as
soon as they occur. When you compile your
application in the development environment, the
compiler would point out where the problem is so
you can fix it instantly.

• Ex: When you forgot to type a semicolon (;) after

the statement, the compiler shows the syntax error
and it would point out where the problem occurred.

15
Checked and Unchecked Operator

Checked Operator:

• When due to a limitation of a datatype, like an

int, we lose the data or get the unpredictable
value, for skipping this garbage value and generate
the "Stackoverflow exception" , use a checked
operator.

Unchecked Operator:

• it is the reverse of a checked operator where you

get the garbage value in the actual scenario. It is
used by default in C#.

EXAMPLE

try
{
int a = 200000;
int b = 300000;
int c = checked(a * b);
Console.WriteLine(c.ToString());
}
catch(Exception ex)
{
Console.WriteLine("Your multiplication cross the limit"
);
}

16
Console.ReadKey();
try
{
int a = 2000000;
int b = 3000000;
int c =unchecked(a * b);
Console.WriteLine(c.ToString());
}
catch(Exception ex)
{
Console.WriteLine("Your multiplication cross the limit"
);
}
Console.ReadKey();
}

17