Session

2
Implementing OOP
concepts in C#

Review

C# is an object oriented language with many powerful

features and is an integral part of the .Net platform
Variables in C# are declared in the following way
AccessModifier DataType VariableName;
C# provides the if and switchcase constructs to
perform operations based on the value of an expression.
C# provides the following types of iteration constructs,
while loop
do loop
for loop
foreach loop
In C#, the data types are divided into two fundamental
categories namely value types and reference types.
C# Simplified / Session 2 / 2 of 28

Review Contd

Boxing is the conversion of a value type into a

reference type while Unboxing refers to
converting a reference type into a value type.
Structs in C# can have methods defined within
them, and represent Value types.
Enums (short for Enumerators) are a set of
named numeric constants.
C# programs can be written using the Visual
Studio .NET IDE as well as Notepad

C# Simplified / Session 2 / 3 of 28

Objectives

Use Constructors In C#

Use Destructors In C#

Explain the working of Garbage Collector

Discuss Method Overloading

Discuss Operator Overloading

Use Inheritance in C#

Discuss Overriding
C# Simplified / Session 2 / 4 of 28

Constructors In C#

Are special types of methods in a class

Are called every time an object is
created
Are generally used for initialization
Have the same name as the class
Return no value

C# Simplified / Session 2 / 5 of 28

Constructors - Example
using System;
public class DaysInYear
{
private int days;
public DaysInYear()
{
days = 365;
}
static void Main(String[] args)
{
DaysInYear newDaysInYear =new DaysInYear();
Console.WriteLine (newDaysInYear.days);
}
}

With Constructor

Without Constructor
C# Simplified / Session 2 / 6 of 28

Parameterized
Constructors

public class DaysInYear

{
private int days;
public DaysInYear()
{
days = 365;
}
public DaysInYear(int day)
{
days = day;
}
public DaysInYear(String dayOne)
{
days =Convert.ToInt32(dayOne);
}
public void setDay(int newDays)
{
days = newDays;
}

Pass different number

of arguments
(or)
Pass the same number
of arguments but of
different types

C# Simplified / Session 2 / 7 of 28

Destructors In C#

Do not take any parameters

Declaration is same as constructors but
preceded with a ~
Called by the Garbage Collector in C#
The Garbage Collector frees memory by
destroying objects that are no longer required
or referenced
Syntax - ~DaysInYear()
{
//Destructor Implementation
}

C# Simplified / Session 2 / 8 of 28

Garbage Collector

Working of a garbage collector:

When an object that has a destructor defined, is allocated

memory, the runtime adds this object to a list of objects
that require destruction (or finalization)

Periodically, the Garbage Collector checks for objects that

have no references

If an object whose name does not appear in the finalizer

list is found, then the object is cleared up instantly

The runtime refers to the destructor as a finalizer, but in

C#, it is called as a destructor

When garbage collection is complete, the finalizer thread is

called, which calls the finalizer methods (destructors) of all
objects, marked as ready for finalization
C# Simplified / Session 2 / 9 of 28

Garbage Collector
Contd

After the finalization of an object has occurred, it is

removed from the list of objects that require finalization

Since the object is neither on the finalizer list nor

referenced, it gets cleared up when garbage collection
takes place the next time

Objects with destructors take up more resources as they

stay for a longer period of time in memory even when
they are not required

Finalization takes place as a separate thread, utilizing

the resources to a great extent

C# Simplified / Session 2 / 10 of 28

Method Overloading
Two ways of overloading methods

By specifying different number of

parameters

By specifying different types of

parameters

C# Simplified / Session 2 / 11 of 28

Method Overloading - Different

number of parameters
using System;
public class Area
{
private int areaVal;
public void AreaCal(int radius)
{
areaVal = (22/7)* radius*radius;
}
public void AreaCal(int length, int
breadth)
{
areaVal = length*breadth;
}
public void AreaCal(int length, int
breadth, int height)
{
areaVal = length*breadth*height;
}

C# Simplified / Session 2 / 12 of 28

Method Overloading Different types of parameters

...
public void Add(int number1, int number2)
{
sum = number1 + number2;
}
public void Add(string value1, string value2)
{
int sum;
sum = Int32.Parse(value1) + Int32.Parse(value2);
Console.WriteLine ("Sum is {0}",sum);
Console.WriteLine ("Strings are converted to integers to
add);
}
...

C# Simplified / Session 2 / 13 of 28

Operator Overloading
Contd

Overloading an operator means making

it
behave differently from its normal
behaviour //line 1
int result = Decimal.Add(54, 200);
//line 2
int result2 = 54 + 200;

Operators are used to make equations look

simple and easy to understand
List of operators that can be overloaded

C# Simplified / Session 2 / 14 of 28

Operator Overloading
using System;
public class Distance
{
int longitude, latitude;
public Distance()
{
longitude = 0;
latitude = 0;
}
public Distance(int longitude, int latitude)
{
this.longitude = longitude;
this.latitude = latitude;
}
public static Distance operator - (Distance
first, Distance second)
{
return new
Distance(first.longitude second.longitude, first.latitude second.latitude);
}
//main
}

public static void Main()

{
Distance start = new Distance();
Distance objDistance = new Distance();
Distance finish = new Distance();
start.longitude = 12;
This statement does
start.latitude = 10;
not return an error as
finish.longitude = 2;
the - operator is
finish.latitude = 1;
overloaded
objDistance = start - finish;
Console.WriteLine ("The Finish is {0}
Degrees East and {1} Degrees North of the Start.",
objDistance.longitude,objDistance.latitude);
}

C# Simplified / Session 2 / 15 of 28

Inheritance In C#

Declare and use a new class as a descendant

of another class

Saves trouble of re-writing code

Provides luxury of code re-use

The class from which the other classes can

inherit is called base class

Two types of Inheritance

Single Inheritance

Multiple Inheritance

C# Simplified / Session 2 / 16 of 28

Single Inheritance

using System;
namespace Ch2Ex5
{
class Inherit
{
static void Main(string[] args)
{
Square squareObj =new Square();
Rectangle rectObj =new
Rectangle();
squareObj.calculateArea(10,20);
rectObj.calculateArea(20,20);
}
}
class Shape
{
public int length;
public int breadth;
public void calculateArea(int len,
int
breadth);
{
}
}

class Rectangle:Shape
{
public Rectangle()
{
length=0;
breadth=0;
}
class Rectangle:Shape
{
public Rectangle()
{
length=0;
breadth=0;
}
public void calculateArea(int len, int
breadth)
{
Console.WriteLine ("Area of a Rectangle
is
{0}",len*breadth);
}

C# Simplified / Session 2 / 17 of 28

Single Inheritance
Contd
class Square:Shape
{
public Square()
{
}
public void calculateArea(int side1, int
side2)
{
int area;
area = side1*side2;
Console.WriteLine ("Area of a Square is
{0}",area);
}
}
}

C# Simplified / Session 2 / 18 of 28

Sealing a Class
A class is sealed when no class
should be allowed to inherit from
that class.
Keyword sealed is used to seal a
class classOne
class. sealed
{
//Class Implementation
}

C# Simplified / Session 2 / 19 of 28

base Keyword

Used to access the members of a

base class from within a derived class
Used to call constructors of a base
class while creating an instance of a
derived class
Using the keyword base in a static
method will result in an error

C# Simplified / Session 2 / 20 of 28

override keyword

Used to modify a method

An override method provides a new
implementation of the base method. The
base method should be declared as virtual
Accessibility level of a base method cannot
be changed by a method overriding it
Keywords new, static, virtual cannot be used
along with override modifier

C# Simplified / Session 2 / 21 of 28

virtual keyword

Keyword virtual is used in the definition of a

method to support polymorphism
Used to modify method declaration in a
class
Child classes are free to implement their
own versions of virtual method using
override keyword
Virtual modifier cannot be used with
modifiers like static and override

C# Simplified / Session 2 / 22 of 28

Virtual keyword Contd

Syntax for declaring a virtual method

[access modifier] virtual [return-type]
name( [parameters-list] )
{
//virtual method implementation
}

C# Simplified / Session 2 / 23 of 28

new keyword

Used as an operator or as a modifier

new modifier is used to explicitly
hide a member that is inherited from
the base class
It is an error to use both new and
override on the same method

C# Simplified / Session 2 / 24 of 28

New keyword Contd

using System;
public class Base
{
public static int val = 123;
}
public class Derv : Base
{
//new modifier required
public static int val = 456;
public static void Main()
{
//will execute derived class variable
Console.WriteLine (val);
}
}

C# Simplified / Session 2 / 25 of 28

Method Overriding

To override an existing method of the

base class:

Declare a new method in the inherited

class with the same name

Prefix it with the new keyword

C# Simplified / Session 2 / 26 of 28

Method Overriding Example

class MethodOverride
{
public static void Main()
{
StringAddition objStringAddition = new
StringAddition();
objStringAddition.add();
}
}

using System;
class IntAddition
{
public void add()
{
int firstNum =1;
int secondNum =2;
Console.WriteLine ("The Sum of the two numbers is :
{0}", firstNum+secondNum);
}
}
class StringAddition : IntAddition
{
new public void add()
{
string firstStr="a";
string secondStr="b";
Console.WriteLine ("The Sum of the two strings is :
{0}", firstStr+secondStr);
}
}

C# Simplified / Session 2 / 27 of 28

Summar
y

Parameterised constructors are constructors that take in parameters.

Constructors can be differentiated during run-time based on the

number of arguments or the type of the arguments passed.

In C#, the destructor is called by Garbage Collector.

Methods can be overloaded in C# in any of the two ways.

By specifying different number of parameters

By specifying different type of parameters

C# allows us to overload operators.

Overloading an operator means making an operator (for example, the

addition operator, +) behave differently when applied on certain
object of classes or structs.

C# does not support multiple inheritances.

To override an existing method of the base class, we declare a new

method in the inherited class of the same name and prefix it with the
new keyword.

C# Simplified / Session 2 / 28 of 28