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:

BPCL B

C

C++

ANSI C

Oak

Java

ANSI C++

C#

1967 1970

1972

1983

1987

1991

1995

1996

2000

Dennis Ritchie

Bjarne Stroustrup

ANSI Committee

James Gostling

Sun MicroSystems

ANSI Committe

Microsoft

Martin Richards Ken Thompson

Cont…. C & C++ languages suffer

from a number of shortcomings in meeting World Wide Web requirements & standards.

Some are as follows:

1. The high complexity of language

2. They are not truly object oriented

3. They have poor type safety

4. They are not suitable for working with new web technologies.

5. They do not support versioning

6. Their low productivity

7. They are weak in consistency

8. Their poor compatibility with the existing systems

VB, a language promoted by Microsoft for overcoming these problems, is not truly object-oriented and becomes increasingly difficult to use when systems become large.

Java which is truly object-oriented 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# The Internet is the mainstream

for many business organization today.

There were a number of limitations in using the WWW over the Internet:

1. We could see only one site at a time

2. The site had to be authored to our hardware environment

3. The information was basically read-only.

4. We could not dynamically compare similar information stored on different sites.

5. 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 Framework

.NET Platform

C#

Cont…

C# is a descendant of C++ which in turn is a descendant of C as illustrated below:

C

C++

Java C# VB

Concept

ProductivityElegance

Concept

Component

Orientation

Object Orentation

Power

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 Introduced1. C# compiles straight from source code to

executable code, with no object files2. In C#, class definition does not use a semicolon

at end3. The first character of Main() function is

capitalized4. C# does not support #include statement5. C# does not support multiple code inheritance6. Casting in C# is much more safer then C++7. C# does not support default arguments8. C# permits declaration of variables between

goto & label

How Does C# differs from C++ ? C++ Features Dropped

1. Macros2. Multiple Inheritance3. Templates4. Pointers5. Global Variables6. Typedef statement7. Default Arguments8. Forward Declaration of Classes

Enhancements to C++1. Automatic Garbage Collection2. Versioning Support3. Strict Type-Safety4. Properties to access data members5. Delegates & Events6. Boxing & Unboxing7. Web Services

How Does C# differs from Java ?1. C# has more primitive data types2. Arrays are declared differently in C#3. C# supports struct type & Java does not4. Java does not provide for operator overloading5. C# provides for better versioning support than Java6. C# provides static constructors for initialization7. Java does not directly support enumerations8. C# uses is operator instead of instanceof operator

in Java9. C# checks overflows uses checked statements10. 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 : 2Understanding .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.

Fig : Three generations of component model

OLE Technology

COM Technology

.NET Technology

Interprocess Communication

Intermodule Communication

Intersite Communication

Phase I – Early 1990s

Phase II – 1995

Phase III – Late 1990s

The .NET Framework

.NET Framework

.NET Building .NET DeviceBlock Services Software

.NET Platform

.NET User

Experience

.NET Infrastructure

& Tools

Visual Studio .NET Experience .NET Services

.NET Infrastructure & Tools

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

Framework Base Classes

.NET Framework

ASP .NET

(Web Services)

Windows Forms

(User Interface)

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…)

Intermedia Language (IL)

Common Type System

Common Language Runtime

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# Programclass 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.

NAMESPACESSystem.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-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 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{


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 Classclass Demo //class definition{

public void display(){

System.Console.WriteLine(“In Demo Class”);}

}

class SampleSeven{


Demo d=new Demo(); //creating d objectd.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

OR multimain.cs/main:Class B

//multimain.csusing System;class A{

public static void Main(){Console.Write(“Class A”);}

}

class B{

public static void Main(){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”);}

}

Errors.cs(2.7): error cs0234: The type or namespace name ‘Systom’ does not exists in the class or namespace

The error message contains:

1. Name of the file being compiled(Errors.cs)

2. Line number & column position of the error(2.7)

3. Error code as defined by the compiler (cs0234)

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

Using Directive Section

Interfaces Section

Classes Section

Main Method Section

Optional

Optional

Optional

Optional

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

PredefinedTypes

User-definedTypes

PredefinedTypes

User-definedTypes

•Integers

•Real Numbers

•Booleans

•Characters

•Classes

•Arrays

•Delegates

•Interfaces

•Objects

•Strings

•Enumerations

•Structures

Declarations of Variables

Variables are names of storage locations.

Declaration does three things1. 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=20Console.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 mint 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 operatorsRelational operatorsLogical operatorsAssignment operatorsIncrement & decrement operatorsConditional operatorsBitwise operatorsSpecial operators

Arithmetic Operators

Operator Symbol Action Example

Addition + Adds two operands

x + y

Subtraction - Subtracts the 2nd operand with 1st operand

x – y

Multiplication * Multiplies two operands

x * y

Division / Divides two operand

x / y

Modulus % Gives the remainder when the operands are divided.

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

Hence code should be:int b3=b1+b2; //no error

Ways of Type Conversion Implicit Conversions Explicit Conversions

Type Conversions

ImplicitConversions

ExplicitConversions

ArithmeticOperations

Casting Operations

Mathematical Functions Present in Math class of System Namespace. Static Members: E and PI Mathematical Methods in Math class:

Method Description

Sin() Sine of an angle in radians

Cos() Cosine of an angle in radians

Tan() Tanget of an angle in radians

Asin() Inverse of Sine

Acos() Inverse of Cosine

Atan() Inverse of Tangent

Sinh() Hyperbolic sine

Cosh() Hyperbolic cosine

Tanh() Hyperbolic tangent

Sqrt() Square Root

Pow() Number raised to a given power

Exp() 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

booleanexpression

?

Statementblock

Statement-X

Next statement

False

True

Entry

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

booleanexpression

?

True-BlockStatement

Statement-X

Next statement

FalseTrue

Entry

False-BlockStatement

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

Test condition1

?

Statement-3

Statement-X

Next statement

TrueFalse

Entry

Statement-1

Test condition2

?Statement-2

TrueFalse

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;

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

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

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…

}

Entry based loop

Body of the loop

Testcond

True

False

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

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

Testcond

• Exit based loop

False

True

Exampleclass 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{


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.

while(……….)

{

………………….

……………………

if (condition)

break;

……………..

……………..

}

……………..

for (……….)

{

………………

if (error)

break;

……………..

……………..

}

………………..

Exit fromloop

do{ …………… ……….. if (condition)

break; ………….. …………..}while (…………….)……….

for (……………….){ ………… for (………..) { ………….. if (condition)

break; …………… } ……………}

Exit fromloop

Exit fromloop Exit from

loop

Exiting a loop with break statement

while (test condition)

{

…………

if (………..)

continue;

………….

………….

}

for (initialization; test condition; increment)

{

…………

if (………….)

continue;

…………

…………

}

do

{

………..

if (………..)

continue;

………….

…………..

} while (test condition);

Bypassing & Continuing in Loops

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 nameConsole.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);

}

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.

List of Method Modifiers

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);

Exampleusing 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; }public static void Main( ){

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;

}public static void Main( ){

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("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 initializedSquare ( 10, out m );Console.WriteLine("m = " + 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( );}public static void Main( ){int [ ] x = { 11, 22, 33 };Parray ( x) ; //call 1Parray ( ) ; //call 2Parray ( 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{

public static void Main(){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: 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}};

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

Exampleusing 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;


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]);

Console.WriteLine(" ");

city.Sort();

Console.WriteLine("After Sort");

for(int i=0;i<city.Count;i++)

Console.WriteLine(" " + city[i]);

}

}

ArrayList Property & MethodsMethod/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().

Exampleusing 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, [ ]

Exampleusing 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:

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.

Exampleusing System;using System.Text; //for StringBuilder classusing 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 Structurestruct struct-name{

datamember1;datamember2;…….

}

The variables inside struct are called as members or fields or elements.

Creating variables of new type:struct-name variablename;

orstruct-name variablename = new struct-name();

Assigning values to Members:variablename.datamember1=value;

Struct data members are private by default & hence declare them as public.

Exampleusing 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);


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 heap

Value Type & stored on stock

Inheritance Support Inheritance Do Not Support Inheritance

Default Values Default value of a class type is null

Default value is the value produced by ‘zeroing out’ the fields of struct

Field Initialization

Permit initialization of instance fields

Do Not

Constructors Permit declaration of parameterless constructors

Do Not

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.


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

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 internal

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; //declarerect=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);

Exampleusing 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="+area

1);}

}

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( ){

int area = length * width;return (area);

}}

class Rect{

public static void Main(){int area1;

Rectangle rect1=new Rectangle(12,10);

area1=rect1.RectArea();

Console.WriteLine("Area="+area1);}

}

Overloaded Constructors• Constructors with same name as of class Constructors with same name as of class

but different no. & name of arguments.but different no. & name of arguments.

• Also known as polymorphism.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( )

{

int area = length * width;

return (area);

}

}

class Area

{


{

int area1;

Room r1=new Room(12,10);

Room r2=new Room(12);

area1=r1.RArea();

Console.WriteLine("Area="+area1);

area1=r2.RArea();

Console.WriteLine("Area="+area1);

}

}

Static Members They are common to all

the objects.

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.

Restrictions on Static Methods: Can only call other

static methods. Can only access static

data. Cannot refer to this or

base in any way

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

They do not take arguments.

Example:class Fun{

…….~Fun(){

…..}

}

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 run-time.

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.

Exampleusing System;class Number{

private int number;

public int Anumber{

get{

return number;

}

set{

number=value;}

}}

class PropertyTest{


Number n=new Number();

n.Anumber=20;int m=n.Anumber;

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: The indexer takes an index

argument & looks like an array.

The indexer is declared using keyword this.

Also referred to as smart arrays.

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.

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{ public static void Main() { 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

Feature X

Feature Y

Feature Z

Feature PBase Class

Derived Class

Classical Inheritance Represents a kind of relationship between two

classes. Example:

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

Class A

Class B

Different Classical Inheritance Implementation

A

B

A

C

B

A

DCB

A

B

C

Grandparent class

Parent class

Child class

Single InheritanceHierarchical Inheritance

Multiple Inheritance

Multilevel 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 Inheritanceusing System;

class Item{

public void Company(){Console.WriteLine("Item Code=XYZ");}

}

class Fan:Item{

public void Model(){

Console.WriteLine("Model=Classic");}

}

class SimpleInheritance{ public static void Main() { 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

Classes

Derived

Classes

Containing

Program

Anywhere

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 Constructorusing 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{ public static void Main() {

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

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.

A

B

C

Grandparent class

Parent class

Child class

Hierarchical Inheritance

Account

CurrentFixed-DepositSavings

LongMediumShort

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.


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{ public static void Main() {

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{ public static void Main() {

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; //ErrorDerived 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.

An abstract method does not have a method body.

Example:public abstract void Draw (int x, int y);

Characteristics:1. It cannot have

implementation.

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.

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

InclusionPolymorphism

OperationPolymorphism

UsingVirtual

Methods

UsingOverloaded

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.


class Dog{}

class Cat{}

class Operation{

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

static void Call(Cat c){Console.WriteLine("Cat is called");}

public static void Main() {

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.

Exampleusing System;class Maruti{

public virtual void Display(){Console.WriteLine("Maruti Car");}

}class SX4:Maruti{

public override void Display(){Console.WriteLine("SX4 Car")}

}

class Swift:Maruti{

public override void Display(){Console.WriteLine("Swift Car");}

}class Inclusion{ public static void Main() {

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: 1using 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 Square:Area{

public double Compute(double x){

return(x*x);}

}

class Circle:Area{

public double Compute(double x){

return(Math.PI*x*x);}

}

class Interface2{


Square s=new Square();Circle c=new Circle();

Area area;area=s as Area;

Console.WriteLine("Area of Square="+area.Compute(10.2));

area=c as Area;

Console.WriteLine("Area of Square="+area.Compute(10.2));

}}

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 Operatorsusing 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);

Console.WriteLine();

}

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 Operatorsusing System;

class Complex

{

double x,y;

public Complex(){ }

public Complex(double real,double imag)

{

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);

}

public void display(){

Console.Write(x);Console.Write(" + j"+y);Console.WriteLine();

}}

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();

}}

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{

public static void Main(){Vector u1=new Vector(1,2,3);Vector u2=new Vector(1,2,3);if(u1==u2)Console.WriteLine("U1 is equal to U2");elseConsole.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 Declarationdelegate int ArithOp(int x,int y);

class MathOperation{

public static int Add(int a,int b){

return(a+b);}public static int Sub(int a,int b){

return(a-b);}

}

class DelegateTest{


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


delegate void MDelegate();

class DM{

public static void Display(){Console.WriteLine("In Display");}

public static void Print(){

Console.WriteLine("In Print");}

}

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;

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.


//Delegate Declarationdelegate void EDelegate(string

str);

class EventClass{

public event EDelegate Status;

public void TriggerEvent(){

Status("Event Triggered");}

}

class EventTest{


EventClass ec=new EventClass();

EventTest et=new EventTest();

ec.Status+= new EDelegate(et.EventCatch);

ec.TriggerEvent();}

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:

12 23 3 34 4 4 45 5 5 5 56 6 6 6 6 67 7 7 7 7 7 78 8 8 8 8 8 8 89 9 9 9 9 9 9 9 9

Formatted Output Use overloaded WriteLine()

method. General Form:

Console.WriteLine(format-string, v1, v2, ….);

Format String contains both static text & markers which indicate

Where the values are to be printed.

How the values are to be formatted.

Example 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);

4 5 + 9 7 6 ----------- 1 0 2 1

Numeric Formatting

Chapter : 18

Managing Errors & Exceptions

THANK YOU

JINESH SHAH

Programming in c#

Technology

Transcript of Programming in c#