IndexIndex

• Introduction to OOPS• Oops Concept• Introduction to C#• Dot Net Framework• Literals and Data Types• Branching and Looping• Constructor• Inheritance• Abstract Class• Interface• Delegates• Events• Structure• Arrays• Enumerator• Collections• Exception Handling• Sealed Class• Files• Generics

• Introduction

• Classes And Object

• OOPS Concepts

• Advantages

Contents:

INTRODUCTION INTRODUCTION

• Object-Oriented Programming allows programmers to use the same terminology to explain the business domain and the program.

• OOP enables users to model real-world objects. Modeling means representing real-world objects as components.

ExplanationExplanation

• Before OOP, programmers used to creating computer applications using procedural-programming (or structure-programming)

• In procedural- programming all the program functionality written in a few modules of code or maybe one module (depending on the program).

• These modules depend on one another and maybe if you change a line of code you will have to rewrite the whole module again and maybe the whole program.

• The introduction of OOP, solved lots of problems of procedural programming.

• In oops codes are written in independent parts called ‘classes’. Each program functionality is divided into classes. The assembly combines these classes to form a single program.

• Now if any changes has to be made then that particular or specific class is taken and necessary changes is to be made.

CLASS & OBJECTCLASS & OBJECT

• The single entity holding the data and methods is called a “class”. An “Object” is an instance of a class.Eg: Car is a class and engine is an object.

• People is a class and Mary is an object.

• A class is a plan from which many objects can be created.

Suppose that someone builds a paper pattern for a shirt. All the shirts done with the same paper pattern will be identical (same design, size, etc.). In this sample, the paper pattern is the class and the shirt is the object. To build the same exact

shirt over and over, you need the paper pattern as a

template.

Paper Pattern is the ClassAnd

Shirt is the Object

OOPS CONCEPTSOOPS CONCEPTS

Polymorphism

Encapsulation

Abstraction

Inheritance

INHERITANCEINHERITANCE

• Inheritance creates a hierarchy of classes and helps you reuse the code of a parent class in a child class.

• A Class inherits the attributes and behavior of its parent class or superclass.

• Superclass: Base class: Parent class. Subclass: Derived class: Child class. • The mechanism of constructing one class from an other

class is called “Inheritance”.

Syntax: <<Access modifiers>> class <subclass name> extends

<superclass name>

• The Shape class is the parent class. Square, Rectangle, and Circle are derived classes that inherit from Shape.

• class declaration class child: parent 

• class Square: Shape

Shape

Circle RectangleTriangle

ENCAPSULATIONENCAPSULATION

• Encapsulation hides internal implementation details from users.

• Internal details, such as data representation should not be accessible externally, this protects outside users from making internal changes.

• There is visibility to the functionalities offered by an object, and no visibility to its data.

• Encapsulation means hiding of non-essential details.

EXAMPLEEXAMPLE

• When a user selects a command from a menu in an application, the code used to perform the actions of that command is hidden from the user.

• A Customer may issue a check and now know how it is processed. The internal processing is hidden from the customer.

ABSTRACTIONABSTRACTION

• Abstraction means representing of essential details.

• An abstract class is a parent class that allows inheritance but can never be instantiated.

• Abstract classes contain one or more abstract

methods that do not have implementation.

• A Shape class, which is an abstract class. In the real world, you never calculate the area or perimeter of a generic shape, you must know what kind of geometric shape you have because each shape (eg. square, circle, rectangle, etc.) has its own area and perimeter formulas.

• People own savings accounts, checking accounts, credit accounts, investment accounts, but not generic bank accounts. In this case, a bank account can be an abstract class and all the other specialized bank accounts inherit from bank account.

TriangleRectangleCircle

Shape

POLYMORPHISMPOLYMORPHISM

• Polymorphism means one entity existing in multiple forms.

• The design principle used in this is the same message sent to different objects results in different behavior.

• Even though classes are derived or inherited from the same parent class, each derived class will have its own behavior.

EXAMPLEEXAMPLE

• All of them are shapes and as shapes their area and perimeter can be calculated; however, each shape calculates its area in a specialized way.

• In the same way Every key of a keyboard performs a specific action when a keystroke message is generated for that key. However, by using polymorphism, the same code with a small change can be used by different keys of the keyboard to trigger specific actions.

Shape

CircleArea=3.14*r*r

(r=Radius)

RectangleArea=H*W(H=height,W=width)

SquareArea=4*S*S

(S=side)

AdvantagesAdvantages

• Enables the use of real-world modeling . - Any real world object is considered as an object.• Promotes the reuse of code. -By the use of inheritance etc, coding in a single class can

be used many times.• Provides flexibility in the modification of an existing

application . -If any changes in a single line code, only that specific

class is taken and made necessary changes. • Helps with the maintainability of code. -You can create classes for different types of

organization. - This helps in maintaining data information separately.

• Introduction

• What Lead to C#

• Features in C#

• Characteristics in C#

Contents:

C# C#

• C# (pronounced "C sharp") is a programming language that is designed for building a variety of applications that run on the .NET Framework.

• C# is simple, powerful, type-safe, and object-oriented.

• Delegates, Interface, Foreach Statements, Enumerations are few features in C# which lag in C++.

• The first component oriented language in the C/C++ family

What lead C#What lead C#

C/C++ Drawbacks:• Poor type safety.• High complexity of language.• Memory leakage.• Weak in consistency.Visual Basic Drawbacks:• Truly not Object- Oriented.• Also could not meet the requirements of World Wide Web.Java Drawbacks:• Lacking in inter-operability with code of other languages.• Truly Object-Oriented but does not feature like Operating

Overloading.

• Hence keeping in view of these drawbacks, The Microsoft wanted new language that will suite the requirements of World Wide Web Application. Hence, Lead to the Introduction of c#( pronounced "C

sharp").

Productivity of Visual Basic,

Power of C++

and Elegance of Java

combines to form C#.

C# is the combination of 70% of Java,10% of C++,

5% of Visual Basic and 15% new features.

New Features:• Boxing/UnBoxing.

• For each Statements.

• Go to.

• Events

• Delegates

• Interfaces

• Rectangular Arrays

Characteristics of c#:• Object Oriented

• Garbage Collection

• Namespace

• Data Types

• Inter Operability

• Versionable

• Security

• Indexes

• Exception Handling

• Data Types

• Introduction

• DotNet Architecture

• Common Language Runtime

• Base Class Library

• DotNet Framework Services

• DotNet Execution Model

• C# and DotNet

Contents:

Dot Net FrameworkDot Net Framework

• C# is mainly dependent for supporting the key features of dot net framework.

• The dot net framework provides an environment for building, deploying and running web services and other applications.

• This is the working platform for applications.

Dot Net Framework ArchitectureDot Net Framework Architecture

VB C++ C# JAVA ….

Common Language Specification

ASP. NETWeb forms, Web Services

ADO.NET and XML

Base Class Library

Common Language Runtime

Window Forms VisualStudio

DotNET

Common Language RuntimeCommon Language Runtime

• Common Language Runtime: -it’s a runtime engine which manages the runtime code

(c# application). -is a part of dot net framework.• Simplify Application Development, Deployment and

Management.

• Managed code: -a code that satisfies the CLR.

Common Language RuntimeCommon Language Runtime

Program written in any DOT NET language(C#,VB.Net etc)

Intermediate Language (IL)(.exe or .dll)

Common Language RuntimeLoads and Executes code

Compiler

Compiler

• Common Type System: -Defines rules that languages must follow, which helps

ensure that objects written in different languages can interact with each other.

-is responsible for interpreting the data types into the common format - e.g. how many bytes is an integer.

• Common Language Specification: -This ensure inter-operability between Languages. -All the rules that apply to the common type system apply to

the CLS, except where stricter rules are defined in the CLS.

• IL Compiler: -takes in the IL code and converts it to the host machine

language.• Security: -ensures that the assembly (the program being executed)

has permissions to execute certain functions.• Garbage collector: -Its function is to reclaim the memory when the object is no

longer in use, this avoids memory leaks and dangling pointers.

• Class loader: -Its sole purpose is to load the classes needed by the

executing application.

.Net Framework Services.Net Framework Services

• ASP.NET: -It’s a server side scripting technology.

• Web Forms: -Manageable code

• Window Forms: -Framework for building rich controls.

• ADO.Net: -Used as connectivity( e.g.: datasets) -XML support.

.NET Base Class Libraries .NET Base Class Libraries

System

System.Data System.Xml

System.Web

Globalization

Diagnostics

Configuration

Collections

Resources

Reflection

Net

IO

Threading

Text

ServiceProcess

Security

Design

ADO

SQLTypes

SQL

XPath

XSLT

Runtime InteropServices

Remoting

Serialization

Serialization

Configuration SessionState

Caching Security

Services Description

Discovery

Protocols

UI HtmlControls

WebControls

System.Drawing

Imaging

Drawing2D

Text

Printing

System.WinForms

Design ComponentModel

Base Class LibraryBase Class Library

• The Framework Class Library or FCL nothing short of a massive collection of classes, structures, enumerated types and interfaces defined and implemented for reuse in your managed software.

• If you like, you can use it like any other library. • That is to say that you can write applications that make use

of the objects in the Base Class Library to read files, display windows, and do various tasks.

• The FCL is a class library; however it has been designed for extendibility and compose ability. This is advanced reuse.

Visual Studio .NETVisual Studio .NET

.NET .NET PlatformPlatform

Man

age

Man

age

and

Co

llab

ora

tean

d C

oll

abo

rate

DeploymentDeployment

TestingTesting

DevelopmentDevelopment

DesignDesign

AnalysisAnalysis

PlanningPlanning

•Visual Studio is an integrated

•development environment published by Microsoft for writing Windows programs.

•.NET can also be used to write managed applications in C#, C++, Visual Basic and any other language

•Visual Studio .NET and the .NET Framework as different products.

.Net Execution.Net Execution

VB C# C++

complier complier complier

assembly assembly assembly

Common Language Runtime / Just-In-Time Complier

Operating system service

Managedcode

Managedcode

Managedcode

Unmanagedcode

Source

code

Native

code

MSIL

CLR Service

Compilation

Execution

• Assembly: -Logical unit of deployment, also contains metadata,

MSIL and resources.• Microsoft Intermediate Language (MSIL or IL): -CPU independent language.• Metadata: -Structured Information (class or method definition,

properties etc). • Managed Code: -Any code that targets the CLR. -Any .Net Language ,including c# ,c++, Visual Basic etc. • JIT-Complier: -All managed code runs in native Language.• Operating System: -your working system.

SampleSample

using System; //Namespace declaration

class Sample //class Declaration

{ static void Main() //method { Console.write(“Hello”); } }

OUTPUT: Hello

The compilation saved with .cs extension which in this case is

“ Sample.cs”

Namespace: -elements designed to help you

organize the program. -avoid clashes between two sets of

code.Class Declaration: -contains data and methods definition

that you use in your program. Method: -It tells what this class will do when

executed. -Main, is always considered as entry

point. Outlet: -console is a class in system

namespace. -and write is a method in console

class. -the (.)separates subordinate

elements. -namespace.class.method=pattern

• Literals

• Data Types

• Reference And Value Type

• Boxing And Unboxing

Contents:

LiteralsLiterals

• Literals are value constants assigned to variables .C# supports several types of literals.

• Boolean

True or False

• String

Sequence of Character. Eg: “ HELLO”.

• Character

Single Character, Simple-escape Sequence like below

Eg: ‘a’ , \a \’ \r \”

• Real

Decimal Digits, Sign like +,-.

• Integer

Decimal Digits, Hexadecimal Digits like below

0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

Literals

Boolean

Integer

Character

String

Real

Data TypesData Types

Integer:• Int , uint 32-bit,• Long , ulong 64-bit,• Short , ushort 16-bit,• Sbyte , byte 8-bit.

Floating Point:• Float 32-bit,• Double 64 bit.

Charactar and String:• Char 16-bit unicode• String-set of unicode

Type Conversion

int i = 5;

double d = 3.2; string s = “432”;

Implicit conversion d = i;

Cast required i = (int)d;

Conversion required i =

System.Convert.Toint32(s);

Value And Reference TypeValue And Reference Type

Value Type• Directly contain data.

• Allocated on Stack.

• Eg: Structs,Enums

Reference Type• Contains reference to object.

• Allocated on Heap using new keyword.

• Eg: Classes,Interface

Ex:

int a=1;

Ex:

object ob=a

Boxing And UnBoxingBoxing And UnBoxing

• Converting value type to reference type is called Boxing.

• Converting reference to value type is called UnBoxing.

•Eg: int a=1; //boxing object ob=a; int j=(int)ob; //unboxing

• Methods

• Kinds of Methods

• Properties

Contents:

MethodsMethods

• Any class has methods and properties.• These are the places where business logic or functionally is

written and executed.• Method is declared as: Return-type methodname ( Parameterslist );

Example: Int Addition(int x,int y){}• Int--- Return-type• Addition---methodname• Int x,int y---parameters list

There are two kinds of method:• Instance method: This method is called by creating object of that class

which contains the method. • Static Method: This method is called by the classname in which the

method is located. We should use the keyword “static” for this method.

Syntax: Classname.methodname();• We can declare the signature of the same method

once again in the same class but with different parameters. The parameters should be different.This is called “method overloading”.

Kinds Of MethodsKinds Of Methods

MethodsMethods

using Systems;class Intsmethod{void show(){int x=100;int y=200;Console.WriteLine(x);Console.WriteLine(y);}static void Main(){Intsmethod a=new Intsmethod();a.show();}}

using System;class Statemethod{static void show(){int x=100;int y=200;Console.WriteLine(x);Console.WriteLine(y);}static void Main(){Statemethod.show();}}

*100200

*100200

Methods with Two ParametersMethods with Two Parameters

using System;class Twopara{void show(int a, int b){Console.WriteLine(a);Console.WriteLine(b);}static void Main(){Twopara t=new Twopara();t.show(200,300);}}

Using System;Class Overloadmet{Void show(int a){Console.WriteLine(a);}Void show(int a, int b){Console.WriteLine(a);Console.WriteLine(b);}Static void Main(){Overloadmet o=new Overloadmet();o.show(2);o.show(5,9);}}

*200300

*2*59

PropertiesProperties

• Properties provide added functionality to the .Net framework.

• In c# property consists of 1. Field Declaration 2. Accessor method(get and set methods) <acces_modifier> <return_type> <property_name>

{           get{}           set{}}

• Get() is used to retrieve a field value and Set() is used to modify field’s value.

• If you want to make the property read-only, omit the set block and to make it write only, omit the get block.

• This is a secured manner to pass the data.

PropertiesProperties

Example:Using System;Class Propertyex{Public string id;Public string Idvalue{Get{Return value;}Set{id=value;}}

Static void Main(){Propertyex pe=new Propertyex();pe.id=“007”;String p=pe.id;Console.WriteLine(“The Value is

{0}”,p);}}OUTPUT:

007

7

6

5

43

2

1

0

• If-Else Statements

• Switch Statements

• While Statements

• Do-While Statements

• For Statements

• Foreach Statements

Contents:

IF-Else StatementsIF-Else Statements

• The first Selection Statements if statement has three forms:

1. Single Selection.

2. If – then - else Selection.

3. Multi - case Selection.

• Syntax:

if( condition1 )

//statement

else if( condition2 )

//statement

else (condition)

//statement

Class elseifsample{ Static void Main() { Console.Writeline(“WRITE A NUMBER”); Int i=Convert.Toint32(Console.ReadLine()); If(i>0 && i<100) { Console.WriteLine(“YOUR NUMBER IS {0}”,i); } Else if(i<0) { Console.WriteLine(“YOUR NUMBER {0} IS NEGATIVE “,i); } Else if(i==0) { Console.WriteLine(“YOUR NUMBER IS ZERO”); } Else { Console.WriteLine(“NUMBER OUT OF RANGE”); } }}

WRITE A NUMBER25

YOUR NUMBER IS 25

OUTPUT:

Switch StatementsSwitch Statements

• The second Selection is Switch case statements• The value is compared to each of case statements untill

match is found.

• Syntax: switch( value ) case result1: statement1; break; case result2: statement1; break; default: statement1

Class SwitchState { static void Main() { string k; int i, j; Console.WriteLine(“Select two numbers”); i= Convert.ToInt32(Console.ReadLine()); j= Convert.ToInt32(Console.ReadLine()); Console.WriteLine(“Select operator +,-,*”); k= Convert.ToChar(Console.ReadLine()); switch (k) { case ‘+’: Console.WriteLine(“{0}+{1}={2}”,i , j,+(i+j)); break; case ‘-’: Console.WriteLine(“{0}-{1}={2}”,i ,j,+(i-j)); break; case ‘*’: Console.WriteLine(“{0}*{1}={2}”,i ,j,+(i*j)); break; default: Console.WriteLine(“Invalid operator {0}”,k); break; } } }

Select two numbers23

Select operator +,-,*+

2+3=5

While StatementsWhile Statements

WHILE statements

• A WHILE loop will check a condition and then continues to execute a block of code as long as the condition is true.

Syntax:

while( condition ) { statement; }

WHILE Statement

Using System;Class whilestate{ static void Main() { int i=0; while (i<10) { Console.Write(“{0} ”,i); i++; } }}

0 1 2 3 4 5 6 7 8 9

OUTPUT:

Do While StatementsDo While Statements

DO WHILE statements• In WHILE loop statements, if condition is false then the

statement will not execute.• But in DO WHILE statement, first the statement in the

block of code executes at least once then checks the condition.

Syntax: do { statement; }while( condition );

DO WHILE Statements

Class dowhilestate{ static void Main() { int i=0; do { System.Console.Write(“{0} ”,i); i++; } while (i<10); }}

0 1 2 3 4 5 6 7 8 9

OUTPUT:

For StatementFor Statement

FOR statements• The ‘for’ loop works like a while loop, except that the syntax of ‘for’

loop includes initialization and condition.• The ‘for loop syntax explains clearly.• The contents in the syntax is separated by semicolons.

Syntax:

For( initialization; condition; iterator )

{

statement;

}

For Statements

Class forstate{ static void Main() { int i=0; for(int k=0;k<10;k++) { System.Console.Write(“{0} “,i); i++; } }}

OUTPUT:

0 1 2 3 4 5 6 7 8 9

Foreach StatementForeach Statement

FOREACH statements

• This is similar to ‘for’ statement.• The ‘foreach’ loop is used to iterate through items in the list.• This is used for arrays or collection such as arraylist.

Syntax:

foreach( datatype varname in arrayname)

{

statement;

}

Foreach Statement

Using System;

Class foreachstate{ static void Main() { int[] number={0,1,2,3,4,5,6,7,8,9}; foreach(int line in number) { Console.Write(“{0} “,line); } }}

0 1 2 3 4 5 6 7 8 9

OUTPUT:

• Introduction

• Static Constructor

• Overloaded Constructor

• Copy Constructor

Contents:

CONSTRUCTORCONSTRUCTOR

• Constructor is a special method, evoked automatically whenever object is created.

• The class and the method both has same name.

• It has no return type.

• The are four types of constructors:

1. Static Constructor2. Overloaded Constructor3. Copy constructor4. Default Constructor

Syntax:

class Myclass

{

public Myclass()

{

}

}

• Object of the class can be created by using the new keyword.

E.g: Myclass m=new Myclass

• Constructors can be declared "private or protected“ but commonly public is used.

Simple ConstructorSimple Constructor

class Cons { int length, height; public Cons ( int a, int b) { length=a; height=b; } public int area () { return length*height; } } class Class1 { public void Main() { Cons c=new Cons ( 3,4); int n=c.area(); Console.WriteLine( “ The area is =

“ +n); } }

OUTPUT

The area is = 12

Static ConstructorStatic Constructor

• “Gets called before the first object is created of the class”

Syntax: class Sample { static Sample //static

constructor { } }

• It is used to perform an action only once.

• Keyword static is used.• It does not contain any

access modifier,no parameters.

• There can be only one static constructor in the class.

OUTPUT: class State { static State() { Console. WriteLine (“This is one”); } public void static land() { Console. WriteLine (“This is two”); } } class Sample { static void Main() { State. land(); State. land(); } }

*This is oneThis is two*This is two

Overloaded ConstructorOverloaded Constructor

Eg: class Load { public Load() { Console. WriteLine (“No Arguments

in this method”); } public Load( int i ) { Console. WriteLine (“The number is

{0}”, I ); } public Load( int i, int j) { Console. WriteLine

(“{0}+{1}={2}“, i ,j ,+(i+j)); } }

class Sample { static void Main() { Load o=new Load(); Load o1=new Load(6); Load o2=new Load(2,3); } }OUTPUT:

No Arguments in this methodThe number is 6

2+3=5

“constructors with different set of parameters”

Copy ConstructorCopy Constructor

Eg:class Person { private int age; private string name; public Person (Person p) //copy constructor { age =p. age; name=p. name; } public Person (int age, string name) //instance {

//constructor this. age= age; this. name= name; } public string Details //get details { get { return name + “is” +age. Tostring(); }

} }

Class Sample { static void Main() { Person h=new

Person(23,”Ram”); Person h1=new Person (h); Console. WriteLine(h. Details); Console. WriteLine(h1. Details); } }

OUTPUT:

Ram is 23Ram is 23

“A copy constructor is a special constructor used to create a new object as a copy of an existing object.”

DestructorDestructor

• In simple terms a destructor is a member that implements the actions required to destruct an instance of a class.

• Opposite to a constructor.

• Syntax: ~ classname() { statement; }

• Introduction

• Simple Inheritance

• Multilevel Inheritance

• Hierarchical Inheritance

• Using Keywords

Contents:

InheritanceInheritance

Access Modifier• public---visible to every code• private---visible only inside that class• protected--- visible only to its class and derived type• internal----visible inside the assembly• protected internal---within the assembly and its derived type.Syntax:Class derivedClass:baseClass (deriving from base class){}• If a function or a property in the base class is declared as virtual it

can be overridden in any derived classes • The new keyword should be used when we intend to hide a

method.

Types of InheritanceTypes of Inheritance

• The mechanism of designing or constructing one class from another is called inheritance.

• One class acquiring property of another class.• There are four types of inheritance1. Single Inheritance2. Hierarchical Inheritance3. Multiple Inheritance4. Multilevel Inheritance

A

B

B

A

BB

A

C

BA

C

Single

Hierarchical

Multilevel

Multiple

C# does not support Multiple Inheritance.

Simple InheritanceSimple Inheritance

class Animal { public void name() { Console.WriteLine("This is

Animals World"); } public void type() { Console.WriteLine("There

are many types"); } public void size() { Console.WriteLine("There

are are big animals"); } }

class Cat : Animal { public void kitty() { Console.WriteLine(" THis is a

Cat"); } } class Simpleinherit { static void Main() { Cat c = new Cat(); c.kitty(); c.name(); c.size(); c.type(); } }

This is a Cat.This is animals World.There are big animals.There are many types

MultilevelMultilevel

class Base { public virtual void who() { Console.WriteLine("This is who from

Base Class"); } } class Derived : Base { public override void who() { Console.WriteLine("This is who from

Derived Class"); } } class Derived1 : Derived { } class Derived2 : Derived1 { }

class Multilevel { static void Main() { Derived2 d2 = new

Derived2(); Base b1 = new Base(); b1.who(); } }

This is Who from DerivedClass

HierarchicalHierarchical

public class Shape { public double area; public Shape() { area=0.0; } public void display( string name, double

a) { Console. WriteLine(“The area of “ +

name + ” is “ +a); }} public class Square: Shape { int side; public Square( int s) { side=s; } public void calculatearea1() { area= 4*s*s; } }

public class Circle: Shape { int radius; public Circle (int r) { radius=r; } public void calculatearea2() { area=3.14*r*r; } }class Sample { static void Main() { Square s=new Square(5); s.calculatearea1(); s. display (“square”,s.area); Circle c=new Circle(5); c.calculatearea2(); c. display(“circle”,c.area); } }

The area of square is 100The area of circle is 78.5

OUTPUT:

Using KeywordsUsing Keywords

class Animal{ public Animal() { Console.WriteLine("Animal

constructor"); } public void Greet() { Console.WriteLine("Animal says

Hello"); } public void Talk() { Console.WriteLine("Animal talk"); } public virtual void Sing() { Console.WriteLine("Animal song"); }}

class Dog : Animal{ public Dog() { Console.WriteLine("Dog constructor"); } public new void Talk() //Hiding Methods using

new keyword { Console.WriteLine("Dog talk"); } public override void Sing() { Console.WriteLine("Dog song"); }} Class Mainclass{ static void Main() { Dog d1 = new Dog(); d1.Talk(); d1.Sing(); d1.Greet(); }}

Animal constructorDog constructor

Dog talkDog song

Animal says Hello

OUTPUT:

• Introduction• Abstract Method• Non-Abstract Method• Partial-Implementation• Using Interface

Contents:Contents:

Abstract ClassAbstract Class

• An abstract class is a type of class that allows inheritance but can never be instantiated.

• An abstract class contains abstract and non-abstract methods. They contain one or more abstract method that do not have implementation. ‘Abstract method’ do not have method body, they are implicitly virtual. ‘Non-Abstract method’ contain method body.

• They provide only ‘Partial Implementation’. This is done by declaring the derived class as abstract class, we can avoid implementing of all or certain abstract methods.

• An abstract class can also implement from ‘interface’. In this method body should be provided while implementing from interface.

Abstract MethodAbstract Method

class Baseclass { public abstract void basemethod() { Console.WriteLine(“This is Base

method”); } }abstract class Abclass:Baseclass { public void absmethod(); }class Subclass:Absclass { public override void absmethod() { Console.WriteLine(“This is Abs

method”); }}

class Mainclass { static void Main() { Subclass s=new Subclass(); s.basemethod(); s.absmethod(); } }

OUTPUT:

This is Base methodThis is Abs method.

Non-Abstract MethodNon-Abstract Method

abstract class nonabs{ public void nonabsmethod() { Console.WriteLine(“This is non

abstract method”); } } class Subclass:nonabs { }class Mainclass { static void Main() { Subclass s=new Subclass(); s.nonabsmethod(); } }

OUTPUT:

This is non abstract method

Using InterfaceUsing Interface

interface Interclass { void intermethod() }abstract class Abclass:Interclass { public void intermethod() { Console.WriteLine(“This is Inter

method”); } public abstract void absmethod(); }class subclass:Absmethod { public abstract void absmethod() { Console.WriteLine(“This is Abs

method”); } }

class Mainclass { static void Main() { Subclass s=new Subclass(); s.absmethod(); s.intermethod(); } } OUTPUT:

This is Inter method.This is Abs method.

Partial ImplementationPartial Implementation

abstract class Baseclass { public abstract void absmethod1(); public abstract void absmethod2(); }abstract class Subabs:Baseclass { public override void absmethod1() { Console.WriteLine(“This is Base

absmethod 1”); } }class Subclass:Subabs { public override void absmethod2() { Console.WriteLine(“This is Subabs

abmethod 2”); } }

class Mainclass { static void Main() { Subclass s=new Subclass() s.absmethod2(); s.absmethod1(); } }OUTPUT:

This is Sub absmethod 2.This is Base absmethod 1.

• Introduction• Single-Cast Delegate• Multi-Cast Delegate

Contents:

DELEGATESDELEGATES

• Delegate is type which  holds the method(s) reference in an object. It is also referred as a type safe function pointers.

• Declaration: public delegate type_of_delegate delegate_name()• Example : public delegate int mydelegate(int delvar1,int

delvar2)• if you are referring the method with two int parameters and

int return type the delegate which you are declaring should be the same format. This is how it is referred as type safe function pointer .

• If the delegate contains a return type of void, then it is automatically aliased to the type of System.MulticastDelegate.

• If the delegate contains a non-void return type then it is aliased to System.Delegate class and it cannot support multiple methods.

• In C#, delegates act as an intermediary between an event source and an event destination.

Eg: A group of people representing a company.

• What if you want to call three methods when a button is clicked?.At this point of time we use multi-cast Delegate .

Single CastSingle Cast

public delegate double TestDelegate(int a,int b);class Class1{

    static double Method1(int val1,int val2)

{  return val1*val2; }

static void Main(){   //Creating the Delegate Instance TestDelegate delObj = new TestDelegate(Method1);

Console.Write("Please Enter Values");  int v1 = Int32.Parse(Console.ReadLine());  int v2 = Int32.Parse(Console.ReadLine());

   //use a delegate for processing   double res = delObj(v1,v2);Console.WriteLine ("Result :"+res) } }

Please Enter Values36

Result:18

OUTPUT:

Multi-CastMulti-Cast

delegate void Multicast(); class Simplemulticast { static public void Method1() { Console.WriteLine("Your in

Method1"); } static public void Method2() { Console.WriteLine("Your in

Method2"); } static void Main() { Multicast m = new

Multicast(Method1); Multicast m1 = new

Multicast(Method2); m(); m1(); Multicast m2 = m + m1; m2(); } }

OUTPUT:

Your in Method1Your in Method2Your in Method 1Your in Method2

EventsEvents

• Events are the actions of the system on user manipulations(e.g. mouse clicks, key press, timer etc.) or any event triggered by the program.

• A large goal of design delegates is their applicability in events model of .Net.

• communication between event source and event receiver is called “delegate”.

event source=objects that raise events. event receiver=object that responds to events.

• Ex: Speaking with a friend on phone. event source=you; event receiver=your friend;

telephone=delegate;

• // Delegate Declaration(<access><delegate><return type><delegate name>)public  delegate void newdelegate();

// Event Declaration (<access><event><delegate name><event name>) public event newdelegate newevent;

• Event method consists of procedure name followed by two arguments.

• The first argument is object firing and second is of System.EventArgs receiver.

• The += is used to hook up the event as a delegate i.e a method stand for another method.

class Myclass { public delegate void MyDelegate(string

message); public event MyDelegate Myevent; public void RaiseEvent(string message) { if (Myevent != null) Myevent(message); } } class Event1 { static void Main() { Myclass c1 = new Myclass(); c1.Myevent += new

Myclass.MyDelegate(c1_Myevent); Console.WriteLine("Please enter

your msg here"); string msg = Console.ReadLine(); c1.RaiseEvent(msg); } static void c1_Myevent(string message) { Console.WriteLine("your message is

{0}", message); } }

OUTPUT:

Please enter your msg here

Welcome to LST

Your message is Welcome to LST

• Introduction• Simple Interface• Explicit Interface• Multiple Interface• Inheriting from a class

Contents:

InterfaceInterface

• C# does not support multiple inheritance. So, c# provides an alternative approach known as interface.

• An interface is a reference type object with no implementation.

• So the interface doesn't actually do anything but only has a signature for interaction with other classes or interfaces.

• It contains only definition, does not contain methods or properties code inside an interface.

Syntax: private Class derivedClass:baseClass , InterfaceX , InterfaceY

(deriving from interface){}

Simple InterfaceSimple Interface

interface In1 //Interface1 { void show(); } interface In2 //Interface2 { void Display(); } class Interface1:In1,In2 //Simple inheritance { public void show() { Console.WriteLine("This is In1 Show

method"); } public void Display() { Console.WriteLine("This is In2 Display

method"); } static void Main() { Interface1 i = new Interface1(); i.Display(); i.show(); } }

This is In1 Show method.This is In2 Display method.This is In1 Show method.

This is In2 Display method.

OUTPUT:

Explicit InterfaceExplicit Interface

interface Int1 //Explicit interface Implementation { //Implementation of 2 methods of same

name void show(); } interface Int2 { void show(); } class Interface2:Int1,Int2 { void Int1.show() { Console.WriteLine("This is Show from Int1"); } void Int2.show() { Console.WriteLine("This is Show from Int2"); } static void Main() { Interface2 l = new Interface2();

Int1 i1 = (Int1)l; //casting i1.show(); Int2 i2 = (Int2)l; i2.show(); //casting } }

This is Show from Int1.This is Show from Int2

OUTPUT:

Multiple InterfaceMultiple Interface

interface Addition { int add(); } interface Multiplication { int mul(); } class Compare : Addition, Multiplication { int x, y; public Compare(int x, int y) { this.x = x; //Current value of X this.y = y; //Current value of y } public int add() { return x + y; } public int mul() { return x * y; } }

class Mulinterface { static void Main() { Compare c = new Compare(5, 5);

Addition a = (Addition)c; //casting

Console.WriteLine(a.add()); //create an instance of implementing class

//and then cast the object to the interface

Multiplication m = (Multiplication)c; //casting

Console.WriteLine(m.mul()); } }OUTPUT: 10

25

Inheriting a classInheriting a class

interface Display { void print(); } class B : Display { public void print() { Console.WriteLine("Base Display"); } } class C : B { public new void print() { Console.WriteLine("Derived Display"); } } class Inheritclass { static void Main() { C c1 = new C(); c1.print();

Display dis = (Display)c1; dis.print();} }

OUTPUT:

Derived DisplayBase Display

Derived DisplayBase Display

• Introduction• Simple Structs• Using Method• Using Interface• Using Constructors

Contents:

StructureStructure

• A C# structure is a value type • The keyword “struct” can be used to declare a structure.• Structure Declaration • Syntax: <modifiers> struct <struct_name>

{//Structure members}

• Remember that unlike classes, the strcut object can also be created without using the “new” operator. 

 Like: MyStruct ms;

• By default its private and therefore cannot be accessed outside the struct definition.

• But static methods can access only other static members and they can't invoke by using an object of the structure. They can invoke only by using the struct name.

• Struct is not permitted to declare Structs, does not support default constructors.

• Since structs doesn't support inheritance, we can't use the keywords virtual, override, new, abstract etc with a struct methods. C# struct types are never abstract and are always implicitly sealed. The abstract or sealed modifiers are not permitted in a struct declaration

Simple & With MethodSimple & With Method

• using System;struct MyStruct{public int x;public int y;}class MyClient{public static void Main(){MyStruct ms = new MyStruct();ms.x = 10;ms.y = 20;int sum = ms.x + ms.y;Console.WriteLine("The sum is {0}",sum);}}

OUTPUT

• using System;struct MyStruct{static int x = 25;static int y = 50;public void SetXY(int i, int j){x = i;y = j;} public static void ShowSum(){int sum = x + y;Console.WriteLine("The sum is {0}",sum);}}class MyClient{public static void Main(){MyStruct ms = new MyStruct();ms.SetXY(100,200);MyStruct.ShowSum();}}OUTPUTThe sum is 30.

The sum is 300.

Interface & ConstructorInterface & Constructor

• using System;interface IInterface{void Method();}struct Complex : IInterface{public void Method(){Console.WriteLine("Struct Method");} } class MyClient{public static void Main(){Complex c1 = new Complex();c1.Method();}}

• using System;struct MyStruct{int x ;int y ;public MyStruct(int i, int j):this(i+j){ }public MyStruct(int i){ x = y = i; }public void ShowXY(){ Console.WriteLine("The field values are {0} & {1}",x,y); }}class MyClient{ static void Main(){MyStruct ms1 = new MyStruct(10,20);ms1.ShowXY();}} Output:

Struct Method

The field valuesAre 30&30.

Output:

• Introduction• ArrayList• HashTable• Stack• Queue

Contents:

CollectionsCollections

• A collection in C# is a group of related objects held in a structure

• The .NET Foundation Class Library contains a namespace called System.Collections that provides classes to manage data structures like arrays, lists and maps.

• The ArrayList class is similar to the Array class except that its size can grow dynamically.

• The Queue and Stack classes provide the ‘First In First Out’ and ‘Last In First Out’ types of collections respectively.

ArrayListArrayList

• Array is used to store only objects of same type, where as in arraylist we can store different types of objects which is stored as object type only.

• It uses its index to refer to an object in its collection.

• The Capacity property gets or sets the number of items that the ArrayList object can contain.

• You can Add an item by using Add() and remove an item using Remove() method.

using System;using System.Collections;class Collections1 { static void Main() { int i = 10; string g = "abc"; ArrayList a =new ArrayList(); a.Add("alexy"); a.Add(i); a.Add(g); for (int x = 0; x < a.Count; x+

+) Console.WriteLine(a[x]); } }

Alexy10abc

Alexy10abc

HashTableHashTable

• The Hashtable provides a faster way of storage and retrieval of items of the object type.

• The Hashtable class provides support for key based searching.

• These keys are unique hash codes that are unique to a specific type.

• To remove an item from the Hashtable class, the Remove() method is used.

• The statement hashTable.Remove(3) would remove the item “Jini” from the Hashtable object created in the code.

using System;using System.Collections;class Test{ static void Main() { Hashtable hashTable = new Hashtable(); hashTable.Add(1, "Joydip"); hashTable.Add(2, "Manashi"); hashTable.Add(3, "Jini"); hashTable.Add(4, "Piku"); Console.WriteLine("The keysare:--"); foreach (int k in hashTable.Keys) { Console.WriteLine(k); } Console.WriteLine("Please enter the keyto search"); int p = int.Parse(Console.ReadLine()); Console.WriteLine(hashTable[p].ToString()); }}

The keysare:--4321

Please enter the keyto search2

Manashi

Output:

QueueQueue

• The Queue is a data structure that provides a First-in-First-out collection of items of the System.Object type.

• The newly added items are stored at the end or the rear of the Queue and items are deleted from the front of the Queue.

• The Enqueue() method is responsible for storing items at the rear of the Queue and

• the method Dequeue() removes them one at a time from the front.

using System;using System.Collections;class Test{ static void Main() { Queue queueObject = new

Queue();

queueObject.Enqueue("Joydip");

queueObject.Enqueue("Steve"); queueObject.Enqueue("Jini"); while (queueObject.Count > 0)

Console.WriteLine(queueObject.Dequeue());

}} Joydip

SteveJini

StackStack

• The Stack class is one that provides a Last-in-First-out (LIFO) collection of items of the System.Object type.

• The last added item is always at the top of the Stack and is also the first one to be removed.

• The Push() method is responsible for storing items in the Stack

• The method Pop() removes them one at a time from the top of the Stack.

using System;using System.Collections;class Test{ static void Main() { Stack stackObject = new

Stack(); stackObject.Push("Joydip"); stackObject.Push("Steve"); stackObject.Push("Jini"); while (stackObject.Count > 0)

Console.WriteLine(stackObject.Pop());

}}

JiniSteveJoydip

• Introduction• Single-Dimensional Array• Multi-Dimensional Array• Jagged Array• Array Class Properties

Contents:

ArraysArrays

• Its Group of related data items that share a common name.

• In C#, arrays can be declared as fixed length or dynamic. Fixed length array can stores a predefined number of items, while size of dynamic arrays increases as you add new items to the array. You can declare an array of fixed length or dynamic.

• int [] intArray; Eg: Dynamic Array

int [] intArray; Eg: fixed Array creates memory location for 5 intarray,intArray = new int[5]; beginning from 0,1,2,3,4

• System.Array class is the name space, used as an abstract base type.

• The variables in an array is called elements

• The value of each individual element in an array is accessed through its index value.

• Arrays in C# are zero-based; i.e. the first element in an array will always have an index of zero.

Arrays can be divided into four categories. These categories are

1. single-dimensional arrays,

2. multidimensional arrays or rectangular arrays,

3. jagged arrays, and

4. mixed arrays

Single Dimension ArraySingle Dimension Array

• This is the simplest of all Arrays.Arrays are objects That means declaring an array doesn’t create an array.After declaring an array, you need to instantiate an array by using “new” operator.

• Example: int[]name; //Declares an array in int name=new int[3]; //declares an array to store 3 //elements from index 0 to 2. name=new int[3]{29,6,99}; //declares and initializes

array of 3 items

• This same thing can be done with other data types.

Single ArraySingle Array

class simplearray { static void Main() { int[] intarray = new int[4]; intarray[0] = 1; intarray[1] = 2; intarray[2] = 3; intarray[3] = 4; foreach (int i in intarray) {

Console.WriteLine(i.ToString());

} } }

OUTPUT:

1234

Multi dimensionalMulti dimensional

• These are array with more than one dimensional.It is declared as follows

string[ , ] name; //2D Array string[ , , ]name; //3D Array

• After declaring we can initialize the array. int[,] num=new int[3,2]{{5,6},{2,7},{0,1}};

Here it can store 6 items of int and an examp le of fixed array string[,] name=new string[,]{ {“alexy”,dede”},{“roja”,raja”}}; here it stores 4 items of sting and an example of dynamic

array.

Multi ArrayMulti Array

class multiarray { static void Main() { string[,] namearray = new

string[,] { {"Rosy","Amy"}, {"Peter","Albert"},

{"Raja","Alexy"} }; for (int i = 0; i < 3; i++) for (int j = 0; j < 2; j++)

Console.WriteLine("Element[{0},{1}]={2}", i, j, namearray[i, j]);

Console.Read(); } }

• OUTPUT:

Element[0,0]=RosyElement[0,1]=AmyElement[1,0]=PeterElement[1,1]=AlbertElement[2,0]=RajaElement[2,1]=Alexy

Two Dimensional ArrayTwo Dimensional Array

class Twodimentional { public static void Main() { int[,] x; x = new int[4, 4]; x[0, 0] = 1; x[1, 1] = 1; x[2, 2] = 1; x[3, 3] =1;Console.WriteLine(x[0, 0] + " " + x[0, 1] + " " + x[0, 2] + " " + x[0, 3]);Console.WriteLine(x[1, 0] + " " + x[1, 1] + " " + x[1, 2] + " " + x[1, 3]);Console.WriteLine(x[2, 0] + " " + x[2, 1] + " " + x[2, 2] + " " + x[2, 3]);Console.WriteLine(x[3, 0] + " " + x[3, 1] + " " + x[3, 2] + " " + x[3, 3]);

} }

1 0 0 00 1 0 00 0 1 00 0 0 1

OUTPUT:

Jagged ArraysJagged Arrays

• Jagged Array is simply called “array of arrays.

• In this elements of array are arrays.

• The elements of jagged array can be of different dimensions and sizes.

Example:

int[][] jarray=new int [3][];

• The example declares an single-dimensional array that has three elements, each of which is a single-dimensional array of integers:

• int[][] jarray=new int [3][];

• These elements must be initialized before using in the program.

jarray[0]=new int[]{1,2,3,4,5};

jarray[1]=new int[]{22,66};

jarray[3]=new int[]{9,5,33,66,1,10,38,44};

• We can access individual array elements like in the following way:

int[][] jarray1= { new int[]{ 1,2,3,4,5}, new int[]{5,6,7,8}, new int[]{22,99} }; jarray1[0][1]=77; //assigning 77 to second element [1] of first array [0]; jarray1[2][1]=66; //assigning 66 to second element [1] of third array[2];• The following is a jagged array three elements of two-

dimensional int[][,] jaggedArray4 = new int[3][,] { new int[,] { {1,3}, {5,7} }, new int[,] { {0,2}, {4,6}, {8,10} }, new int[,] { {11,22}, {99,88}, {0,9} } };

Jagged ArrayJagged Array

class Jagged { int[][] x = new int[2][]; void set() { x[0] = new int[2]; x[1] = new int[2];

x[0][0] = 1; //first array,first element

x[0][1] = 2; //first array,second element

} void show() { for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { Console.WriteLine(x[i][j]); } } }

public static void Main() { Jagged j = new Jagged(); j.set(); j.show(); } }

• OUTPUT:

1200

• IsFixedSize : Return a value indicating if an Array has a fixed size or not.• IsReadOnly : Returns a value indicating if an Array is read- only or not.• Length : Returns the total number of items in all hedimensions of an Array .• Rank : Returns the number of dimensions of an Array.• BinarySearch : This method searches a one-dimensional sorted Array for a value, using a binary search algorithm.• Clear : This method removes all items of an Array and sets a range of items in the array to 0.• Clone : This method creates a shallow copy of the Array.• Copy : This method copies a section of one Array to another Array and performs type casting and boxing as required.• CopyTo : This method copies all the elements of the current one- dimensional Array to the specified one-dimensional Array starting at the specified destination • CreateInstance : This method initializes a new instance of the Array class.• GetEnumerator : This method returns an IEnumerator for the Array.• GetLength : This method returns the number of items in an Array.

ARRAY CLASS PROPERTIES.ARRAY CLASS PROPERTIES.

ARRAY CLASS PROPERTIES.ARRAY CLASS PROPERTIES.

• GetLowerBound : This method returns the lower bound of an Array.• GetUpperBound : This method returns the upper bound of an Array.• GetValue : This method returns the value of the specified item in an Array. • IndexOf : This method returns the index of the first occurrence of a value in a one-dimensional Array or in a portion of it.• Initialize : This method initializes every item of the value-type Array by calling the default constructor of the value type.• LastIndexOf : This method returns the index of the last occurrence of a value in a one-dimensional Array or in a portion of it.• Reverse : This method reverses the order of items in a one- dimensional Array or in a portion of the Array.• SetValue : This method sets the specified items in the current Array

to the specified value.• Sort : This method sorts the items in one-dimensional Array objects.

Using array propertiesUsing array properties

using System;Class Program{ static void Main() {

int[]num={99,24,56,3,15}; Array.Sort(num); foreach(int I in num) Console.WriteLine(I);

Console.WriteLine(“Length=“+num.length);

} }

• Output

315245699

Length=5

EnumeratorEnumeratorEnumeratorEnumerator

• a distinct type consisting of a set of named constants called the enumerator.

Syntax: <modifier> enum <enum_name> Eg: enum Months

{ { // Enumeration list jan,feb,mar,apr } }

• By default the first enumerator has the value of zero and the value of each successive enumerator is increased by 1.

The following are the restrictions apply to an enum type in C# • They can't define their own methods. • They can't implement interfaces. • They can't define properties or indexers. • the use of enum makes the code more readable and self-

documenting.

Simple EnumSimple Enum

• using System;enum Months : long{jan = 10,feb = 20,mar}class MyClient{public static void Main(){long x = (long)Months.jan;long y = (long)Months.feb;long z = (long)Months.mar;

Console.WriteLine("JANUARY={0},FEbriary = {1},March={2}",x,y,z);}} 

OUTPUT:

JANUARY=10,FEBUARY=20,

MARCH=21

• Introduction• Try and Catch Block• Multiple Catch Block• Finally Block• User Exception

Contents:

Exception HandlingException Handling• To detect and handle run time errors.• These exception can be due to user, logic or system errors.

• Three keywords are mainly used in this i.e. try, catch and finally.

• The try encloses the statements that might throw an exception whereas catch handles an exceptions if one exits. The finally can be used for doing any clean up process.

• Syntax: try catch( type e) finally { { { } } }

• In try if there is no exception, it transfers to finally block. The Finally block is always executed.

• There is no usage of break, continue, return, goto.

• C# provides standard exception or user can create exception provided that it should inherit from System.Exception class.

• Run-time error: after successful compilation program may produce wrong results.

• Compile time error: syntax errors will be detected and displayed by compiler.

Normal coding:

class Notry { static void Main() { int e = 0; int div = 100 / e;

Console.WriteLine(div);

} }

Output:

• This code Will raise an Exception that DivideByZeroException is Unhandled.

• Now the code next to it contains TRY and CATCH block.

• Here in this controls passes from TRY block to CATCH block. Then it will execute this CATCH block and continues with the program.

Using try and catchUsing try and catch

class Singletry { public static void Main() { int i = 0; int div=0; try { div = 100 / i; Console.WriteLine("This

line is Exception"); } catch (DivideByZeroException

e) {

Console.WriteLine("Exception Occured");

} Console.WriteLine("Result is

{0}", div); } }

• Output:

This line is ExceptionException Occurred

Result is 0

Multiple Catch BlockMultiple Catch Block

class Multicatch { static void Main() { int[] a ={ 5, 10 }; int b = 5; try { int x = a[2] / b - a[1]; } catch (IndexOutOfRangeException e) { Console.WriteLine(e); } catch (ArgumentNullException o) { Console.WriteLine(o); } catch (ArrayTypeMismatchException n) { Console.WriteLine(n); } catch (DllNotFoundException k) { Console.WriteLine(k); } int y = a[1] / a[0]; Console.WriteLine(“y=“y); } }

OUTPUT:

System.IndexOutOfRangeException: Index was outside the bounds of the array. at ConsoleApplication1.ErrorHandling.Multicatch.Main() in C:\Documents and Settings\Administrator\Desktop\Alexy\Projects\ConsoleApplication1\ConsoleApplication1\ErrorHandling\Multicatch.cs:line 15Y=2

Array element 2 does not exist, hence index 2 is out of range, so the try block raises an exception and catching the right exception, leaving the rest alone.

Finally BlockFinally Blockclass Finallyblock { static void Main() { int i = 0; int div = 0; try { div = 100 / i; Console.WriteLine("This line is

Exception"); } catch (Exception e) { Console.WriteLine("INVALID"); } finally { Console.WriteLine("finally"); Console.WriteLine("Result is {0}",

div); } } }

OUTPUT:

THIS IS INVALID DIVISIONfinally blockResult is 0

First the try block will raise an exception, to the catch block. But note that the program is not terminated an it continues. How ever the finally block will be executed.

User ExceptionUser Exception

class Myexception : Exception { public Myexception(string

Messsage):base(Messsage) { Console.WriteLine("user defined

exception"); } } class OwnException { public static void Main() { try { throw new Myexception(“Raja"); } catch (Myexception e) { Console.WriteLine(e.Message); } Console.WriteLine("Last

Statement"); } }

OUTPUT:

user defined exceptionAlexy

Last Statement

Sealed ClassSealed Class

• Sealed Classes is used to restrict the feature of inheritance.

• A class is declared as sealed simply by using the keyword “sealed”.

• In C# structs are implicitly sealed.

Syntax:

• Sealed class SealedClass { .... }

ExampleExample

class Class1{static void Main(string[] args){SealClass Cls = new SealClass();int total = Cls.Add(4, 5);Console.WriteLine("Total = " +

total.ToString());}} sealed class SealClass{public int Add(int x, int y){return x + y;}}

• OUTPUT:

Total=9

Sealing MethodsSealing Methods

• In C# a method can not be declared as sealed.

• However when we override a method in a derived class, we can declare the overridden method as “sealed”.

• By declaring it as sealed, we can avoid further overriding of this method.

• “Sealed” keyword serves the purpose of sealed. If a class is derived from a sealed class,compiler throws an error.

• We can mark a class or method as sealed for commercial reasons, in order to prevent a third party from extending our classes.

• Introduction• Namespace and Instance• Writing in a file• Reading from a file

Contents:

FilesFiles

• With any programming language there is always a need to read and write to files.

• The class FileStream, which is actually derived from the Stream class, adds to Stream the functionality needed to read and write to files.

• Like other languages, C# utilizes a Stream class, which gives basic functionality when working with streams (any situation where you need to read and write data to some endpoint). The class FileStream, which is actually derived from the Stream class, adds to Stream the functionaly needed

to read and write to files.

Namespace and InstanceNamespace and Instance

• System.IO provides all the necessary classes, methods, and properties for manipulating directories and files.

• create an instance of FileStream:

FileStream file = new FileStream(“C://path.txt", FileMode.option, FileAccess.option);

FileMode specifies what the FileStream should do with the file to begin with. The options are: Append, Create, CreateNew, Open, OpenOrCreate, or Truncate, and can be accessed by FileMode.option.

FileAccess specifies the file priveledges. The options are: Read, ReadWrite, or Write, and can be accesed by FileAccess.option.

After reading or writing close the file

file.Close();

Writing to a fileWriting to a file

• To write to a file we will need to use class StreamWriter, which is derived from the TextWriter class.

StreamWriter sw = new StreamWriter(file);

• With StreamWriter, you have two options for writing to a file: Write, or WriteLine.

sw.Write("Hello file system world!");

• Now don't forget to close the stream when you are done!

sw.Close();

using System;using System.IO;class Fileclass{ static void Main() { FileStream file=new

FileStream (“C://Myfile.txt”,FileMode.Create, FileAccess.Write);

StreameWriter sw=new StreamWriter(file);

sw.WriteLine(“Hello”); sw.WriteLine(“Welcome”); sw.WriteLine(“Bye”); sw.Close(); Console.Writeline(“Success”); file.Close(); } }

• Output:

SucessSucess

HelloWelcome

Bye

HelloWelcome

Bye

In c drive a note pad will be created with the name “Myfile”.It will contain the following.

Reading from a fileReading from a file

• To read from a file we will need to use class StreamReader. derived from the TextReader class.

StreamReader sr = new StreamReader(file);

• With StreamReader, there are four options for reading from a file: Read, ReadBlock, ReadLine, or ReadToEnd.

string s = sr.ReadToEnd();

ReadToEnd, which just like the title implies, reads the entire file.

ReadLine, reads each and every line including spaces.

sr.Close();

Using System;Using System.IO;Class Fileclass{ static void Main() { FileStream file=new FileStream

(“C://Myfile.txt”,FileMode.Open, FileAccess.Read);

StreamReader sr=new StreamReader(file);

string s=sr.ReadToEnd(); While(s!=null) { Console.ReadLine(s); s=sr.Readline(); } sr.close(); file.Close(); } }

• Output:

HelloWelcome

Bye

HelloWelcome

Bye

• Introduction• Generic Terminology and Syntax• Generic Type• Generic Method• Constraints• Types of Constraints• Generic Class

Contents:

GenericsGenerics

• Generics are a new feature in version 2.0 of the C# language and the common language runtime (CLR).

• Generics are used to help make the code in the software components much more reusable.

• By the generic types in the System.Collections.Generic namespace-unless your type collection needs custom functionality, you won't even have to define a single collection type in your class library!

• Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code.

• We can refer to a class, where we don't force it to be related to any specific Type, but we can still perform work with it in a Type-Safe manner

• For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:(Cont)

public class GenericList<T> // Declare the generic class { //T=Type Parameter void Add(T input) { }}class TestGenericList{ private class ExampleClass { } static void Main() { // Declare a list of type int GenericList<int> list1 = new GenericList<int>();

// Declare a list of type string GenericList<string> list2 = new GenericList<string>();

// Declare a list of type ExampleClass GenericList<ExampleClass> list3 = new

GenericList<ExampleClass>(); }}

Generic Terminology and SyntaxGeneric Terminology and Syntax

• Type Parameter : A type parameter is the core of enabling generic functionality. It

is just like any other parameter in the sense that you pass an argument to it when you use the type or method.

• Generic Type and Generic Method: "generic type" and "generic method." A generic type is a type

(class, struct, delegate, or event) that defines one or more type parameters, as in the MySample class in Example. A generic method is any method that defines one or more type parameters, as in the DoSomething method in Example. It is important to note that generic methods do not have to be declared within generic types

• Example: public class MySample<T> //generic type  { public void DoSometing<K,V>() //generic method  {}  }

Normal CodeNormal Code

class Class1 { static void Main() { int[] intarrey ={ 1, 2, 3, 4, 5,

6 }; double[] doublearray ={ 1.2,

2.2, 3.3, 4.4, 5.5, 6.6, 7.7 }; char[] chararray ={ 'a', 'l', 'e',

'x', 'y' }; Console.WriteLine("This is Int

Array"); Printarray(intarrey); Console.WriteLine("This is

double array"); Printarray(doublearray);

Console.WriteLine("This is char array");

Printarray(chararray); }

static void Printarray(int[] input) { foreach (int element in input) Console.Write(element+ " " ); Console.WriteLine("\n"); } static void Printarray(double[] input) { foreach (double element in input) Console.Write(element + " "); Console.WriteLine("\n"); } static void Printarray(char[] input) { foreach (char element in input) Console.Write(element + " "); Console.WriteLine("\n"); } }

OUTPUTOUTPUT

This is Int Array:1 2 3 4 5 6

This is Double Array:1.2,2.2,3.3,4.4,5.5,6.6,7.7

This is char Array:a l e x y

This is lengthy process and also time consuming.

Generics Methods Generics Methods

class Class2 { static void Main() { int[] intarrey

={0,0,0,0,0,0,0 }; double[] doublearray ={ 1.2,

2.2, 3.3, 4.4, 5.5, 6.6, 7.7 }; char[] chararray ={ 'a', 'l', 'e',

'x', 'y' }; Console.WriteLine("This is Int

Array"); Printarray(intarrey); Console.WriteLine("This is

double array"); Printarray(doublearray); Console.WriteLine("This is

char array"); Printarray(chararray); }

static void Printarray<E>(E[] input) { foreach (E element in input) Console.Write(element + " "); Console.WriteLine("\n"); } }

OutputOutput

This is Int Array:1 2 3 4 5 6

This is Double Array:1.2,2.2,3.3,4.4,5.5,6.6,7.7

This is char Array:a l e x y

By using generics the code is used for int,double and string.The length is reduced.But we get the same output.

public class Col<T>

{ T t; public T Val{get{return t;}set{t=value;}}}

public class ColMain { public static void Main() {//create a string version of our generic

class Col<string> mystring = new

Col<string>(); mystring.Val = "hello"; //set the valueSystem.Console.WriteLine(mystring.Val);

System.Console.WriteLine(mystring.Val.GetType());

//create another instance of our generic class, using a different type

Col<int> myint = new Col<int>();//load the value

myint.Val = 5;//output the value

System.Console.WriteLine(myint.Val);//output the value's type System.Console.WriteLine(myint.Val.GetType());

}}

Generic TypeGeneric Type

Generic TypeGeneric Type

• The class name “col<T>” indicates that this is of generic type.<T> is called the Type parameter.

• Variable declaration “T t” member variable with type of T.

• The actual value of T will be specified during construction of class(it will actually gets inserted by the CLR automatically).

• The actual value of T can be specified while creating the object as shown in the example.

Constraints Constraints • Constraints are a feature of .NET generics that enable the

creator of a generic to specify that only certain types may be passed in as type arguments to his generic.

• Constraints solve a problem that involves the usage of type parameters within a generic type.

• Constraints are applied by using the contextual keyword where.

• More than one constraints can be added using where Keyword.

Types of Constraints Types of Constraints Where T: struct

The type argument must be a value type. Any value type except Nullable can be specified.

Where T : class The type argument must be a reference type; this applies also to any class,

interface, delegate, or array type. Where T : new()

The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.

Where T : <base class name> The type argument must be or derive from the specified base class.

Where T : <interface name> The type argument must be or implement the specified interface. Multiple

interface constraints can be specified. The constraining interface can also be generic.

Where T : U The type argument supplied for T must be or derive from the argument

supplied for U. This is called a naked type constraint.

class Factory<U> where U : new()

{ public static U GetNew() { return new U(); } } class Program { static void Main(){ int i = Factory<int>.GetNew(); object obj =

Factory<object>.GetNew(); Console.WriteLine(i);Console.WriteLine(obj);} }

OUTPUT:

0object

// Here, 'i' is equal to 0 and 'obj' references an instance of the class 'object'.

Generic Class Nongeneric Counterpart in System.Collections

Meaning in Life

Collection<T> CollectionBase The basis for a generic collection

Comparer<T> Comparer Compares two generic objects for equality

Dictionary<K, V> Hashtable A generic collection of name/value pairs

List<T> ArrayList A dynamically resizable list of items

Queue<T> Queue A generic implementation of a first-in, first-out (FIFO) list

Stack<T> Stack A generic implementation of a last-in, first-out (LIFO) list

SortedDictionary<K, V>

SortedList A generic implementation of a sorted set of name/value pairs

ReadOnlyCollection<T> ReadOnlyCollectionBase A generic implementation of a set of read-only items

ExampleExample

using System.Collections.Generic;public class MainClass {static void Main(){ List<int> myInts = new List<int>();  myInts.Add(1); myInts.Add(2); myInts.Add(3);  for (int i = 0; i<myInts.Count; i++) { Console.WriteLine("MyInts: {0}",

myInts[i]); }}

• using a generic List collection is similar to arrays.

• The Count property is a difference between collections and arrays in that an array uses a Length property for the same thing.

MyInts:1MyInts:2MyInts:3

The End