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:

Martin Richards Ken Thompson

1967 BPCL B 1970

1972 C Dennis Ritchie

1983 C++ Bjarne Stroustrup

1987 ANSI C ANSI Committee

1991 Oak James Gostling

1995 Java Sun MicroSystems

1996 ANSI C++ ANSI Committe

2000 C# Microsoft
Cont….
 C & C++ languages suffer from a  VB, a language promoted by
number of shortcomings in Microsoft for overcoming these
meeting World Wide Web problems, is not truly object-
requirements & standards. oriented and becomes
 Some are as follows: increasingly difficult to use when
systems become large.
1. The high complexity of language
 Java which is truly object-
2. They are not truly object oriented has not retained some
oriented powerful C++ features such as
3. They have poor type safety operator overloading.
4. They are not suitable for  Java also lacks inter-operability
working with new web with code developed in other
technologies. languages.
5. They do not support versioning  Microsoft therefore decided to
6. Their low productivity design a new language.
7. They are weak in consistency
 The result is C#, a simple &
modern language that directly
8. Their poor compatibility with addresses the needs of
the existing systems component-based software
development.
Evolution of C#
 The Internet is the mainstream  The outcome is a new generation
for many business organization platform called .NET.
today.  Microsoft introduced C# as a de
 There were a number of facto language of the .NET
limitations in using the WWW platform.
over the Internet:  C# has been particularly designed
1. We could see only one site at a to build software components
time for .NET and it supports key
2. The site had to be authored to our features of .NET natively.
hardware environment  C# compiler is embedded into
3. The information was basically .NET as shown below:
read-only.
4. We could not dynamically
compare similar information
stored on different sites. .NET Platform
5. The internet is a collection of
many information islands that do
not co-operate with each other. .NET Framework
 Microsoft wanted to develop a
software platform which will
overcome these limitations &
make the Web both C#
programmable and intelligent.
Cont…
 C# is a descendant of C++ which in turn is a
descendant of C as illustrated below:
C
Object
Orentation

C++
Concept Power Concept

Component

Java Orientation C# VB
Elegance Productivity
Characteristics of C# (5 marks)
 Simple
 C# simplifies C++ by eliminating irksome operators such as ->, ::, and pointers.
 C# treats integers & Boolean data types as entirely different types.

 Consistent
 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 inter-
operation with other .NET languages

 Interoperable
 C# provides support for using COM objects, no matter what language was used to
author them.

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

 Enhancements to C++
1. Automatic Garbage Collection
2. Versioning Support
3. Strict Type-Safety
4. Properties to access data members
5. Delegates & Events
6. Boxing & Unboxing
7. Web Services
How Does C# differs from Java ?
1. C# has more primitive data types
2. Arrays are declared differently in C#
3. C# supports struct type & Java does not
4. Java does not provide for operator overloading
5. C# provides for better versioning support than Java
6. C# provides static constructors for initialization
7. Java does not directly support enumerations
8. C# uses is operator instead of instanceof operator in
Java
9. C# checks overflows uses checked statements
10. There is no labeled break statement in C#. The goto
statement is used to achieve this.
11. 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 Interprocess Communication

Phase II – 1995 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 .NET Device

Block Services Software

.NET User .NET Infrastructure

Experience & Tools

.NET Infrastructure & Tools

Visual Studio .NET Experience

.NET Services

Windows .NET .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)

Framework Base Classes

Common Language Runtime

The Common Language Runtime (CLR)
 Is heat & 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 Language Runtime

Common Type System

Intermedia Language (IL)

Execution Support Functions

Security

Garbage Collection

Class Loader

Memory Layout
Framework Base Classes
 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
{
public static void Main()
{
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-linecomments (//)
 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 program’s 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
{
public static void Main()
{
A.WriteLine(“Hello World!!!”);
}
}
Passing String Objects to WriteLine Method

using System;
class SampleFive
{
public static void Main()
{
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
{
public static void Main(string[] args)
{
Demo d=new Demo(); //creating d object
d.display(); //callinf display() function
}
}
Providing Interactive Input
using System;
class SampleEight
{
public static void Main(string[] args)
{
Console.Write(“Enter Your Name”);
string name=Console.ReadLine();
Console.WriteLine(“Hello ”+name);
}
}
Using Mathematical Functions
using System;
class SampleNine
{
public static void Main(string[] args)
{
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 //multimain.cs
method in different classes. using System;
class A
 In such situations there would be {
multiple entry points in the
program. public static void Main()
{
 There should be only one. Console.Write(“Class A”);
}
 This problem can be resolved by }
specifying which Main is to be
used to the compiler at the time
of compilation: class B
{
 csc filename.cs/main:classname public static void Main()
 Example : {
 multimain.cs/main:Class Console.Write(“Class B”);
OR
 multimain.cs/main:Class B }
}
Compile Time Errors
 A program is never totally error-free  Errors.cs(2.7): error cs0234: The type
 Types of errors: or namespace name ‘Systom’ does not
exists in the class or namespace
 Syntax Errors
 Logic Errors
 Syntax errors will be caught by the
 The error message contains:
compiler
 Logical errors should be eliminated by 1. Name of the file being
testing the program logic carefully. compiled(Errors.cs)
 When the compiler cannot interpret 2. Line number & column position of the
what we are attempting to convey error(2.7)
through our code the result is syntax
error. 3. Error code as defined by the compiler
(cs0234)
4. Short description of error
 Example:

using Systom;
class SampleTen
{
public static void main()
{
Console.Write(“Hello”);
}
}
 Program Structure
 The documentation section
consists of a set of comments Documentation Section Optional
giving the name of the
program, the author, date &
other details. Using Directive Section Optional
 The using directive section
includes all those namespaces Interfaces Section Optional
that contain classes required
by the application
Classes Section Optional
 A interface is similar to a
class but contains only
abstract classes.Used in Main Method Section Essential
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.
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#
 Value types
 Reference types
 Pointers

 Values types are stored on stack

 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 Pointers Reference Types

Predefined User-defined Predefined User-defined

Types Types Types 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

1. 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.

 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 0
char type ‘\x000’
float type 0.0f
double type 0.0d
decimal type 0.0m
bool type false
enum type 0
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
 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.
 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.
 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 Example

Addition + Adds two x+y

operands

Subtraction - Subtracts the 2nd x–y

operand with 1st
operand

Multiplication * Multiplies two x*y

operands

Division / Divides two x/y

operand

Modulus % Gives the x%y

remainder when
the operands are
divided.
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
 Here ‘v’ is a variable, ‘exp’ is an expression & ‘op’ is an C# binary operator.
 The operator op= is known as shorthand assignment operator.

 Example:
 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 ++x, x++

operand by one

Decrement -- Decrements the --x, x--

operand by one
Prefix and Postfix modes

 When used in prefix mode, the increment and

decrement operators modify their operand before
it’s used.

 When used in postfix mode, the increment and

decrement operators modify their operand after
it’s 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

*/% 1

+- 2
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.
Type Conversions
 Hence code should be:
int b3=b1+b2; //no error
Implicit Explicit
Conversions Conversions
 Ways of Type Conversion
 Implicit Conversions
Arithmetic Casting
 Explicit Conversions
Operations Operations
Mathematical Functions
 Present in Math class of System Namespace.
 Static Members: E and PI
 Mathematical Methods in Math class:
Cosh() Hyperbolic cosine
Method Description
Tanh() Hyperbolic tangent
Sin() Sine of an angle in
radians
Sqrt() Square Root
Cos() Cosine of an angle in
radians Pow() Number raised to a
Tan() Tanget of an angle in given power
radians Exp() Exponential
Asin() Inverse of Sine
Log() Natural logarithm
Acos() Inverse of Cosine
Abs() Absolute value
Atan() Inverse of Tangent
Min() Lower of two numbers
Sinh() Hyperbolic sine
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 False
expression
?

True
Jumping
Statement
block

Statement-X

Next statement
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 if…else control
Entry

True boolean False

expression
?

True-Block False-Block
Statement 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

Test True
False
condition1
?

Test
False True
condition2
?
Statement-3 Statement-2 Statement-1

Statement-X

Next statement
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  Here, the expression must be an integer
program dramatically as the type or char or string type
alternatives increases.
 The program becomes difficult to read
& follow.  Value-1, value-2 … are constants or
 C# offers an alternative with the help of constant expressions & are known as
switch statement case labels.
 General Form:
switch(expression)
{
 Block-1, block-2…… are statement lists
and may be zero or more statements.
case value-1:
block-1
break;
case value-2:
block-2
break;
--------------------
--------------------
--------------------
default:
default-block
break;
}
statement-x;
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  Example
statement in a case block, if the
control moves to the next block
without any problem, it is known switch(m)
as ‘fallthrough’. {
case 1:
 Fallthrough is permitted in C, C+ x=y;
+ & Java.
goto case2;
case 2:
 C# does not permit automatic
fallthrough, if the case block x=y+m;
contains some code. goto default;
default:
 However, it is allowed if the case x=y-m;
block is empty. break;
}
 If we want two consecutive case
blocks to be executed
continuously, we have to force the
process using the goto statement.
Chapter : 7
Decision Making & Looping
The While Statement
 The process of repeatedly  Entry based loop
executing a block of statements is
known as looping.

 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. Test False
cond
 Syntax:
initialization;
True
while(test condition)
{ Body of the
Body of the Loop… 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 • Exit based loop
necessary to execute the body of
the loop before test is performed

 This can be handled using do

statement.

 Is an exit-controlled loop
statement.
Body of the
 The body of the loop is executed loop
at least once.

 Syntax:
initialization; Test False
do cond
{
Body of the Loop…
True
}while(test condition);
Example
class DowhileTest
{
public static void Main ( )
{
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
{
public static void Main()
{
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)
if (condition) break;
break; Exit from …………..
loop …………..
…………….. }while (…………….)
Exit from …………….. ……….
loop
}
……………..

for (……….) for (……………….)

{
{ …………
……………… for (………..)
{
if (error)
…………..
break; if (condition)
Exit from …………….. break;
loop Exit from ……………
……………..
loop }
} ……………
……………….. }
Bypassing & Continuing in Loops
while (test condition) do
{ {
………… ………..
if (………..) if (………..)
continue; 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 doesn’t
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.
extern The method is implemented externally, in a different language.
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
{
public static void Main()
{
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 System;
using an object & dot operator. class Nesting
{
public void Largest ( int m, int n )
 A method can be called using only
{
its name by another method of
the same class. int large = Max ( m , n );
Console.WriteLine( large );
}
 This is known as nesting of int Max ( int a, int b )
methods. {
int x= ( a > b ) ? a : b ;
return ( x );
}
}
class NestTesting
{
public static void Main( )
{
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 using System;
parameters are passed by class PassByValue
value.
{
static void change (int m)
 When a method is invoked,
the value of actual {
parameters are assigned to m = m+10;
the corresponding formal }
parameters.
public static void Main( )
{
 Any changes to formal
parameters does not affect int x = 100;
the actual parameters. change (x);
Console.WriteLine("x =" +
 There are 2 copies of x);
variables when passed by }
value. }
Pass By Reference
 We can force the value parameters to using System;
be passed by reference. class PassByRef
{
 Use ref keyword. static void Swap ( ref int x, ref int y )
{
 This does not create a new storage int temp = x;
location.
x = y;
y = temp;
 It represents the same storage
location as the actual parameter. }
public static void Main( )
 When a formal parameter is declared {
as ref, the corresponding actual int m = 100;
argument in the method invocation
must be declared as ref. int n = 200;
Console.WriteLine("Before Swapping;");
 Used when we want to change the Console.WriteLine("m = " + m);
values of variables in the calling Console.WriteLine("n = " + n);
method.
Swap (ref m , ref n );
Console.WriteLine("After Swapping;");
Console.WriteLine("m = " + m);
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;
}
public static void Main( )
{
int m; //need not be initialized
Square ( 10, out m );
Console.WriteLine("m = " + m);
}
}
Variable Argument Lists
 We can define methods that can using System;
handle variable number of class Params
arguments using parameter
arrays. {
static void Parray (params int [ ]
arr)
 Parameter arrays are declared
using the keyword params {
Console.Write("array elements
are:");
 The parameter arrays should be a
one-dimensional arrays. foreach ( int i in arr)
Console.Write(" " + i);
Console.WriteLine( );
}
public static void Main( )
{
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 Console.WriteLine(add(312L,22L,21));
method with the same name, but with }
the different parameter lists &
different definitions. static int add(int a,int b)
{
 Required when methods are required return(a+b);
to perform similar tasks but using }
different input parameters.
static float add(float a,float b)
{
 Example
return(a+b);
}
using System;
static long add(long a,long b,int c)
class Overloading
{
{
return(a+b+c);
public static void Main()
}
{
}
Console.WriteLine(add(2,3));
Console.WriteLine(add(2.6F,3.1F));
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:
 Syntax: type[] arrayname;
 Example: int[] counter;
float[] marks;
int[] x,y;

 Creation of Arrays:
 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;
public static void Main( )
{
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
array
GetLength() Gives the number of elements in a given
dimension of the array
GetValue() 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
{
public static void Main( )
{
int[] x ={10,5,2,11,7};

Console.WriteLine("Before Sort");
foreach(int i in x)
Console.WriteLine(" " + i);
Console.WriteLine(" ");

Array.Sort(x);

Console.WriteLine("After Sort");
foreach(int i in x)
Console.WriteLine(" " + i);
Console.WriteLine(" ");
}
}
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: city.Add(“Delhi”);
city.Add(“Mumbai”);
 Removing Elements: city.RemoveAt(1);
 Modifying Capacity: city.Capacity=20;
Example
using System;
using System.Collections;

class Sort
{
public static void Main( )
{
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]);
Console.WriteLine(" ");
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
{
public static void Main()
{
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
{
public static void Main()
{
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:
 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
 A regular expression (also known as pattern string) is a
string containing two types of 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
{
public static void Main ( )
{
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
{
public static void Main( )
{
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
{
public static void Main ( )
{
Rectangle rect = new Rectangle ( 10, 20 );
rect.Display ( ); //invoking Display ( ) method
}
}
 Difference between Classes & Structs (5 Marks)

Category Classes Structs

Data Type Reference type & stored on Value Type & stored on
heap stock
Inheritance Support Inheritance Do Not Support
Inheritance
Default Values Default value of a class Default value is the value
type is null produced by ‘zeroing out’
the fields of struct
Field Permit initialization of Do Not
Initialization instance fields
Constructors Permit declaration of Do Not
parameterless constructors
Destructors Supported Not Supported

Assignment Copies the referennce 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 EnumTest
class Area {
public static void Main( )
{
{
public enum Shape {Circle,Square}
Area area = new Area ( );
public void AreaShape ( int x, Shape shape)
area.AreaShape ( 15, Area.Shape.Circle);
{ area.AreaShape ( 15, Area.Shape.Square);
double area; area.AreaShape ( 15, (Area.Shape) 1 );
switch (shape) area.AreaShape ( 15, (Area.Shape) 10 );
{ }
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;
}
}
}
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
protected Member is accessible only to its own class & in derived
class.
internal Member is available within the assembly or component
that is being created but not to the clients of that
component.
protected Available in the containing program & in the derived
internal 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 Rect
class Rectangle {
{ public static void Main()
public int length, width; {
int area1;
public void GetData(int x, int y) Rectangle rect1=new Rectangle();
{ rect1.GetData(12,10);
length = x; area1=rect1.RectArea();
width = y; Console.WriteLine("Area="+area1);
} }
public int RectArea( ) }
{
int area = length * width;
return (area);
}
}
Constructors
 Used to initialize an object when it is class Rect
created. {
 Have the same name as that of the public static void Main()
class.
{
 They do not have a return type.
int area1;
using System;
Rectangle rect1=new Rectangle(12,10);
class Rectangle
{
area1=rect1.RectArea();
public int length, width;

Console.WriteLine("Area="+area1);
public Rectangle(int x, int y)
}
{
}
length = x;
width = y;
}
public int RectArea( )
{
int area = length * width;
return (area);
}
}
Overloaded Constructors
• Constructors with same name as of class but class Area
different no. & name of arguments. {
• Also known as polymorphism. public static void Main()
{
using System;
int area1;
class Room
Room r1=new Room(12,10);
{
public int length, width; Room r2=new Room(12);

public Room(int x, int y) area1=r1.RArea();

{ Console.WriteLine("Area="+area1);
length = x; area1=r2.RArea();
width = y; Console.WriteLine("Area="+area1);
} }
}
public Room(int x)
{
length = width=x;
}

public int RArea( )

{
int area = length * width;
return (area);
}
}
Static Members
 They are common to all  Restrictions on Static
the objects. Methods:
 Can only call other static
 Are accessed without using methods.
a particular object.  Can only access static
data.
 Cannot refer to this or
 Also referred as class base in any way
variables & class methods.

 A static variable is
common to all instances of
a class.

 Even methods can be

declared as static.
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
{
public static void Main()
{
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.  Example:
class Fun
 It is a method called when an {
object is no longer required. …….
~Fun()
 The name of destructor is {
same as that of class name &
is preceded by a tilde(~). …..
}
 They do not have a return }
type.
 C# manages memory
 They do not take arguments. 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  Example:
of a constant member at run- class Numbers
time.
{
public readonly int m;
 Also allows to have different
constant values for different public static readonly int n;
objects of the class. public Numbers(int x)
{
 The value of the member is m=x;
set using constructor & }
cannot be modified later.
static Numbers()
{
 Can be declared as either
static fields or instance fields. 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 PropertyTest
class Number {
{ public static void Main()
private int number; {
Number n=new Number();
public int Anumber n.Anumber=20;
{ int m=n.Anumber;
get
{ Console.WriteLine("Number="+m);
return number; }
} }

set
 Above class declares a get accessor
method (getter) & a set accessor
{ method (setter).
number=value;
}
}
}
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.  Difference between indexers &
properties:
 A property can be static
 Used to access class objects. member, whereas an indexer is
always an instance member.
 An indexer looks like a property
& is written like it but with 2  A get accessor of a property
differences: corresponds to a method with
 The indexer takes an index no parameters, whereas for
argument & looks like an array. indexer it corresponds to same
formal parameter list as the
 The indexer is declared using indexer.
keyword this.
 A set accessor of a property
 Also referred to as smart arrays. 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.
Example
using System; class MyClient
using System.Collections; {
public static void Main()
class MyClass {
{ MyClass mc = new MyClass();
private string []data = new string[5]; mc[0] = “UniqueInfotech";
public string this [int index] mc[1] = “18";
{ mc[2] = “Janardan Arcade";
get mc[3] = “Dahanu";
{ mc[4] = “West";
return data[index]; Console.WriteLine("{0},{1},{2},{3},
} {4}",mc[0],mc[1],mc[2],mc[3],mc[4]);
set }
{ }
data[index] = value;
}
}
}
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 X
Feature Y
Feature Y
Feature Z
Feature Z
Feature P
Base Class
Derived
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 A

B B C D
Hierarchical
Single Inheritance
Inheritance

A Grandparent class
A B

B Parent class

C Child class C

Multilevel Multiple
Inheritance Inheritance
Containment Inheritance
 Also known as containership  Here object a is contained in
inheritance. object b.

 Example:  This relationship is referred

class A to as ‘has-a’ relationship.
{
….
 The outer class B which
contains the inner class A is
} termed the ‘parent’ class &
class B the contained class A is
{ termed a ‘child’ class.
….
A a; //a is contained in b  Example:
}
 Car has-a radio.
 City has-a road.
B b;
….
Defining a Subclass
 Syntax:
class subclass-name : baseclass-name
{
variable declaration;
methods declaration;
}
Example: Simple Inheritance
using System; class SimpleInheritance
{
class Item public static void Main()
{ {
public void Company() Fan f=new Fan();
{ f.Company();
Console.WriteLine("Item Code=XYZ"); f.Model();
} }
} }

class Fan:Item
{
public void Model()
{
Console.WriteLine("Model=Classic");
}
}
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
Classes Classes Program Outside the program
Private Y
Protected Y Y
Internal Y Y
P.Internal Y Y Y
Public y Y 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; public int Volume()
class Room {
{ return(length*breadth*height);
public int length; }
public int breadth; }
public Room(int x, int y) class InherTest
{ {
length=x; public static void Main()
breadth=y; {
} BedRoom room1=new
public int Area() BedRoom(10,11,12);
{
return(length*breadth); int area1=room1.Area();
} int vol=room1.Volume();
} Console.WriteLine("Area= "+area1);
class BedRoom:Room
Console.WriteLine("Volume= "+vol);
{
int height; }
public BedRoom(int x,int y,int }
z):base(x,y)
{
height=z;
}
Multilevel Inheritance
 Uses derived class as a super class

A Grandparent class

B Parent class

C 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; public Sub(int x,int y) : base(x)
{
class Super this.y=y;
{ }
public int x; public override void Display()
public Super(int x) {
{ Console.WriteLine("Super
this.x=x; x="+x);
} Console.WriteLine("Sub y="+y);
public virtual void Display() }
{ }
Console.WriteLine("Super
x="+x); class Test
} {
} public static void Main()
class Sub:Super {
{ Sub s1=new Sub(100,200);
int y; s1.Display();
}
}
Method Hiding (IMP)
 With the help of virtual & override class Derived:Base
keywords we can hide an method {
declared in a base class.
public new void Display()
{
 What if the class is provided by
someone else? Console.WriteLine("Derived
Method");
}
 Here the base class method cannot be
declared as virtual. }

 To override such method use modifier class HideTest

new to tell the compiler the derived {
class method “hides” the base class
method. public static void Main()
{
 Example: Derived d=new Derived();
using System; d.Display();
class Base }
{ }
public void Display()
{
Console.WriteLine("Base Method");
}
}
Abstract Classes
 At times we can have one base  Example:
class & a number of different abstract class Base
derived classes.
{
………
 The top-most base class simply
acts as a base for others & is not }
useful on its own. class Dervied:Base
{
 We might not want to create an ……..
objects of such classes.
}
…….
 This can be done by making the
class as abstract. …….
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  Characteristics:
the modifier abstract. 1. It cannot have
implementation.
 It is implicitly a virtual
method & does not provide 2. Its implementation must be
any implementation. provided in non-abstract
derived classes by overriding
 An abstract method does not the method.
have a method body.
3. It can be declared only in
 Example: abstract classes.
public abstract void Draw (int
x, int y); 4. It cannot take either static
or virtual modifiers.

5. An abstract definition is
permitted to override a
virtual method.
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 Inclusion
Polymorphism Polymorphism

Using Using
Overloaded Virtual
Methods 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)
{
class Dog Console.WriteLine("Cat is
{ called");
} }

class Cat public static void Main()

{ {
} Dog dog=new Dog();
Cat cat=new Cat();
class Operation Call(dog);
{ Call(cat);
static void Call(Dog d) }
{ }
Console.WriteLine("Dog is
called");
}
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 Swift:Maruti
class Maruti {
{ public override void Display()
public virtual void Display() {
{ Console.WriteLine("Swift Car");
Console.WriteLine("Maruti Car"); }
} }
} class Inclusion
class SX4:Maruti {
{ public static void Main()
public override void Display() {
{ Maruti m=new Maruti();
Console.WriteLine("SX4 Car") 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; public int Mul()
interface Addition {
{ return(x*y);
int Add(); }
} }
interface Multiplication
{ class InterfaceTest
int Mul(); {
} public static void Main()
class Computation:Addition,Multiplication {
{ Computation com=new Computation(10,20);
int x,y; Addition add=(Addition)com; //casting
public Computation(int x,int y) Console.WriteLine("Sum="+add.Add());
{
this.x=x; Multiplication mul=(Multiplication)com;
this.y=y; Console.WriteLine("Product="+mul.Mul());
} }
public int Add() }
{
return(x+y);
}
Example: 2 --- Multiple Implementation of an Interface
using System; class Interface2
{
interface Area public static void Main()
{ {
double Compute(double x); Square s=new Square();
} Circle c=new Circle();

class Square:Area Area area;

{ area=s as Area;
public double Compute(double x)
{ Console.WriteLine("Area of
return(x*x); Square="+area.Compute(10.2));
}
} area=c as Area;

class Circle:Area Console.WriteLine("Area of

Square="+area.Compute(10.2));
{
public double Compute(double x)
}
{
}
return(Math.PI*x*x);
}
}
Interfaces & Inheritance
 A base class of a derived class may class D:B
implement an interface. {
public new void Print()
 When an object of the derived class is {
converted to the interface type, the
inheritance hierarchy is searched for a Console.WriteLine("Derived
class that directly implements the Display");
interface. }
}
 Example:
class Interface3
using System; {
interface Display public static void Main()
{ {
void Print(); D d=new D();
} d.Print();
class B:Display
{ Display dis=(Display)d;
public void Print() dis.Print();
{ }
Console.WriteLine("Base }
Display");
}
}
Explicit Interface Implementation
 It may be possible that multiple class C1:I1,I2
interface have a method of a same {
name.
void I1.display()
{
 This may create a problem when a
class implements more than one Console.WriteLine("I1 Display");
interface. }
void I2.display()
 C# supports a technique known as {
explicit interface implementation,
which allows a method to specify Console.WriteLine("I2 Display");
explicitly the name of the interface it }
is implementing.
}
class Interface4
 Example:
{
using System;
public static void Main()
interface I1
{
{
C1 c=new C1();
void display();
I1 i1=(I1)c;
}
i1.display();
interface I2
I2 i2=(I2)c;
{
i2.display();
void 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 SpaceTest
class Space
{ {
int x,y,z; public static void Main()
public Space(int a,int b, int c)
{ {
x=a; Space s=new Space(10,-
y=b; 20,30);
z=c;
} Space q;
public void Display()
{
Console.Write(" "+x); Console.Write("S: ");
Console.Write(" "+y); s.Display();
Console.Write(" "+z);
Console.WriteLine();
q=-s;
}
public static Space operator -(Space s)
{
Console.Write("Q: ");
s.x=-s.x; q.Display();
s.y=-s.y;
s.z=-s.z;
return(s); }
} }
}
Overloading Binary Operators
using System; public void display()
class Complex {
Console.Write(x);
{
Console.Write(" + j"+y);
double x,y; Console.WriteLine();
public Complex(){ } }
public Complex(double real,double }
imag)
{ class ComplexTest
x=real; {
public static void Main()
y=imag;
{
}
Complex a,b,c;
public static Complex operator + a=new Complex(2.5,3.5);
(Complex c1,Complex c2) b=new Complex(1.6,2.7);
{ c=a+b;
Complex c3=new Complex(); c.display();
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; public static bool operator !=(Vector
class Vector v1,Vector v2)
{ {
int x,y,z; return(!(v1==v2));
public Vector(int a,int b,int c) }
{ }
x=a;
y=b; class CompareTest
z=c; {
} public static void Main()
public static bool operator ==(Vector {
v1,Vector v2) Vector u1=new Vector(1,2,3);
{ Vector u2=new Vector(1,2,3);
if(v1.x==v2.x && v1.y==v2.y) if(u1==u2)
return(true); Console.WriteLine("U1 is equal to
else U2");
return(false); 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; class DelegateTest
{
//Delegate Declaration public static void Main()
delegate int ArithOp(int x,int y); {

class MathOperation ArithOp op1=new

{ ArithOp(MathOperation.Add);
public static int Add(int a,int b)
{ ArithOp op2=new
ArithOp(MathOperation.Sub);
return(a+b);
}
int result1=op1(3,20);
public static int Sub(int a,int b)
int result2=op2(40,20);
{
return(a-b);
} 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; class MDelegateTest
{
delegate void MDelegate(); public static void Main()
{
class DM MDelegate m1=new
{ MDelegate(DM.Display);
public static void Display()
{ MDelegate m2=new
MDelegate(DM.Print);
Console.WriteLine("In Display");
}
MDelegate m3=m1+m2;
MDelegate m4=m2+m1;
public static void Print()
MDelegate m5=m3-m2;
{
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; class EventTest
{
//Delegate Declaration public static void Main()
delegate void EDelegate(string str); {
EventClass ec=new
class EventClass EventClass();
{ EventTest et=new
EventTest();
public event EDelegate Status;
ec.Status+= new
public void TriggerEvent() EDelegate(et.EventCatch);
{ ec.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()  Example:
method. int a=45;
 General Form: int b=976;
 Console.WriteLine(format-
string, v1, v2, ….); int c=a+b;

 Format String contains both Console.WriteLine(“{0,5\n+{1,5}\

static text & markers which n} ------- \n{2,5}”,a,b,c);
indicate
 Where the values are to be printed.
 How the values are to be formatted. 45
+976
 Example -----------
 Console.WriteLine(“Sum of {0} 1021
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
Numeric Formatting
Chapter : 18
Managing Errors & Exceptions
THANK YOU
JINESH SHAH