Programming in C#

PROGRAMMING IN C#
Chapter : 1
Introducing C#
What is C#?
Is a compute-programming language developed by

Microsoft Corporation, USA.
Is fully object-oriented language.
Is first Component-oriented language.
Suitable for developing Web-based applications
Designed for developing robust, reliable & durable

components to handle real-world applications.
Highlights of C#
Derived from C/C++ family.
It simplifies & modernizes C++.
It is only component oriented language available today.
It is a language designed for the .NET Framework.
It is a concise, lean & modern language.
It combines the best features of many commonly used

languages: the productivity of VB, the power of C++, & the
elegance of Java.
It is intrinsically object-oriented & web-enabled.
It has a lean & consistent syntax.
Is simple, robust & productive.
Major parts of .NET Framework are actually coded in C#.
Why C# ?????
The primary motivation while developing any language is the concern that it able to
handle the increasing complexity of programs that are robust, durable &
maintainable.
The history of major languages developed is as follows:
Ken Thompson
B
1970
Martin Richards
BPCL
1967
Dennis Ritchie
1972
1983
C++
Bjarne Stroustrup
1987
ANSI C
ANSI Committee
1991
Oak
James Gostling
1995
Java
Sun MicroSystems
1996
ANSI C++
2000
C#
ANSI Committe
Microsoft
Cont.
1.
2.
3.
4.
5.
6.
7.
8.
C & C++ languages suffer from a

number of shortcomings in
meeting World Wide Web
requirements & standards.
Some are as follows:
The high complexity of language
They are not truly object
oriented
They have poor type safety
They are not suitable for
working with new web
technologies.
They do not support versioning
Their low productivity
They are weak in consistency
Their poor compatibility with
the existing systems
VB, a language promoted by

Microsoft for overcoming these
problems, is not truly objectoriented and becomes
increasingly difficult to use when
systems become large.
Java which is truly objectoriented has not retained some
powerful C++ features such as
operator overloading.
Java also lacks inter-operability
with code developed in other
languages.
Microsoft therefore decided to
design a new language.
The result is C#, a simple &
modern language that directly
addresses the needs of
component-based software
development.
Evolution of C#
1.
2.
3.
4.
5.
The Internet is the mainstream

for many business organization
today.
There were a number of
limitations in using the WWW
over the Internet:
We could see only one site at a
time
The site had to be authored to our
hardware environment
The information was basically
read-only.
We could not dynamically
compare similar information
stored on different sites.
The internet is a collection of
many information islands that do
not co-operate with each other.
Microsoft wanted to develop a
software platform which will
overcome these limitations &
make the Web both
programmable and intelligent.
The outcome is a new generation

platform called .NET.
Microsoft introduced C# as a de
facto language of the .NET
platform.
C# has been particularly designed
to build software components
for .NET and it supports key
features of .NET natively.
C# compiler is embedded into
.NET as shown below:
.NET Platform
.NET Framework
C#
Cont
C# is a descendant of C++ which in turn is a

descendant of C as illustrated below:
C
Object
Orentation
C++
Power
Concept
Concept
Component
Java
Orientation
Elegance
C#
VB
Productivity
Characteristics of C# (5 marks)
Simple
Consistent
C# simplifies C++ by eliminating irksome operators such as ->, ::, and pointers.
C# treats integers & Boolean data types as entirely different types.
C# supports an unified type system which eliminates the problem of varying ranges of
integer types.
All types are treated as objects.
Modern
C# is called modern language bcoz it supports:
Automatic garbage collection

Rich intrinsic model for error handling
Decimal data types for financial applications
Modern approach to debugging
Robust security model
Object-Oriented
C# is truly object-oriented. It supports:
Encapsulation
Inheritance
Polymorphism
Cont.
Type-Safe
Type safety promotes robust programs.
C# incorporates number of type-safe measures:
All dynamically allocated objects & arrays are initialized to zero
Use of any uninitialized variables produces an error message by the compiler
Access to arrays are range-checked
C# does not support unsafe casts
C# supports automatic garbage collection
Versionable
Making new versions of software modules work with the existing applications is
known as versioning
C# provides support for versioning with the help of new & override keywords.
Compatible
C# enforces the .NET common language specifications & therefore allows interoperation with other .NET languages
Interoperable
C# provides support for using COM objects, no matter what language was used to
author them.
Flexible
We may declare certain classes & methods as unsafe and then use pointers to
manipulate them.
Applications of C#
C# is a new language developed exclusively to
suit the features of .NET platform.
It can be used for a variety of applications that
are supported by the .NET platform
Console
applications
Windows applications
Developing Windows Controls
Developing ASP .NET Projects
Creating Web Controls
Providing Web Services
Developing .NET component library
How Does C# differs from C++ ?
Changes Introduced
1.
2.
3.
4.
5.
6.
7.
8.
C# compiles straight from source code to executable

code, with no object files
In C#, class definition does not use a semicolon at
end
The first character of Main() function is capitalized
C# does not support #include statement
C# does not support multiple code inheritance
Casting in C# is much more safer then C++
C# does not support default arguments
C# permits declaration of variables between goto &
label
How Does C# differs from C++ ?
C++ Features Dropped
1.
2.
3.
4.
5.
6.
7.
8.
Macros
Multiple Inheritance
Templates
Pointers
Global Variables
Typedef statement
Default Arguments
Forward Declaration of Classes
Enhancements to C++
1.
2.
3.
4.
5.
6.
7.
Automatic Garbage Collection

Versioning Support
Strict Type-Safety
Properties to access data members
Delegates & Events
Boxing & Unboxing
Web Services
How Does C# differs from Java ?

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
C# has more primitive data types

Arrays are declared differently in C#
C# supports struct type & Java does not
Java does not provide for operator overloading
C# provides for better versioning support than Java
C# provides static constructors for initialization
Java does not directly support enumerations
C# uses is operator instead of instanceof operator in
Java
C# checks overflows uses checked statements
There is no labeled break statement in C#. The goto
statement is used to achieve this.
In Java, the switch statement can have only integer
expression, while C# supports either an integer or string
expressions
Chapter : 2
Understanding .NET: The C# Environment
The .NET STRATEGY
.NET is a software framework that includes

everything required for developing software for
web services.
It integrates presentation technologies,
component technologies & data technologies on a
single platform so as to enable users to develop
Internet applications.
The Origins of .NET Technology
The current technology of .NET has gone through three different phases of development:
OLE technology
COM technology
.NET technology
OLE (Object Linking & Embedding) technology
Developed by Microsoft to enable easy inter-process communications.
OLE provides support to achieve following:
To embed documents from one application into another application
To enable one application to manipulate objects located in another application
COM Technology:
Overcomes the problems of maintaining and testing of software.
A program can be divided into number of independent components where each one offers a
particular service.
Each component can be developed & tested independently and then integrated into the
main system.
This technology is known as Component Object Model (COM) and the software built using
COM is referred to as componentware.
Benefits:
Reduces Complexity
Enhances software maintainability
Enables distributed development acrossmultiple organizations
The Origins of .NET Technology (cont)
.NET Technology
Is third generation component model
Provides a new level of inter-operability compared to COM technology
Inter-module communication is achieved using Microsoft Intermedia
Language (MSIL) or simply IL
IL allows for true cross language integration
IL also provides metadata : describes characteristic of data including
datatypes & locations.
.NET also includes host of other languages & tools that enable us to develop
& implement Web-based applications easily.
Phase I Early 1990s OLE Technology

Phase II 1995
Interprocess Communication
COM Technology Intermodule Communication
Phase III Late 1990s .NET Technology Intersite Communication

Fig : Three generations of component model
The .NET Framework

.NET Platform
.NET Building
Block Services
.NET Device
Software
.NET User
.NET Infrastructure
Experience
& Tools
.NET Infrastructure & Tools

Visual Studio
.NET
Windows .NET
.NET Experience
Services
.NET Framework
.NET Framework
The .NET Framework (cont)
The .NET framework is one of the tools provided by the .NET infrastructure
& tools component of the .NET platform.
The .NET framework provides an environment for building, deploying &
running web services & other applications.
It consists of three distinct technologies:
Common Language Runtime

Framework Base Classes
User & program interfaces(ASP .NET)
.NET Framework
ASP .NET
Windows Forms
(Web Services)
(User Interface)
The Common Language Runtime (CLR)

Is heart & soul of the .NET framework
Is responsible for loading & running C#
programs.
Supports cross-language interoperability.
Services provided:
Loading
& execution of programs

Verification of type-safety
Providing metadata
Memory management
Enforcement of security
Interoperability with other systems
Managing exceptions & errors
Debugging
Components of CLR (cont)

Common Type System
Intermedia Language (IL)
Execution Support Functions
Security
Garbage Collection
Class Loader
Memory Layout
Allows to implement applications quickly

The functionality of the base framework classes resides in
the namespace called System
Provides:
Input/Output operations
String handling
Managing arrays, lists,maps,etc
Accessing files & file systems
Accessing the registry
Security
Windowing
Database management
Drawing
Managing errors & exceptions
Connecting to Internet
User & Program Interfaces
The .NET framework provides the following tools

for managing user & application interfaces:
Windows
forms
Web forms
Console applications
Web Services
These tools enables users to develop user-friendly

desktop-based as well as web-based applications.
Benefits of the .NET Approach
The .NET technology provides a number of benefits to

developers & users.
Some of them are:
Simpler & faster systems development

Enhanced built-in functionality
Many different ways to communicate with the outside world
Integration of different languages into one platform
Easy execution
Wide range of scalability
Interoperability with existing applications
Fewer bugs
Potentially better performance
Chapter : 3
Overview of C#
Introduction
C# can be used to develop two categories of

programs:
Executable
application programs &

Component libraries
Executable programs are written to carryout

certain tasks & require Main method in one of
the classes.
Component libraries do not require Main
declaration because they are not standalone
application programs.
They
are written for use by other applications.
A Simple C# Program
class SampleOne
{
public static void Main()
{
System.Console.WriteLine(C# is sharper than C++);
}
}
Executing the program

Save the above file with SampleOne.cs name
Compile as : csc SampleOne.cs
C# compiler compiles your code and create an executable file by
name
SampleOne.exe
For executing the program, simply type in the name of the

executable file at the command prompt.
NAMESPACES
System.Console.WriteLine();
Here System is a namespace in which the Console class is
located.
This class can be accessed using the dot operator.
C# supports using directive that can be used to import the
namespace System into the program.
using System;
class SampleTwo
{
{
Console.WriteLine(Hello World!!!);
}
}
Adding Comments
Enhances readability & understanding of the

code.
Programs should have information such as
implementation details, change history and tasks
performed.
Types of comments:
Single-line
comments (//)
Multiline comments (/* .. .. */)
Main Returning a Value
Main() can also return a value if it is declared as int instead of

void.
When the return type is int, we must include a return statement at
the end of the method.
using System;
class SampleThree
{
public static int Main()
{
Console.WriteLine(Hello World!!!);
return 0;
}
}
The value returned serves as the programs termination status

code.
It allows communication of success or failure to the execution
environment.
Using Aliases for NAMESPACE Classes

using A=System.Console;
class SampleFour
{
{
A.WriteLine(Hello World!!!);
}
}
Passing String Objects to WriteLine Method

using System;
class SampleFive
{
{
string name=PentaSoft Technologies;
Console.WriteLine(name);
}
}
Command Line Arguments
Can be used to take an input from a user.

Command line arguments are parameters supplied to the
Main method at the time of invoking it for execution
using System;
class SampleSix
{
public static void Main(string[] args)
{
string name=Welcome to;
Console.Write(name);
Console.Write( +args[0]);
Console.WriteLine( +args[1]);
}
}
MAIN with a Class

class Demo //class definition
{
public void display()
{
System.Console.WriteLine(In Demo Class);
}
}
class SampleSeven
{
{
Demo d=new Demo(); //creating d object
d.display(); //callinf display() function
}
}
Providing Interactive Input

using System;
class SampleEight
{
{
Console.Write(Enter Your Name);
string name=Console.ReadLine();
Console.WriteLine(Hello +name);
}
}
Using Mathematical Functions

using System;
class SampleNine
{
{
double x=5.0;
double y;
y=Math.Sqrt(x);
Console.WriteLine(y = +y);
}
}
Multiple Main Methods
In C# it is possible to have Main

method in different classes.
In such situations there would be
multiple entry points in the
program.
There should be only one.
This problem can be resolved by
specifying which Main is to be
used to the compiler at the time
of compilation:
csc filename.cs/main:classname
Example :
multimain.cs/main:Class A
multimain.cs/main:Class B
OR
//multimain.cs
using System;
class A
{
{
Console.Write(Class A);
}
}
class B
{
{
Console.Write(Class B);
}
}
Compile Time Errors
A program is never totally error-free

Types of errors:
Syntax Errors
Logic Errors
Syntax errors will be caught by the

compiler
Logical errors should be eliminated by
testing the program logic carefully.
When the compiler cannot interpret
what we are attempting to convey
through our code the result is syntax
error.
Example:
using Systom;
class SampleTen
{
public static void main()
{
Console.Write(Hello);
}
}
1.
2.
3.
4.
Errors.cs(2.7): error cs0234: The type

or namespace name Systom does not
exists in the class or namespace
The error message contains:
Name of the file being
compiled(Errors.cs)
Line number & column position of the
error(2.7)
Error code as defined by the compiler
(cs0234)
Short description of error
Program Structure
The documentation section

consists of a set of comments
giving the name of the
program, the author, date &
other details.
The using directive section
includes all those namespaces
that contain classes required
by the application
A interface is similar to a
class but contains only
abstract classes.Used in
multiple inheritance
A C# program may contain
multiple class definitions.
Every C# program requires a
Main method as its starting
point, the class containing the
Main is the essential part of
program.
Documentation Section
Optional
Using Directive Section
Optional
Interfaces Section
Optional
Classes Section
Optional
Main Method Section
Essential
Chapter : 4
Literals, Variables & Data Types
Literals
Literals are the value constants assigned to

variables in a program.
C# supports seven types of literals.
Integral
Literals : Decimal & Hexadecimal Integers

Real Literals
Boolean Literals :True / False
Single Character Literals
String Literals
Backslash Character Literals : \a, \b, \n, \t, \\, \
Variables
Is an identifier that denotes a storage location used to store

data value.
May take different values at different times during program
execution.
Name should be meaningful.
May consist of alphabets, digits & the underscore.
Conditions:
Not begin with a digit

Uppercase & lowercase are distinct
It should not be a keyword
White space is not allowed
Name can be of any length
Data Types
Every variable in c# is associated with a data type
Specifies the size and type of values that can be stored
Types in C#
Values types are stored on stack
Value types
Reference types
Pointers
When a value of a variable is assigned to another variable,
the value is actually typed.
Reference types are stored on heap
When a value of a variable is assigned to another reference

variable, only the reference is copied.
Taxonomy C# data types

C# Data Types
Value Types
Predefined
Types
Pointers
User-defined
Types
Reference Types
Predefined
Types
User-defined
Types
Integers
Enumerations
Objects
Classes
Real Numbers
Structures
Strings
Arrays
Booleans
Delegates
Characters
Interfaces
Declarations of Variables
Variables are names of storage locations.
Declaration does three things
Tells the compiler what the variable name is.

2. Specifies what type of data the variable will hold.
3. The place of declaration decides the scopeof variable.
1.
Syntax:
type variable1, variable2,. variableN
Default Values
A variable is either explicitly assigned a value or automatically

assigned a default value.
Following categories of variables are automatically initialized to
their default values.
Static variables
Instance variables
Array elements
Type
Default Value
All integer types
char type
\x000
float type
0.0f
double type
0.0d
decimal type
0.0m
bool type
false
enum type
All reference type
null
Constant Variables
Variables whose values do not change during the

program execution are known as constants.
Eg.
const
int Rows=10
const int Cols=10
Advantages
Programs
are easier to read & understand

Programs are easier to modify
Accidental errors are minimized
Scope of Variables
It is region of code within which the variable can be accessed.

Depends on type of the variable and its place of declaration.
Consider following Eg
class ABC
{
static int m;
int n;
void fun(int x, ref int y, out int z, int[] a)
{
int j=10;
..
..
}
}
Static variables
The value parameter x will exists till the end of fun() method
The reference & output parameters (y & z) do not create a new storage locations.
Declared at the class level

Known as fields or field variables.
The scope of these variables begins at the place of their declaration & ends when the
Main method terminates.
Their scope is same as the underlying variables that are passed as arguments.
Array element a[0] come into existence when an array instance is created, & cease to
exist when there are no references to that array instance.
Variables declared inside a method are called local variables.
Their scope is until the end of block inside which they are declared.
Boxing & Unboxing
In OOP, methods are invoked with the help of objects.

Value types such as int & long are not objects, we cannot
use them to call methods.
C# achieve this through a technique called as boxing.
Boxing means the conversion of a value type on the stack to
a object type on the heap.
The conversion from an object type back to a value type is
known as unboxing.
Boxing
Any type, value or reference can be assigned to an object without an explicit

conversion.
When a compiler finds a value type where it needs a reference type, it creates an
object box into which it places the value of the value type.
Example:
int m=100;
object om=m; //creates a box to hold m
This code creates a temporary reference type box for the object on heap.
This can also be done with:
int m=100;
object om=(object)m; //C-style casting
Here the variable m & om exist but the value of om resides on the heap. The values
are independent of each other.
int m=100;
object om=m;
m=20;
Console.WriteLine(m); //m=20
Console.WriteLine(om); //om=10
Unboxing
It is the process of converting the object type back to the

value type.
We can only unbox a variable that has previously been
boxed.
Unboxing is an explicit operation using C-style casting.
int m=100;
object om=m; //box m
int n=(int)om; //unbox om back to an int
When unboxing a value, we have to ensure that the value

type is large enough to hold the value of the object.
Chapter : 5
Operators & Expressions
Type of Operators
Arithmetic
operators
Relational operators
Logical operators
Assignment operators
Increment & decrement operators
Conditional operators
Bitwise operators
Special operators
Arithmetic Operators
Operator
Symbol
Action
Addition
Adds two
operands
x+y
Subtraction
Subtracts the 2nd

operand with 1st
operand
xy
Multiplication
Multiplies two
operands
x*y
Division
Divides two
operand
x/y
Modulus
Gives the
remainder when
the operands are
divided.
Example
x%y
Exercise
Write a program to demonstrate use of all

Arithmetic operators.
Relational Operators.
Relational operators are used to compare

expressions.
An expression containing a relational operator
evaluate to either true(1) or false (0).
Relational Operators.
Syntax: (ae-1 relational operator ae-2)
Operator
Symbol
Equal
==
Greater than
>
Less Than
<
Greater than or equal to
>=
Less than or equal to
<=
Not Equal to
!=
Exercise
Write a program to demonstrate use of relational

operators.
Logical operators
Logical operators helps a user to combine two or more relational

expressions into a single expression.
Operator
Symbol
AND
&&
OR
||
NOT
Bitwise logical AND
&
Bitwise logical Or
Bitwise logical exclusive Or
The Assignment Operator:
Used to assign the value of an expression to a variable.

The assignment operator is the equal sign (=).
Syntax : variable = expression;
For e.g. a=b;
C# also has a set of short assignment operator.
Syntax: v op=exp
Example:
Here v is a variable, exp is an expression & op is an C# binary operator.

The operator op= is known as shorthand assignment operator.
x+ = y+1;
is same as
x=x+(y+1);
Advantages of shorthand assignment operators:
Easier to read.
The statement is more concise
Results in more efficient code
C# Unary mathematical operators:Operator
Symbol
Action
Examples
Increment
++
Increments the
operand by one
++x, x++
Decrement
--
Decrements the
operand by one
--x, x--
Prefix and Postfix modes
When used in prefix mode, the increment and

decrement operators modify their operand before
its used.
When used in postfix mode, the increment and
decrement operators modify their operand after
its used.
Exercise:
Write a program to demonstrate prefix and

postfix modes.
Conditional Operator
Is C#s only ternary operator.
Takes three operators.
Syntax : exp1 ? exp2 :exp3;

Here if exp1 evaluates to true, then value of exp2
is assigned else of exp3.
Eg.
a=10;
b=15;
x = (a > b) ? a :b;
Operator Precedence and Parentheses
Some rules are needed about the order in which operations are
performed.
This order, called operator precedence, is strictly spelled out in C#
Operators
Relative Precedence
*/%
+-
Type Conversion
Used to convert data of one type to another type.

Example:
byte b1=10;
byte b2=20;
byte b3=b1+b2;
Results in an error message because, when we add two byte
values, the compiler automatically converts them into int
types and the result is an integer.
Hence code should be:
int b3=b1+b2; //no error
Ways of Type Conversion
Implicit Conversions
Explicit Conversions
Type Conversions
Implicit
Conversions
Explicit
Conversions
Arithmetic
Operations
Casting
Operations
Mathematical Functions
Present in Math class of System Namespace.

Static Members: E and PI
Mathematical Methods in Math class:
Method
Description
Sin()
Asin()
Sine of an angle in
radians
Cosine of an angle in
radians
Tanget of an angle in
radians
Inverse of Sine
Acos()
Inverse of Cosine
Atan()
Inverse of Tangent
Sinh()
Hyperbolic sine
Cos()
Tan()
Cosh()
Hyperbolic cosine
Tanh()
Hyperbolic tangent
Sqrt()
Square Root
Pow()
Exp()
Number raised to a
given power
Exponential
Log()
Natural logarithm
Abs()
Absolute value
Min()
Lower of two numbers
Max()
Higher of two numbers
Exercise:
Write a program to find square root of number 25

Write a program to find minimum between two
numbers 25 & 35 using Math class.
Chapter : 6
Decision Making & Branching
The if Statement
Is a powerful decision making statement

Used to control the flow of execution of
statements
General form:
if (boolean-expression)
{
statement-block;
}
statement-x;
Flowchart of simple if control

Entry
boolean
expression
?
True
Statement
block
Statement-X
Next statement
False
Jumping
Exercise
Write a program that stores weight & height of

10 person in array & count number of person
with height greater than 170 & weight more than
55.
The IF.. ELSE Statement
Is an extension of if statement.
General form:
if (boolean-expression)
{
true-block statement (s);
}
else
{
false-block statement (s);
}
statement-x;
Flowchart of ifelse control

Entry
True
boolean
expression
?
False
False-Block
Statement
True-Block
Statement
Statement-X
Next statement
Exercise
Write a program that counts total of even & odd

numbers stored in an array number.
Nesting of If.Else Statements
Used when a series of decisions are involved.

General form:
if (test condition1)
{
if (test condition2)
{
statement-1;
}
else
{
statement-2;
}
}
else
{
statement-3;
}
statement-x;
Flowchart of nested if.else statements

Entry
False
Test
condition1
?
False
Statement-3
Statement-2
Statement-X
Next statement
True
Test
condition2
?
True
Statement-1
Exercise
Write a program that finds largest among 3

numbers using nested if..else statement.
The Else If Ladder
Used when multipath decisions are involved.

It is an chain of ifs in which the statement associated with each else is an
if.
General form:
if (condition 1)
statement-1;
else if (condition 2)
statement-2;
else if (condition 3)
statement-3;
else if (condition n)
statement-n;
else
default-statement;
statement-x;
Exercise
Write a program that finds the grade of a student

using else if ladder.
The Switch Statement
If statements increases complexity of a

program dramatically as the
alternatives increases.
The program becomes difficult to read
& follow.
C# offers an alternative with the help of
switch statement
General Form:
switch(expression)
{
case value-1:
block-1
break;
case value-2:
block-2
break;
---------------------------------------------------------default:
default-block
break;
}
statement-x;
Here, the expression must be an integer

type or char or string type
Value-1, value-2 are constants or
constant expressions & are known as
case labels.
Block-1, block-2 are statement lists
and may be zero or more statements.
Example
using System;
class CityGuide
{
public static void main()
{
Console.WriteLine(Select your choice);

Console.WriteLine(London);
Console.WriteLine(Bombay);
Console.WriteLine(Paris);
Console.WriteLine(Type your choice);
String name = Console.ReadLine ( );
switch (name)
{
case Bombay:
Console.WriteLine(Bombay : Guide 5) ;
beak;
case London:
Console.WriteLine(london : Guide 10) ;
beak;
case Paris:
Console.WriteLine(Paris : Guide 15) ;
beak;
default:
Console.WriteLine(Invalid choise) ;
break;
}
Fallthrough in Switch Statement
In the absence of the break

statement in a case block, if the
control moves to the next block
without any problem, it is known
as fallthrough.
Fallthrough is permitted in C, C+
+ & Java.
C# does not permit automatic
fallthrough, if the case block
contains some code.
However, it is allowed if the case
block is empty.
If we want two consecutive case
blocks to be executed
continuously, we have to force the
process using the goto statement.
Example
switch(m)
{
case 1:
x=y;
goto case2;
case 2:
x=y+m;
goto default;
default:
x=y-m;
break;
}
Chapter : 7
Decision Making & Looping
The While Statement
The process of repeatedly

executing a block of statements is
known as looping.
Entry based loop
Is an entry-controlled loop
statement.
The test condition is evaluated
and if the condition is true, then
the body of the loop is executed.
Syntax:
initialization;
while(test condition)
{
Body of the Loop
}
Test False
cond
True
Body of the
loop
Example
class DowhileTest
{
public static void Main ( )
{
int two,count,y;
two = 2;
count=1;
System.Console.WriteLine("Multiplication Table \n");
while(count<=10)
{
y = two * count ;
System.Console.WriteLine("2 * " + count + " = " + y) ;
count = count + 1;
}
}
}
The Do Statement
On some occasions it might be

necessary to execute the body of
the loop before test is performed
Exit based loop
This can be handled using do

statement.
Is an exit-controlled loop
statement.
The body of the loop is executed
at least once.
Syntax:
initialization;
do
{
Body of the Loop
}while(test condition);
Body of the
loop
Test
cond
False
True
Example
class DowhileTest
{
{
int two,count,y;
two = 2;
count=1;
System.Console.WriteLine("Multiplication Table \n");
do
{
y = two * count ;
System.Console.WriteLine("2 * " + count + " = " + y) ;
count = count + 1;
}while ( count <= 10 ) ;
}
}
Exercise
Program using do..while to print all the odd

numbers till 20
The For Statement
Is an entry-controlled loop
Syntax:
for(initialization;testcondition;increment)
{
Body of the loop..
}
All the three actions, namely initialization,
testing & incrementing, are placed in the for
statement itself.
Exercise
Program using for loop to print multiplication

table from 2 to 5
The FOREACH Statement
Enables to iterate elements in an array.

General form:
foreach(type variable in expression)
{
Body of the loop
}
The type & variable declares the iteration variable.
During execution, iteration variable represents the array
element for which iteration is currently being performed.
in is a keyword.
Example
using System;
class ForeachTest
{
{
int[] arryInt={11,22,33,44};
foreach(int m in arryInt)
{
Console.Write(" " + m);
}
Console.WriteLine();
}
}
Jumps in Loops
C# permits a jump from one statement to the end or

beginning of a loop as well as jump out of a loop.
Jumping Out of a loop
An early exit from a loop can be accomplished by using the
break & goto statements.
Using break statement the loop is immediately exited and
the program continues with the statement immediately
following the loop.
Skipping a Part of a Loop
The continue statement causes the loop to continue with
the next iteration after skipping any statements in the
between.
Exiting a loop with break statement

while(.)
do
{
{
.
if (condition)
break;
..
Exit..
from
} loop
Exit from
loop
..
if (condition)
break;
..
..
}while (.)
.
..
for (.)
{
if (error)
break;
..
..
Exit from
} loop
..
Exit from
loop
for (.)
{
for (..)
{
..
if (condition)
break;
Bypassing & Continuing in Loops

while (test condition)
do
if (..)
continue;
.
.
}
if (..)
continue;
.
..
} while (test condition);
for (initialization; test condition; increment)

{
if (.)
continue;
..
Labelled Jumps
Used to jump a set of nested loops or to continue a loop that

is outside a current one.
Example
Public static void Main(String a[])
{
if(a.Length==0)
goto end;
Console.WriteLine(a.Lenght);
end; //Label name
Console.WriteLine(end);
}
Chapter : 8
Methods in C#
Declaring Methods
Methods are declared inside the body of a class

General form:
modifiers type methodname(formal-parameter-list)
{
method---body
}
Method declaration has five parts:
Name of the method

Type of value the method returns
List of parameters
Body of the method
Method modifiers
Example:
int Product(int x,int y)
{
int m=x*y;
return(m);
}
List of Method Modifiers

Modifier
Description
new
The method hides an inherited method with the same signature.
public
The method can be access from anywhere, including outside the class.
protected
The method can be access from within the class to which it belongs, or a type
derived from that class.
internal
The method can be accessed from within the same program.
private
The method can only be accessed inside the class to which it belongs.
static
The method does not operate on a specific instance of the class
virtual
The method can be overridden by a derived class.
abstract
A virtual method which defines the signature of the method, but doesnt
provide an implementation.
override
The method overrides an inherited virtual or abstract method.
sealed
The method overrides an inherited virtual method, but cannot be overridden

by any class which inherit from this class. Must be used in conjunction with
override.
The method is implemented externally, in a different language.
extern
Invoking Methods
Once method is defined, they must be activated

for operations.
Process of activating a method is known as
invoking or calling
General form:
objectname.methodname(actual-parameter-list);
Example
using System;
class Method // class containing the method
{
// Define the Cube method
public int Cube(int x)
{
return(x*x*x);
}
}
// Client class to invoke the cube method
class MethodTest
{
public static void Main( )
{
// Creat object for invoking cube
Method M = new Method( );
// invoke the cube method
int y = M.Cube(5); //Method call
// Write the result

Console.WriteLine(y);
}
Program for calling a static method

using System;
class StaticMethod
{
{
double y = Square (2.5F); //Method Call
}
Console.WriteLine( y );
static double Square ( float x )

{
return ( x * x );
}
}
Nesting of Methods
Methods can be invoked without

using an object & dot operator.
A method can be called using only
its name by another method of
the same class.
This is known as nesting of
methods.
using System;
class Nesting
{
public void Largest ( int m, int n )
{
int large = Max ( m , n );
Console.WriteLine( large );
}
int Max ( int a, int b )
{
int x= ( a > b ) ? a : b ;
return ( x );
}
}
class NestTesting
{
{
Nesting next = new Nesting ( ) ;
next.Largest ( 100, 200 ) ;
}
}
Method Parameters
For managing the process of passing values &

getting back the results, C# employs four kinds of
parameters.
Value
Parameters
Reference Parameters
Output Parameters
Parameter Arrays
Pass By Value
By default, method
parameters are passed by
value.
When a method is invoked,
the value of actual
parameters are assigned to
the corresponding formal
parameters.
Any changes to formal
parameters does not affect the
actual parameters.
There are 2 copies of
variables when passed by
value.
using System;
class PassByValue
{
static void change (int m)
{
m = m+10;
}
{
int x = 100;
change (x);
Console.WriteLine("x =" +
x);
}
}
Pass By Reference
We can force the value parameters to

be passed by reference.
Use ref keyword.
This does not create a new storage
location.
It represents the same storage
location as the actual parameter.
When a formal parameter is declared
as ref, the corresponding actual
argument in the method invocation
must be declared as ref.
Used when we want to change the
values of variables in the calling
method.
using System;
class PassByRef
{
static void Swap ( ref int x, ref int y )
{
int temp = x;
x = y;
y = temp;
}
{
int m = 100;
int n = 200;
Console.WriteLine("Before Swapping;");
Console.WriteLine("m = " + m);
Console.WriteLine("n = " + n);
Swap (ref m , ref n );
Console.WriteLine("After Swapping;");
Console.WriteLine("n = " + n);
}
}
The Output Parameters
Used to pass results back to the calling method.
Declare the parameters with an out keyword.
It does not create a new storage location.
When a formal parameter is declared as out, the corresponding actual argument in the method
invocation must also be declared as out.
using System;
class Output
{
static void Square ( int x, out int y )
{
y = x * x;
}
{
int m; //need not be initialized
Square ( 10, out m );
}
}
Variable Argument Lists
We can define methods that can

handle variable number of
arguments using parameter
arrays.
Parameter arrays are declared
using the keyword params
The parameter arrays should be a
one-dimensional arrays.
using System;
class Params
{
static void Parray (params int [ ]
arr)
{
Console.Write("array elements
are:");
foreach ( int i in arr)
Console.Write(" " + i);
Console.WriteLine( );
}
{
int [ ] x = { 11, 22, 33 };
Parray ( x) ;
//call 1
Parray ( ) ;
//call 2
Parray ( 100, 200 ) ;//call 3
}
}
Method Overloading
Enables us to create more than one

method with the same name, but with
the different parameter lists &
different definitions.
Required when methods are required
to perform similar tasks but using
different input parameters.
Example
using System;
class Overloading
{
{
Console.WriteLine(add(2,3));
Console.WriteLine(add(2.6F,3.1F));
Console.WriteLine(add(312L,22L,21));
}
static int add(int a,int b)
{
return(a+b);
}
static float add(float a,float b)
{
return(a+b);
}
static long add(long a,long b,int c)
{
return(a+b+c);
}
Chapter : 9
Handling Arrays
Introduction
Array is a group of contiguous or related data

items that share a common name.
A particular value is indicated by writing a
number called index number or subscript in
brackets after the array name.
Example : marks[10]
The complete set of values is referred to as an
array.
The individual values are called elements.
One-Dimensional Arrays
A list of items can be given one variable name using only one subscript & such
a variable is called a one-dimensional array.
Declaration of Arrays:
Creation of Arrays:
Syntax: type[] arrayname;

Example:
int[] counter;
float[] marks;
int[] x,y;
Syntax: arrayname = new type[size];
Example:
counter=new int[5];
marks=new float[4];
Combination:
int[] counter=new int[5];
Initialization of Arrays:
Syntax: arrayname[subscript]=value;
Example:
marks[0]=60;
marks[1]=70;
int[] counter={10,20,30,40,50};
int len=c.Length;
//Returns Length of Array
Exercise
Write a program to sort an array of 5 number

taking from user as input.
Two-Dimensional Arrays
Allows to store table of values.
Example: v[4,5];
Each dimension of the array is indexed from zero to its

maximum size minus one.
First index specifies the row & second index specifies the
column within that row.
Declaration: int[,] myArray;
Creation: myArray=new int[3,4];
Combination: int[,] myArray=new int[3,4];
Initialization: int[,] n={{0,0,0},
{1,1,1}};
Example
using System;
class MulTable
{
static int ROWS = 5;
static int COLUMNS = 10;
{
int[,] product =new int[ROWS,COLUMNS];
int i,j;
for (i=1; i<ROWS; i++)
{
for (j=1; j<COLUMNS; j++)
{
product[i, j] = i*j;
Console.Write(" " +product[i , j]);
}
Console.WriteLine(" ");
}
}
}
Variable-Size Arrays
C# treats multidimensional arrays as arrays of arrays.
It is possible to declare two-dimensional array as follows:
int[][] x=new int[3][]; //three rows array

x[0]=new int[2]; //first row has two elements
x[1]=new int[4]; //second row has four elements
x[2]=new int[3]; //third row has three elements
These statements create a two-dimensional array having

different length for each row.
Also called as jagged arrays.
Initializing: x[1][1]=10;
System.Array Class
In C# every array we create is automatically derived from

the System.Array class.
Methods/properties present in this class:
Method/Property
Purpose
Clear()
Sets a range of array elements to empty values
CopyTo()
Copies elements from source array to destination
GetLength()
array
Gives the number of elements in a given
GetValue()
dimension of the array

Gets the value for a given index in the array
Length
Gets the lengths of an array
SetValue()
Sets the value for a given index in the array
Reverse()
Reverses the contents of a one-dimensional array
Sort()
Sorts the elements in a one-dimensional array.
Example
using System;
class Sort
{
{
int[] x ={10,5,2,11,7};
Console.WriteLine("Before Sort");
foreach(int i in x)
Console.WriteLine(" " + i);
Array.Sort(x);
Console.WriteLine("After Sort");
foreach(int i in x)
Console.WriteLine(" " + i);
ArrayList Class
Present in System.Collections namespace.
Can store a dynamically sized array of objects.
Has an ability to grow dynamically.
Example:
ArrayList
city=new ArrayList(30);
Creates city with a capacity to store 30 objects.
Default is 16.
Adding Elements:
Removing Elements:
Modifying Capacity:
city.Add(Delhi);
city.Add(Mumbai);
city.RemoveAt(1);
city.Capacity=20;
Example
using System;
using System.Collections;
class Sort
{
{
ArrayList city=new ArrayList();
city.Add("Delhi");
city.Add("Mumbai");
city.Add("Madras");
city.Add("Kerela");
Console.WriteLine("Capacity=" + city.Capacity);
for(int i=0;i<city.Count;i++)
Console.WriteLine(" " + city[i]);
city.Sort();
Console.WriteLine("After Sort");
for(int i=0;i<city.Count;i++)
Console.WriteLine(" " + city[i]);
ArrayList Property & Methods

Method/Property
Purpose
Add()
Adds an object to a list
Clear()
Removes all the elements from the list
Contains()
Determines if an element is in the list
CopyTo()
Copies a list to another
Insert()
Inserts an elements into the list
Remove()
Removes the first occurrence of an element
RemoveAt()
Removes the element at the specified place
RemoveRange()
Removes a range of elements
Sort()
Sorts the elements
Capacity
Gets or sets the number of elements in the list
Count
Gets the number of elements currently in the

list.
Chapter : 10
Manipulating Strings
Introduction
Represents a sequence of characters

Example : string s1=abc;
Copying String:
string s2=s1;
string s2=String.Copy(s1);
Concatenating String:
string s3=s1+s2;
string s3=string.Concat(s1,s2);
Reading from keyboard:
string s=Console.ReadLine();
Conversion:
int num=111;
string s=num.ToString();
Verbatim Strings: Starts with @ symbol. Tells the compiler
to use string as verbatim string even if it includes escapes
characters.
String s1=@\EGB\CSharp\String.cs;tim
String Methods
String objects are immutable.

Thus we cannot modify the characters contained
in them.
However we can produce a modified version of a
string using built in operations.
Methods:
Compare(), Concat(), Copy(), Equals(), Insert(),
Join(), Replace(), Split(), ToLower(), ToUpper(),
Trim(), TrimStart(), TrimEnd().
Example
using System;
class demo
{
{
string s1="Lean";
string s2=s1.Insert(3,"r");
string s3=s2.Insert(5,"er");
string s4="Learner";
string s5=s4.Substring(4);
Console.WriteLine(s2);
Console.WriteLine(s3);
if(s3.Equals(s4))
Console.WriteLine("Two Strings are Equal");
Console.WriteLine("Substring="+s5);
}
}
Mutable Strings
They cab be modified using StringBuilder class.
Can grow dynamically.
Also known as dynamic strings.
Example:
StringBuilder s=new StringBuilder(abc);
Methods:
Append(), Insert(), Remove(), Replace()
Property:
Capacity, Length, [ ]
Example
using System;
using System.Text;
class StringBuild
{
{
StringBuilder s=new StringBuilder("Object ");
Console.WriteLine("Original="+s);
Console.WriteLine("Length="+s.Length);
s.Append("Language");
Console.WriteLine("Append="+s);
s.Insert(6," Oriented ");
Console.WriteLine("Inserted="+s);
Regular Expressions
Provides a powerful tool for searching & manipulating a

large text.
Used to:
A regular expression (also known as pattern string) is a

string containing two types of characters,
Locate substrings & return them

Modify one or more substrings & return them
Identify substrings that begin with or end with a pattern of
characters
Find all words that begin with a group of characters and
end with some other characters
Literals
Metacharacters
Literals are characters that we wish to search & match in

the text
Metacharacters are special types of characters that give
commands to the regular expression parser.
Cont.
Examples of Regular Expression:
Expression
Meaning
\bm
Any Word Beginning with m
er\b
Any word Ending with er
\bm\S*er\b
Any word beginning with m and ending with er
|,
Any word separated by spaces or comma
System.Text.RegularExpressions supports a number of

classes that can be used for searching, matching &
modifying a text document.
Example
using System;
using System.Text; //for StringBuilder class
using System.Text.RegularExpressions;
//for Regex class
class RegexTest
{
{
string str;
str = "Amar, Akbar, Antony are friends!";
Regex reg = new Regex (" |, ");
StringBuilder sb = new StringBuilder( );
int count = 1;
foreach(string sub in reg.Split(str))
{
sb.AppendFormat("{0}: {1}\n", count++, sub);
}
Console.WriteLine(sb);
}
}
Chapter : 11
Structures & Enumerations
Structures
We can create our own value types using structures.
Used to pack data of different types.
Syntax: Define Structure

struct struct-name
{
datamember1;
datamember2;
.
}
The variables inside struct are called as members or fields or elements.
Creating variables of new type:
struct-name variablename;
or
struct-name variablename = new struct-name();
Assigning values to Members:
variablename.datamember1=value;
Struct data members are private by default & hence declare them as public.
Example
using System;
struct Item
{
public string name;
public int code;
public double price;
}
class StructTest
{
{
Item fan;
fan.name = "Bajaj";
fan.code = 123;
fan.price = 1576.50;
Console.WriteLine("Fan name: " + fan.name);

Console.WriteLine("Fan code: " + fan.code);
Console.WriteLine("Fan cost: " + fan.price);
Structs with Methods
We can also assign values to data members using constructors.

A constructor is a method which is used to set values of data
members at the time of declaration.
struct Number
{
int number;
public Number (int value)
{
number=value;
}
}
The constructor is invoked as follows:

Number num=new Number(190);
Example
using System;
struct Rectangle
{
int a, b;
public Rectangle ( int x, int y ) //constructor
{
a = x;
b = y;
}
public int Area( ) //a method
{
return ( a * b );
}
public void Display ( )
//another method
{
Console .WriteLine("Area = " + Area( ) );
}
}
class TestRectangle
{
{
Rectangle rect = new Rectangle ( 10, 20 );
rect.Display ( );
//invoking Display ( ) method
}
}
Difference between Classes & Structs (5 Marks)

Category
Data Type
Inheritance
Classes
Reference type & stored on
heap
Support Inheritance
Default Values
Default value of a class

type is null
Field
Initialization
Constructors
Destructors
Permit initialization of
instance fields
Permit declaration of
parameterless constructors
Supported
Assignment
Copies the referennce
Structs
Value Type & stored on
stock
Do Not Support
Inheritance
Default value is the value
produced by zeroing out
the fields of struct
Do Not
Do Not
Not Supported
Copies the value
Enumerations
Is a user defined integer type.
Provides ways for attaching names to numbers.
Enum keyword automatically enumerates list of words by

assigning them values 0,1,2 & so on.
General Form:
enum Shape
{
Circle,
Square,
Triangle
}
Here Circle has value 0, Square has value 1 & Triangle has
value 2.
Example
using System;
class Area
{
public enum Shape {Circle,Square}
public void AreaShape ( int x, Shape shape)
{
double area;
switch (shape)
{
case Shape.Circle:
area = Math.PI * x * x;
Console.WriteLine("Circle Area = "+area);
break;
case Shape.Square:
area = x * x ;
Console.WriteLine("Square Area = " +area);
break;
default:
Console.WriteLine("Invalid Input");
break;
}
}
}
class EnumTest
{
{
Area area = new Area ( );
area.AreaShape ( 15, Area.Shape.Circle);
area.AreaShape ( 15, Area.Shape.Square);
area.AreaShape ( 15, (Area.Shape) 1 );
area.AreaShape ( 15, (Area.Shape) 10 );
}
}
Chapter : 12
Classes & Objects
Introduction
C# is a true object oriented language.

We create objects of a have class that have state
& behavior.
Object oriented language employ 3 core
principles:
Encapsulation
Inheritance
Polymorphism.
Member Access Modifiers
OOP provides data hiding

A class may be designed to hide its members from outside
accessibility.
This is achieved using access specifiers.
In C# all members have private access by default.
Modifier
Accessibility Control
private
Member is accessible only from the class containing the

member.
public
Member is accessible from anywhere outside the class as

well. Also accessible in derived class
Member is accessible only to its own class & in derived
class.
protected
internal
protected
internal
Member is available within the assembly or component

that is being created but not to the clients of that
component.
Available in the containing program & in the derived
class
Objects
An object in C# is a block of memory that contains space to

store all the instance variable.
Creating an Object:
Rectangle rect; //declare
rect=new Rectangle(); //instantiate
Or
Rectangle rect=new Rectangle();
We can create n number of objects of a class each having a
different memory storage area.
Accessing Class Members:
objectname.variablename;
objectname.methodname(parameter-list);
Example
using System;
class Rectangle
{
public int length, width;
public void GetData(int x, int y)

{
length = x;
width = y;
}
public int RectArea( )
{
int area = length * width;
return (area);
}
class Rect
{
{
int area1;
Rectangle rect1=new Rectangle();
rect1.GetData(12,10);
area1=rect1.RectArea();
Console.WriteLine("Area="+area1);
}
}
Constructors
Used to initialize an object when it is

created.
Have the same name as that of the
class.
They do not have a return type.
using System;
class Rectangle
{
public Rectangle(int x, int y)

{
length = x;
width = y;
}
public int RectArea( )
{
return (area);
}
class Rect
{
{
int area1;
Rectangle rect1=new Rectangle(12,10);
area1=rect1.RectArea();
}
Overloaded Constructors
Constructors with same name as of class but

different no. & name of arguments.
Also known as polymorphism.
using System;
class Room
{
public Room(int x, int y)
{
length = x;
width = y;
}
public Room(int x)
{
length = width=x;
}
public int RArea( )

{
return (area);
}
class Area
{
{
int area1;
Room r1=new Room(12,10);
Room r2=new Room(12);
area1=r1.RArea();
area1=r2.RArea();
Static Members
They are common to all the

objects.
Restrictions on Static
Methods:
Are accessed without using

a particular object.
Also referred as class
variables & class methods.
A static variable is
common to all instances of
a class.
Even methods can be
declared as static.
Can only call other static

methods.
Can only access static
data.
Cannot refer to this or
base in any way
Example
using System;
class Mathopt
{
public static float mul(float x, float y)
{
return(x*y);
}
public static float divide(float x, float y)
{
return(x/y);
}
}
class MathApp
{
{
float a=Mathopt.mul(10,20);
float b=Mathopt.divide(20,4);
Console.WriteLine("Multiplication="+a);
Console.WriteLine("Division="+b);
}
}
Static Constructors
Is called before any object of a class is created.
Useful to do any housekeeping work that needs to be done once.
Used to assign initial values to static data members.
Static constructor do not have any parameters.
Example:
class Abc
{
static Abc()
{
}
}
A class can have only one static constructor
Copy Constructors
A copy constructor creates an object by copying

variables from another object.
Example:
public Item(Item item)
{
code=item.code;
price=item.price;
}
Item item2=new Item(item1);

Here item2 is an copy of item1.
Destructors
It is opposite to constructor.
It is a method called when an

object is no longer required.
The name of destructor is
same as that of class name &
is preceded by a tilde(~).
They do not have a return

type.
Example:
class Fun
{
.
~Fun()
{
They do not take arguments.
..
C# manages memory
dynamically & uses a
garbage collector, to execute
all destructors on exit.
This process is called
finalization.
The This Reference
This refers to the object that called the method.

Used to distinguish between local & instance variables that have the same
name.
Example:
class Integers
{
int x;
int y;
public void SetXY(int x, int y)
{
this.x=x;
this.y=y;
}
..
..
}
Constant Members (IMP)
They are the variables whose value cannot be changed

during program execution.
Example:
public const int size=100;
Any attempt to change the value of a constant result in
compilation error.
The const members are implicitly static.
Const members are accessed using class name.
Value must be set when cont is defined.
Read-Only Members (IMP)
Allows us to decide the value

of a constant member at runtime.
Also allows to have different
constant values for different
objects of the class.
The value of the member is
set using constructor &
cannot be modified later.
Can be declared as either
static fields or instance fields.
Example:
class Numbers
{
public readonly int m;
public static readonly int n;
public Numbers(int x)
{
m=x;
}
static Numbers()
{
n=100;
}
}
Properties (IMP)
In C# private data members can only be accessed using

methods of a class.
Such methods are called as an accessor methods.
Drawbacks of using these methods:
We have to code them manually.

User have to remember that they have to use accessor
methods to work with data members.
C# provides properties that has same capabilities as of

accessor methods.
Using property we can access data members as if they are
public.
Also referred to as smart fields.
Example
using System;
class Number
{
private int number;
public int Anumber
{
get
{
return number;
}
set
{
class PropertyTest
{
{
Number n=new Number();
n.Anumber=20;
int m=n.Anumber;
number=value;
Console.WriteLine("Number="+m);
}
Above class declares a get accessor

method (getter) & a set accessor
method (setter).
Property (cont)
A property can omit either a get clause or a set clause.

A property that has only a getter is called a read-only
property.
A property that has only a setter is called a write-only
property.
Other features:
Properties can also represent dynamic data.

Properties are also inheritable.
Can be used with static keyword.
Indexers (IMP)
Indexers are locations indicators.
Used to access class objects.
An indexer looks like a property

& is written like it but with 2
differences:
Difference between indexers &

properties:
A property can be static

member, whereas an indexer is
always an instance member.
A get accessor of a property

corresponds to a method with
no parameters, whereas for
indexer it corresponds to same
formal parameter list as the
indexer.
A set accessor of a property

corresponds to a method with a
single parameter named value,
whereas for indexer it
corresponds to same formal
parameter list as the
indexer,plus the paramter
named value.
It is an error for an indexer to

declare a local variable with the
same name as an indexer
parameter.
The indexer takes an index

argument & looks like an array.
The indexer is declared using
keyword this.
Also referred to as smart arrays.
Example
using System;
using System.Collections;
class MyClass
{
private string []data = new string[5];
public string this [int index]
{
get
{
return data[index];
}
set
{
data[index] = value;
}
}
}
class MyClient
{
{
MyClass mc = new MyClass();
mc[0] = UniqueInfotech";
mc[1] = 18";
mc[2] = Janardan Arcade";
mc[3] = Dahanu";
mc[4] = West";
Console.WriteLine("{0},{1},{2},{3},
{4}",mc[0],mc[1],mc[2],mc[3],mc[4]);
}
}
Chapter : 13
Inheritance & Polymorphism
(IMP)
Introductoin
Inheritance is a process of constructing or

designing one class from another.
Forms of Inheritance
Classical
form
Containment form
Feature X
Feature Y
Feature Z
Base Class
Feature X
Feature Y
Feature Z
Feature P
Derived Class
Classical Inheritance
Represents a kind of relationship between two classes.
Example:
Class A
Class B
Here class A is referred to as base class, parent class or

super class.
Class B is referred to as derived class, child class or sub
class.
Also referred to as is-a relationship.
Example:
Dog is-a type of animal

Ford is-a type of car
Different Classical Inheritance Implementation

A
C
Hierarchical
Inheritance
Single Inheritance
Grandparent class
Parent class
Child class
Multilevel
Inheritance
C
Multiple
Inheritance
Containment Inheritance
Also known as containership

inheritance.
Example:
class A
{
.
}
class B
{
.
A a; //a is contained in b
}
B b;
.
Here object a is contained in

object b.
This relationship is referred
to as has-a relationship.
The outer class B which
contains the inner class A is
termed the parent class &
the contained class A is
termed a child class.
Example:
Car has-a radio.

City has-a road.
Defining a Subclass
Syntax:
class subclass-name : baseclass-name
{
variable declaration;
methods declaration;
}
Example: Simple Inheritance

using System;
class Item
{
public void Company()
{
Console.WriteLine("Item Code=XYZ");
}
}
class Fan:Item
{
public void Model()
{
Console.WriteLine("Model=Classic");
}
}
class SimpleInheritance
{
{
Fan f=new Fan();
f.Company();
f.Model();
}
}
Characteristic of Inheritance
A derived class extends its direct base class. It can add new
members to those it inherits. However, it cannot change or
remove the definition of an inherited member.
A derived class can hide an inherited member.
A derived class can override an inherited member.
An instance of a class contains a copy of all instance fields

declared in the class & its base class.
Constructors and destructors are not inherited.
Visibility Control
Class Visibility :
A class may be declared as:
public: Accessible within & outside the program assembly

internal (default): Accessible only within program assembly
private: Accessible only within the class.
Class Members Visibility :
Can be declared as either:
public
private
protected
internal
protected internal
Keyword
Visibility
Containing
Derived
Containing
Anywhere
Private
Classes
Y
Classes
Program
Outside the program
Protected
Internal
P.Internal
Public
Y
Y
Accessibility Constraints
Constraints on the accessibility of members &

classes when they are used in process of
inheritance:
The
direct base class of a derived class must be at

least as accessible as the derived class itself.
Accessibility
domain of a member is never larger than

that of the class containing it.
The
return type of a method must be as accessible as

the method itself.
Defining Subclass Constructor

using System;
class Room
{
public int length;
public int breadth;
public Room(int x, int y)
{
length=x;
breadth=y;
}
public int Area()
{
return(length*breadth);
}
}
class BedRoom:Room
{
int height;
public BedRoom(int x,int y,int
z):base(x,y)
{
height=z;
}
public int Volume()

{
return(length*breadth*height);
}
}
class InherTest
{
{
BedRoom room1=new
BedRoom(10,11,12);
int area1=room1.Area();
int vol=room1.Volume();
Console.WriteLine("Area= "+area1);
Console.WriteLine("Volume= "+vol);
}
Multilevel Inheritance
Uses derived class as a super class

A
Grandparent class
Parent class
Child class
Here A servers as base class for B which in turn serves as base

class for C.
The chain ABC is known as inheritance path.
This process may be extended to any number of levels.
Write a program to store & display student information using

multilevel inheritance.
Hierarchical Inheritance
Account
Savings
Fixed-Deposit
Current
Short
Medium
Long
Write a program to demonstrate use of hierarchical inheritance.
Method Overriding (IMP)
In derived class we can create a method with same

signature as in base class.
This concept is called as method overriding.
This method can have same name, same arguments &
same return type as a method in base class.
When the method is called, the method defined in the
subclass is invoked & executed.
The method in base class should be specified as virtual.
The method in base class should be specified with keyword
override.
Example
using System;
class Super
{
public int x;
public Super(int x)
{
this.x=x;
}
public virtual void Display()
{
Console.WriteLine("Super
x="+x);
}
}
class Sub:Super
{
int y;
public Sub(int x,int y) : base(x)

{
this.y=y;
}
public override void Display()
{
Console.WriteLine("Super x="+x);
Console.WriteLine("Sub y="+y);
}
class Test
{
{
Sub s1=new Sub(100,200);
s1.Display();
}
}
Method Hiding (IMP)
With the help of virtual & override

keywords we can hide an method
declared in a base class.
What if the class is provided by
someone else?
Here the base class method cannot be
declared as virtual.
To override such method use modifier
new to tell the compiler the derived
class method hides the base class
method.
Example:
using System;
class Base
{
public void Display()
{
Console.WriteLine("Base Method");
}
}
class Derived:Base
{
public new void Display()
{
Console.WriteLine("Derived
Method");
}
}
class HideTest
{
{
Derived d=new Derived();
d.Display();
}
}
Abstract Classes
At times we can have one base

class & a number of different
derived classes.
The top-most base class simply

acts as a base for others & is not
useful on its own.
We might not want to create an
objects of such classes.
This can be done by making the
class as abstract.
Example:
abstract class Base
{
}
class Dervied:Base
{
..
}
.
.
Base b1; //Error
Derived d1; //Ok
Characteristic:
It cannot be instantiated
directly.
It can have abstract members.
We cannot apply a sealed
modifier to it.
Abstract Methods
Method declaration includes

the modifier abstract.
It is implicitly a virtual
method & does not provide
any implementation.
1.
2.
Its implementation must be

provided in non-abstract
derived classes by overriding
the method.
3.
It can be declared only in

abstract classes.
4.
It cannot take either static or

virtual modifiers.
5.
An abstract definition is
permitted to override a
virtual method.
An abstract method does not

have a method body.
Example:
public abstract void Draw (int
x, int y);
Characteristics:
It cannot have
implementation.
Sealed Classes: Preventing Inheritance
Prevent a class from being further sub classed.
Such classes are called sealed classes.
Example:
sealed class AClass
{
..
}
sealed class BClass:Someclass
{
..
}
Any attempt to inherit these classes will cause an error & compiler will
not allow it.
Standalone utility classes are created as sealed classes.
Sealed Methods
When an instance method declaration includes the sealed modifier, the

method is said to be a sealed method.
A derived class cannot override this method.
A sealed method is used to override an inherited virtual method with the
same signature.
Example:
class A
{
public virtual void Fun()
{
}
}
class B: A
{
public sealed override void Fun()
{
}
}
Now any derived class of B cannot further override the method Fun().
Polymorphism
Means one name .. many forms.
Polymorphism can be achieved in two ways:
Polymorphism
Operation
Polymorphism
Inclusion
Polymorphism
Using
Overloaded
Methods
Using
Virtual
Methods
Operation Polymorphism
Implemented using overloaded methods & operators.

Overloaded methods are selected for invoking by matching
arguments, in terms of number, type & order.
This information is known to compiler at compile time.
Also called as early binding, or static binding or static
linking.
Also known as compile time polymorphism.
Early binding means an object is bound to its method call
at compile time.
Example
using System;
static void Call(Cat c)

{
Console.WriteLine("Cat is
called");
}
class Dog
{
}
class Cat
{
}
class Operation
{
static void Call(Dog d)
{
Console.WriteLine("Dog is
called");
}

{
Dog dog=new Dog();
Cat cat=new Cat();
Call(dog);
Call(cat);
}
Inclusion Polymorphism
Achieved through use of virtual functions.

Assume class A implements virtual method M. Classes B &
C are derived from A and override method M. When B is
cast to A, a call to method M from A is dispatched to B.
Similarly when C is cast to A, a call to method M from A is
dispatched to C.
Also known as run-time polymorphism.
Since method is linked with a particular class much later
after compilation, this process is also called late binding.
Also known as dynamic binding as the selection of method
is done dynamically at run time.
Example
using System;
class Maruti
{
public virtual void Display()
{
Console.WriteLine("Maruti Car");
}
}
class SX4:Maruti
{
{
Console.WriteLine("SX4 Car")
}
}
class Swift:Maruti
{
{
Console.WriteLine("Swift Car");
}
}
class Inclusion
{
{
Maruti m=new Maruti();
m=new SX4();
m.Display();
m=new Swift();
m.Display();
}
}
Chapter : 14
Interfaces: Multiple Inheritance
Introduction
C# does not support multiple inheritance.
A class cannot have more than one superclass.
C# provides an approach known as interface to

support the concept of multiple inheritance.
An interface is a class with some differences:
All
members of an interface are implicitly public &

abstract.
An interface cannot contain constant fields,
constructors & destructors.
Its members cannot be declared static
Defining an Interface
General Form:
interface Interfacename
{
member declarations;
}
Like classes, interfaces can also be extended.
That is, an interface can be sub interfaced from other interfaces.
General Form:
interface name2:name1
{
Members of name2
}
Note: An interface can not extend classes
Example: 1
using System;
interface Addition
{
int Add();
}
interface Multiplication
{
int Mul();
}
class Computation:Addition,Multiplication
{
int x,y;
public Computation(int x,int y)
{
this.x=x;
this.y=y;
}
public int Add()
{
return(x+y);
}
public int Mul()

{
return(x*y);
}
}
class InterfaceTest
{
{
Computation com=new Computation(10,20);
Addition add=(Addition)com; //casting
Console.WriteLine("Sum="+add.Add());
Multiplication mul=(Multiplication)com;
Console.WriteLine("Product="+mul.Mul());
}
Example: 2 --- Multiple Implementation of an Interface

using System;
interface Area
{
double Compute(double x);
}
class Interface2
{
{
Square s=new Square();
Circle c=new Circle();
class Square:Area
{
public double Compute(double x)
{
return(x*x);
}
}
Area area;
area=s as Area;
class Circle:Area
{
public double Compute(double x)
{
return(Math.PI*x*x);
}
}
Console.WriteLine("Area of
Square="+area.Compute(10.2));
Console.WriteLine("Area of
Square="+area.Compute(10.2));
area=c as Area;
Interfaces & Inheritance
A base class of a derived class may

implement an interface.
When an object of the derived class is
converted to the interface type, the
inheritance hierarchy is searched for a
class that directly implements the
interface.
Example:
using System;
interface Display
{
void Print();
}
class B:Display
{
public void Print()
{
Console.WriteLine("Base Display");
}
}
class D:B
{
public new void Print()
{
Console.WriteLine("Derived
Display");
}
}
class Interface3
{
{
D d=new D();
d.Print();
Display dis=(Display)d;
dis.Print();
Explicit Interface Implementation
It may be possible that multiple

interface have a method of a same
name.
This may create a problem when a
class implements more than one
interface.
C# supports a technique known as
explicit interface implementation,
which allows a method to specify
explicitly the name of the interface it
is implementing.
Example:
using System;
interface I1
{
void display();
}
interface I2
{
void display();
}
class C1:I1,I2
{
void I1.display()
{
Console.WriteLine("I1 Display");
}
void I2.display()
{
Console.WriteLine("I2 Display");
}
}
class Interface4
{
{
C1 c=new C1();
I1 i1=(I1)c;
i1.display();
I2 i2=(I2)c;
i2.display();
}
}
Abstract Class & Interfaces
An abstract class can use an interface in the base class list.
Here the interface methods are implemented as abstract methods.
Example:
interface A
{
void Method();
}
abstract class B:A
{
.
.
public abstract void Method();
}
Here class B does not implement the interface method; it simply redeclares as a
public abstract method.
It is the duty of the class that derives from B to override & implement the method.
Chapter : 15
Operator Overloading
Introduction
The C# operators can be defined to work with the user-defined data

types such as structs & classes.
C# has the ability to provide the operators with a special meaning
for a data type.
This mechanism of giving such special meaning to an operator is
known as operator overloading.
Following is list of operators that can be overloaded.
Category
Operators
1. Binary Arithmetic
+,*,/,-,%
2. Unary Arithmetic
+,-,++,--
3. Binary bitwise
&,|,^,<<,>>
4. Unary bitwise
!,~,true,false
5. Relational Operators
==,!=,>=,<,<=,>
Cont
Following is list of operators that cannot be overloaded.

Category
Operators
1. Conditional operators
&&,||
2. Compound assignment
+=,-=,*=,/=,%=
3. Other operators
[ ],( ),=,?:,->,new,sizeof,typeof,is,as
Need for Operator Overloading
Operator overloading gives us syntactical convenience.

It helps us to generate more readable code in a number of
situations. These includes:
Financial programs.
Mathematical or physical modeling
Graphical programs
Text manipulations
General form of an operator method:

public static retval operator op(arglist)
{
Method body..
}
Overloading Unary Operators

using System;
class Space
{
int x,y,z;
public Space(int a,int b, int c)
{
x=a;
y=b;
z=c;
}
public void Display()
{
Console.Write(" "+x);
Console.Write(" "+y);
Console.Write(" "+z);
}
public static Space operator -(Space s)
{
s.x=-s.x;
s.y=-s.y;
s.z=-s.z;
return(s);
}
}
class SpaceTest
{
{
Space s=new Space(10,20,30);
Space q;
Console.Write("S: ");
s.Display();
q=-s;
Console.Write("Q: ");
q.Display();
Overloading Binary Operators

using System;
class Complex
{
double x,y;
public Complex(){ }
public void display()

{
Console.Write(x);
Console.Write(" + j"+y);
}
public Complex(double real,double

imag)
class ComplexTest
{
{
Complex a,b,c;
a=new Complex(2.5,3.5);
b=new Complex(1.6,2.7);
c=a+b;
c.display();
}
}
x=real;
y=imag;
}
public static Complex operator +
(Complex c1,Complex c2)
{
Complex c3=new Complex();
c3.x=c1.x+c2.x;
c3.y=c1.y+c2.y;
return(c3);
}
Overloading Comparison Operators
C# supports six comparison operators that can be

considered in three pairs:
==
& !=
> & <=
< & >=
The significance of pairing is two-fold:

Within
each pair, the second operator should always

give exactly the opposite result to the first.
C# always requires us to overload the comparison
operators in pairs. That is, if we overload ==, then we
must overload != also, otherwise it is an error.
Example:
using System;
class Vector
{
int x,y,z;
public Vector(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
public static bool operator ==(Vector
v1,Vector v2)
{
if(v1.x==v2.x && v1.y==v2.y)
return(true);
else
return(false);
}
public static bool operator !=(Vector

v1,Vector v2)
{
return(!(v1==v2));
}
}
class CompareTest
{
{
Vector u1=new Vector(1,2,3);
Vector u2=new Vector(1,2,3);
if(u1==u2)
Console.WriteLine("U1 is equal to
U2");
else
Console.WriteLine("U1 is not equal to
U2");
}
}
Chapter : 16
Delegates & Events
(IMP)
Introduction
A delegate object is a special type of object that contains the

details of a method rather than data.
Delegates in C# is used for two purposes:
Callback
Event Handling
Dictionary meaning of delegate is a person acting for

another person, in C# it means a method acting for another
method.
A delegate in C# is a class type object & is used to invoke a
method that has been encapsulated into it at the time of its
creation.
Delegate Declaration
General Form:
modifier delegate return-type delegate-name(parameters);
Delegate is derived from System.Delegate class.
The modifier controls the accessibility of the delegate.
Delegate may take any of the following modifiers:

new, public, private, protected, internal.
It is a class type & can be declared in any place where a
class definition is permitted.
A delegate may be defined in the following places:
Inside a class
Outside all classes
As the top level object in a namespace.
Delegate Methods
The methods whose references are encapsulated

into a delegate instances are known as delegate
methods (or callable entities)
The signature & return type of delegate methods
must exactly match the signature & return type
of the delegate.
Delegate Instantiation
A delegate-creation-expression is used to create a new instance of

a delegate.
General Form:
new delegate-type(expression)
Here the delegate-type is the name of the delegate declared earlier
whose object is to be created.
Expression must be the method name.
The method & the object to which a delegate refers are

determined when the delegate is instantiated.
This remains constant for the entire lifetime of the delegate.
It is not possible to change them, once the delegate is created.
Delegate Invocation
When a delegate is invoked, it in turn invokes the

method whose reference has been encapsulated
into the delegate.
General Form:
delegate_object(parameter
list);
The optional parameter list provides values for the
parameters pf the method to be used.
Example:
using System;
//Delegate Declaration
delegate int ArithOp(int x,int y);
class DelegateTest
{
{
class MathOperation
{
public static int Add(int a,int b)
{
return(a+b);
}
public static int Sub(int a,int b)
{
return(a-b);
}
}
ArithOp op1=new
ArithOp(MathOperation.Add);
ArithOp op2=new
ArithOp(MathOperation.Sub);
int result1=op1(3,20);
int result2=op2(40,20);
Console.WriteLine("Result1="+result1
);
Console.WriteLine("Result2="+result2
);
}
Multicast Delegate
It is possible for delegates to hold & invoke multiple

methods.
Such delegates are called multicast delegates.
Also known as combinable delegates.
They must satisfy following conditions:
Return type of such delegate must be void.

None of the parameters of the delegates can be declared as
output parameters, using out keyword.
If D is a delegate & d1,d2,d3 & d4 are its instances, then

the statements:
d3=d1+d2 //refers to two methods.

d4=d3-d2 //refers to only d1 method
Example
using System;
delegate void MDelegate();
class DM
{
public static void Display()
{
Console.WriteLine("In Display");
}
class MDelegateTest
{
{
MDelegate m1=new
MDelegate(DM.Display);
MDelegate m2=new
MDelegate(DM.Print);
MDelegate m3=m1+m2;
MDelegate m4=m2+m1;
MDelegate m5=m3-m2;
public static void Print()

{
Console.WriteLine("In Print");
}
}
}
m3();
m4();;
m5();
Events(IMP)
An event is a delegate type class member that is used by

the object or class to provide a notification to other object
that an event has occurred.
The client object can act on an event by adding an event
handler to the event.
General Form:
modifier event type event-name;
Since events are based on delegates, we must first declare a

delegate and then declare an instance of the delegate using
the keyword event.
Example
using System;
//Delegate Declaration
delegate void EDelegate(string str);
class EventClass
{
public event EDelegate Status;
class EventTest
{
{
EventClass ec=new
EventClass();
EventTest et=new
EventTest();
ec.Status+= new
EDelegate(et.EventCatch);
ec.TriggerEvent();
}
public void TriggerEvent()

{
Status("Event Triggered");
}
public void EventCatch(string str)

{
Console.WriteLine(str);
}
Chapter : 17
Managing Console I/O Operations
The Console Class
The methods for reading & writing to the console are

provided by the System.Console class.
This class gives us access to the standard input, standard
output & standard error streams:
Stream Object
Represents
Console.In
Standard Input
Console.Out
Standard Output
Console.Error
Standard Error
Console Input
Supports two methods for obtaining input from

the keyboard.
Read():
Returns a single character as int.
ReadLine():
Returns a string containing a line of text.
Console Output
Supports two methods for writing to the console.

Write():
Outputs one or more values to the screen

without a new line character.
WriteLine():
Outputs one or more values to the screen

but adds a new line character at the end of the
output.
Exercise
Write a program in C# to print the following

output:
1
22
333
4444
55555
666666
7777777
88888888
999999999
Formatted Output
Use overloaded WriteLine()

method.
General Form:
Console.WriteLine(formatstring, v1, v2, .);
Format String contains both

static text & markers which
indicate
Example
Where the values are to be printed.

How the values are to be formatted.
Console.WriteLine(Sum of {0}
and {1} is {2},a,b,c);
We can also specify a width for

the value using the format:
{n,w}
n is the index number
w is the width for the value
Example:
int a=45;
int b=976;
int c=a+b;
Console.WriteLine({0,5\n+{1,5}\
n} ------- \n{2,5},a,b,c);
45
+976
----------1021
Numeric Formatting
Chapter : 18
Managing Errors & Exceptions
THANK YOU

Programming in C#

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programming in C#

Uploaded by

Copyright:

Available Formats

PROGRAMMING IN C#

Is a compute-programming language developed by

Is fully object-oriented language.

Is first Component-oriented language.

Suitable for developing Web-based applications

Designed for developing robust, reliable & durable

Derived from C/C++ family.

It simplifies & modernizes C++.

It is only component oriented language available today.

It is a language designed for the .NET Framework.

It is a concise, lean & modern language.

It combines the best features of many commonly used

It is intrinsically object-oriented & web-enabled.

It has a lean & consistent syntax.

Is simple, robust & productive.

Major parts of .NET Framework are actually coded in C#.

C & C++ languages suffer from a

VB, a language promoted by

The Internet is the mainstream

The outcome is a new generation

C# is a descendant of C++ which in turn is a

C# is called modern language bcoz it supports:

Automatic garbage collection

C# is truly object-oriented. It supports:

How Does C# differs from C++ ?

C# compiles straight from source code to executable

How Does C# differs from C++ ?

C++ Features Dropped

Automatic Garbage Collection

How Does C# differs from Java ?

C# has more primitive data types

The .NET STRATEGY

.NET is a software framework that includes

The Origins of .NET Technology

The Origins of .NET Technology (cont)

Phase I Early 1990s OLE Technology

COM Technology Intermodule Communication

Phase III Late 1990s .NET Technology Intersite Communication

The .NET Framework

.NET Infrastructure & Tools

The .NET Framework (cont)

Common Language Runtime

Framework Base Classes

Common Language Runtime

The Common Language Runtime (CLR)

& execution of programs

Components of CLR (cont)

Framework Base Classes

Allows to implement applications quickly

User & Program Interfaces

The .NET framework provides the following tools

These tools enables users to develop user-friendly

Benefits of the .NET Approach

The .NET technology provides a number of benefits to

Simpler & faster systems development

C# can be used to develop two categories of

application programs &

Executable programs are written to carryout

are written for use by other applications.

Executing the program

For executing the program, simply type in the name of the

Enhances readability & understanding of the

Main Returning a Value