Access Specifier

Encapsulation is defined 'as the process of enclosing one or more

items within a physical or logical package'. Encapsulation, in object
oriented programming methodology, prevents access to
implementation details.

Abstraction and encapsulation are related features in object oriented

programming. Abstraction allows making relevant information
visible and encapsulation enables a programmer to implement the
desired level of abstraction.

Encapsulation is implemented by using access specifiers. An access

specifier defines the scope and visibility of a class member. C#
supports the following access specifiers −

• Public
• Private
• Protected
• Internal
• Protected internal

Public Access Specifier

Public access specifier allows a class to expose its member variables
and member functions to other functions and objects. Any public
member can be accessed from outside the class.

The following example illustrates this −

using System;

namespace RectangleApplication {
class Rectangle {
//member variables
public double length;
public double width;

public double GetArea() {

return length * width;
}
public void Display() {
Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle {
static void Main(string[] args) {
Rectangle r = new Rectangle();
r.length = 4.5;
r.width = 3.5;
r.Display();
Console.ReadLine();
}
}
}

In the preceding example, the member variables length and width

are declared public, so they can be accessed from the function
Main() using an instance of the Rectangle class, named r.

The member function Display() and GetArea() can also access these
variables directly without using any instance of the class.

The member functions Display() is also declared public, so it can

also be accessed from Main() using an instance of the Rectangle
class, named r.
Private Access Specifier
Private access specifier allows a class to hide its member variables
and member functions from other functions and objects. Only
functions of the same class can access its private members. Even an
instance of a class cannot access its private members.

namespace RectangleApplication {
class Rectangle {
//member variables
private double length;
private double width;

public void Acceptdetails() {

Console.WriteLine("Enter Length: ");
length = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter Width: ");
width = Convert.ToDouble(Console.ReadLine());
}
public double GetArea() {
return length * width;
}
public void Display() {
Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle {
static void Main(string[] args) {
Rectangle r = new Rectangle();
r.Acceptdetails();
r.Display();
Console.ReadLine();
}
}
}
In the preceding example, the member variables length and width
are declared private, so they cannot be accessed from the function
Main(). The member functions AcceptDetails() and Display() can
access these variables. Since the member
functions AcceptDetails() and Display() are declared public, they
can be accessed from Main() using an instance of the Rectangle
class, named r.

Protected Access Specifier

Protected access specifier allows a child class to access the member
variables and member functions of its base class. This way it helps
in implementing inheritance. We will discuss this in more details in
the inheritance chapter.

Internal Access Specifier

Internal access specifier allows a class to expose its member
variables and member functions to other functions and objects in
the current assembly. In other words, any member with internal
access specifier can be accessed from any class or method defined
within the application in which the member is defined.

The following program illustrates this −

Live Demo
using System;

namespace RectangleApplication {
class Rectangle {
//member variables
internal double length;
internal double width;

double GetArea() {
return length * width;
}
public void Display() {
 Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle {
static void Main(string[] args) {
Rectangle r = new Rectangle();
r.length = 4.5;
r.width = 3.5;
r.Display();
Console.ReadLine();
}
}
}

When the above code is compiled and executed, it produces the

following result −

Length: 4.5
Width: 3.5
Area: 15.75

In the preceding example, notice that the member

function GetArea() is not declared with any access specifier. Then
what would be the default access specifier of a class member if we
don't mention any? It is private.
C# - Methods

A method is a group of statements that together perform a task.

Every C# program has at least one class with a method named
Main.

To use a method, you need to −

• Define the method

• Call the method

Defining Methods in C#
When you define a method, you basically declare the elements of its
structure. The syntax for defining a method in C# is as follows −

<Access Specifier> <Return Type> <Method Name>(Parameter List) {

Method Body
}

Following are the various elements of a method −

• Access Specifier − This determines the visibility of a variable or a

method from another class.
• Return type − A method may return a value. The return type is
the data type of the value the method returns. If the method is
not returning any values, then the return type is void.
• Method name − Method name is a unique identifier and it is case
sensitive. It cannot be same as any other identifier declared in
the class.
• Parameter list − Enclosed between parentheses, the parameters
are used to pass and receive data from a method. The
parameter list refers to the type, order, and number of the
parameters of a method. Parameters are optional; that is, a
method may contain no parameters.
 • Method body − This contains the set of instructions needed to
complete the required activity.

Example
Following code snippet shows a function FindMax that takes two
integer values and returns the larger of the two. It has public access
specifier, so it can be accessed from outside the class using an
instance of the class.

class NumberManipulator {

public int FindMax(int num1, int num2) {

/* local variable declaration */
int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}
...
}

Calling Methods in C#
You can call a method using the name of the method. The following
example illustrates this −

Live Demo
using System;

namespace CalculatorApplication {
class NumberManipulator {
public int FindMax(int num1, int num2) {
/* local variable declaration */
int result;
 if (num1 > num2)
result = num1;
else
result = num2;
return result;
}

static void Main(string[] args) {

/* local variable definition */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();

//calling the FindMax method

ret = n.FindMax(a, b);
Console.WriteLine("Max value is : {0}", ret );
Console.ReadLine();
}
}
}

When the above code is compiled and executed, it produces the

following result −

Max value is : 200

You can also call public method from other classes by using the
instance of the class. For example, the method FindMax belongs to
the NumberManipulator class, you can call it from another
class Test.

Passing Parameters to a Method

When method with parameters is called, you need to pass the
parameters to the method. There are three ways that parameters
can be passed to a method −
Sr.No. Mechanism & Description

Value parameters
This method copies the actual value of an argument into the formal parameter of the
1
function. In this case, changes made to the parameter inside the function have no effect
on the argument.

Reference parameters
2 This method copies the reference to the memory location of an argument into the formal
parameter. This means that changes made to the parameter affect the argument.

Output parameters
3
This method helps in returning more than one value.

C# Constructors
A class constructor is a special member function of a class that is
executed whenever we create new objects of that class.

A constructor has exactly the same name as that of class and it

does not have any return type. Following example explains the
concept of constructor −

Live Demo
using System;

namespace LineApplication {
class Line {
private double length; // Length of a line

public Line() {
Console.WriteLine("Object is being created");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
 static void Main(string[] args) {
Line line = new Line();

// set line length

line.setLength(6.0);
Console.WriteLine("Length of line : {0}",
line.getLength());
Console.ReadKey();
}
}
}

When the above code is compiled and executed, it produces the

following result −

Object is being created

Length of line : 6

A default constructor does not have any parameter but if you need, a
constructor can have parameters. Such constructors are
called parameterized constructors. This technique helps you to assign
initial value to an object at the time of its creation as shown in the
following example −

Live Demo
using System;

namespace LineApplication {
class Line {
private double length; // Length of a line

public Line(double len) { //Parameterized

constructor
Console.WriteLine("Object is being created,
length = {0}", len);
length = len;
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
 return length;
}
static void Main(string[] args) {
Line line = new Line(10.0);
Console.WriteLine("Length of line : {0}",
line.getLength());

// set line length

line.setLength(6.0);
Console.WriteLine("Length of line : {0}",
line.getLength());
Console.ReadKey();
}
}
}

When the above code is compiled and executed, it produces the

following result −

Object is being created, length = 10

Length of line : 10
Length of line : 6

Base and Derived Classes

A class can be derived from more than one class or interface, which
means that it can inherit data and functions from multiple base
classes or interfaces.

The syntax used in C# for creating derived classes is as follows −

<acess-specifier> class <base_class> {

...
}
class <derived_class> : <base_class> {
...
}

Consider a base class Shape and its derived class Rectangle −

Live Demo
using System;

namespace InheritanceApplication {
class Shape {
public void setWidth(int w) {
width = w;
}
public void setHeight(int h) {
height = h;
}
protected int width;
protected int height;
}

// Derived class
class Rectangle: Shape {
public int getArea() {
return (width * height);
}
}
class RectangleTester {
static void Main(string[] args) {
Rectangle Rect = new Rectangle();

Rect.setWidth(5);
Rect.setHeight(7);

// Print the area of the object.

Console.WriteLine("Total area: {0}",
Rect.getArea());
Console.ReadKey();
}
}
}
When the above code is compiled and executed, it produces the
following result −

Total area: 35

Initializing Base Class

The derived class inherits the base class member variables and
member methods. Therefore the super class object should be
created before the subclass is created. You can give instructions for
superclass initialization in the member initialization list.

The following program demonstrates this −

Live Demo
using System;

namespace RectangleApplication {
class Rectangle {

//member variables
protected double length;
protected double width;

public Rectangle(double l, double w) {

length = l;
width = w;
}
public double GetArea() {
return length * width;
}
public void Display() {
Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}//end class Rectangle
 class Tabletop : Rectangle {
private double cost;
public Tabletop(double l, double w) : base(l, w) {
}

public double GetCost() {

double cost;
cost = GetArea() * 70;
return cost;
}
public void Display() {
base.Display();
Console.WriteLine("Cost: {0}", GetCost());
}
}
class ExecuteRectangle {
static void Main(string[] args) {
Tabletop t = new Tabletop(4.5, 7.5);
t.Display();
Console.ReadLine();
}
}
}

When the above code is compiled and executed, it produces the

following result −

Length: 4.5
Width: 7.5
Area: 33.75
Cost: 2362.5