C# AND .

NET

UNIT I
INTRODUCTION to C#: Introducing C#, Understanding .NET, Overview of C#, Literals,
Variables, Data Types, Operators, Expressions, Branching, Looping, Methods, Arrays, Strings,
Structures, Enumerations.
UNIT II
OBJECT ORIENTED ASPECTS OF C#: Classes, Objects, Inheritance, Polymorphism, Interfaces,
Operator Overloading, Delegates, Errors and Exceptions.
UNIT III
WINDOWS APPLICATIONS: Drawbacks of Console Applications, Container Controls, Non
Container Controls, Developing Windows Application from Notepad and Visual Studio, Events,
Types of Events – Mouse, Focus, Drag, Key and Other Related Events, Building Windows
Applications.
ADO.NET: Problems with File Handling, Data Source Communication, Drivers and Providers,
Introduction of ADO.NET, ADO.NET Namespaces, ADO.NET Objects, Accessing Data with
ADO.NET.
UNIT IV
BUILDING ASP.NET WEB PAGES: HTML form Development, Client side Scripting, Server side
Scripting, Web applications and Web servers, HTTP, Advantages Using ASP.NET, ASP.NET
Application, ASP.NET Namespaces, ASP.NET Web Page Structure, Creating Sample C# Web
Applications, ASP.NET Web Page Execution Architecture, Debugging and Tracing of ASP.NET.
UNIT V
ASP.NET WEB CONTROLS: Web Form Structures, Introduction to Web Form controls, Server
Side Controls, Web Server Controls, GET and POST, Page Submission, Web Page Creation
Techniques, Redirection between Web Pages, Validation Controls.
UNIT VI
WEB SERVICES: Web Services, Web Service Architecture, WSDL, Building WSDL Web Service.
CONFIGURING .NET ASSEMBLIES: Private Assemblies, Shared Assemblies, and Versioning.
MULTITHREADED PROGRAMMING: Thread Class, Life Cycle of a Thread, Steps for Creating
a Thread, Thread Synchronization.

1 School of Computer Science & Engineering | RGMCET

 C# AND .NET

UNIT I
.NET:
 .NET stands for Network Enable Technology which is developed by Microsoft Corporation.
 .NET is free, cross-platform,open source.
 .NET is a collection of languages like VC#.NET, VC++.NET, VB.NET and so on.
 .NET is a Framework which provides a common platform to Execute or Run the applications
developed in various programming languages.
.NET Objectives: The .NET Framework is designed to fulfil the following objectives
 Platform independent: As .exe and .dll files work in any operating system with the help of
CLR, hence .Net is called as platform independent.
 (.exe) is executable file, it consists of executable code, and (.dll) is dynamic link library file it
consist of reusable code. .exe and .dll files contains the code in the format of byte code is also
called as MSIL (Microsoft intermediate language) code.
 Machine language is also called as native code. CLR is common language runtime; CLR
software converts byte code into native code. Dot Net is platform independent but CLR
software is platform dependent.
One question arises if we go in detail, that is either Dot Net is pure platform independent or
not? Answer is Dot Net is partially platform dependent, as of now CLR software's are not
available for DOS operating system and Windows 95. 

 Language independent: As Dot Net programming logic can be developed in any Dot Net
framework compatible languages; hence Dot Net is called as language independent.

2 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Microsoft is introducing approximately 40 languages into Dot Net framework, out of which
as of now approximately 24 languages and one specification are released. 
Ex: VC#.Net,VB.Net,VC+
+,VJ#,VF#,PHP,COBOL,PERL,PHYTHON,SMALLTALK,JSCRIPT...etc One specification
is ASP.Net.
 Language interoperability: It is a concept of developing an application with the help of
more than one .NET programming language. After an application is compiled, the source
code will be converted into byte code. Byte code follows a standard instruction set provided
by cls(common language specification).Cls provides common rules and syntaxes for all the
languages and cls also provides common data types for all the languages and these common
data types are called as CTS(common type system).
C++ C# VB .NET
int(2) short(2) short(2)
long(4) int(4) integer(2)
long(8) long(8)
SYSTEM.INT16
SYSTEM.INT32
SYSTEM.INT64
 It supports object-oriented programming environment.
 It supports to work with database programming with the help of ADO.NET.
 It supports to work with WPF (windows presentation foundation) for developing animations.
 It Provides environment for developing various types of applications, such as Windows-
based applications and Web-based applications
 It Supports to develop 3-tier architecture with the help of Dot Net remoting
 Supports to develop game programming with the help of multi-threading
 Supports to work with link programming
Dot Net remoting: It provide interface communication between application domine by using
Remoting Frame Mask.
Managed Code: The code is developed and running under the control of the CLR is often
termed managed code.
Unmanaged code: The code which takes OS help while execution is called as unmanaged code
Note: Managed code is faster in execution.
In simple words, a function ,class or anything written in one language can be easily used in another
language(c# to VB.NET).Therefore, impove the efficiency of the development process.
Interoperability:Any language code can use code written in any other language.
(or)
 The ability of code to interact with code that is written that is written using different
programming language.
 Language interoperability can help maximize code reverse
 Every code written in any .NET language and compiled could be reversed by another .NET

3 School of Computer Science & Engineering | RGMCET

 C# AND .NET

languages.

os Unmanaged code

CLR
.net .dll Output
.exe
Managed code

.NET Framework:
 The .Net framework is a revolutionary platform that helps you to write the following types of
applications:
Windows applications
Web applications
Web services
 The .NET framework applications are multi-platform applications.
 The .NET framework has been designed in such a way that it can be used by .NET
framework compatible languages ( C#, C++, Visual Basic, Jscript, COBOL, etc). All .NET
framework compatible languages can access the framework as well as communicate with
each other.
 The .NET frame work contain three major things that is
 Languages—VB,C#,PASCAL,COBOL
 Technology—ASP.NET,ADO.NET
 Servers—SQL SERVER,SHARE POINT SERVER
 In platform independent languages, the code gets executed under the control of special
software called framework.
Example: java-->JVM
.NET-->CLR
 Framework: A framework is a software which masks the functionalities of a OS and makes
the code to execute under its control .Frame work provides the following basic features like
 Platform independency
 Security
 Memory management
 Microsoft has started the development of .NET framework in late 90’s originally under the
name of NGWS (next generation windows services).
 To develop the framework first the Microsoft has prepared a set of specifications known as

4 School of Computer Science & Engineering | RGMCET

 C# AND .NET

CLI (Common Language Infrastructure).

 The .NET specifications are open to all (everyone can develop) which is standardized under
ISO (International Standards organization) AND ECMA(European computer manufacture
association).
 CLI specification talks about four important aspects that is
CLS (common language specification)
CTS (common Type system)
BCL (Base class libraries)
VES (Virtual execution system) or CLR (common language runtime)
 .NET framework versions
Versions Release Date
1.0 2002
1.1 2003
2.0 2005
3.0 2006
3.5 2007
4.0 2009
4.8 2019
 The .Net framework consists of an enormous library of codes used by the client languages
such as C#. Following are some of the components of the .Net framework:
 Common Language Runtime (CLR)
 The .Net Framework Class Library
 Common Language Specification
 Common Type System
 Metadata and Assemblies
 Windows Forms
 ASP.Net and ASP.Net AJAX
 ADO.Net
 Windows Workflow Foundation (WF)
 Windows Presentation Foundation
 Windows Communication Foundation (WCF)
 LINQ
.NET framework architectural diagram: The .NET framework is one of the tool provided by
the .NET infrastructure and tools component of the .NET platform. The .NET framework provides an
environment for building, deploying and running web services and .NET applications.

Modern UI Runtime Task Based Asychronous Model

5 School of Computer Science & Engineering | RGMCET

 C# AND .NET

PLINQ TPL

LINQ ADO.NET ENTITY FRAMEWORK

WPF WCF WF CARD SPACE

ADO.NET ASP.NET WIN FORMS

BASE CLASS LIBRARIES

COMMON LANGUAGE RUNTIME(CLR)

Common language runtime (CLR):
 CLR is the heart of the .NET framework. It is the execution engine of .NET framework,
where all .net applications are running under the supervision of CLR. The main function of
CLR is to convert the managed code into native code and then execute the program. CLR acts
as a layer between OS and the applications written in .NET languages. CLR provides various
features to applications like
 Security
 Platform independency
 Automatic memory management
 Runtime error handling
 Code verification
 Compilation
 Thread management
Code verification: functions are passed with the correct number and type of parameter.
Thread Management: Allows you to run multiple thread of execution.
 The components of CLR are
Class Loader: It is used to load all the classes at runtime for the execution of an application.
JIT Compiler: It is responsible for the conversion of MSIL (byte code) into machine code
(native code).
Code Manager: Is responsible for managing code at runtime.
Garbage Collector: The .NET garbage collector is responsible for automatic memory
management, where memory management is a process of allocation and de-allocation of
memory that is required for a program execution. Memory management is of two types
1. Manual/explicit memory management: In this the programmers are responsible
for allocation and deallocation of memory that is required for a program execution.

6 School of Computer Science & Engineering | RGMCET

 C# AND .NET

2. Automatic/implicit memory management: In this case the garbage collector will

take care of allocation and deallocation process of memory.
The garbage collector will allocates the memory for an object when and where they are
required and also deallocates the memory of those objects once they become unused under
the program. The unused object of a program is called garbage and deallocate immediately.
Security Engine (manager): It is responsible for taking care of the security of the
application that is security engine will not allow the application to interact directly with the
operating system (or) OS to interact with the application.
Type Checker: It enforces strictness in type checking that is type checker will verify the
types used in the application with CTS (or) CLS standards supported by the CLR.
Common type system: Common Type System (CTS) describes a set of types that can be
used in different .Net languages in common. That is, the Common Type System (CTS) ensure
that objects written in different .Net languages can interact with each other.
Microsoft Intermediate Language (MSIL): MSIL stands for Microsoft Intermediate
Language. We can call it as Intermediate Language (IL) or Common Intermediate Language
(CIL). During the compile time, the compiler convert the source code into Microsoft
Intermediate Language (MSIL) .Microsoft Intermediate Language (MSIL) is a CPU-
independent set of instructions that can be efficiently converted to the native code. During the
runtime the Common Language Runtime (CLR)'s Just In Time (JIT) compiler converts the
Microsoft Intermediate Language (MSIL) code into native code to the Operating System.

Thread Support: It allows multithreading support to our application.

Debug engine: It allows proper debugging of an application.
Base class library: It provides all the types that an application need at runtime.
Exception manager: Handles all the exception for an application during runtime.
COM Marshaller: It provides interoperability to our applications.
 Base class libraries:

7 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 A library is a set of reusable functionalities where each and every programming language has
built in library like header files in c/c++ ,packages in java similarly .NET languages have
built in libraries known as base class libraries .the speciality of these library is that they can
be consumed under any .NET language(BCL are the best example of language
interoperability because those library are developed in C# language and can be consumed in
any .NET framework compatible languages.
 The very popular namespace in base class library is system
 We can use the base class library in system namespace for many different tasks including.
 Input/output operations
 String handling
 Managing arrays, lists and maps
 Accessing files and file systems
 Security
 Windowing
 Windows messages
 Drawing
 Database management
 Managing errors and exceptions
 Win form technology is used to develop windows based applications.
 Asp.net is used to build rich internet based web applications
 Ado.net is used to create Data Access Layer to query and manipulate data from underlying data
source like SQL Server, Oracle etc.
 WPF (windows presentation foundation) is used to create applications with a rich user
experience. It includes application User Interface, 2D graphics, 3D graphics and multimedia. It
takes advantage of hardware acceleration of modern graphic cards. WPF makes the User
Interface faster, scalable and resolution independent.
 WCF (windows communication foundation) is used for building and developing services based
on Web Services standards.
 WF (WWF) stands windows workflow foundation, which is used to build process oriented
business workflow and rules engine. (validate business logic by multiple rules.)
 LINQ (language integrated query) allows you to query(communicate) for the data from the
various data sources (like SQL databases, XML documents, Ado.Net Datasets, Various Web
services and any other objects such as Collections, Generics etc.) using a SQL Query like syntax

8 School of Computer Science & Engineering | RGMCET

 C# AND .NET

with .Net framework languages like C# and VB.

 ADO.NET Entity Framework provides added features under the traditional ADO.NET. This is
used to query and store data into to the relational databases (like SQL Server, Oracle, DB2 etc.)
in ORM (Object-relational mapping) fashion.
 TPL (Task Parallel Library): The purpose of TPL is to make the developers more productive
by simplifying the process of adding parallelism and concurrency to applications.
 PLINQ (Parallel Language Integrated Query): It is used to maximize processor utilization
with increased throughput in a multicore architecture.
 Modern UI Runtime: Microsoft added some API’s for creating universal windows platform
applications for windows using .NET languages.
 Task Based Asynchronous Model: It is used describe the asynchronous operations and tasks
in .NET Framework.
The Origins of .NET Technology: The Origins of the .NET Technology are
 OLE Technology (Object Linking and Embedding): Object linking and embedding (OLE)
was developed by Microsoft in the early 1990’s to enable inter process communication.OLE
provides support to achieve the following.
 To embed documents from one application into another application.
 To enable one application to manipulate objects located in other application.
OLE Technology allows us to develop applications which required interoperability between
various modules such as MS-Word and MS-Excel
 COM Technology (Component Object Model): Till the advent of com technology, the
monolithic approach had been used for developing software. But when the programs became
too large and complex, the monolithic approach leads to a number of problems in terms of
maintainability and testing of software. To overcome these problems Microsoft introduced a
component based model for developing software. In this approach a program is divided into
number of independent components where each one offers a particular task. Each Component
can be developed and tested independently and then integrated into the main system. This
technology is called component object model (COM).
Benefits:
1. It reduces the complexity of software.
2. It enhances software maintainability
3. It enables distributed development among multiple departments (or) organizations.
 .NET Technology (Network Enable Technology):

9 School of Computer Science & Engineering | RGMCET

 C# AND .NET

1. It is a third-generation component model which provides a new level of interoperability

Compared to COM technology.
2. It Enables Application level communication by Microsoft intermediate language(MSIL or
CIL) mechanism. 
3. .NET Technology allows true cross-language integration with MSIL. 
4. .NET Technology contains MSIL and also includes other technologies and tools that
enable users to develop and implement applications easily.
.NET Languages: The .NET framework is a language neutral. So we can use the number of
languages for developing .NET applications. They include
Native to .NET(provided by the .NET):
 C#
 Visual basic.NET
 C++
 Jscript.NET,J#
Third-Party languages:
 COBOL
 Eiffel
 Perl
 Python
 Small Talk
 Mercury
 Scheme
 ML
 Haskell
 APL
All .NET languages are not created equal. Some can use the components of other languages, some
can use the classes produced in other languages to create objects, and some languages can extend the
classes of other languages using the inheritance features of .NET.
Benefits of the .NET Framework
 Simple and faster system development
 Enhanced built in functionality.
 It supports rich oop concepts
 Integration of different applications into one platform.
 Ease of deployment and execution
 Interoperability with existing applications.
 Wide range of scalability
 Simple and easy to build sophisticated(high degree of complexity) development tools.
 Fewer bugs

10 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 Potentially better performance.

Features of .NET:
 Language independency
 Base class library’s
 Portability
 COM interoperability
 CLR
 Memory management
 Simplified development
Integrated Development Environment (IDE) for C#: An IDE is a tool that helps you write your
programs Microsoft provides the following development tools for C# programming:
 Visual Studio 2010 (VS)
 Visual C# 2010 Express (VCE)
 Visual Web Developer
The last two are freely available from Microsoft official website. Using these tools, you can
write all kinds of C# programs from simple command-line applications to more complex
applications. You can also write C# source code files using a basic text editor like Notepad, and
compile the code into assemblies using the command-line compiler, which is again a part of the
.NET Framework.
Visual C# Express and Visual Web Developer Express edition are trimmed down versions
of Visual Studio and has the same appearance. They retain most features of Visual Studio.
INTRODUCING C# (PRONOUNCED "C SHARP"): C# is a simple, modern, general-purpose,
object-oriented and type-safe programming language developed by Microsoft, USA and approved by
European Computer Manufacturers Association (ECMA) and International Standards Organization
(ISO).
C# was developed by Anders Hejlsberg and his team during the development of .Net
Framework. C# is designed for Common Language Infrastructure (CLI), which consists of the
executable code and runtime environment that allows to use of various high-level languages on
different computer platforms and architectures.
C# can be used to create various types of applications, such as web, windows, console
applications or other types of applications using Visual studio.
HISTORY OF C# LANGUAGE: During the development of .NET, the class libraries were
originally written in a language called simple managed code (SMC) and later the language had been
renamed as C#.

11 School of Computer Science & Engineering | RGMCET

 C# AND .NET

The C# principal designer and lead architect Anders Hejlsberg has previously involved with
the design of visual j++, Borland Delphi, Turbo Pascal languages.
The following reasons make C# a widely used professional language:
 It is a modern, general-purpose programming language
 It is object oriented.
 It is component oriented.
 It is easy to learn.
 It is a structured language.
 It produces efficient programs.
 It can be compiled on a variety of computer platforms.
 It is a part of .Net Framework.
OVERVIEW OF C#: C# can be used to develop two categories of programs, that is
 Executable application programs: These programs are written to carry out certain tasks and
require the main method in one of the classes.
 Component libraries: These do not require a main declaration because they are not stand-
alone application programs. These are written for use by other applications.
CHARACTERISTICS OF C#:
SIMPLE:
1. C# is simple by eliminating some operators such as "::” or "->" and pointers.
2. C# treats integer and Boolean data types as entirely two different data types. Boolean values
are pure true or false values in C# so no more errors of "="operator and "=="operator."==" is
used for comparison operation and "=" is used for assignment operation.
MODERN: C# is a modern language because of the following features.
1. It provides Automatic garbage collection.
2. It provides Rich intrinsic model for error handling.
3. It provides Modern approach to debugging
4. It provides robust security model.
5. It provides Decimal data type for financial applications.
OBJECT ORIENTED:
1. C# truly object oriented. It supports Data Encapsulation, inheritance, polymorphism,
interfaces.
2. In C#, everything is an object .there are no more global functions, variables and constants.
TYPE SAFE:

12 School of Computer Science & Engineering | RGMCET

 C# AND .NET

1. In C# we cannot perform unsafe casts like convert double to a Boolean.

2. All dynamically allocated objects and arrays are initialized to zero.
3. Usage of any uninitialized variable produces an error message by the compiler.
4. Access to Arrays is range checked and warned if it goes out of boundary.
5. C# checks the Overflow in arithmetic operations.
6.  C# supports automatic garbage collection
INTEROPERABILITY: C# provides support for using COM objects, No matter what language
was used to develop them. C# also supports a special feature that enables a program to call out any
native API.
CONSISTANT: C# supports an unified system(uniform), which eliminates the problem of varying
integer types. All types are treated as objects and developers can extend the type system simply and
easily.
VERSIONABLE: Making new versions of software modules work with the existing  applications is
known as versioning with the help of new and override keywords, With this support, a programmer
can guarantee that his new class library will maintain binary compatibility with the existing client
application.
COMPATIBLE: C# enforces the .NET CLS (common language specification) and therefore allows
interoperation with other .NET language. C# provides support for transparent access to COM and
OLE Applications.

Applications of C#:
 Console applications
 Windows applications
 Developing windows controls
 Developing ASP.NET projects
 Creating web controls
 Providing web services
 Developing .NET component library
NOTES:
C# is case sensitive.
All statements and expression must end with a semicolon (;).
The program execution starts at the Main method.
Unlike Java, program file name could be different from the class name.

13 School of Computer Science & Engineering | RGMCET

 C# AND .NET

CREATING A SIMPLE C# PROGRAM: A simple code that prints the words "Hello World":
using System;
namespace HelloWorldApplication
{
class HelloWorld
{
public static void Main(string[] args)
{
Console.WriteLine("Hello World");
Console.ReadKey();
}
}
}
Output: Hello World
using System:
using System:
 using is the keyword, which is used to specify namespace.
 The above line tells the compiler to look into the System namespace library for unresolved
class names.
 Because of the above line we have not used system prefix to the console class in the output
line.
 When the compiler parses the Console.WriteLine method, it will understand that the method
is undefined, However it will search through the namespaces specified in using directives and
upon finding the method in the system namespace ,will compile the code without any
complaint.
Namespace declaration: A namespace is a collection of classes. The HelloWorldApplication
namespace contains the class Hello World.
Class Declaration: The next line has a class declaration, the class HelloWorld contains the data and
method definitions that your program uses. Classes generally contain multiple methods. Methods
define the behaviour of the class. However, the HelloWorld class has only one method Main. The
line
class Helloworld:
 The above line Declares a class, C# is true object oriented language and therefore everything
must be placed inside a class.
 Class is keyword, which declares new class definition.
 Helloworld is the name of the class. It should be a valid identifier.
Braces({ }):C# is a block structured language and the code always enclosed by { and }.therefore
every class definition in c# begins with opening brace { and ends with a closing brace }.

14 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Public static void Main(): The line

public static void Main()
 The above line defines a method named Main. Every C# executable program must include
the Main() method in one of the classes. This is the starting point for executing the program.
A C# application can have any number of classes but only one class can have the Main()
method to initiate the execution.
 The above line contains public, static and void keywords
public: It tells the C# compiler that Main() method is accessible by anyone.
static: The keyword static declares the Main() method is a global one and can be called
without creating an instance of the class.
void: The keyword void is a type modifier that tells that the main method does not return any
value.
 In contrast to other languages main has capital, not lower case M.
Output line: System.Console.WriteLine(“hi”);
 The WriteLine is the static method of the Console class, Which is located in system
namespace.
 . is represented as the member access operator.
 ; is called line terminator
 WriteLine always append a newline character to the end of the string. This means any
subsequent output will start on a newline
COMMENTS: Comments play very important role in the maintenance of programs.They are used
to enhance readability and understanding of code. C# supports two types of comments
 Single line comments: Single line comments begins with a double backslash (//)symbol and
terminate at the end of the line.
Example: //c# program
 Multiline comments: If we want to use multiple lines for a comment, This comment starts
with /* and terminates with */.
Example: /* this is Example of c#
Csharp program */
Console.ReadKey (); The line Console.ReadKey (), Makes the program wait for a key press and it
prevents the screen from running and closing quickly when the program is launched from Visual
Studio .NET.
COMPILING AND EXECUTING THE PROGRAM: If you are using Visual Studio.Net for

15 School of Computer Science & Engineering | RGMCET

 C# AND .NET

compiling and executing C# programs, take the following steps:

o Start Visual Studio.
o On the menu bar, choose File -> New -> Project.
o Choose Visual C# from templates, and then choose Windows.
o Choose Console Application.
o Specify a name for your project and click OK button. This creates a new project in Solution
Explorer.
o Write code in the Code Editor.
o Click the Run button or press F5 key to execute the project. A Command Prompt window
appears that contains the line Hello World.
YOU CAN COMPILE A C# PROGRAM BY USING THE COMMAND-LINE INSTEAD OF
THE VISUAL STUDIO IDE:
 Open a text editor and add the above-mentioned code.
 Save the file as helloworld.cs
 Open the command prompt tool and go to the directory where you saved the file.
 Type csc helloworld.cs and press enter to compile your code.
 If there are no errors in your code, the command prompt takes you to the next line and
generates helloworld.exe executable file.
 Type helloworld to execute your program.
 You can see the output Hello World printed on the screen.
Example: Implementation of a Rectangle class and discuss C# basic syntax:
using System;
namespace RectangleApplication
{
class Rectangle
{
// member variables
double length;
double width;
public void Acceptdetails()
{
length = 4.5;
width = 3.5;
}
public double GetArea()
{
return length * width;
}
public void Display()
16 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}
class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
r.Acceptdetails();
r.Display();
Console.ReadLine();
}
}
}
Output: Length: 4.5 Width: 3.5 Area: 15.75
USING ALIASES FOR NAMESPACE CLASSES: we have seen how we can avoid the prefix
System to the Console class by implementing the using System; statement. can use this approach to
avoid prefixing of System.Console to the method WriteLine() ? The answer is no.
System is a namespace and Console is a class. The using directive can be applied only to
the namespaces and cannot be applied to classes. Therefore the statement
using System.Console;
The above statement is illegal. However, we can overcome this problem by using aliases for
namespace classes. This takes the following form.
using aliasname=classname;
Example: using A= System.Console; //A is alias for System.Console
class sample
{
pubic static void Main()
{
A.WriteLine(“Hello”);
}
}
PASSING STRING OBJECTS TO WRITELINE METHOD: So far we have seen constant string
output to the Console. we can store string values in string objects and use these objects as parameters
to the WriteLine method. We can use string data type to create string variable and assign string
constant to it.
string s=”abc”;
The content of s may be printed out using the WriteLine method.
System.Console.WriteLine(s);
Example: using System;

17 School of Computer Science & Engineering | RGMCET

 C# AND .NET

class sample
{
class static void Main()
{
string name=”c sharp”;
Console.WriteLine(name);
}
}

COMMAND LINE ARGUMENTS: command line arguments are parameters supplied to the Main
method at the time of invoking it for execution.

Example: using System;

class sample
{
public static void Main(string[] args)
{
Console.Write(“welcome to”);
Console.Write(“ ”+arg[0]);
Console.WriteLine(“ ”+args[1]);
}
}
In this program the Main is declared with a parameter args.The parameter args is declared as an array
of strings(known as string objects).Any arguments provided in the command line(at the time of
execution) are passed to the array args as its elements.We can access the array elements by using a
subscript like args[0],args[1] and so on.
For example , consider the command line => Sample c sharp
This command line contains two arguments which are assigned to the array args as follows
C  args[0]
Sharp  args[1]
If we execute the program with the above command line, we will get the following output
Output: welcome to c sharp
WriteLine(): Outputs one (or) more values to the screen but adds a newline character at the end of
the output.
Example: Console.WriteLine(“hello”);
Console.WriteLine(“c sharp”);
Output: hello
C sharp
Write():Outputs one (or) more values to the screen without a newline character.
Example: Console.Write(“hello”);
Console.Write(“\n”);
Console.Write(“ c sharp”);
18 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Output: hello
C sharp
MAIN WITH A CLASS:
Example: class testclass
{
public void fun()
{
System.Console.WriteLine(“C# is simple”);
}
}
class sample
{
public static void Main()
{
testclass test= new testclass(); // creating test object
test.fun(); // calling fun() function
}
}
 The above program has two class declarations, one for the testclass and another for the Main
method.testclass contains only one method to print a string “C# is simple”.The Main method
in simple class creates an object of testclass and uses it to invoke the method fun() contained
in testclass.
 The object test is used to invoke the method fun() of testclass with the help of the dot
operator.
PROVIDING INTERACTIVE INPUT: So far we have seen two approaches for giving values to
string objects.
 Using an assignment statement.
 Through command line arguments.
It is possible to give values to string variables interactively through the keyboard at the time of
execution.

Example: using System;

class sample
{
public static void Main()
{
Console.WriteLine(“enter your name”);
string name=Console.ReadLine();
Console.WriteLine(“Hello”+name);
}
}
The method “Console.WriteLine(“enter your name”);” outputs the message “enter your name”
and the method “Console.ReadLine();” causes the the execution to wait for the user to enter his

19 School of Computer Science & Engineering | RGMCET

 C# AND .NET

name. The moment the user types his name and presses the enter key, the input is read into the string
variable name. The second output line “Console.WriteLine(“Hello”+name);” concatenates the
name-string with hello and presents the resultant string to the user.
Output: enter your name raja
Hello raja
Example1: using System;
class sample
{
public static void Main()
{
Console.WriteLine(“what is your name”);
string s=Console.ReadLine();
Console.WriteLine(“Hello”+s);
Console.WriteLine(“what is your age”);
string s=Console.ReadLine();
Console.WriteLine(“you look nice at”+s);
}
}
TOKENS: The smallest, non-reducible, textual elements in a program are referred to as tokens.
The compiler recognizes them for building up expressions and statements. A C# program is a
collection of tokens, comments and whitespaces. The c# tokens are
 Keywords
 Identifiers
 Literals
 Operators
 Punctuators
KEYWORDS: Keywords are reserved words which are, predefined to the C# compiler. They have
fixed meanings and these meanings cannot be changed. Keywords serve as basic building blocks for
program statements. All keywords must be written in lowercase. Keywords cannot be used as
identifiers except when they are prefaced by the @ character.

20 School of Computer Science & Engineering | RGMCET

 C# AND .NET

In C#, some identifiers have special meaning in context of code, such as get and set, these are called
contextual keywords.

IDENTIFIERS: An identifier is a name, which is used to identify a class, variable, function,

interface, namespace and label. The basic rules for framing identifiers in C# are as follows:
 They can have alphabets, digits (0 - 9), or underscore.
 They must not begin with a digit.
 Upper case and lower case letters are distinct.
 It should not be a C# keyword.
LITERALS: Literals are value constants assigned to variables in a program. C# supports several
types of literals.
Numeric literals:
Integer literals: An integer literal refers to a sequence of digits. There are two types of integers,
namely decimal and hexadecimal integers.
Decimal integers: Decimal integers contains a set of digits from 0 to 9 with an optional + or – sign
Example: Valid examples Invalid examples
1. 123 1. 153 43
2. –76565 2. 20,000
3. 0 3. $667
4. +736 4. 9-898
Hexadecimal integers: A sequence of digits preceded by 0x (or) 0X is considered as a hexadecimal
21 School of Computer Science & Engineering | RGMCET
 C# AND .NET

integer. It may also include alphabets A through F (or) a through f.A letter A through F represents the
numbers from 10 through 15.
Examples: Valid examples Invalid examples
1. 0x2 1.0xnmjk
2. 0x87665 2.0x1286m
3. 0xabc 3.08972
4. 0x53647 4.0khjdi
Real literals: The numbers containing fractional part is called real (or) floating-point literals. We
have two Notations for representing real literals.
 Decimal notation
 Scientific notation (or) exponential notation
Decimal notation: It represents numbers having a whole number followed by decimal point and
fractional part.
Example: 215.
.95
-.75
+.5
Scientific notation: A real number may also be expressed in exponential (or) scientific notation.
Example: The number 215.65 may be written as 2.1565e2 in exponential notation.e2 means multiply
by 102.
Syntax: mantissa e exponent
Mantissa: mantissa is either a real number expressed in decimal notation.
Exponent: It is an integer number with an optional sign.
E (or) e: It separates the mantissa and the exponent can be written in either uppercase (or) lower
case.
Example: 0.65e4
12e-2
1.5e+5
3.18e3
 Exponential notation is useful for representing the numbers that are either very large (or) very
small in magnitude.
Example: 7500000000 is equals to 7.5e9 is also equals to 75e8
-0.000000368 is equals to -3.68e-7
Boolean literals: There are two Boolean literal values
true
false
 Character literals:
Single Character Constants: A single character constant contains a single character enclosed by
single quote marks is called single character constants.
Examples: ‘a’
22 School of Computer Science & Engineering | RGMCET
 C# AND .NET

’#’
’2’
’’
String Constants: A string constant is a sequence of characters enclosed by double quotes. The
character may be any letter, digits, special characters and blank space .
Example: “Welcome to c programming”
“2001”
“Well done”
“34+23”
“d”
BACKSLASH CHARACTER CONSTANTS: C# supports some special backslash character
constants that are used in output methods. Each backslash character constant contains two
characters to represent a single character. These combinations are called escape sequences.
1. \a – alert
2. \b – Backspace
3. \f – Form feed
4. \n – New line
5. \r – Carriage return
6. \t – Horizontal tab
7. \v – Vertical tab
8. \\ – Backslash
9. \' – Single quote
10. \" – Double quote
11. \0 - Null
DATA TYPES: Every variable in C# is associated with a data type.Data types specify the type and
size of values that a variable can be stored. The data types in C# are primarily divided into two
types.:
 Value types
 Reference types
Value types and reference types differ in two characteristics:
 Where they are stored in the memory
 How they behave in the context of assignment statements.
Value Type: Value types (which are of fixed length) are stored on the stack(stack is a place where
the data stores in fixed length like float,int etc.), when a value of a variable is assigned to a variable
the value is actually copied. This means that two identical copies of the value are available in
memory.
The value types of C# can be grouped into two categories, namely,
 User defined types (or) complex types
 Predefined types (or) simple types

23 School of Computer Science & Engineering | RGMCET

 C# AND .NET

User defined types (or) complex types: Here we can define our own complex types by using
predefined types known as User defined value types, which includes
 structures
 enumerations
Predefined types: These are also known as simple types (or) primitive types. Predefined types are
divided into
 Numeric types
 Boolean types
 Character types
Numeric types: Numeric types include integral types, floating point types and decimal types.
Subtypes:
1. Integer
2. Float
3. decimal

Integral types: Integral types can hold whole numbers such as 123, -96 and 5639.The size of the
values that can be stored depends on the integral data type we choose. C# supports the concept of
signed and unsigned types and therefore it supports eight types of integers .
Signed integers: signed integer types can hold both positive and negative numbers.
Type Size Minimum value Maximum value
sbyte 1 byte -128 +127
short 2 byte -32768 +32767
int 4 byte 2147483648 +2147483647
long 8 byte -9223372036854775808 +9223372036854775807
Unsigned integers: unsigned integer types can hold only positive numbers
Type Size Minimum value Maximum value
byte 1 byte 0 255
ushort 2 byte 0 65535
uint 4 byte 0 4294967295
ulong 8 byte 0 18446744073709551615
All integers are by default int type. In order to specify other integer types, we must append the
characters U,L or UL
 123U(for uint type)
 123L(for long type)
 123UL(for ulong type)
Floating point types: Floating point types hold numbers containing fractional parts such as 27.59
and -1.375.There are two kinds of Floating point storage in C#
The Floating point values are single-precision numbers with a precision of seven digits.

24 School of Computer Science & Engineering | RGMCET

 C# AND .NET

The double types represent double-precision numbers with a precision of 15/16 digits
Type Size Minimum value Maximum value
float 4 byte 1.5x10-45 3.4x1038
double 8 byte 5.0x10-324 1.7x10308
Floating point numbers by default as double-precision quantities.to force them to be in single
precision mode, we must append f (or) F to the numbers.
Example: 1.23f
7.56923f
Double-precision types are used when we need greater precision in storage of floating-point
numbers.
Floating-point data types support a special value known as Not-a-Number(NaN).NaN is used to
represent the result of operations such as dividing zero by zero,where an actual number is not
produced. Most operations NaN as an operand will produce NaN as result.
Decimal type: The decimal type is a high precision,128-bit data type that is designed for use in
financial monetary calculations. It can store values in the range 1.0x10 -28 to 7.9x1028 with 28
significant digits.
To specify a number to be decimal type, we must append the character M or mto the value.
Example: 123.45M (if we omit M, the value will be treated as double).
Character type: In order to store single characters in memory, C# provides a character data type
called char. The char type assumes a size of two bytes but, in fact it can hold only a single character.
char data type has been designed to hold a 16-bit Unicode character, in which 8-bit ASCII code is a
subset.
Boolean type: Boolean condition can be used when we want to test a particular condition during the
execution of the program. There are two values that a Boolean type can take true (or) false. Boolean
type can be denoted by the keyword bool and uses only one bit of storage.
Reference types: reference types (which are of variable length) are stored on the heap, and when an
assignment between two reference variables occurs, only the reference is copied. The actual values
remains in the same memory location. This means there are two references to a single value. The
reference types can be divided into two groups
 User defined types (or) complex types
 Predefined types (or) simple types
User defined types: user defined reference types refer to those types which we define using
predefined type. They include
 Classes
 Delegates
 Interfaces
25 School of Computer Science & Engineering | RGMCET
 C# AND .NET

 Arrays
Predefined types: Predefined types include two types
 Object type
 String type
VARIABLES: A variable is an identifier that denotes a storage location uses to store a data value. A
variable may take different values at different times during the execution of the program. Every
variable has a type that determines what values can be stored in the variable.
Rules for forming a variable:
 They must not begin with a digit.
 Uppercase and lower case is distinct. This means that the variable TOTAL is not same as total
or Total.
 It should not be a keyword.
 White space is not allowed.
 Variable names can be of any length.
Variable declaration: After designing suitable variable names, we must declare the variable before
it used in the program. Declaration does three things
 It tells the compiler what the variable name is.
 It specifies what type of data the variable will hold.
 The place of declaration in the program decides the scope of the variable.
Syntax: data_type variable1, variable2,……. variableN;
Here, data_type must be a valid C# data type including char, int, float, double, or any user-defined
data type, and variables are separated by commas. Some valid variable definitions are shown here:
int i, j, count;
float f, salary;
double pi;
byte b;
char c1,c2,c3;
decimal d1,d2;
uint m;
ulong n;
Initializing Variables: The process of giving initial values to the variables is called initialization.
Once the declaration has been done then initializes the variables with the assignment operator. The
general form of initialization is:
Syntax: variable_name = value;
It is also possible to assign a value at the time of its declaration.
Syntax: <data_type> <variable_name> = value;

26 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example:
int d = 3, f = 5;
byte z = 22;
double pi = 3.14159;
char x = 'x';
Example:
float x,y,z; //declares three variables
int m=5,n=10; //declares and initializes two int variables
int m, n=10; //declares m and n and initializes n.
Example: The following example uses various types of variables:
using System;
namespace VariableDefinition
{
class Program
{
static void Main(string[] args)
{
short a; int b ; double c;
/* actual initialization */
a = 10; b = 20; c = a + b;
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
Console.ReadLine();
}
}
}
Output: a = 10, b = 20, c = 30
Scope of variables: The scope of the variable determines over what part(s) of the program a variable
is actually available for use (active).This depends on the type of the variable and place of its
declaration. C# defines several categories of variables.
 Static variables
 Instance variables
 Array elements
 Value parameters
 Reference parameters
 Output parameters
 Local variables
Example: class ABC
{
static int m;
int n;
void fun (int x , ref int y, out int z, int[] a)
{
int j = 10;
}
}
 m = static variable,
 n = instance variable,
 x = value parameter,

27 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 y = reference parameter,
 j = local variable,
 z =output parameter,
 a[0] = array element
TYPE CONVERSION: The process of converting one data type into another data type is known as
type casting or type conversion. Type conversions are divided into two types.
1. Implicit (or) up casting (or) widening (or) automatic type conversion.
2. Explicit (or) down casting (or) narrowing type conversion.
Implicit type conversion (Automatic type conversion): Converting lower data type into higher
data type is called widening. In this one data type is automatically converted into another type as per
the rules described in c# language, which means the lower level data type is converted automatically
into higher level data type before the operation proceeds. The result of the data type having higher
level data type.
Example: byte x = 12;
int y = x;
In the above statement, the conversion of data from byte to int is done implicitly, in other words
programmers don’t need to specify any type operators. Widening is safe because there will not be
any loss of data. This is the reason even though the programmer does not use the cast operator the
compiler does not complaint because of lower data type is converting into higher data type. Here
higher data type having the much more space to store the lower data type.
Example: using System;
  namespace explicit_cast_conversion
{
    class Program
     {
         static void Main(string[] args)
         {
             int num1=10;
            long num2=num1;
              Console.WriteLine("num2 value is : " +num2);
             Console.ReadLine();
         }
     }
}
Explicit type conversion: Converting higher data type into lower data type is called narrowing.
Here we can place intended data type in front of the variable to be cast.
Syntax: data-type variablename1=(cast-type)variablename2;
Example: double d=12.67853;
int n = (int) d;
Here we are converting higher level data type into lower level data type that means double type is
converted into int type, the fractional part of the number is lost and only 12 is stored in n. Here we

28 School of Computer Science & Engineering | RGMCET

 C# AND .NET

are losing some digits this is the reason the compiler forces the programmer to use the cast operator
when going for explicit casting.

Example: The following example shows an explicit type conversion:

using System;
namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 5673.74;
int i;
i = (int)d;
Console.WriteLine(i);
Console.ReadKey();
}
}
}
Output: 5673
Example: using System;
  namespace explicit_cast_conversion
{
     class Program
     {
         static void Main(string[] args)
         {
             int num1, num2;
             float avg;
             num1 = 10;
             num2 = 21;
             avg = (float)(num1 + num2) / 2;
              Console.WriteLine("average is : " + avg);
             Console.ReadLine();
         }
     }
}
Microsoft .NET provides three ways of type conversion:
 Parsing
 Convert Class
 Boxing and unboxing
parsing: Parsing is used to convert string type data to primitive value type. For this we use parse
methods with value types.
Example:
using System;
class Program
{
static void Main()
{
29 School of Computer Science & Engineering | RGMCET
 C# AND .NET

string text = "500";// Convert string to number.

int num = int.Parse(text);
Console.WriteLine(num);
int num2 = int.Parse(Console.ReadLine());
Console.WriteLine(num2);
}
}
Note: If the string cannot be converted then the int.parse() returns an exception.
Error: Unhandled exception: system Formate Exception Input string was not in a correct formate.
Example: using System;
 namespace parsing
{
     class Program
     {
         static void Main(string[] args)
         {
             int number;
            float weight;
              Console.Write("Enter any number : ");
             number = int.Parse(Console.ReadLine());
              Console.Write("Enter your weight : ");
             weight = float.Parse(Console.ReadLine());
              Console.WriteLine("You have entered : " + number);
             Console.WriteLine("You weight is : " + weight);
              Console.ReadLine();
         }
     }
}
int.parse(“ “)
float.parse(“ “)
double.parse(“ “)
bool.parse(“ ”)
char.parse(“ ”)
Convert class: It is used to convert one primitive type to another primitive type. Convert is the
predefined class. C# provides the following built-in type conversion methods as described:
S.No Method Description
1 ToBoolean Converts a type to a Boolean value, where possible
2 ToByte Converts a type to byte.
3 TOChar Converts a type to single Unicode character, where possible.
4 ToDateTime Converts a type to date time structures.
5 ToDecimal Converts a floating point or integer type to decimal type.
6 ToDouble Converts a type to double type.
7 ToInt16 Converts a type to a 16-bit integer.
8 ToInt32 Converts a type to a 32-bit integer.
9 ToInt64 Converts a type to a 64-bit integer.
10 ToSbyte Converts a type to a signed byte type.
11 ToSingle Converts a type to a small floating point number.
12 ToString Converts a type to a string.
13 ToType Converts a type to a specified type.

30 School of Computer Science & Engineering | RGMCET

 C# AND .NET

14 ToUInt16 Converts a type to unsigned int type.

15 ToUInt32 Converts a type to unsigned long type.
16 ToUInt64 Converts a type to unsigned big integer.
Convert class supports Boolean,char,SByte,byte,Int16,single,double,Decimal,string.
Example: The following example converts various value types to string type:
using System;
namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;
Console.WriteLine(i.ToString());
Console.WriteLine(f.ToString());
Console.WriteLine(d.ToString());
Console.WriteLine(b.ToString());
Console.ReadKey();
}
}
}
Output: 75
53.005
2345.7652
True
Example:
using System;
namespace Arithmetic_Operators
{
   class Program
    {
      static void Main(string[] args)
       {
            Console.Write("VAL:",+Convert.ToChar(“A”));
Console.Write("VAL:",+Convert.ToByte(“255”));
Console.Write("VAL:",+Convert.ToSByte (“127”));
Console.Write("VAL:",+Convert.ToINT16(“_12345”));
Console.Write("VAL:",+Convert.ToINT32(“_12345”));
Console.Write("VAL:",+Convert.ToINT64(“_12345”));
Console.Write("VAL:",
+Convert.ToUINT32(“_12345”));
Console.Write("VAL:",
+Convert.ToUINT64(“_123456789”));
  Console.ReadLine();           
   }
  }
}
31 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Example: using System;
namespace convert_conversion
{
     class Program
     {
        static void Main(string[] args)
         {
Convert.ToSingle(“3.14”);
Convert.ToSingle(“3.14”);
Convert.ToSingle(“3.14”);
Console.WriteLine(“Convert.ToSingle(“3.14”));
              Console.ReadLine();
         }
     }
}
BOXING AND UNBOXING: In object oriented programming, methods are invoked using objects.
Since value types such as int and long are not objects, we cannot use them to call methods. C#
enables us to achieve this through a technique known as boxing.
Boxing: Boxing is the process of converting a value type to the reference type.
Boxing is an implicit type casting. To work with boxing, we required a predefined data type called
object. Object data type is capable to hold any type of data.
Example: int m=10;
object om=m; //Boxing
The first line we created a Value Type m and assigned a value to m. The second line, we created an
instance of Object om and assign the value of m to om. From the above operation, we saw converting
a value of a Value Type into a value of a corresponding Reference Type. This type of operation is
called Boxing.
We can also use a c-style cast for boxing.
int m=10;
object om=(object)m; // c-style casting
Note that the boxing operation creates a copy of the value of the m integer to the object om. Now
both the variables m and om exist but the value of om resides on the heap. This means that the values
are independent of each other. Consider the following code
int m=10;
object om=m;
m=20;
Console.WriteLine(m); //m=20
Console.WriteLine(om); //om=10
When a code changes the value of m, the value of om not affected.
Unboxing: Unboxing is the process of converting a reference type to value type. Remember that we
can only unbox a variable that has previously been boxed. Unboxing is an explicit type conversion.

32 School of Computer Science & Engineering | RGMCET

 C# AND .NET

When unboxing a value, we have to ensure that the value type is large enough to hold the
value of the object (reference type value). Otherwise, the operation may result in runtime error.
Example: int m=10;
object om=m;
byte n=(byte)om;
The above code will produce a runtime error.
Notice that when unboxing, we need to use explicit cast. This is because in case of unboxing, an
object could be cast to any type. Therefore, the cast operator is necessary for the compiler to verify
that it is valid as per the specified value type.
Example: int m = 10;
Object om = m; //Boxing
int i = (int)om; //Unboxing
The first two lines show how to Box a Value Type. The next line (int i = (int) om) shows extracts the
Value Type from the Object (reference type) . That is converting a value of a Reference Type into a
value of a Value Type. This operation is called Unboxing.
A c-style cast for unboxing
int m=10;
object om=m;
int n=(int)om;
 Example: using System;
  namespace boxing
{
     class Program
     {
         static void Main(string[] args)
         {
             int i = 10;
             object a = i;             // boxing
             int j = (int)a;          // unboxing
              Console.WriteLine("value of o object : " + a);
             Console.WriteLine("Value of j : " + j);
  Console.ReadLine();
         }
     }
}
OPERATORS: An operator is a symbol that tells the computer to perform specific mathematical or
logical manipulations. Operators are used in programs to manipulate data and variables. C# has rich
set of operators. C# operators can be classified into the following types:
 Arithmetic Operators
 Relational Operators
 Logical Operators
 Assignment Operators
33 School of Computer Science & Engineering | RGMCET
 C# AND .NET

 Increment and decrement operators

 Conditional operators
 Bitwise Operators
 Special Operators
Arithmetic Operators: The operators that are used to perform Arithmetic operations such as
addition, subtraction, multiplication, ----etc. are called Arithmetic operators. Assume variable A
holds 10 and variable B holds 20 then:
Operator Meaning Description Example
+ Addition operator Adds two operands a+b=30
- Subtraction operator Subtracts second operand from the first a-b=-10
* Multiplication operator Multiplies both operands a*b=200
/ Division operator Divides numerator by de-numerator b/a=2
% Modulus division operator It gives Remainder after an integer division b%a=0
Integer Arithmetic: When both the operands in a single arithmetic expression such as a+b are
integers, the expression is called as integer expression and the operation is called integer arithmetic
The a=4, b=2, then
a+b = 6
a-b = 2
a*b = 8
a/b = 2
a%b = 0
Real Arithmetic: An arithmetic operation involving only real operands is called real arithmetic. A
real operand may assume values either in decimal or exponential notation.
Example: a=20.5F,b=6.4F
a+b =26.9
a-b = 14.1
a*b = 131.2
a/b = 3.203125
a%b = 1.3
Example:
Mixed-mode Arithmetic: When one of the operands is real and the other is integer, the expression is
called a mixed-mode arithmetic expression. If either operand is real type, then the other operand is
converted to real and real arithmetic is performed. The result will be real.
Example: 15/10.0=1.5
15.0/10=1
Example: The following example demonstrates all the arithmetic operators available in C#:
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
34 School of Computer Science & Engineering | RGMCET
 C# AND .NET

int a = 21;
int b = 10;
int c;
c = a + b;
Console.WriteLine("Line 1 - Value of c is {0}", c);
c = a - b;
Console.WriteLine("Line 2 - Value of c is {0}", c);
c = a * b;
Console.WriteLine("Line 3 - Value of c is {0}", c);
c = a / b;
Console.WriteLine("Line 4 - Value of c is {0}", c);
c = a % b;
Console.WriteLine("Line 5 - Value of c is {0}", c);
c = a++;
Console.WriteLine("Line 6 - Value of c is {0}", c);
c = a--;
Console.WriteLine("Line 7 - Value of c is {0}", c);
Console.ReadLine();
}
}
}
Output: Line 1 - Value of c is 31
Line 2 - Value of c is 11
Line 3 - Value of c is 210
Line 4 - Value of c is 2
Line 5 - Value of c is 1
Line 6 - Value of c is 21
Line 7 - Value of c is 22
Relational Operators: These operators are used to compare the value of two variables. Relational
operator’s checks relationship between two operands. If the relation is true, it returns value
1 and if the relation is false, it returns value 0.Assume variable A holds 10 and variable B holds
20, then:
Operator Meaning Description Example
> Greater than Checks if the value of left operand is greater than (a>b) is
the value of right operand, if yes then condition not true
becomes true.
< Less than Checks if the value of left operand is less than (a<b) is
the value of right operand, if yes then condition true
becomes true.
<= Less than or equals to Checks if the value of left operand is less than or a<=b is
equal to the value of right operand, if yes then true
condition becomes true.
>= Greater than or equals to Checks if the value of left operand is greater than a>=b is
or equal to the value of right operand, if yes then not true
condition becomes true.
!= Not equals to Checks if the values of two operands are equal or a!=b is
not, if values are not equal then condition true
becomes true.
35 School of Computer Science & Engineering | RGMCET
 C# AND .NET

== Equals to Checks if the values of two operands are equal or a==b is

not, if yes then condition becomes true. not true
Example: The following example demonstrates all the relational operators available in C#:
using System;
class Program
{
static void Main(string[] args)
{
int a = 21;int b = 10;
if (a == b)
Console.WriteLine("Line 1 - a is equal to b");
else
Console.WriteLine("Line 1 - a is not equal to b");
if (a < b)
Console.WriteLine("Line 2 - a is less than b");
else
Console.WriteLine("Line 2 - a is not less than b");
if (a > b)
Console.WriteLine("Line 3 - a is greater than b");
else
Console.WriteLine("Line 3 - a is not greater than b");
a = 5;
b = 20;
if (a <= b)
Console.WriteLine("Line 4 - a<=b");
if (b >= a)
Console.WriteLine("Line 5-b >=b");
}
}
Output: Line 1 - a is not equal to b
Line 2 - a is not less than b
Line 3 - a is greater than b
Line 4 - a is either less than or equal to b
Line 5 - b is either greater than or equal to b
Logical Operators: These operators are used to perform logical operations on the given two
variables. Logical operators are used to combine expressions containing relation operators.
Assume variable A holds Boolean value true and variable B holds Boolean value false, then:
Operator Meaning Description Example
&& Logical AND If both operands are non-zero then (a&&b) is false
condition becomes true
|| Logical OR If any of the two operands is non-zero then (a||b) is true
condition becomes true
! Logical NOT Used to reverse the logical state of its !(a&&b) is true
operand. If a condition is true then logical
NOT operator will make false.
Example: The following example demonstrates all the logical operators available in C#:
using System;
namespace OperatorsAppl

36 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
class Program
{
static void Main(string[] args)
{
bool a = true;
bool b = true;
if (a && b)
Console.WriteLine("Line 1 - Condition is true");
if (a || b)
Console.WriteLine("Line 2 - Condition is true");
/* lets change the value of a and b */
a = false;
b = true;
if (a && b)
Console.WriteLine("Line3-Condition is true");
else
Console.WriteLine("Line3-not true");
if (!(a && b))
Console.WriteLine("Line4-Condition is true");
Console.ReadLine();
}
}
}
Output: Line 1 - Condition is true
Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true
Assignment Operators: These are used to assign the values for the variables in C# programs. The
most common assignment operator is =.The syntax is shown below:
data type Variable_name = expression;

Operator Meaning Example Same as

= Assignment a=b a=b

+= Addition assignment a+=b a=a+b
-= Subtraction assignment a-=b a=a-b
*= Multiplication assignment a*=b a=a*b
/= Division assignment a/=b a=a/b
%= Modula division assignment a%=b a=a%b
Example: The following example demonstrates all the assignment operators available in C#:
using System;
namespace OperatorsAppl
{
class Program

37 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
static void Main(string[] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine("Line 1 - =Value of c = {0}", c);
c += a;
Console.WriteLine("Line 2 - += Value of c = {0}", c);
c -= a;
Console.WriteLine("Line 3 - -=Value of c = {0}", c);
c *= a;
Console.WriteLine("Line 4 - *=Value of c = {0}", c);
c /= a;
Console.WriteLine("Line 5 - /=Value of c = {0}", c);
c = 200;
c %= a;
Console.WriteLine("Line 6 - %=Value of c = {0}", c);
Console.ReadLine();
}
}
}
Output: Line 1 - =Value of c = 21
Line 2 - += Value of c = 42
Line 3 - -= Value of c = 21
Line 4 - *= Value of c = 441
Line 5 - /= Value of c = 21
Line 6 - %= Value of c = 11
Increment/Decrement Operators: Increment operators are used to increase the value of the variable
by one and decrement operators are used to decrease the value of the variable by one in C programs.
Increment Operators:
1. ++ is an increment operator. This is an unary operator.
2. It increments the value of the operand by one.
Syntax: Incrementoperator: ++var_name; (or) var_name++;
Post Increment:If the increment operator ++ is placed after the operand, then operator is called Post
Increment. As the name indicates Post indicates means increment after the operand value is used.
Pre Increment:If the increment operator ++ is placed before the operand. Then operator is called
Pre Increment. As the name indicates Pre indicates, increment before the operand value is used.
Decrement Operators:
 -- is a decrement operator. This is an unary operator.
 It decrements the value of the operand by one.
The decrement operator is classified into two categories:
Post Decrement(Ex: a--) :If the decrement operator -- is placed after the operand. Then the operator

38 School of Computer Science & Engineering | RGMCET

 C# AND .NET

is called post decrement. So the operand value is used first and then the operand value is
decremented by 1.
Pre Decrement(Ex:--a) : If the decrement operator -- is placed before the operand then the
operator is called Pre decrement. So the operand value is decrement by 1 first and this
decremented value is used.
Example: using System;
class Program
{
static void Main(string[] args)
{
int i = 4;
i++;
Console.WriteLine(i);
++i;
Console.WriteLine(i);
i--;
Console.WriteLine(i);
--i;
Console.WriteLine(i);
}
}
Example: using System;
class Program
{
static void Main(string[] args)
{
int i = 4;int y = 0;
y = i++;
Console.WriteLine("i = " + i);
Console.WriteLine("y = " + y);
Console.WriteLine();
++i;
Console.WriteLine("i = " + i);
Console.WriteLine("y = " + y);
Console.WriteLine();
y = i--;
Console.WriteLine("i = " + i);
Console.WriteLine("y = " + y);
Console.WriteLine();
y = --i;
Console.WriteLine("i = " + i);
Console.WriteLine("y = " + y);
}
}
Conditional Operators:The conditional operator is also called a ternary operator. As the name
indicates an operator that operates on three operands is called ternary operator.The ternary operators
consisting two symbols i.e ? and :
39 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Syntax: (Condition? true_value: false_value);

Where condition is an expression evaluated True or False.If condition is evaluated to True, the
ture_value is executed.If condition is evaluated to False, the false_value is executed.
Bitwise Operator: A bitwise operator works on each bit of data. Bitwise operators are used in
bit level programming
x y x|y x&y x^y Operator Description
0 0 0 0 0 & Bitwise_AND
0 1 1 0 1 | Bitwise OR
1 0 1 0 1 ~ One’s
compliment
1 1 1 1 0 ^ XOR
  << Left Shift
>> Right Shift
Example: The following example demonstrates all the bitwise operators available in C#:
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
Console.WriteLine("Line 1 - Value of c is {0}", c );
c = a | b; /* 61 = 0011 1101 */
Console.WriteLine("Line 2 - Value of c is {0}", c);
c = a ^ b; /* 49 = 0011 0001 */
Console.WriteLine("Line 3 - Value of c is {0}", c);
c = ~a; /*-61 = 1100 0011 */
Console.WriteLine("Line 4 - Value of c is {0}", c);
c = a << 2; /* 240 = 1111 0000 */
Console.WriteLine("Line 5 - Value of c is {0}", c);
c = a >> 2; /* 15 = 0000 1111 */
Console.WriteLine("Line 6 - Value of c is {0}", c);
Console.ReadLine();
}
}
}
Output: Line 1 - Value of c is 12
Line 2 - Value of c is 61
Line 3 - Value of c is 49
Line 4 - Value of c is -61
Line 5 - Value of c is 240
Line 6 - Value of c is 15

40 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Miscellaneous Operators: There are few other important operators including sizeof, typeof and ? :
supported by C#.

Example: using System;

namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
/* example of sizeof operator */
Console.WriteLine("The size of int is {0}", sizeof(int));
Console.WriteLine("The size of short is {0}", sizeof(short));
Console.WriteLine("The size of double is {0}", sizeof(double));
/* example of ternary operator */
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine("Value of b is {0}", b);
b = (a == 10) ? 20 : 30;
Console.WriteLine("Value of b is {0}", b);
Console.ReadLine();
}
}
}
Output: The size of int is 4
The size of short is 2
The size of double is 8
Value of b is 30

41 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Value of b is 20

CONDITIONAL STATEMENT: A block of code that is executed based on a condition is called

conditional statement. These are divided into two types.
 Conditional branching
 Conditional looping
When a program breaks the sequential flow and jumps to another part of the code, it is called
branching. Branching statements are used to execute a statement or a group of statements
Conditional branching: when branching takes place based on certain condition is called (or)
conditional branching. The conditional branching statements are.
 ifsimple if, if-else, if-else if-else, nested-if
 switch
Unconditional branching: when branching takes place without any condition is called
unconditional branching. The unconditional branching statements are
 break
 continue
 goto
 return
Simple-if: A simple-if statement is used to execute a block of code only if condition is true.
Syntax:
if( boolean_expression (Or) condition)
{
True-block-statement(s);
}
If the Boolean expression evaluates to true, then the block of code inside the simple-if statement is
executed. If Boolean expression evaluates to false, the execution will jump to the statements after if
statement.
Flow Diagram

Example: using System;

namespace DecisionMaking
{
class Program
{
42 School of Computer Science & Engineering | RGMCET
 C# AND .NET

static void Main(string[] args)

{
int age = 10;
if (a >=18)
Console.WriteLine("you are eligible for voting”);
Console.WriteLine("Thank you”);
Console.ReadLine();
}
}
}
Output: Thank you
if...else Statement: The if-else statement is the extension of simple-if statement. The if else
statement is used to execute true-block-statements if condition is true, otherwise it will execute the
else false-block-statements.
Syntax: if(boolean_expression(or) condition)
{
True-block-statement(s);
}
else
{
False-block-statement(s) will execute if the Boolean expression is false */
}
If the Boolean expression evaluates to true, then the true block of code is executed, otherwise false-
block-statements is executed.
Flow Diagram

Example: using System;

namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
int a = 100;
if (a < 20)
Console.WriteLine("a is less than 20");
else
Console.WriteLine("a is not less than 20");
Console.WriteLine("value of a is : {0}", a);
Console.ReadLine();
}

43 School of Computer Science & Engineering | RGMCET

 C# AND .NET

}
}
Output: a is not less than 20;
value of a is : 100
if...else if...else Statement: It is also called as multi-way decision statement .In this the conditions
are evaluated from top to downwards, when the true condition is found, the statements associated
with it is executed. When all the n conditions become false, then the final contains default statement
will be executed.
Syntax: if(boolean_expression 1)
Statement-1;
else if( boolean_expression 2)
Statement-2;
else if( boolean_expression 3)
Statement-n;
else
Default-Statement;
Example: using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
int a = 100;
if (a == 10)
Console.WriteLine("Value of a is 10");
else if (a == 20)
Console.WriteLine("Value of a is 20");
else if (a == 30)
Console.WriteLine("Value of a is 30");
else
Console.WriteLine("None of the values is matching");
Console.WriteLine("Exact value of a is: {0}", a);
Console.ReadLine();
}
}
}
Output: None of the values is matching
Exact value of a is: 100
Example: using System;
namespace if_else_construct
{
   class Program
    {
      static void Main(string[] args)
       {
         int opt, num1, num2;
         float result;
44 School of Computer Science & Engineering | RGMCET
 C# AND .NET

          label:
          Console.WriteLine("\n\tMenu");
         Console.WriteLine("\nPress 1 for add");
         Console.WriteLine("Press 2 for subtraction");
         Console.WriteLine("Press 3 for multiplication");
         Console.WriteLine("Press 4 for Division");
           Console.Write("\n\nEnter first number:\t");
         num1 = Convert.ToInt32(Console.ReadLine());
          Console.Write("Enter second number:\t");
         num2 = Convert.ToInt32(Console.ReadLine());
          Console.Write("\nEnter your option:\t");
         opt = Convert.ToInt32(Console.ReadLine());
          if (opt == 1)
          {
            result = num1 + num2;
            Console.WriteLine("\n{0}+{1}={2}",num1,                
num2, result);
          }
         else if (opt == 2)
          {
            result = num1 - num2;
            Console.Write("\n{0}-{1}={2}",num1,num2, result);
          }
         else if (opt == 3)
          {
            result = num1 * num2;
            Console.Write("\n{0}x{1}={2}",num1, num2, result);
          }
         else if (opt == 4)
          {
            result = (float)(num1 / num2);
            Console.Write("\n{0} / {1}={2}", num1, num2, result);
          }
         else
          {
            Console.WriteLine("Invalid option. Try again");
            goto label;
          }
         Console.ReadLine();           
       }
   }
}
Example: using System;
class BiggestNumber
{
static void Main()
{
int a = int.Parse(Console.ReadLine());
int b = int.Parse(Console.ReadLine());
int c = int.Parse(Console.ReadLine());
45 School of Computer Science & Engineering | RGMCET
 C# AND .NET

if (a > b && a > c)

{
Console.WriteLine("The biggest number is: {0}", a);
}
else if (b > a && b > c)
{
Console.WriteLine("The biggest number is: {0}", b);
}
else
{
Console.WriteLine("The biggest number is: {0}", c);
}
}
}

Example: The program finds greatest of three numbers and then prints the number which is
the greatest. If all 3 input numbers are same then it prints "Entered Numbers are not
Distinct.".
using System;
namespace DotNetMirror
{
class GreatestOfThreeNumbers
{
static void Main()
{
int number1, number2, number3;
Console.Write("Enter three numbers (followed by Enter key): ");
number1 = Convert.ToInt16(Console.ReadLine());
number2 = Convert.ToInt16(Console.ReadLine());
number3 = Convert.ToInt16(Console.ReadLine());
if (number1 > number2 && number1 > number3)
{
Console.Write("Number {0} is largest.", number1);
}
else if (number2 > number1 && number2 > number3)
{
Console.Write("Number {0} is largest.", number2);
}
else if (number3 > number1 && number3 > number2)
{
Console.Write("Number {0} is largest.", number3);
}
else
{
Console.Write("Entered Numbers are not Distinct.");
}
46 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Console.ReadLine();
}
}
}

Nested if Statements: The statements within the if statement can contain another if statement and
which in turn may contain another if and so on is called nested if-else statement. The nested if
statement is used when multiple conditions needs to be tested. The inner statement will execute only
when outer if statement is true otherwise control won't even reach inner if statement
Syntax: if( boolean_expression1)
{
if(boolean_expression2)
{
Statement-1;
}
else
{
Statement-2;
}
}
else
{
Statement-3;
}
Example: using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
int a = 100;
int b = 200;
if (a == 100)
{
if (b == 200)
Console.WriteLine("Value of a is 100 and b is 200");
}
Console.WriteLine("Exact value of a is : {0}", a);
Console.WriteLine("Exact value of b is : {0}", b);
Console.ReadLine();
}
}
}
Output: Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200

47 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example: using System;

namespace DecisionMaking
{
class Program
{
public static void Main()
{
double n1, n2, n3;
Console.WriteLine("Enter three numbers: ");
n1=Console.ReadLine();
n2=Console.ReadLine();
n3=Console.ReadLine();
if (n1>=n2)
{
if(n1>=n3)
Console.WriteLine ("%.2lf is the largest number.", n1);
else
Console.WriteLine ("%.2lf is the largest number.", n3);
}
else
{
if(n2>=n3)
Console.WriteLine ("%.2lf is the largest number.", n2);
else
Console.WriteLine ("%.2lf is the largest number.",n3);
}
}
}
}
Example: using System;
namespace NestingIfStatementsDemo
{
public class Program
{
public static void Main()
{
int age;
string gender;
Console.Write("Enter your age: ");
age = Convert.ToInt32(Console.ReadLine());
Console.Write("Enter your gender (male/female): ");
gender = Console.ReadLine();
if (age > 12)
{
if (age < 20)
{
if (gender == "male")
Console.WriteLine(“teenage boy.");
else
Console.WriteLine("teenage girl.");
48 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
else
{
Console.WriteLine("already an adult.");
}
}
else
{
Console.WriteLine("You are still too young.");
}
}
}
}
Switch Statement: A switch statement allows a variable or value of an expression to be tested for
equality against a list of possible case values and when match is found, the block of code associated
with that case is executed. Otherwise default case is executed.

Syntax: switch (expression)

{
case constant1: statements_block1;

break;
case constant2: Statements_lock2;
break;
default: default_block
}
 The expression is evaluated first.
 The value of the expression is compared against the constants, constant1, constant2…If a
case is found whose value matches the value of the expression, then the block of statements
that follows the case are executed.
 The break statement at the end of each block signals the end of a particular case and causes
an exit from the switch statement, transferring the control to the statements following the
switch.
 The default is an optional case. when present, it will be executed if the value of the
expression does not match any of the case values. If not present, no action takes place when
all matches fail and the control goes to the statements following the switch
Flow Diagram

49 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Rules for switch statement:-

1. The switch expression must be an integral Type (integer, character)
2. Case labels must be consonants or consonant expression.
3. Case label must be of integral Type (Integer, Character).
4. Case labels must be unique. No two labels can have the same values.
5. Case Labels must end with Colon.
6. The break statements transfer the control out of switch statement.
7. The break statement is optional. i.e; two or more case labels may belong to the same statements.
8. The default label is optional if present it will be executed when the expression does not find a
matching case label.
9. There can be at most one default label.
10. The default may be placed anywhere but usually placed at the end.
11. Nesting ( switch within switch ) is allowed
Example: using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
char grade = 'B';
switch (grade)
{
case 'A':Console.WriteLine("Excellent!");
break;
case 'B':
case 'C':Console.WriteLine("Well done");
break;
case 'D':Console.WriteLine("You passed");
break;
case 'F':Console.WriteLine("Better try again");
break;
default:Console.WriteLine("Invalid grade");
break;
50 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
Console.WriteLine("Your grade is {0}", grade);
Console.ReadLine();
}
}
}
Output: Well done
Your grade is B
Example: using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
int a = 100;int b = 200;
switch (a)
{
case 100:Console.WriteLine("This is part of outer switch ");
switch (b)
{
case 200:Console.WriteLine("This is part of inner switch ");
break;
}
break;
}
Console.WriteLine("Exact value of a is : {0}", a);
Console.WriteLine("Exact value of b is : {0}", b);
Console.ReadLine();
}
}
}
Output: This is part of outer switch
This is part of inner switch
Exact value of a is : 100
Exact value of b is : 200
CONDITIONAL LOOPING: Loop control statements are used to execute a block of code several
times until the given condition is true
Or
The looping control statements that enable the programmer to execute a set of statements repeatedly
till the required activity is completed are called looping control statements
TYPES OF LOOPING CONTROL STATEMENTS: The looping control statements are divided
into two types. They are
Entry controlled loop: In such type of loop, the test condition is checked first before the loop is
executed. Examples of Entry controlled loop are: for and while.

51 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Exit controlled loop: In such type of loop, the loop is executed first, then condition is checked, the
loop executed at least one time even the condition if false. Examples of exit controlled loop is do-
while.

For Loop: Repeats a block of code multiple times until a given condition is true. Initialization,
looping condition and update expression (increment/decrement) is part of for loop.
Syntax: for ( initialization; condition; increment/decrement )
{
statement(s);
}
Here is the flow of control in a for loop:
 The initialization is usually an assignment statement that sets the loop control variable. For
Example: i=1 and count=0 Here i, count are loop control variables
 Next, the condition is evaluated. If it is true, the body of the loop is executed. If it is false, the
body of the loop does not execute and flow of control jumps to the next statement just after
the for loop.
 After the body of the for loop executes, the flow of control jumps back up to the increment
statement. This statement allows you to update any loop control variables. This statement can
be left blank, as long as a semicolon appears after the condition.
 The condition is now evaluated again. If it is true, the loop executes and the process repeats
itself (body of loop, then increment step, and then again testing for a condition). After the
condition becomes false, the for loop terminates.

52 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example: using System;

namespace Loops
{
class Program
{
static void Main(string[] args)
{
for (int a = 10; a < 20; a = a + 1)
Console.WriteLine("value of a: {0}", a);
Console.ReadLine();
}
}
}
Output: value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19

Example: Write a program to print following output using for loop.

1
22
333
4444
55555
using System;
namespace Example2
{
   class Program
    {
      static void Main(string[] args)
       {

53 School of Computer Science & Engineering | RGMCET

 C# AND .NET

         int i,j;
       i=0;
         j=0;
          for (i = 1; i <= 5; i++)
          {
            for (j = 1; j <= i; j++)
             {
               Console.Write(i);
             }
            Console.Write("\n");
          }
         Console.ReadLine();
       }
    }
}
Example: using System;
namespace nested_loop
{
class Program
{
static void Main(string[] args)
{
int i, j;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= i; j++) //Nested for loop
{
Console.Write(j);
}
Console.Write("\n");
}
Console.ReadLine();
}
}
}

While Loop: A while loop repeats a statement or group of statements until a given condition is true.
It tests the condition before executing the loop body.
Syntax: while (condition)
{
statement(s);
}
Here is the flow of control in a while loop:
 while is keyword
 condition: The Test condition is evaluated and if the condition is true, then the body of the
loop is executed. After execution of the body, the test condition is once again evaluated and if

54 School of Computer Science & Engineering | RGMCET

 C# AND .NET

it is true, the body is executed once again. This process of repeated execution of the body
continues until the test condition is true. The test condition must be enclosed with in
parentheses.
 Body of the loop: The body of the loop may have one or more statements. The braces are
needed only if the body contains two or more statements.
Flow Diagram

Example: using System;

namespace Loops
{
class Program
{
static void Main(string[] args)
{
int a = 10;
while (a < 20)
{
Console.WriteLine("value of a: {0}", a);
a++;
}
Console.ReadLine();
}
}
}

Output: value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
Example: C# Program to Find Magnitude of Integer
using System;
class Program

55 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
public static void Main()
{
int num, mag=0;
Console.WriteLine("Enter the Number : ");
num = int.Parse(Console.ReadLine());
Console.WriteLine("Number: " + num);
while (num > 0)
{
mag++;
num = num / 10;
}
Console.WriteLine("Magnitude: " + mag);
Console.Read();
}
}
Do...While Loop: Similar to while loop, but it tests the condition at the end of the loop body. The
block of code inside do while loop will execute at least once even though the condition is false.
Syntax: do
{
statement(s);
}while( condition );
 Where do and while are two keywords.
 Here the body of the loop is executed first. At the end of the loop, the condition in the while
statement is evaluated. If the condition is true, the program continues to execute the body of
the loop once again. This process continues as long as the condition is true. When the
condition becomes false, the loop will be terminated and the control goes to the statements
that appears immediately after the while statement. Remember the body of the loop is always
executed at least once.
 There is semicolon at the end of while(condition); in do-while loop

Flow Diagram

Example: using System;

namespace Loops
56 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
class Program
{
static void Main(string[] args)
{
int a = 10;
do
{
Console.WriteLine("value of a: {0}", a);
a = a + 1;
} while (a < 20);
Console.ReadLine();
}
}
}
Output: value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
Nested Loops: C# allows to use one loop inside another loop. Following section shows few
examples to illustrate the concept.
Syntax: for ( init; condition; increment )
{
for ( init; condition; increment )
{
statement(s);
}
statement(s);
}
The syntax for a nested while loop statement in C# is as follows:
while(condition)
{
while(condition)
{
statement(s);
}
statement(s);
}
The syntax for a nested do...while loop statement in C# is as follows:
do
{
statement(s);
do
57 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
statement(s);
}while( condition );
}while( condition );
A final note on loop nesting is that you can put any type of loop inside of any other type of loop. For
example a for loop can be inside a while loop or vice versa.
Example: Write a program uses a nested for loop to find the prime numbers from 2 to 50
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
int i, j;
for (i = 2; i < 20; i++)
{
for (j = 2; j <= (i / j); j++)
if ((i % j) == 0) break;
if (j > (i / j))
Console.WriteLine("{0} is prime", i);
}
Console.ReadLine();
}
}
}
Output: 2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime
17 is prime
19 is prime

LOOP CONTROL STATEMENTS: A Loop control statement alters the normal execution path of
a program. Loop control statements are used when we want to skip some statements inside loop or
terminate the loop immediately when some condition becomes true.
Break Statement: When the break statement is encountered inside a loop, the loop is immediately
terminated and program control resumes at the next statement following the loop. It can be used to
terminate a case in the switch statement. If you are using break statement in nested loops (i.e., one
loop inside another loop), the break statement will stop the execution of the innermost loop and start
executing the next line of code after the block.
Syntax: break;
Flow Diagram:
58 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Example: using System;

namespace Loops
{
class Program
{
static void Main(string[] args)
{
int a = 10;
while (a < 20)
{
Console.WriteLine("value of a: {0}", a);
a++;
if (a > 14)
break;
}
Console.ReadLine();
}
}
}
Output: value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14

Continue Statement: The continue statement is used to skip some part(s) of loop's body. It means
We can use continue statement inside any loop (for, while and do-while). It skips the remaining
statements of loop's body and starts next iteration.
Syntax: continue;
Flow Diagram:

Example: using System;

namespace Loops
{
class Program
{
59 School of Computer Science & Engineering | RGMCET
 C# AND .NET

static void Main(string[] args)

{
int a = 10;
do
{
if (a == 15)
{
a = a + 1;
continue;
}
Console.WriteLine("value of a: {0}", a);
a++;
} while (a < 20);
Console.ReadLine();
}
}
}
Output: value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 16
value of a: 17
value of a: 18
value of a: 19
goto:
1. C# supports the “goto‟ statement to jump unconditionally from one point to another in the
program.
2. The goto requires a label in order to identify the place where the jump is to be made.
3. A label is any valid variable name and must be followed by a colon( : ).
4. The label is placed immediately before the statement where the control is to be transferred.
5. The label can be anywhere in the program either before or after the goto label statement.
6. During running of a program, when a statement like “goto begin;”is met, the flow of control
will jump to the statement immediately following the label “begin:” this happens
unconditionally.
7. goto‟ breaks the normal sequential execution of the program.
8. If the “label:” is before the statement “goto label;” a loop will be formed and some statements
will be executed repeatedly. Such a jump is known as a „backward jump‟.
9. If the “label:” is placed after the “goto label;” some statements will be skipped and the jump is
known as a “forward jump”.

60 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example: using System;

namespace Loops
{
class Program
{
static void Main(string[] args)
{
int i;
double number, average, sum=0.0;
for(i=1; i<=5; ++i)
{
Console.WriteLine("Enter a number:”);
number=double.Parse(Console.ReadLine());
if(number < 0.0)
goto jump;
sum += number; // sum = sum+number;
}
jump:
average=sum/(i-1);
Console.WriteLine ("Sum value is" +sum);
Console.WriteLine ("Average is" +average);
}
}
}
Infinite Loop: A loop becomes infinite loop if a condition never becomes false. We can make an
endless (or) infinite loop by leaving the conditional expression empty.
Example: using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
for (; ; )
Console.WriteLine ("Hey! I am Trapped");
}
}
}
ARRAYS: An array is a set of similar type values that are stored in sequential order.
Or
Array is a group of related data items that shares a common name.
Or
Array is collection of homogeneous data elements
In C# the array index starts at zero. That means the first item of an array starts at 0 th
61 School of Computer Science & Engineering | RGMCET
 C# AND .NET

position. The position of the last item of an array will totalnumber of items-1.so if an array has 10
items, the last 10th item is at 9th position.In C#, arrays can be declared as fixed length or dynamic.
Fixed length arrays: A fixed length array can store a predefined number of items.
Dynamic arrays: A dynamic array does not have a predefined size. The size of a dynamic
array increases as you add new items to the array.
 To access an element we can use array name and index value of the concern (or) particular
element.
 In c# arrays are reference types. Hence it stores default values based on data type.
Types of Arrays: C# .NET supports three types of arrays.
One-dimensional array: Arranging collection of elements in a single row can be called One-
dimensional array.
Or
A list of items can be given under single variable name using only one subscript is called single
subscripted variable (or) One-dimensional array.
All items in a single dimension array are stored contiguously starting from 0 to the size of the array-
1.
Declaration: Like other variables arrays must be declared before they are used. To declare an array
in C#, you can use the following syntax:
Syntax: datatype[] arrayName=new data type[size];
or
data type[] arrayname;
arrayname=new datatype[size];
or
int[] arrayname={list of values};
Where,
 data type- It is used to specify the type of elements in the array.
 [ ]- specifies subsciptinal operator.
 Size-specifies the size of the array.
 array name-specifies the name of the array.
 new-memory allocation operator.
Example: int[] a=new int[10];
Or
double[] balance;
balance=new double[5];
Initializing an Array: Once an array is declared, the next step is to initialize an array. The
62 School of Computer Science & Engineering | RGMCET
 C# AND .NET

initialization process of an array includes adding actual data to the array. Array is a reference type, so
you need to use the new keyword to create an instance of the array.
Example: You can assign values to the array at the time of declaration as shown:
double[] balance = { 2340.0, 4523.69, 3421.0};
Example: You can also create and initialize an array as shown:
int [] marks = new int[5]{ 99,98, 92, 97, 95};
Example: You may also omit the size of the array as shown:
int [] marks = new int[] { 99,98, 92, 97, 95};
You can copy an array variable into another target array variable. In such case, both the target and
source point to the same memory location (Both the array will have same values).
int [] marks = new int[] { 99,98, 92, 97, 95};
int[] score = marks;
When you create an array, C# compiler implicitly initializes each array element to a default value
depending on the array type. For example, for an int array all elements are initialized to 0.
Example: using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int [] n = new int[10];
int i,j;
for ( i = 0; i < 10; i++ )
n[ i ] = i + 100;
for (j = 0; j < 10; j++ )
Console.WriteLine("Element[{0}] = {1}", j, n[j]);
Console.ReadKey();
}
}
}
Output: Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Example: using System;
  namespace One_Dimensional_Array
63 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
   class Program
    {
      static void Main(string[] args)
       {
                 string[] Books = new string[5];
         Books[0] = "C#";
         Books[1] = "Java";
         Books[2] = "VB.NET";
         Books[3] = "C++";
         Books[4] = "C";
          Console.WriteLine(“Element of Books array is:\n\n");
                     int i = 0;
        Console.Write("\t1\t2\t3\t4\t5\n\n\t");
         for (i = 0; i < 5; i++)
          Console.Write("{0}\t", Books[i]);
                 Console.ReadLine();
       }
    }
}
foreach Loop: It is specially designed for accessing the value of an array (or) collection( list, hash-
table, stack, queue and linked list) where for each iteration of the loop one value of the array is
assigned to the loop variable and the return to us.
Syntax: foreach(type variable_name in expression)
{
Body of the loop;
}
Where,
 type-specifies the data type
 variable_name-specifies the array variable name.
 in- it is a keyword.
 expression - specifies array type or collection type.
Example: using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int [] n = new int[10];
for ( int i = 0; i < 10; i++ )
n[i] = i + 100;
foreach (int j in n )
{
int i = j-100;
Console.WriteLine("Element[{0}] = {1}", i, j);
i++;
}

64 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.ReadKey();
}
}
}
Output: Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Example: using System;
namespace store_value_in_array
{
class Program
{
static void Main(string[] args)
{
int i;
int[] arr = new int[5]; // 5 size array
for (i = 0; i < 5; i++)
{
Console.Write("\nEnter your number:\t");
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine("\n\n");
for (i = 0; i < 5; i++)
{
Console.WriteLine("you entered {0}", arr[i]);
}
Console.ReadLine();
}
}
}
Example: using System;
namespace accessing_array_value
{
class Program
{
static void Main(string[] args)
{
int[] age=new int[6];
string[] name = new string[6];
int i,j=0;
string find;
for (i = 0; i < 6; i++)
{
65 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Console.Write("\n\nEnter your name:\t");

name[i] = Console.ReadLine();
Console.Write("Enter your age:\t\t");
age[i] = Convert.ToInt32(Console.ReadLine());
}
Console.Write("\n\nEnter your name to find age:\t");
find = Console.ReadLine();
for (i = 0; i < 6; i++)
{
if (name[i] == find)
{
Console.WriteLine("\n\nName\t:{0}", name[i]);
Console.WriteLine("Age\t:{0}", age[i]);
j++;
}
}
if (j == 0)
{
Console.WriteLine("Not Found!!!");
}
Console.ReadLine();
}
}
}
Example: using System;
namespace forgetCode
{
class Program
{
public static void Main()
{
int n;
float large, small;
int[] a = new int[50];
Console.WriteLine("Enter the size of Array");
string s = Console.ReadLine();
n = Int32.Parse(s);
Console.WriteLine("Enter the array elements");
for (int i = 0; i < n; i++)
{
string s1 = Console.ReadLine();
a[i] = Int32.Parse(s1);
}
Console.Write("");
large = a[0];
small = a[0];
for (int i = 1; i < n; i++)
{
if (a[i] > large)
large = a[i];
66 School of Computer Science & Engineering | RGMCET
 C# AND .NET

else if (a[i] < small)

small = a[i];
}
Console.WriteLine("Largest element in the array is {0}", large);
Console.WriteLine("Smallest element in the array is {0}", small);
}
}
}
Example: C# Program to Convert Digits to Words
using System;
public class ConvertDigitsToWords
{
public static void Main()
{
int num;
int nextdigit;
int numdigits;
int[] n = new int[20];
string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven",
"eight","nine" };
Console.WriteLine("Enter the number");
num = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Number: " + num);
Console.Write("Number in words: ");
nextdigit = 0;
numdigits = 0;
do
{
nextdigit = num % 10;
n[numdigits] = nextdigit;
numdigits++;
num = num / 10;
} while(num > 0);
numdigits--;
for( ; numdigits >= 0; numdigits- -)
Console.Write(digits[n[numdigits]] + " ");
Console.WriteLine();
Console.ReadLine();
}
}
Two-Dimensional Arrays: The simplest form of the multidimensional array is the 2-dimensional
array. Arranging a set of values in rows and columns is called 2- dimensional array. In this all rows
must have equal number of elements.
A 2-dimensional array can be thought of as a table, which has x number of rows and
y number of columns. Following is a 2-dimensional array, which contains 3 rows and 4 columns:

67 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Thus, every element in the array a is identified by an element name of the form a[ i, j ], where a is the
name of the array, and i and j are the subscripts that uniquely identify each element in array a.
Declaration: Like other variables arrays must be declared before they are used. To declare an array
in C#, you can use the following syntax:
Syntax: datatype[,] arrayName=new data type[rows , columns];
or
data type[,] arrayname;
arrayname=new datatype[rows , columns];
or
int[,] arrayname={list of values};
Where,
 data type- It is used to specify the type of elements in the array.
 [ ]- specifies subsciptinal operator.
 rows-specifies the row size .
 column-specifies the column size .
 array name-specifies the name of the array.
 new-memory allocation operator.
Example: int[,] a=new int[10,5];
Or
double[,] balance;
balance=new double[5,5];
Initializing Two-Dimensional Arrays: Multidimensional arrays may be initialized by specifying
bracketed values for each row. The following array is with 3 rows and each row has 4 columns.
int [,] a = int [3,4] = { {0, 1, 2, 3} , /* initializers for row indexed by 0 */
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};
The following code creates two multi-dimensional arrays with no limit.
int[,] numbers = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
string[,] names = new string[,] { { "Rosy", "Amy" }, { "Peter", "Albert" } };
You can also omit the new operator as we did in single dimension arrays. You can assign these
values directly without using the new operator. For example:
int[,] numbers = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
string[,] names = { { "Rosy", "Amy" }, { "Peter", "Albert" } };
 We can also initialize the array items one item at a time. The following code is an example of
initializing array items one at a time.
 int[,] numbers = new int[3, 2];

68 School of Computer Science & Engineering | RGMCET

 C# AND .NET

numbers[0, 0] = 1;
numbers[1, 0] = 2;
numbers[2, 0] = 3;
numbers[0, 1] = 4;
numbers[1, 1] = 5;
numbers[2, 1] = 6;
Example: using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };
int i, j;
for (i = 0; i < 5; i++)
{
for (j = 0; j < 2; j++)
Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
}
Console.ReadKey();
}
}
}
Output: a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8
Jagged Array (or) arrays of arrays (or) dynamic arrays: Jagged array is collection rows which
contain distinct number of elements in each row that means all the rows may not contain same
number of elements.
Or
Jagged array is collection of one-dimensional arrays of varying size.
Declaration: Declaration of a jagged array involves two brackets.
type[][] array_name = new type[3][];
or
type[][] array_name={list of values};
Initialization: Before a jagged array can be used, its items must be initialized. The following code
snippet initializes a jagged array; the first item with an array of integers that has two integers, second

69 School of Computer Science & Engineering | RGMCET

 C# AND .NET

item with an array of integers that has 4 integers, and a third item with an array of integers that has 6
integers.
Example:
int[][] ar=={new int[]{1,2,3},new int[]{1,2,3,4},new int[]{1,2}};
type[][] array_name = new type[3][];
intJaggedArray[0] = new int[2]{2, 12};
intJaggedArray[1] = new int[4]{4, 14, 24, 34};
intJaggedArray[2] = new int[6] {6, 16, 26, 36, 46, 56 };
Example: example illustrates using a jagged array:
using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
/* a jagged array of 5 array of integers*/
int[][] a = new int[][]{{new int[]{0,0},new int[]{1,2},
new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };
int i, j;
/* output each array element's value */
for (i = 0; i < 5; i++)
{
for (j = 0; j <; 2; j++)
{
Console.WriteLine("a[{0}][{1}] = {2}",i, j, a[i][j]);
}
}
Console.ReadKey();
}
}
}
Output: a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8
Passing Arrays as Function Arguments: You can pass an array as a function argument in C#.For
this we follow the rules.
1. The function must be called by passing only the name of the array and the size of the array.
Syntax: max(a,n);

70 School of Computer Science & Engineering | RGMCET

 C# AND .NET

2. In the function definition, the formal parameter must be an array type; the size of the array does
not need to specified.
3. The function header might look like:
Syntax: float max(float[] array , int size)
using System;
namespace ArrayApplication
{
class MyArray
{
double getAverage(int[] arr, int size)
{
int i;double avg;int sum = 0;
for (i = 0; i < size; ++i)
sum += arr[i];
avg = (double)sum / size;
return avg;
}
static void Main(string[] args)
{
MyArray app = new MyArray();
int [] balance = new int[]{1000, 2, 3, 17, 50};
double avg;
/* pass pointer to the array as an argument */
avg = app.getAverage(balance, 5 ) ;
/* output the returned value */
Console.WriteLine( "Average value is: {0} ", avg );
Console.ReadKey();
}
}
}
Output: Average value is: 214.4
Variable argument list (or) Param Arrays: At times, while declaring a method, you are not sure of
the number of arguments passed as a parameter. C# param arrays (or parameter arrays) come into
help at such times.in C# we can define methods that can handle variable number of arguments is
called parameter arrays. Parameter arrays are declared using the keyword params.
Only one params keyword is allowed and no additional parameter is allowed after params keyword
in a function declaration.
Example: using System;
namespace ArrayApplication
{
class p
{
Public void show(params,int[] val)
{
for(int i=0;i<val.length;i++)

71 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Console.WriteLine(val[i]);
}
public static void Main(string[] args)
{
p p1=new p();
P1.show();
}
}
}
class TestClass
{
static void Main(string[] args)
{
ParamArray app = new ParamArray();
int sum = app.AddElements(512, 720, 250, 567, 889);
Console.WriteLine("The sum is: {0}", sum);
Console.ReadKey();
}
}
}
Output: The sum is: 2938
Array Class: The Array class is the base class for all the arrays in C#. Array Class is defined in the
System namespace. In C# every array is automatically derived from the System.Array class. The
Array class provides various properties and methods to work with arrays.
Properties of the Array Class: The following table describes some of the most commonly used
properties of the Array class:
S.No Property name Description
1 Length Gets a 32-bit integer that represents the total number of
elements in all the dimensions of the array.
2 Rank Gets the rank (number of dimensions) of the array.
3 IsFixedSize Gets a value indicating whether the array has fixed size.
4 IsReadOnly Gets a value indicating whether the array is read only
5 LongLength Gets a 64-bit integer that represents the total number of
elements in all the dimensions of the array.
Methods of the Array Class: The following table describes some of the most commonly used
methods of the Array
S.No Property name Description
1 Clear Sets the range of elements in the array to zero, to false,
(or) to null, depending on the element type.
2 Copy() Copies the range of elements from an array starting at the
first element and pastes them into another array
3 CopyTo() Copies all the elements of the current one dimensional
array to the specified one dimensional array starting at the
specified destination array index.
4 GetLenth Gets a 32-bit integer that represents the number of
elements in the specified dimension of the array.

72 School of Computer Science & Engineering | RGMCET

 C# AND .NET

5 GetLongLength Gets a 64-bit integer that represents the number of

elements in the specified dimension of the array.
6 GetLowerBound Get the lower bound of the specified dimension in the
array
7 GetUpperBound Get the Upper bound of the specified dimension in the
array
8 GetType Gets type of the current instance.
9 GetValue() Gets the value at the specified position in the one
dimensional array
10 IndexOf() Searches for the specified object and returns the index of
the first occurrence within the entire one dimensional
array.
11 Reverse() Reverses the sequence of the elements in the entire one
dimensional array.
12 SetValue() Sets a value to the element at the specified position in the
one dimensional array.
13 Sort() Sorts the elements in an entire one dimensional array.
Example: The following program demonstrates use of some of the methods of the Array class:
using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int[] list = { 34, 72, 13, 44, 25, 30, 10 };
int[] temp = list;
Console.Write("Original Array: ");
foreach (int i in list)
Console.Write(i + " ");
Console.WriteLine();
// reverse the array
Array.Reverse(temp);
Console.Write("Reversed Array: ");
foreach (int i in temp)
Console.Write(i + " ");
Console.WriteLine();
//sort the array
Array.Sort(list);
Console.Write("Sorted Array: ");
foreach (int i in list)
Console.Write(i + " ");
Console.WriteLine();
Console.ReadKey();
}
}
}
Output: Original Array: 34 72 13 44 25 30 10
Reversed Array: 10 30 25 44 13 72 34
Sorted Array: 10 13 25 30 34 44 72
73 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Example: Programming Examples of array class

using System;
namespace Array_Class
{
class Program
{
static void printarray(int[] arr)
{
Console.WriteLine("\nElements of array is:\n");
foreach (int i in arr)
{
Console.Write("\t{0}", i);
}
Console.WriteLine("\n");
}
static void Main(string[] args)
{
int[] arr1=new int[5]{43,25,33,14,5};
int[] arr2 = new int[5];
int len,rank;
bool fixedsize, read_only;
len = arr1.Length;
Console.WriteLine("Length:\t{0}", len);
rank = arr1.Rank;
Console.WriteLine("Rank:\t{0}", rank);
fixedsize = arr1.IsFixedSize;
Console.WriteLine("Fixed Size:\t{0}", fixedsize);
read_only = arr1.IsReadOnly;
Console.WriteLine("Read Only:\t{0}", read_only);
Array.Sort(arr1);
printarray(arr1);
Console.WriteLine("Get Length:\t{0}",arr1.GetLength(0));
Console.WriteLine("Get Value:\t{0}", arr1.GetValue(2));
Console.WriteLine("Get Index:\t{0}",Array.IndexOf(arr1, 33));
Array.Copy(arr1, arr2,5);
printarray(arr2);
Array.Clear(arr1, 0, 5);
printarray(arr1);
Console.ReadLine();
}
}
}

Example: Write a program of sorting an array. Declare single dimensional array and accept 5
integer values from the user. Then sort the input in ascending order and display output.
using System;
namespace Example1
{
class Program
74 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
static void printarray(int[] arr)
{
Console.WriteLine("\n\nElements of array are:\n");
foreach (int i in arr)
{
Console.Write("\t{0}", i);
}
}
static void Main(string[] args)
{
int[] arr = new int[5];
int i;
for (i = 0; i < 5; i++)
{
Console.Write("Enter number:\t");
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Program.printarray(arr);
Array.Sort(arr); //use array's sort function
Program.printarray(arr);
Console.ReadLine();
}
}
}
Differences between for and foreach loop:
S.No for foreach
1 Loop variable refers to the index of an Loop variable refers to the values of an array
array.
2 Loop variable is integer type The type of the loop variable is similar to the
type of values inside an array
3 It is used for both accessing and assigning It is used only for accessing.
values to an array
STRINGS: String represents sequence of characters. C# supports two types of strings.
 Mutable strings(dynamic strings)
 Immutable strings
Immutable strings: String objects are immutable, meaning that we cannot modify the characters
contained in them. String is alias for the predefined System.String class in the CLR, there are many
built in operations available that work with strings.
C# also supports regular expressions that can be used for complex string manipulations and pattern
matching.
Creating a String Object: C# supports a predefined reference type known as string. We can use
string to declare string type objects. You can create string object using one of the following methods:
 By assigning a string literal to a String variable

75 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 Copying from one object to another.

 Concatenating two objects.
 Reading from the keyword.
 Using ToString method.
By assigning a string literal to a String variable: The most common way to create a string is to
assign a quoted string of characters known as string.
Example: string S1;
S1=”abc”
(or)
string S1=”abc”;
COPYING STRINGS: we can also create new copies of existing strings. This can be done in two
ways.
 Using the assignment operator (=)
 Using the static copy method.
Example: string s2=s1;
string s2=string.Copy(s1);
both these statements would accomplish the same thing, namely, copying the contents of s1 into s2.
Concatenating strings: We may also create new strings by Concatenating existing strings. This can
be done in two ways.
 Using the overloaded operator (+)
 Using the static Concat method
Example: string s3=s1+s2;
string s3=string.Concat(s1,s2);
If s1=”abc” and s2=”xyz”, then both the statements will store the string “abcxyz” in s3.
Reading from the keyword: It is possible to read a string value interactively from the keyboard and
assign it to a string object.
string s=Console.ReadLine();
On reaching this statement, the computer will wait for a string of characters to be entered from the
keyboard. When the return key is pressed, the string will be read and assigned to the string object s.
Using ToString method: Another way of creating string is to call the ToString method on an object
and assign the result to a string variable.
int number=123;
string numStr=number.ToString();
The above statement convert the number123 to a string “123” and then assigns the string value to the
string variable numStr.
Verbatim Strings: String can also be created using verbatim strings. Verbatim strings are those that
start with the @ symbol. This symbol tells the compiler that the string should be used verbatim even
if it includes escape characters.

76 School of Computer Science & Engineering | RGMCET

 C# AND .NET

string s1= @”\EBG\Csharp\string.cs”;

In order to obtain the same output without using the symbol @, The input string should be written as
follows.
string s1= ”\\EBG\\Csharp\\string.cs”;
we may also use escape characters such as \n and \t in @-quoted strings. They will not be processed
during output.
It tells the compiler to ignore the escape character and line Breaks.
 @ symbol tells the compiler to ignore the escape character and line breaks.
Note: If ordinary string contains an embedded \n, the string that follows \n will be displayed on the
next line when the string is processed for output.
Methods for immutable strings:
S.No Method Operation
1 Compare() Compares two strings
2 CompareTo() Compared the current instance with another instance
3 ConCat() Concatenates two or more strings
4 Copy() Creates a new string by copying another
5 CopyTo() Copies a specified number of characters to an array of Unicode
characters
6 EndsWith() Determines whether the substring exists at the end of the string
7 Equals() Determines if two strings are equal
8 IndexOf() Returns position of first occurrence of a substring
9 Insert() Inserts a string at a specified position.
10 Join() Joins an array of strings together.
11 LastIndexOf() Returns the position of the last occurrence of a substring.
12 PadLeft() Left-aligns the string in a field.
13 PadRight() Right-aligns the string in a field.
14 Remove() Deletes characters from the string.
15 Replace() Replaces all instances of a character with a new character.
16 Split() Creates an array of strings by splitting the string at any occurrence of
one.
17 StartsWith() Determines whether the substring exists at the beginning of the string
18 SubString() Extracts a substring.
19 ToLower() Returns a lower case version of the string
20 ToUpper() Returns a upper case version of the string
21 Trim() Removes white space from the string.
22 TrimEnd() Removes a string of characters from the end of the string.
23 TrimStart() Removes a string of characters from the beginning of the string
Inserting Strings: We can insert the string at specified position using the Insert() method, which is
available in System.String class.
Example: using System;
class Stringmethod
{
public static void Main()
{
string s1=”lean”;

77 School of Computer Science & Engineering | RGMCET

 C# AND .NET

string s2=s1.Insert(3,”r”);
string s3=s2.Insert(5,”er”);
for(int i=0;i<s3.Length;i++)
{
Console.Write(s3[i]);
}
}
}
In the above program ,when the statement
string s2=s1.Insert(3,”r”);
is executed, the string variable s2 contains the string “Learn”. The string “r” is inserted in s1 after 3
characters. Similarly, the string “er” is inserted at the end of the string. Finally the variable s3
contains the value “Learner”.

Example: Take two inputs as string from the users and copies the input of string2 to string5 and
checks for the string3 ends with IDE or not. The program shows true if string3 ends with IDE.
Searches char ‘a’ from the string1.Insert hello in string6 at position 6 and shows the atring6.
using System;
namespace SearchString
{
class Program
{
public void Display()
{
string str1=””;
Console.Write(“Enter a string”);
str1=Console.ReadLine();
string str2=””;
Console.Write(“Enter another string”);
str2=Console.ReadLine();
string str3=”C# 2005 is developed in Visual Studio 2005IDE”;
Console.Write(“string str3 is {0}”,str3);
string str5=string.Copy(str2);
Console.Write(“ string str5 is copied from str2: {0}”,str5);
Console.Write(“ string str5 is {0} characters long:”,str5.Length);
Console.Write(“ the 10th character of string str3 is : {0}”,str3[9]);
Console.Write(“ string str3 {0} \n ends with IDE?:
{1}\n”,str3,str3.EndsWith(“IDE”));
Console.Write(“Ends with studio?:{0}”,str3.EndsWith(“studio”));
Console.Write(“\n the first time character ‘a’ occurred in string str1 at
position:{0}”,str1.IndexOf(“a”+1);
String str6=str2.Insert(6,”hello”);
Console.Write(“ ’hello’ is inserted in string str6.string str6 is noe:
{0}”,str6);
}
static void Main()

78 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Program prg=new Program();
Prg.Display();
}
}
}
Comparing Strings: String class supports overloaded methods and operators to compare whether
two strings are equal or not. They are
 Overloaded Compare() Method
 Overloaded Equals() Method
 Overloaded == operator
Compare() method: There are two versions of overloaded static Compare() method. The first one
takes two strings as parameters and compares them.
Example: int n=string.Compare(s1,s2);
This performs case-sensitive comparison and returns different integer values for different conditions
as under:
Zero , if s1 is equal to s2.
A positive integer(1), if s1>s2.
A negative integer(-1), if s1<s2.
s1=”hello”; s2=”hello”; s3=”csharp”; s4=”mello”
s1,s2=0
s2,s3=1
s3,s4=-1
Example: s1=”abc”
s2=”ABC”;
int n=string.Compare(s1,s2);
Output: n value is -1.
The second version of Compare () method takes an additional bool type parameter to decide whether
case should be ignored or not. If the bool parameter is true, case is ignored.
Example: int n = string.Compare(s1,s2,true);
Example: s1=”abc”
s2=”ABC”;
int n=string.Compare(s1,s2,true);
output: n value is 0.
Example: using System;
namespace StringApplication
{
class StringProg
{
static void Main(string[] args)
{
string str1 = "This is test";
string str2 = "This is text";
if (String.Compare(str1, str2) == 0)
79 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Console.WriteLine(str1 + " and " + str2 +" are equal.");

else
Console.WriteLine(str1+"and"+str2 + " are not equal.");
Console.ReadKey() ;
}
}
}
Output: This is test and this is text are not equal.
Equals() method: The string class supports an overloaded Equals method for testing the equality of
strings.There are again two versions of Equals method(case sensitive).
If, s1=”abc”;
s2=”ABC”;
bool b1=s2.Equals(s1);
bool b1=string.Equals(s2,s1);
These methods return a Boolean value true if s1 and s2 are equal, otherwise false.
The == operator: A simple and natural way of testing the equality of strings is by using overloaded
== operator.
Example: bool b3= (s1==s2); //b3 is true if they are equal.
Or
If(s1==s2)
Console.Write(“equal”);
Finding substrings: It is possible to extract substrings from a given string using the overloaded
Substring method available in String class. There are two versions of Substring:
s.Substring(n): It extract substrings from the nth position to the last character of the string contained
in s.
s.Substring(n1,n2):It extracts a substring from s beginning at n1 position and ending at n2 position.
Examples: string s1=”NEW YORK”;
string s2=s1.Substring(5);
string s3=s1.Substring(0,3);
string s4=s1.Substring(5,8);
When the above statements are executed, the string variables will contain the following substrings
s2:YORK
s3:NEW
s4:YORK

Mutable strings: string objects are mutable, meaning strings are modifiable. Mutable strings are
created using StringBuilder class.
Example: StringBuilder str1=new StringBuilder(“abc”);//with initial size of three
characters
StringBuilder str2=new StringBuilder(); //empty string
The string object str1 is created with an initial size of three characters and str2 is created as an empty
string. They can grow dynamically as more characters are added to them.

80 School of Computer Science & Engineering | RGMCET

 C# AND .NET

The StringBuilder class supports many methods that are useful for manipulating dynamic strings.
StringBuilder mehods:
S.No Method Operation
1 Append() Appends a string
2 AppendFormat() Appends string using specific format
3 EnsureCapacity() Ensure sufficient size
4 Insert() Insert a string at a specified position
5 Remove() Removes the specified characters
6 Replace() Replaces all instances of a character with a specified one.
C# also supports some special functions known as properties.
StringBuilder properties:
S.No Method Operation
1 Capacity To retrieve or set the number of characters the object can hold
2 Length To retrieve or set the length
3 MaxCapacity To retrieve the maximum capacity of the object
4 [] To get or set a character at a specified position.
The System.Text namespace contained the StringBuilder class and therefore we must include the
using System.Text directive for creating and manipulating mutable strings.
Example: using System.Text; using System;
class StringBuilderMethod
{
public static void Main()
{
StringBuilder s=new StringBuilder(“object”);
Console.WriteLine(“original string:”+s);
Console.WriteLine(“length:”+s.Length);
s.Append(“language”);
Console.WriteLine(“String now:”+s);
s.Insert(7,”oriented”);
Console.WriteLine(“modified string:+s);
int n=s.Length;
s[n-1]=’!’;
Console.WriteLine(“”final string:”+s);
}
}
Output: original string: object
Length : 7
String now: object language
Modified string: object oriented language
Final string: object oriented language!
Example: program to accept two string inputs from users and appends the first string to a predefined
value. Using StringBuilder class, a string value is inserted in the string. Then, all spaces in first are
replaced with * and the program calculates the length of two strings after appending.
Arrays of strings: The statement
string[] itemarray=new string[3];
the above will create itemarray of size 3 to hold three strings. we can assign the strings to the

81 School of Computer Science & Engineering | RGMCET

 C# AND .NET

itemarray element by element using 3 different statements (or) using for loop.
string[] itemarray={”a”,”b”,”c”};
Example: using System;
class Strings
{
public static void Main()
{
string[] countries={“india”,”Germany”,””America”,”France”};
int n=countries.Length;
Array.Sort(countries);
for(int i=0;i<n;i++)
Console.WriteLine(countries[i]);
Array.Reverse(countries);
for(int i=0;i<n;i++)
Console.WriteLine(countries[i]);
}
}
Regular expressions: Regular expressions provide a powerful tool for searching and manipulating a
large text. A regular expression may be applied to a text to accomplish tasks such as.
 To locate substrings and return them.
 To modify one (or) more substrings and return them.
 To identify substrings that begins with (or) ends with a pattern of characters.
 To find all words that begins with a group of characters and end with some other characters.
 To find all occurrences of a substring.
A regular expression is a string containing two types of characters.
Literals: These are characters that we wish to search and match in the text.
Metacharacters: These are special characters that give commands to the regular expression parser.
Examples:
S.No Expression Meaning
1 “\bm” Any word beginning with m
2 “er\b” Any word ending with er
3 “\BX\B” Any X in the middle of the word
4 “\bm\S*er\b” Any word beginning with m and ending with er.
5 “|,” Any word separated by a space or a comma
In the above table ,\b,\B,\S* and | are metacharacters and m, er, X and comma are literals.
The .NET framework provides support for regular expression matching and replacement. The
namespace System.Text.RegularExpressions support a number of classes that can be used for
searching, matching and modifying a text document. The important classes are
 Regex
 MatchCollection
 Match
Example: using System;
82 School of Computer Science & Engineering | RGMCET
 C# AND .NET

using System.Text;
using System.Text.RegularExpressions;
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);
}
}
Output: 1:amar
2:akbar
3:antony
4:are
5:friends
STRUCTURES: Structure is collection of data items of different type.
Or
A structure is a collection of heterogeneous data elements
 Structures are similar to classes in C#.
 In C# structure is a value type data type.
Defining a Structure: To define a structure, you must use the struct keyword.
Syntax: struct struct_name
{
Data member1;
Data member2;
Data member3;
}
Or
struct struct_name
{
Data member1;
Data member2;
Data member3;
};

Example: struct Books

{
public string title;
public string author;
public string subject;
}
83 School of Computer Science & Engineering | RGMCET
 C# AND .NET

In the above code the keyword struct declares Books as a new data type that can hold three variables
of different data types. These variables are known as members or elements.
Declaring structure variables: we can declare structure variables using the structure-tag in the
program. A structure variable declaration is similar to the declaration of variables of any other data
types. It includes the following elements.
 The structure tag name
 List of variable names separated by commas
 A terminating semicolon
Syntax: structure_tag structure_var1, structure _var2,........structure _varN;
Example: Books book1,book2,book3;
Each one of the variables has three members as specified by the template.
Assigning values to structure members: Structure members can be accessed using the simple dot
notation.
Syntax: structurevariablename.structuremember= value;
Example: book1.title=”c#”;
book1.author=”raja”;
book1.subject=”c sharp”;
Copying Structure Variables Two variables of the same structure type can be copied the same way
as ordinary variables. If person1 and person2 belongs to the same structure, then the fallowing
assignment operations are valid:
person1 = person2; ------ assigns person1 to person2
person2 = person1; ------ assigns person2 to person1
Note:
1. we can also use the operator new to create stricture variables
Syntax: struct-tag structure-variable=new struct-tag();
Example: books b1=new books();
2. Structure members are by default private and therefore cannot be accessed outside the
structure definition.
Example: The following program shows the use of the structure:
using System;
struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
};
public class testStructure
{
public static void Main(string[] args)
{
Books Book1;

84 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Books Book2;
Book1.title = "C Programming";
Book1.author = "Nuha Ali";
Book1.subject = "C Programming Tutorial";
Book1.book_id = 6495407;
Book2.title = "Telecom Billing";
Book2.author = "Zara Ali";
Book2.subject ="Telecom Billing Tutorial";
Book2.book_id = 6495700;
Console.WriteLine( "Book 1 title : {0}", Book1.title);
Console.WriteLine("Book 1 author : {0}", Book1.author);
Console.WriteLine("Book 1 subject : {0}", Book1.subject);
Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);
Console.WriteLine("Book 2 title : {0}", Book2.title);
Console.WriteLine("Book 2 author : {0}", Book2.author);
Console.WriteLine("Book 2 subject : {0}", Book2.subject);
Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);
Console.ReadKey();
}
}
Output: Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700
Example: The following program shows the use of the structure:
using System;
namespace Structure
{
class Program
{
struct book
{
public string bookname;
public int price;
public string category;
}
static void Main(string[] args)
{
book language, database;
Console.Write("Enter book name:\t");
language.bookname = Console.ReadLine();
Console.Write("Enter book price:\t");
language.price=Convert.ToInt32(Console.ReadLine());
Console.Write("Enter book category:\t");
language.category = Console.ReadLine();
Console.Write("\n\nEnter book name:\t");
85 School of Computer Science & Engineering | RGMCET
 C# AND .NET

database.bookname = Console.ReadLine();
Console.Write("Enter book price:\t");
database.price=Convert.ToInt32(Console.ReadLine());
Console.Write("Enter book category:\t");
database.category = Console.ReadLine();
Console.Write("\n\n===================");
Console.Write("\n\t\tLanguage\n");
Console.Write("===================\n\n");
Console.Write("BookName:\t{0}",language.bookname);
Console.Write("\nBook Price:\t{0}", language.price);
Console.Write("\nBook Category:\t{0}", language.category);
Console.Write("\n\n==================\n");
Console.Write("\t\tDatabase\n");
Console.Write("====================\n\n");
Console.Write("BookName:\t{0}",database.bookname);
Console.Write("\nBookPrice:\t{0}",database.price);
Console.Write("\nBookCategory:\t{0}",database.category);
Console.ReadLine();
}
}
}
Output: Enter book name : C Sharp
Enter book price : 34
Enter book category : Object Oriented Programming
Enter book name : SQL Server
Enter book price : 23
Enter book category: Database Programming
=============================================
Language
=============================================
Enter book name : C Sharp
Enter book price : 34
Enter book category: Object Oriented Programming
=============================================
Database
=============================================
Enter book name : SQL Server
Enter book price : 23
Enter book category : Database Programming
Structures with methods: we have seen that values may be assigned to the data members using
structure_variable and the dot operator. We can also assign values to the data members using what
are known as constructors.
A constructor is a method which is used to set values of data members at the time of
declaration.
Example: struct Number
{
int number; // data member

86 School of Computer Science & Engineering | RGMCET

 C# AND .NET

public Number(int value) // constructor

{
number=value;
}
}
The constructor method has the same name as structure-tag and declared as public.the constructor is
invoked as follows.
Number n1=new Number(100);
The above statement creates a structure object n1 and assigns the value of 100 to its only data
member number. C# does not support default constructor.
Example: using System;
struct Rectangle
{
int a,b;
public Rectangle(int x, int y);
{
a=x;
b=y;
}
public int Area()
{
return (a*b);
}
public void display()
{
Console.WriteLine(“Area=”+Area());
}
}
class TestRectangle
{
public static void Main()
{
Rectangle rect=new Rectangle(10,20);
rect.display();
}
}
Nested structures: Structure inside the structure is called nested structure.
Syntax: struct employee
{
public string name;
public int code;
public struct salary
{
public double basic;
public double allowance;
}
}

87 School of Computer Science & Engineering | RGMCET

 C# AND .NET

We can also use Structure variables as members of another Structure.

struct M
{
public int x;
}
struct N
{
public int y;
public M m;
};
Class versus Structure: Classes and Structures have the following basic differences:
class Structure

1 classes are reference types struts are value types

2 classes are stored on heap struts are stored on stack
3 Classes support inheritance Structures do not support inheritance
4 Permit initialization of instance fields Do not Permit initialization of instance fields
5 Classes supports default constructor structures do not support default constructor
6 Classes supports destructors Structures do not support destructors
7 Default value is NULL Default value is zero
8 It copies the reference It copies the value.
Example: using System;
struct Books
{
private string title;
private string author;
private string subject;
private int book_id;
public void getValues(string t, string a, string s, int id)
{
title = t;
author = a;
subject = s;
book_id = id;
}
public void display()
{
Console.WriteLine("Title : {0}", title);
Console.WriteLine("Author : {0}", author);
Console.WriteLine("Subject : {0}", subject);
Console.WriteLine("Book_id :{0}", book_id);
}
};
public class testStructure
{
public static void Main(string[] args)

{
Books Book1 = new Books(); /* Declare Book1 of type Book */
Books Book2 = new Books(); /* Declare Book2 of type Book */
88 School of Computer Science & Engineering | RGMCET
 C# AND .NET

/* book 1 specification */
Book1.getValues("C Programming", "Nuha Ali","C Programming
Tutorial",6495407);
/* book 2 specification */
Book2.getValues("Telecom Billing", "Zara Ali", "Telecom Billing
Tutorial", 6495700);
/* print Book1 info */
Book1.display();
/* print Book2 info */
Book2.display();
Console.ReadKey();
}
}
Output: Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700
Features of C# Structures: The C# structures have the following features:
 Structures can have methods, fields, indexers, properties, operator methods, and events.
 Structures can have defined constructors, but not destructors. However, you cannot define a
default constructor for a structure.
 Structures cannot inherit other structures or classes. Structures cannot be used as a base for
other structures or classes.
 A structure can implement one or more interfaces.
 Structure members cannot be specified as abstract, virtual, or protected.
 When you create a struct object using the new operator, it gets created and the appropriate
constructor is called. structs can be instantiated without using the New operator.
 If the New operator is not used, the fields remain unassigned and the object cannot be used
until all the fields are initialized.
Enumerationas: Enumerated Types allow us to create our own symbolic names for a list of related
ideas. It is defined as
Syntax: enum Identifier{Value 1,value 2,…..value n};
Example: enum shape
{
Circle;
Square;
Triangle;
}
Or
89 School of Computer Science & Engineering | RGMCET
 C# AND .NET

enum shape
{
Circle;
Square;
Triangle;
};
enum: It is the keyword which allows the user to create our own symbolic names for a list of ideas.
Identifier: It is the name of enumerated data type
Example: enum day{mon,tue,wed….sun};

The compiler automatically assign integer digits beginning with 0 to all enumeration constants, that
is value1=0,value2=1……however the programmer can change the default values.
enum day{ mon=0,tue=10,wed=20...sun=15};
Example: The following example demonstrates use of enum variable:

using System;
namespace EnumApplication
{
class EnumProgram
{
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
static void Main(string[] args)
{
int WeekdayStart = (int)Days.Mon;
int WeekdayEnd = (int)Days.Fri;
Console.WriteLine("Monday: {0}", WeekdayStart);
Console.WriteLine("Friday: {0}", WeekdayEnd);
Console.ReadKey();
}
}
}
Output: Monday: 1
Friday: 5
Enumerator initialization: As mentioned earlier, by default, the value of the first enum number is
set to 0, and that of each subsequent member is incremented by one. However we may assign
specific values for different members.
Example: enum Days
{
Sun=1;
Mon=3;
Sat=5;
}
We can also have expressions.
Example: enum Days
{
Sun=1;
90 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Mon=Mon+3;
Sat=Sun+Mon+5;
}
If the declaration of an enum member has no initializer, then its value is set implicitly as follows.
Example: enum Alphabet
{
A,
B=5,
C,
D=20,
E
}
Output: A=0
B=5
C=6
D=20
E=21
Enumerator base types: By default, The type of an enum is int .However, we can declare explicitly
a base type for each enum.The valid base types are: byte, sbyte, short, ushort, int, uint, long and
ulong.
Example: enum Position:byte
{
Off;
On:
}
The values assigned to the members must be within the range of values that can be represented by
the base type.
Enumerator type conversion: enum types can be converted to their base types and back again with an
explicit conversion using a cast .
Example: enum values
{
Value0;
Value1;
Value2;
}
--------
--------
Values u1=(Values) 1;
int a=(int) u1;
Example: using system
class Enumtype
{
enum Direction
{
North,
East==10,

91 School of Computer Science & Engineering | RGMCET

 C# AND .NET

West,
South
}
public static void Main()
{
Direction d1=0,
Direction d2= Direction.East;
Direction d3= Direction.West;
Direction d4= (Direction)12;
Console.WriteLine(“d1=”+d1);
Console.WriteLine(“d2=”+(int)d2);
Console.WriteLine(“d3=”+d3);
Console.WriteLine(“d4=”+d4);
}
}
Output: d1=North
d2=10
d3=West
d4=South
Example: write a c# program which stores values in two enumerations, Staff and Company. It
uses two functions to display the data contained in Staff and Company enumerations.
using system;
enum Staff { Directors, Managers, Executives }
enum Company
{
Newsoftltd,
Technologieslnc,
Hillrockltd
}
class program
{
public static void Show(staff st)
{
switch(st)
{
case staff.Directors: Console.WriteLine(“you are a director”);
break;
case staff.Managers: Console.WriteLine(“you are a manager”);
break;
case staff.Executives: Console.WriteLine(“you are a executive”);
break;
default: break;
}
}
public static void CompDisplay(Company com)
{
switch(st)
{
case Company. Newsoftltd: Console.WriteLine(“Newsoftltd”);
break;
92 School of Computer Science & Engineering | RGMCET
 C# AND .NET

case Company.Technologieslnc: Console.Write(“Technologieslnc”);

break;
case Company. Hillrockltd: Console.WriteLine(“Hillrockltd”);
break;
default: break;
}
}
static void Main()
{
Staff st;
st=Staff.Directors;
Console.WriteLine(“this is an example of enumeration”);
Show(st);
Company com;
com=Company.Newsoftltd;
Console.Write(“Director belongs to Company:”);
CompDisplay(com);
}
}

UNIT II
93 School of Computer Science & Engineering | RGMCET
 C# AND .NET

C# is true object oriented programming language. All object oriented languages employ three core
principles, namely
 Encapsulation
 Abstraction
 Inheritance
 Polymorphism
These are often referred as pillars (or) building blocks of oop.
Encapsulation (or) data hiding (or) information hiding: Encapsulation is the process of
hiding irrelevant data from the user . The outside users may not be able to change the state of an
object directly. However, the state of an object may be altered indirectly using the access modifier
keywords public, private and protected. To understand encapsulation, consider an example of
mobile phone. Whenever you buy a mobile, you don’t see how circuit board works. You
are also not interested to know how digital signal converts into analog signal and vice
versa. These are the irrelevant information for the mobile user, that’s why it is
encapsulated inside a cabinet.
Inheritance: It is the concept we use to build new classes using the existing class definitions. The
original class is known as base (or) parent class and the modified one is known as derived class (or)
subclass (or) child class. Inheritance provides the reusability of existing code and thus improves
integrity of programs and productivity of programmers.
Polymorphism: It is the ability to take more than one form. For example, an operation may exhibit
different behaviour in different situations. The behaviour depends upon the types of data used in the
operation. for example, an addition operation involves two numeric values will produce a sum and
same addition operation will produce a string if the operands are string values instead of numbers.
Abstraction: Abstraction is just opposite of Encapsulation. Abstraction is mechanisim to show only
relevent data to the user . Consider the same mobile example again. Whenever you buy a mobile
phone,you see their different types of functionality as camera, mp3, player, calling function,
recording function, multimedia, etc. It is abstraction, because you are seeing only relevant
information instead of their internal enginnering.
CLASSES: It is a collection of objects.
Or
A class is a blueprint of an object that contains variables for storing data and functions to
perform operations on the data. 
Or

94 School of Computer Science & Engineering | RGMCET

 C# AND .NET

A class is a collection of member variables and member functions.

A class will not occupy any memory space and hence it is only a logical representation of data.
Defining a Class: A class definition starts with the keyword class followed by the class name; and
the class body enclosed by a pair of curly braces. Following is the general form of a class definition:
class class_name
{
Variable declaration;
Methods declaration;
}
 Class is keyword
 Class name is any C# valid identifier.
 Everything inside the square brackets is called body of the class .
Example: class class_name
{
}
In the above class body is empty, this class does not contain any properties and therefore cannot do
anything.
Adding variables: data is encapsulated in a class by placing the data fields inside the body of the
class definition. These variables are called instance variables because they are created whenever an
object of the class is instantiated. We can declare the instance variables exactly the same way as we
declare local variables.
Example: class Rectangle
{
int length;
int width;
}
The class Rectangle contains two integer type instance variables. Remember these variables are only
declared and therefore no storage space has been created in the memory. Instance variables are also
known as member variables.
Adding methods: methods are declared inside the body of the class, usually after the declaration of
instance variables.
Syntax: type methodname(parameter_list)
{
Method-body;
}
The method body actually describes the operations to be performed on the data.
Example: class Rectangle
{
int length;
int width;
public void GetData(int x,int y)
{

95 School of Computer Science & Engineering | RGMCET

 C# AND .NET

length=x;
width=y;
}
}
Note that the method has a return type void because it does not return any value. We pass two integer
values to the method, which are then assigned to the instance variables length and width. The
GetData() method is basically added to provide values to the instance variables. Now we are able to
use directly length and width inside the method.
Example: class Rectangle
{
int length;
int width;
public void GetData(int x,int y)
{
length=x;
width=y;
}
public int RectArea()
{
int area=length*width;
return area;
}
}
The method RectArea() computes the area of the rectangle and returns the result.
Member access modifiers: C# provides a set of access modifiers that can be used with the members
of a class to control their visibility to outside users.
Modifier Accessibility control
private Private members of a class are completely restricted and are
accessible only within the class in which  they are declared.
public Member is accessible from anywhere outside the class as well. It is accessible in
derived classes.
protected Member is visible only its own class and its derived classes
internal Member is available with in the assembly that is being created and not
accessible in outside namespace
Protected Available in the containing program or assembly and in the derived classes.
internal (outside the namespace)
In C# all members have private access by default. If we want a member to have any other visibility
range, then we must specify a suitable access modifier to it individually.
Example: class Visibility
{
public int x;
internal int y;
protected double d;
float p;
}
Local variables: The variables which are declared within the method is called local variables.

96 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example: public void print()

{
int a; // local variable
string s; // local variable
}
Instance variable: The variables which are created within the class are called instance variables.
Example: class abc
{
private int a; // Instance variable
private string s; // Instance variable
}
Note: when the local variable name and instance variable name is same then default the importance
is given to local variables.
Object: An object is an instance of a class
Creating objects: Object in c# is created using the new operator .the new operator creates an object
of the specified class and returns a reference to that object.
Syntax: classname object=new classname();
Example: Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle();
Accessing class members: Now we have created objects, each containing its own set of variables,
we should assign values to these variables in order to use them in our program. Since we are outside
the class, we cannot access the instance variables and the methods directly. To do this, we must use
the concerned object and dot operator.
Syntax: objectname.variablename;
objectname.methodname(parameter-list);
Where,
 Objectname: It is the name of the object.
 Variablename: It is the name of the instance variable inside the object that we wish to
access.
 Methodname: It is the name of the method we wish to call.
 parameter-list: It is a comma separated list actual values that must match in type and number
with the parameter-list of the method name declared in the class.
The instance variables of the rectangle class may be accessed and assigned value as follows.
rect1.length=15;
rect1.width=10;
rect2.length=20;
rect2.width=12;
Another way of assigning values to the instance variables is to use a method that is declared inside a
class. Here the method GetData can be used to do this work. We can call the GetData method on any
Rectangle object to set the values of both length and width.

97 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example: Rectangle rect1 = new Rectangle();

rect1.GetData(15,10);
Example: using System;
class Rectangle
{
int length;
int width;
public void GetData(int x,int y)
{
length=x;
width=y;
}
public int RectArea()
{
int area=length*width;
return area;
}
}
Class RectangleArea
{
public static void Main()
{
int area1,area2;
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle();
rect1.length=15;
rect1.width=10;
area1= rect1.length* rect1.width;
rect2.GetData(20,12);
area2=rect2.RectArea();
Console.WriteLine(Area1=”+area1);
Console.WriteLine(Area2=”+area2);
}
}
Example: using System;
namespace BoxApplication
{
class Box
{
public double length; // Length of a box
public double breadth; // Breadth of a box
public double height; // Height of a box
}
class Boxtester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
98 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Volume of Box1 : {0}",volume);
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Output: Volume of Box1 : 210
Volume of Box2 : 1560
Main(): as mentioned earlier, C# programs start execution at a Main() method. This method must be
static method of a class and must have either int or void return type.
public static int Main()
public static void Main()
The Main() method can also have parameters which may receive values from the command line at
the time execution.
public static int Main(string[] args)
public static void Main(string[] args)
METHOD: A method is a self-contained block of code that performs a particular task. Every C#
program has at least one class with a method named Main.
Defining Methods (or) declaring methods: methods are declared inside the body of the class,
normally after the declaration of data fields.
Syntax:
< Access modifier > <Return Type> <Method Name> (Parameter List)
{
Method Body
}
Where,
Method name: Method name is a valid c# identifier and it is case sensitive. It cannot be same as any
other identifier declared in the class.
Parameter list: Enclosed between parentheses, the parameters are used to pass and receive data
from a method. The parameter list refers to the type, order, and number of the parameters of a
method. Parameters are optional; that is, a method may contain no parameters.
Method body: This contains the set of instructions needed to complete the required activity and
method body can be enclosed in curly braces.
Return type: Return type specifies the type of value the method will return. If the method is not
returning any values, then the return type is void.
Access modifier: This determines the visibility of a variable or a method from another class.

99 School of Computer Science & Engineering | RGMCET

 C# AND .NET

List of Method Modifiers:

Modifier Description
new The method hides an inherited method with the same signature.
public The method can be accessed from anywhere, including outside the class
protected The method can be accessed 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 from 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 does not 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
classes which inherit from this class. Must be used in conjunction with override.
extern This method is implemented externally, in a different language.
Invoking or Calling Methods: once methods have been defined, they must be activated for
operations. The process of activating a method is known as invoking (or) calling. You can call a
method using dot operator.
Syntax: objectname.methodname(actual-parameterlist);
Here, object name is the name of the object on which we are calling the method.
The actual parameter list is a comma separated list of actual values that must match in type, order
and number with formal parameter list method declared in class
Example: using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
static void Main(string[] args)
{
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
ret = n.FindMax(a, b);
Console.WriteLine("Max value is : {0}", ret );

100 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.ReadLine();
}
}
}
Output: Max value is : 200
Example:
using System;
namespace CalculatorApplication
{
class Method
{
int Cube(int x)
{
return (x*x*x);
}
}
class MethodTest
{
static void Main(string[] args)
{
Method M = new Method();
int y=M.Cube(5);
Console.WriteLine("y” );
}
}
}
Output: Max value is: 125
Nesting of methods: we have earlier that a method can be called only by an object of that class if it
is called outside the class. We can also called a method without using any object or dot operator. That
is, a method can be called only its name by another method of the same class. This is known as
nesting of methods.
Example: using System;
class nesting
{
void largest(int m,int n)
{
int large=Max(m,n);
Console.WritLine(large);
}
int Max(int a, int b)
{
int x=(a>b)?a:b;
return x;
}
}
class nesttesting
{
public static void Main()
101 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
nesting next=new nesting();
next.largest(100,200);
}
}
Method parameters:
 Input parameters: Input parameters are used for bringing a value into the method for
execution.
 Value parameters: Value parameters are used for passing parameters into methods by value.
 Reference parameters: Reference parameters are used to pass parameters into methods by
reference.
 Output parameters: Output parameters are used to pass results back from a method.
 Parameter arrays: Parameter arrays are used in a method definition to enable it to receive
variable number of arguments when called.
Parameters Passing Methods: There are three ways that parameters can be passed to a method.
Passing Parameters by Value: In this type value of actual arguments are passed to the formal
arguments of the called function. Any changes made in the formal arguments does not effect the
actual arguments in the calling function.
Or
In call by value method, the value of the variable is passed to the function as parameter.
The value of the actual parameter cannot be modified by formal parameter.
Different Memory is allocated for both actual and formal parameters. Because, value of
actual parameter is copied to formal parameter.
Example:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(int x, int y)
{
int temp;
temp = x;
x = y;
y = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
int a = 100;
int b = 200;

102 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.WriteLine("Before swap, value of a : {0}", a);

Console.WriteLine("Before swap, value of b : {0}", b);
n.swap(a, b);
Console.WriteLine("After swap, value of a : {0}", a);
Console.WriteLine("After swap, value of b : {0}", b);
Console.ReadLine();
}
}
}
Output: Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200
It shows that there is no change in the values though they had changed inside the function.
Passing Parameters by Reference: In call by reference, the address of actual arguments is passed to
formal arguments of the called function and any change made to the formal arguments in the called
function have effect on the values of actual arguments in the calling function
Or
In call by reference method, the address of the variable is passed to the function as parameter.
The value of the actual parameter can be modified by formal parameter.
Same memory is used for both actual and formal parameters since only address is used by
both parameters
You can declare the reference parameters using the ref keyword.
Example:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(ref int x, ref int y)
{
int temp;
temp = x;
x = y;
y = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
int a = 100;
int b = 200;
Console.WriteLine("Before swap, value of a : {0}", a);
Console.WriteLine("Before swap, value of b : {0}", b);
n.swap(ref a, ref b);
Console.WriteLine("After swap, value of a : {0}", a);

103 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.WriteLine("After swap, value of b : {0}", b);

Console.ReadLine();
}
}
}
Output: Before swap, value of a : 100
Before swap, value of b : 200
After swap, value of a : 200
After swap, value of b : 100
It shows that the values have changed inside the swap function and this change reflects in the Main
function.
Passing Parameters by Output: Output parameters are used to pass results back to the calling
method. This is achieved by declaring the parameters with an out keyword. Output parameters are
similar to reference parameters, except that they transfer data back to the calling method.
Example:
using System;
namespace CalculatorApplication
{
class output
{
public void quare(int x,out int y )
{
y=x*x;
}
static void Main(string[] args)
{
int m;
square(10, out m);
Console.WriteLine("m="+m);
Console.ReadLine();
}
}
}
Output: m=100
Example:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValue(out int x )
{
int temp = 5;
x = temp;
}
static void Main(string[] args)
{

104 School of Computer Science & Engineering | RGMCET

 C# AND .NET

NumberManipulator n = new NumberManipulator();

int a = 100;
Console.WriteLine("Before method call, value of a : {0}", a);
n.getValue(out a);
Console.WriteLine("After method call, value of a : {0}", a);
Console.ReadLine();
}
}
}
Output: Before method call, value of a : 100
After method call, value of a : 5
The variable supplied for the output parameter need not be assigned a value. Output parameters are
particularly useful when you need to return values from a method through the parameters without
assigning an initial value to the parameter. Go through the following example, to understand this:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValues(out int x, out int y )
{
Console.WriteLine("Enter the first value: ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Enter the second value: ");
y = Convert.ToInt32(Console.ReadLine());
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
int a , b;
n.getValues(out a, out b);
Console.WriteLine("After method call, value of a : {0}", a);
Console.WriteLine("After method call, value of b : {0}", b);
Console.ReadLine();
}
}
}
Output: Enter the first value:7
Enter the second value:8
After method call, value of a : 7
After method call, value of b : 8
Example: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace ConsoleApplication7
{

105 School of Computer Science & Engineering | RGMCET

 C# AND .NET

class Rectangle
{
public void swap(int x,int y,out int h, out int k)
{
int temp;
temp = x;
x = y;
y = temp;
h = x;
k = y;
}
static void Main(string[] args)
{
Rectangle n = new Rectangle();
int a = 100;
int b = 200; int d, c;
Console.WriteLine("Before swap, value of a : {0}", a);
Console.WriteLine("Before swap, value of b : {0}", b);
n.swap(a,b,out d,out c);
Console.WriteLine("After swap, value of a : {0}", d);
Console.WriteLine("After swap, value of b : {0}", c);
Console.ReadLine();
}
}
}
Variable argument list (or) Param Arrays: At times, while declaring a method, you are not sure of
the number of arguments passed as a parameter. C# param arrays (or parameter arrays) come into
help at such times.in C# we can define methods that can handle variable number of arguments is
called parameter arrays. Parameter arrays are declared using the keyword params.
Example:
using System;
namespace ArrayApplication
{
class ParamArray
{
public int AddElements(params int[] arr)
{
int sum = 0;
foreach (int i in arr)
sum += i;
return sum;
}
}
class TestClass
{
static void Main(string[] args)
{
ParamArray app = new ParamArray();
106 School of Computer Science & Engineering | RGMCET
 C# AND .NET

int sum = app.AddElements(512, 720, 250, 567, 889);

Console.WriteLine("The sum is: {0}", sum);
Console.ReadKey();
}
}
}
Output: The sum is: 2938
Recursive Method Call: A method can call itself. This is known as recursion. Following is an
example that calculates factorial for a given number using a recursive function:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
int result;
if (num == 1)
return 1;
else
{
result = factorial(num - 1) * num;
return result;
}
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
Console.WriteLine("Factorial of 6 is : {0}", n.factorial(6));
Console.WriteLine("Factorial of 7 is : {0}", n.factorial(7));
Console.WriteLine("Factorial of 8 is : {0}", n.factorial(8));
Console.ReadLine();
}
}
}
Output: Factorial of 6 is: 720
Factorial of 7 is: 5040
Factorial of 8 is: 40320
Method overloading: C# allows us to create more than one method with same name, but with
different parameter list and different definitions. This is called method overloading. Method
overloading is used when methods are required to perform similar tasks but using different input
parameters. Overloaded methods must differ in number and/or type of parameters they take. This
enables the compiler to decide which one of the definitions to execute depending on the type and
number of arguments in the method call.
Example: using System;
using System.Collections.Generic;
107 School of Computer Science & Engineering | RGMCET
 C# AND .NET

using System.Text;
  namespace ConsoleApplication3
{
     class Method_overloading
     {
        public int Addition(int a, int b)
         {
            int x;
             return x=a+b;
         }
         public int Addition(int a, int b,int c)
         {
             int y;
             return y = a + b+ c;
         }
         public float Addition(float a, float b)
         {
             float u;
            return u = a + b;
         }
         public float Addition(float a, float b, float c)
         {
             float v;
             return v = a + b+ c;
         }
     }
class hub
{
public static void Main(String[] args)
{
Method_overloading mthover = new Method_overloading();
Console.WriteLine("Addition of two integers::::::::::::::::" + mthover.Addition(2, 5));
Console.WriteLine("Addition of two double type values::::::" + mthover.Addition(0.40f, 0.50f));
Console.WriteLine("Addition of three integers::::::::::::::" + mthover.Addition(2, 5, 5));
Console.WriteLine("Addition of three double type values:" + mthover.Addition(0.40f, 0.50f, 0.60f));
Console.ReadLine();
}
}
}

C# CONSTRUCTORS: constructor is a special type of method which is automatically executed

when the object is created. A constructor has exactly the same name as that of the class name and it
does not have any return type. Constructors are responsible for object initialization and memory
allocation of its class. If we create any class without constructor, the compiler will automatically
create one default constructor for that class. The default constructor initializes all numeric fields in
the class to zero and all string and object fields to null. 
Some of the key points regarding the Constructor are:
108 School of Computer Science & Engineering | RGMCET
 C# AND .NET

 A class can have any number of constructors.

 A constructor doesn't have any return type, not even void.
 A static constructor cannot be a parameterized constructor.
 Within a class you can create only one static constructor
Types of Constructors: Basically constructors are 5 types those are
1. Default Constructor
2. Parameterized Constructor
3. Copy Constructor
4. Static Constructor
5. Private Constructor
Default Constructor: A constructor without any parameters is called a default constructor; in other
words this type of constructor does not take parameters. The drawback of a default constructor is that
every instance of the class will be initialized to the same values and it is not possible to initialize
each instance of the class to different values. The default constructor initializes.
1. All numeric fields in the class to zero.
2. All string and object fields to null.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample() // Default Constructor
{
param1 = "Welcome";
param2 = "Aspdotnet-Suresh";
}
}
class Program
{
static void Main(string[] args)
{
Sample obj=new Sample();
Console.WriteLine(obj.param1);
Console.WriteLine(obj.param2);
Console.ReadLine();
}
}
}
Output: Welcome
Aspdotnet-Suresh

109 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Example:
using System;
namespace LineApplication
{
class Line
{
private double length;
public Line()
{
Console.WriteLine("Object is being created");
}
public void setLength( double len )
{
length = len;
}
public double getLength()
{
return length;
}
static void Main(string[] args)
{
Line line = new Line();
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Result: Object is being created
Length of line : 6
Parameterized Constructors: A constructor with at least one parameter is called as parameterized
constructor. The advantage of a parameterized constructor is that you can initialize each instance of
the class to different values.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample(string x, string y
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)

110 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Sample obj=new Sample("Welcome","Aspdotnet-Suresh");
Sample obj1=new Sample("Welcome1","Aspdotnet-Suresh1");
Console.WriteLine(obj.param1 +" to "+ obj.param2);
Console.WriteLine(obj1.param1 +" to "+ obj1.param2);
Console.ReadLine();
}
}
}
Output: Welcome to Aspdotnet-Suresh
Welcome1 to Aspdotnet-Suresh1
Copy Constructor: The constructor which creates an object by copying variables from another
object is called a copy constructor. Main purpose of copy constructor is to initialize new object to the
values of an existing object. Here the copy constructor contains a parameter, which is of class type.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample(string x, string y)
{
param1 = x;
param2 = y;
}
public Sample(Sample obj) // Copy Constructor
{
param1 = obj.param1;
param2 = obj.param2;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj = new Sample("Welcome", "Aspdotnet-Suresh");
Sample obj1=new Sample(obj);
Console.WriteLine(obj1.param1 +" to " + obj1.param2);
Console.ReadLine();
}
}
}
Output: Welcome to Aspdotnet-Suresh
Static Constructor: A static constructor is used to initialize any static data (or) to perform a
particular action that needs to be performed once only. static constructor will be invoked only once
for all the objects of the class. Static constructor gets called when the first object of the class is
created.
111 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Importance points of static constructor

 Static constructor will not accept any parameters because it is automatically called by CLR.
 Static constructor will not have any access modifiers.
 Static constructor will execute automatically whenever we create first instance of class
 Only one static constructor will allowed in the class.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
static Sample()
{
Console.WriteLine("Static Constructor");
}
public Sample()
{
param1 = "Sample";
param2 = "Instance Constructor";
}
}
class Program
{
static void Main(string[] args)
{
// Here Both Static and instance constructors are invoked for first instance
Sample obj=new Sample();
Console.WriteLine(obj.param1 + " " + obj.param2);
// Here only instance constructor will be invoked
Sample obj1 = new Sample();
Console.WriteLine(obj1.param1 +" " + obj1.param2);
Console.ReadLine();
}
}
}
Output: Static Constructor
Sample Instance Constructor
Sample Instance Constructor
Private Constructor: You can also create a constructor as private. When a class contains
at least one private constructor, then it is not possible to create an instance for the
class. Private constructor is used to restrict the class from being instantiated when it
contains every member as static. 
Important points of private constructor
 One use of private construct is when we have only static member.

112 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 Once we provide a constructor that is either private or public or any, the compiler will not
allow us to add public constructor without parameters to the class.
 If we want to create object of class even if we have private constructors then we need to have
public constructor along with private constructor
Example: using System;
namespace ConsoleApplication3
{
public class Sample
{
public string param1, param2;
public Sample(string a,string b)
{
param1 = a;
param2 = b;
}
private Sample() // Private Constructor Declaration
{
Console.WriteLine("Private Constructor with no prameters");
}
}
class Program
{
static void Main(string[] args)
{
// Here we don't have chance to create instace for private constructor
Sample obj = new Sample("Welcome","to Aspdotnet-Suresh");
Console.WriteLine(obj.param1 +" " + obj.param2);
Console.ReadLine();
}
}
}
Output: Welcome to Aspdotnet-Suresh
Note: In above method we can create object of class with parameters will work fine. If create object
of class without parameters it will not allow us create.
// it will works fine
Sample obj = new Sample("Welcome","to Aspdotnet-Suresh");
// it will not work because of inaccessability
Sample obj=new Sample();
Example: using System;
namespace defaultConstractor
{
     public class Counter
   {
         private Counter()   //private constrctor declaration
     {
     }
        public static int currentview;
         public static int visitedCount()
113 School of Computer Science & Engineering | RGMCET
 C# AND .NET

     {
             return ++ currentview;
     }
   }
     class viewCountedetails
   {
         static void Main()
     {
             // Counter aCounter = new Counter();   // Error
             Console.Write("Private constructor example ");
             Console.WriteLine();
       Counter.currentview = 500;
       Counter.visitedCount();
Console.WriteLine(" view count is: {0}",
Counter.currentview();
             Console.ReadLine();
     }
   }
}
Constructor Overloading: The process of creating more than one constructor with same name,
which is similar to class name, but with different parameters is called constructor overloading.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample() // Default Constructor
{
param1 = "Hi";
param2 = "I am Default Constructor";
}
public Sample(string x, string y)
// Declaring Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj= new Sample(); // Default Constructor will Called
Sample obj1=new Sample("Welcome","Aspdotnet-Suresh");
// Parameterized Constructor will Called
Console.WriteLine(obj.param1 + ", "+obj.param2);
Console.WriteLine(obj1.param1 +" to " + obj1.param2);
Console.ReadLine();
114 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
}
Output: Hi, I am Default Constructor
Welcome to Aspdotnet-Suresh
C# DESTRUCTORS: A destructor is a special method that is automatically executed when an
object is destroyed. A destructor has exactly the same name as that of the class name with a prefixed
tilde (~) and without return a value and without access specifier. Destructor can be very useful for
releasing memory resources before exiting the program. Destructors cannot be inherited or
overloaded.
Example: using System;
namespace LineApplication
{
class Line
{
private double length;
public Line()
{
Console.WriteLine("Object is being created");
}
~Line()
{
Console.WriteLine("Object is being deleted");
}
public void setLength( double len )
{
length = len;
}
public double getLength()
{
return length;
}
static void Main(string[] args)
{
Line line = new Line();
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
}
}
}
Output: Object is being created
Length of line : 6
Object is being deleted
STATIC CONCEPTS:
Static Classes: C# provides the feature to create static classes. There are two main features of static
classes
 We cannot create object for static classes
115 School of Computer Science & Engineering | RGMCET
 C# AND .NET

 Static classes contain only static members

The main benefit to create a static class is we do not need to make any instance of the class and all
members of the class be accessed by class name followed by class property (or) method dot and
followed by (i.e. class name).A static class can be created using static keyword.
The features of a static class are as follows:
 static classes can only contain static members.
 static classes cannot be instantiated.
 static classes are sealed and therefore cannot be inherited.
 static classes cannot contain Instance Constructors .
Example: using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication8
{
public static class Square
{
public static double side;
public static double Perimeter()
{
return side * 4;
}
public static double Area()
{
return side * side;
}
}
public class Exercise
{
public static void Main()
{
Square.side = 36.84;
Console.WriteLine("Square Characteristics");
Console.Write("Side: ");
Console.WriteLine(Square.side);
Console.Write("Perimeter: ");
Console.WriteLine(Square.Perimeter());
Console.Write("Area: ");
Console.WriteLine(Square.Area());
}
}
}
Output: Square Characteristics
Side: 36.84
Perimeter: 147.36
Area: 1357.1856

116 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Static Members: The members of a class that can be accessed without creating an
instance and directly by using class name are called as static members.  
Static variable:  a variable that is declared by using a static modifier (or) a variable
that is declared inside of any static block is called static variable.
Example: class MySettings
{
public static int height;
public static int width = 20;
}
a static variable is get initialized immediately once the execution of class starts.
A static variable is initialized one time in the life cycle of the class.
A static variable of the class can be accessed using the class name.
Static Methods: A method that is declared by using a static modifier is called static
method. When a method is declared as static then that method can access only other
static members available in the class and it is not possible to access instance members
static int max(int x, int y);
Example: using system;
namespace example
{
class mathoperation
{
public static float mul(float x, float y)
{
return x*y;
}
public static float divide(float x, float y)
{
return x/y;
}
}
class mathapplication
{
public static void Main()
{
float a=mathoperation.mul(4.0f,5.0f);
float b=mathoperation.divide(a,2.0f);
Console.WriteLine(“b=”+b);
}
}
}
Example: using system;
namespace example
{
class MySettings

117 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
private static int height = 100;
private static int width = 150;
public static void MyMethod()
{
Console.WriteLine("{0},{1}", height, width);
}
}
class AllSettings
{
public static void Main()
{
MyClass.MyMethod();
}
}
Example: using system;
namespace Static_var_and_fun
{
class number
{
// Create static variable
public static int num;
//Create static method
public static void power()
{
Console.WriteLine("Power of {0} = {1}", num, num * num);
}
}
class Program
{
static void Main(string[] args)
{
Console.Write("Enter a number\t");
number.num = Convert.ToInt32(Console.ReadLine());
number.power();
}
}
}
CONSTANTS: constants are immutable values which are known at compile time and do not change
for the life of the program. Constants are declared using const modifier.
 The const modifier is used to declare constant variables that cannot be changed.
 Constant variables must be given initial values when they are declared.
public cons int size=100;
 The behaviour of const variable is similar to static variable, except const variable cannot be
modified.
Example: using System;

118 School of Computer Science & Engineering | RGMCET

 C# AND .NET

namespace UsingConst
{
class Program
{
const int a = 10;
static void Main(string[] args)
{
const int b = 20;
const int c = b + a;
Console.WriteLine(c);
Console.ReadLine();
}
}
}
readonly variable: A readonly field can be initialized either at the time of declaration or with in the
constructor of same class. Therefore, readonly fields can be used for run-time constants.
Only values are assigned to readonly fields,then those must be same throughout the application.
Example: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication8
{
class SampleClass
{
public int x;
// Initialize a readonly field
public readonly int y = 25;
public readonly int z;
public SampleClass()
{
// Initialize a readonly instance field
z = 24;
}
public SampleClass(int p1, int p2, int p3)
{
x = p1;
y = p2;
z = p3;
}
static void Main()
{
SampleClass k1 = new SampleClass(11, 21, 32);
Console.WriteLine("k1:x={0},y={1},z={2}",p1.x,p1.y,p1.z);
SampleClass k2 = new SampleClass();
k2.x = 55;
Console.WriteLine("k2:x={0},y={1},z={2}",p2.x,p2.y,p2.z);
}

119 School of Computer Science & Engineering | RGMCET

 C# AND .NET

}
}
this reference: The this keyword refers to the current instance of the class. This reference is
available within all the member methods and always refers to the current instance. It is used to
distinguish local and instance variables that have the same name.
Example: using System;
class Demo
{
int a=2,b=10;
public void Get()
{
int a=23,b=34;
Console.WriteLine("a={0} b={1}",this.a,this.b);
Console.WriteLine("It is the class variable");
Console.WriteLine("Now the local variables are:");
Console.WriteLine("a={0} b={1}",a,b);
}
}
class MainClass
{
static void Main(string args[])
{
Demo d= new Demo();
d.Get();
}
}
Nesting of classes: To define a class within the scope of another class is called nesting of classes.
Syntax: public class outer
{
……..
……..
public class inner
{
…….
…….
}
}
Example: using System;
namespace innerclassexample
{
public class nestedclass
{
public static void Main()
{
outerclass obj2=new outerclass();
obj2.show();
outerclass.innerclass obj1=new outerclass.innerclass();
obj1.display();

120 School of Computer Science & Engineering | RGMCET

 C# AND .NET

}
}
Public class outerclass
{
public void show()
{
Console.WriteLine(“outer class”);
}
public class innerclass
{
public void display()
{
Console.WriteLine(“innerclass class”);
}
}
}
INHERITANCE: One of the most important concepts in object-oriented programming is
inheritance.
Creating a new class from existing class is called as inheritance
(Or)
Acquiring (taking) the properties of one class into another class is called inheritance. 
(Or)
When a new class needs same members as an existing class, then instead of creating
those members again in new class, the new class can be created from existing class,
which is called as inheritance.
Main advantage of inheritance is reusability of the code. During inheritance, the class
that is inherited is called as base class and the class that does the inheritance is called
as derived class.
Base class: is the class from which features are to be inherited into another class.
Syntax: class base-class-name
{
           Members of class
}
Derived class: it is the class in which the base class features are inherited.
Syntax: class derived-class-name: base-class-name
{
           Members of class
}
Types of inheritance: Inheritance can be classified into 5 types
1. Single Inheritance
2. Hierarchical Inheritance
3. Multi-Level Inheritance
121 School of Computer Science & Engineering | RGMCET
 C# AND .NET

4. Hybrid Inheritance
5. Multiple Inheritance
Single Inheritance: when a single derived class is created from a single base class then
the inheritance is called as single inheritance.

Syntax: class A
{
----
----
}
class B:A
{
----
----
}
Example: using System;
namespace InheritanceApplication
{
class a
{
public void display()
{
System.Console.WriteLine("hahahaha");
}
}
class b : a //b is child of a
{
public void display1()
{
System.Console.WriteLine("hihihih");
}
}
class c
{
public static void Main()
{
b x=new b();//Normally object of child
x.display();
x.display1();
}
}
}
Example: using System;
namespace InheritanceApplication
122 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
Rect.setWidth(5);
Rect.setHeight(7);
Console.WriteLine("Total area: {0}",Rect.getArea());
Console.ReadKey();
}
}
}
Output: Total area: 35
Hierarchical Inheritance: when more than one derived class are created from a single
base class, then that inheritance is called as hierarchical inheritance.

Syntax: class A
{
----
----
}
class B:A
{
----
----

123 School of Computer Science & Engineering | RGMCET

 C# AND .NET

}
class C:A
{
----
----
}
Example: C# Program to Illustrate Hierarchical Inheritance
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Inheritance
{
class Program
{
static void Main(string[] args)
{
Principal g = new Principal();
g.Monitor();
Teacher d = new Teacher();
d.Monitor();
d.Teach();
Student s = new Student();
s.Monitor();
s.Learn();
Console.ReadKey();
}
class Principal
{
public void Monitor()
{
Console.WriteLine("Monitor");
}
}
class Teacher : Principal
{
public void Teach()
{
Console.WriteLine("Teach");
}
}
class Student : Principal
{
public void Learn()
{
Console.WriteLine("Learn");
}
}
}
}
124 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Multi-Level Inheritance: when a derived class is created from another derived class,
then that inheritance is called as multi-level inheritance.

Syntax: class A
{
----
----
}
class B:A
{
----
----
}
class C:B
{
----
----
}
Example: C# Program to Illustrate Multilevel Inheritance.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication8
{
class a
{
public void display()
{
Console.WriteLine("hahahaha");
}
}
class b : a //b is child of a
{
public void display1()
{
Console.WriteLine("hihihih");
}
}
class d : b //d is child of b
{
public void display2()
{
Console.WriteLine("hohohohoh");
}
125 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
class c
{
public static void Main()
{
d x = new d();//Normally object of child
x.display();
x.display1();
x.display2();
}
}
}
Hybrid Inheritance: Any combination of single, hierarchical and multi-level
inheritances is called as hybrid inheritance.

Multiple Inheritance: when a derived class is created from more than one base class
then that inheritance is called as multiple inheritance.

But multiple and hybrid inheritance is not supported by .net using classes and can be
done using interfaces.
POLYMORPHISM: Polymorphism means one name many forms (ability to take more than one
form). In Polymorphism poly means “multiple” and morph means “forms” so polymorphism means
many.In polymorphism we will declare methods with same name and different parameters in same
class or methods with same name and same parameters in different classes. Polymorphism has ability
to provide different implementation of methods that are implemented with same name.
Types of polymorphism:
 Compile Time Polymorphism(or)Early Binding (or) Overloading (or) static binding
 Run Time Polymorphism(or)Late Binding (or) Overriding (or) dynamic binding
Static Polymorphism: The mechanism of linking a function with an object during compile time is
called early binding. It is also called static binding. C# provides two techniques to implement static
polymorphism. They are:
1. Function (or) method overloading
2. Constructor overloading.
126 School of Computer Science & Engineering | RGMCET
 C# AND .NET

3. Operator overloading

Function (or) method Overloading: The process of creating more than one method in a
class with same name is called as method overloading. The definition of the function must
differ from each other by the types and/or the number of arguments in the argument list.
Example: using System;
namespace PolymorphismApplication
{
class Printdata
{
void print(int i)
{
Console.WriteLine("Printing int: {0}", i );
}
void print(double f)
{
Console.WriteLine("Printing float: {0}" , f);
}
void print(string s)
{
Console.WriteLine("Printing string: {0}", s);
}
static void Main(string[] args)
{
Printdata p = new Printdata();
p.print(5);
p.print(500.263);
p.print("Hello C++");
Console.ReadKey();
}
}
}
Output: Printing int: 5
Printing float: 500.263
Printing string: Hello C++
Example: using System;
namespace MethodOverloadingByManishAgrahari
{
class Program
{
public class TestOverloading
{
public void Add(string a1, string a2)
{
Console.WriteLine("Adding Two String :" + a1 + a2);
}
public void Add(int a1, int a2)

127 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Console.WriteLine("Adding Two Integer :" + a1 + a2);
}
}
static void Main(string[] args)
{
TestOverloading obj = new TestOverloading();
obj.Add("Manish " , "Agrahari");
obj.Add(5, 10);
Console.ReadLine();
}
}
}
Constructor Overloading: The process of creating more than one constructor with same name,
which is similar to class name, but with different parameters is called constructor overloading.
Example: using System;
namespace ConsoleApplication3
{
class Sample
{
public string param1, param2;
public Sample() // Default Constructor
{
param1 = "Hi";
param2 = "I am Default Constructor";
}
public Sample(string x, string y)
// Declaring Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj= new Sample(); // Default Constructor will Called
Sample obj1=new Sample("Welcome","Aspdotnet-Suresh");
// Parameterized Constructor will Called
Console.WriteLine(obj.param1 + ", "+obj.param2);
Console.WriteLine(obj1.param1 +" to " + obj1.param2);
Console.ReadLine();
}
}
Output: Hi, I am Default Constructor
Welcome to Aspdotnet-Suresh
OPERATOR OVERLOADING: This is something very much similar to the concept of method

128 School of Computer Science & Engineering | RGMCET

 C# AND .NET

overloading. Operator overloading allows us to define multiple behaviours of an operator. In operator

overloading the behaviour of an operator changes according to the operands types which we use in
an expression.
For example ‘+’ is an overloaded operator, which can be used for both addition as well as
concatenation. It works as addition operator when the operator used between numeric operands and
works as concatenation operator when the operator used between string operands.
We can also add new behaviour to any existing operators by defining operator method.
Syntax: public static returntype operator op(argumentslist)
{
Method body
}
Where,
 They must be defined as public and static.
 Return type specifies the type of result we are expecting when the operator is used between
two operands..
 Operator is a keyword which represents the operator method for overloading.
 Op is an any overloadable operator.
 The argument list is the list of arguments passed.
Example:
Unary minus:Public static bank operator –(bank b)
{
Method body
}
Vector addition (Binary operator): Public static Vector operator +(Vector x ,Vector y)
{
Method body
}
Comparison Operator: Public Static Vector operator ==(Vector x,Vector y)
{
Method body
}
Overloadable Operators:
Operators that can be overloaded in c# as shown below:

Non Overloadable Operators: 

Operators that can not be overloaded in C# as shown below:

129 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Unary operator overloading: In case of unary operators, the argument must be the same type as
that of enclosing class or struct
Example: using System;
class bank
{
int x;
int y;
public bank(int a, int b)
{
x = a;
y = b;
}
public bank()
{
}
public void display()
{
Console.Write(" " + x);
Console.Write(" " + y);
Console.WriteLine();
}
public static bank operator -(bank b)
{
b.x = -b.x;
b.y = -b.y;
return b;
}
}
class program
{
public static void Main()
{
bank ba1 = new bank(10,-20);
ba1.display();
bank ba2 = new bank();
ba2.display();
ba2 = -ba1;
ba2.display();
Console.ReadLine();
}

}
Output: 10 -20
1 0
-10 20
130 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Example: using System;

namespace OperatorOvlApplication
{
class calculation
{
   int a, b, c;
   public calculation(int x, int y, int z)
   {
     a = x;
     b = y;
     c = z;
   } 
   public static calculation operator ++(calculation op1)
   {
     op1.a++;
     op1.b++;
     op1.c++;
     return op1;
   }
   public void ShowTheResult()
   {
     Console.WriteLine(a + "," + b + "," + c);
     Console.ReadLine();
   }
}
class Program
{
     static void Main(string[] args)
   {
         calculation i = new calculation(10, 20, 30);
         i++;
     i.ShowTheResult();
         Console.WriteLine();
   }
}
Output: 11,21,31
Binary operator overloading: In case of binary operators, the argument must be the same type as
that of enclosing class or struct.
Example: using System;
namespace binary_overload
{
class complexNumber
{
int x;
double y;
public complexNumber(int real, double imagnary)
{
x = real;
y = imagnary;
131 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
public complexNumber()
{
}
public static complexNumber operator +(complexNumber c1,
complexNumber c2)
{
complexNumber c = new complexNumber();
c.x=c1.x+c2.x;
c.y=c1.x-c2.y;
return c;
}
public void show()
{
Console.Write(x);
Console.Write("+j"+y);
Console.WriteLine();
}
}
class Program
{
static void Main(string[] args)
{
complexNumber p, q, r;
p = new complexNumber(10, 2.0);
q = new complexNumber(20, 15.5);
r = p + q;
Console.Write("p=");
p.show();
Console.Write("q=");
q.show();
Console.Write("r=");
r.show();
Console.ReadLine();
}
}
}
Output: p=10+j2
Q=20+j15.5
R=30+j-5.5
Example: using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
public double getVolume()
{
132 School of Computer Science & Engineering | RGMCET
 C# AND .NET

return length * breadth * height;

}
public void setLength( double len )
{
length = len;
}
public void setBreadth( double bre )
{
breadth = bre;
}
public void setHeight( double hei )
{
height = hei;
}
// Overload + operator to add two Box objects.
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
}
class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}", volume);
// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);
// Add two object as follows:
Box3 = Box1 + Box2;
// volume of box 3
volume = Box3.getVolume();
133 School of Computer Science & Engineering | RGMCET
 C# AND .NET

Console.WriteLine("Volume of Box3 : {0}", volume);

Console.ReadKey();
}
}
}
Output: Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400
Comparison operator overloading: There are six comparison operators that can be considered in
three pairs:
 == and !=
 < and <=
 and >=
Example: using System;
namespace comparison
{
class Vector
{
int x, y, z;
public Vector(int p, int q, int r)
{
x = p;
y = q;
z = r;
}
public static bool operator ==(Vector v1, Vector v2)
{
if (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z)
return (true);
else
return (false);
}
public static bool operator !=(Vector v1, Vector v2)
{
return (!(v1 == v2));
}
}
class comparison
{
static void Main()
{
Vector v1 = new Vector(10, 20, 30);
Vector v2 = new Vector(40, 50, 60);
if (v1 == v2)
Console.WriteLine("v1 and v2 both are Equal");
else
Console.WriteLine("v1 and v2 are not equal");
if (!(v1 == v2))
Console.WriteLine("true");
else
Console.WriteLine("false");

134 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.ReadLine();
}
}
}
Output: v1 and v2 are not equal
Dynamic Polymorphism (or) Run time polymorphism (or) late binding (or) method overriding:
The process of re-implementing the parent class method under the child class with same name and
same signature is called method overriding. Method overriding means same method names with
same signatures in different classes. In this run time polymorphism or method overriding we can
override a method in base class by creating similar function in derived class this can be achieved by
using inheritance principle and using “virtual & override” keywords. In base class if we declare
methods with virtual keyword then only we can override those methods in derived class
using override keyword.
Syntax: class A
{
public virtual void show()
{
---
---
}
}
class B:A
{
public override void show()
{
----
----
}
}
Notes:
1. Overriding virtual method of parent class under child class is only optional for child classes.
2. When a method overrides under the child class. The object of the child class gives the
preference to local method and invokes the method it has overridden, but not the virtual
method of parent.
3. Using the base keyword we can invoke the virtual method of the parent class from child class
after overriding. Using the base keyword in the static blocks is not possible.
Example: using System;
namespace OperatorOvlApplication
{
public class Bclass
{
public virtual void Sample1()

135 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Console.WriteLine("Base Class");
}
}
// Derived Class
public class DClass : Bclass
{
public override void Sample1()
{
Console.WriteLine("Derived Class");
}
}
// Using base and derived class
class Program
{
static void Main(string[] args)
{
// calling the overriden method
DClass objDc = new DClass();
objDc.Sample1();
// calling the base class method
Bclass objBc = new BClass();
objBc.Sample1();
}
}
}
Output: Derived Class
Base Class
Example: using System;
namespace methodoverriding
{
class Program
{
static void Main(string[] args)
{
employee obj = new employee();
obj.display();
Console.ReadLine();
}
}
public class cls
{
public virtual void display()
{
Console.WriteLine("hello");
}
}
public class employee : cls
{
public override void display()
136 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
Console.WriteLine("welcome");
}
}
}

Example: using System;

namespace PolymorphismApplication
{
class super
{
protected 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("super y=" +y);
}
}
class Tester
{
static void Main(string[] args)
{
sub s1= new sub(100,200);
s1.display();
Console.ReadKey();
}
}
}
Output: super x=100
Sub y=200

DIFFERENCES BETWEEN OVERLOADING AND OVERRIDING:

137 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Overloading Overriding
It is implementing multiple method with same It is implementing multiple method with same
name and different signature name and same signature
This can be performed in one single class as This can be performed only in child class
parent/child classes also.
To overload a parent class method under child To override a parent class method under child
class we do not need any permission from class we require an explicit permission from
parent parent
This is all about providing multiple behaviour This is all about changing the behaviour of the
to a method. method.

METHOD HIDING (OR) SHADOWING: This is another approach for re-implementing a parent
class method under child class even if they are not declared as virtual that re-implementation is
performed without parent class permission.This can be done using new keyword .The compiler hides
the function (or) method of base class.
Syntax: class A
{
public void show()
{
---
---
}
}
class B:A
{
public new void show()
{
----
----
}
}
Example: using System;
namespace App
{
class base
{
public void display()
{
Console.WriteLine(“base method”);
}
}
class derived:base
{
public new void display()
{

138 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Console.WriteLine(“derived method”);
}
}
class test
{
public static void Main()
{
derived d=new derived();
d.display();
}
}
Output: derived method
Note: we can hide an inherited member using new, new does not remove the member, its only makes
the member inaccessible in the derived class.
ABSTRACT CLASS: In c sharp Abstract class is defined using "abstract" keyword. When a class
contains at least one abstract method, then the class must be declared as  abstract class.
If an Abstract class contain any abstract methods, then those methods must be implemented under
the child class using override modifier.
Characteristics of abstract classes:
1. Abstract Class cannot be instantiated directly.
2. Abstract Class can have both abstract methods and non-abstract methods.
3. If any child class of abstract class wants to consume non abstract method of its parent, first
they require to implement all the abstract methods of parent otherwise consuming non
abstract methods of parent will not be possible.
4. An abstract class can consume only by child classes that to after providing the
implementation for all the abstract methods of abstract class.
5. You cannot declare an abstract method outside an abstract class
6. When a class is declared sealed, it cannot be inherited, abstract classes cannot be declared
sealed.
Syntax: abstract class class1
{
public abstract void add(int x, int y);
}
ABSTRACT METHOD: A method without method body is known as abstract method. It contains
only declaration of the method. We can define abstract method using abstract keyword.
Characteristics of abstract methods:
1. Abstract method cannot have implementation.
2. Abstract method implementation must be provided in non-abstract derived classes by
overriding the method using override modifier.
139 School of Computer Science & Engineering | RGMCET
 C# AND .NET

3. Abstract method can be declared only in Abstract classes.

4. Abstract method cannot take static and virtual modifiers.
Example: using System;
namespace ConsoleApplication8
{
abstract class parent
{
public void add(int x, int y)
{
Console.WriteLine(x + y);
}
public void sub(int x, int y)
{
Console.WriteLine(x - y);
}
public abstract void mul(int x, int y);
public abstract void div(int x, int y);
}
class child : parent
{
public override void mul(int x, int y)
{
Console.WriteLine(x * y);
}
public override void div(int x,int y)
{
Console.WriteLine(x / y);
}
}
class test
{
static void Main(string[] args)
{
child c = new child();
c.add(10, 20);
c.sub(20, 10);
c.mul(10, 10);
c.div(20, 10);
}
}
}
Example: using System;
namespace PolymorphismApplication
{
abstract class Shape
{
public abstract int area();
}
class Rectangle:Shape
140 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
private int length;
private int width;
public Rectangle( int a, int b)
{
length = a;
width = b;
}
public override int area ()
{
Console.WriteLine("Rectangle class area :");
return (width * length);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(10, 7);
double a = r.area();
Console.WriteLine("Area: {0}",a);
Console.ReadKey();
}
}
}
Output: Rectangle class area: Area: 70
SEALED CLASSES (PREVENTING INHERITANCE): A class that cannot be subclassed is called
sealed class. Sealed classes can be created using sealed modifier.
Some points to remember:   
 a class, which restricts inheritance for security reason is declared, sealed class.
 Sealed class is the last class in the hierarchy.
 Sealed class can be a derived class but can't be a base class.
 A sealed class cannot also be an abstract class. Because abstract class has to provide
functionality and here we are restricting it to inherit.
Syntax: accessmodifier sealed class classname
{
------
------
}
Example: class1
{
public virtual void show()
{
----
----
}
}
class2
{
141 School of Computer Science & Engineering | RGMCET
 C# AND .NET

public override void show() //valid

{
----
----
}
}
Class3
{
public override void show() //valid
{
----
----
}
}
Example: class1
{
public virtual void show()
{
----
----
}
}
class2
{
public sealed override void show() //valid
{
----
----
}
}
Class3
{
public override void show() //invalid
{
----
----
}
}
Example: using System;
namespace sealed_class
{
class Program
{
public sealed class BaseClass
{
public void Display()
{
Console.WriteLine("This is a sealed class which
can;t be further inherited");
}
142 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
//public class Derived : BaseClass
// {
// this Derived class can;t inherit BaseClass because it is sealed
//}
static void Main(string[] args)
{
BaseClass obj = new BaseClass();
obj.Display();
Console.ReadLine();
}
}
}
SEALED METHOD: when an instance method declaration includes the sealed modifier, the
method is called sealed method. It means a derived class cannot be override this method. Sealed
keyword is always used with override keyword.
Syntax: access_modifier sealed override returntype methodname(Params_list)
{
----
----
}
Example: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace sealed_method
{
class Program
{
public class BaseClass
{
public virtual void Display()
{
Console.WriteLine("Virtual method");
}
}
public class DerivedClass : BaseClass
{
// Now the display method have been sealed and can;t be overridden
public override sealed void Display()
{
Console.WriteLine("Sealed method");
}
}
//public class ThirdClass: DerivedClass
//{
//public override void Display()
//{

143 School of Computer Science & Engineering | RGMCET

 C# AND .NET

//Console.WriteLine("Here we try again

to override display method which is
not possible and will give error");
//}
//}
static void Main(string[] args)
{
DerivedClass ob1 = new DerivedClass();
ob1.Display();
Console.ReadLine();
}
}
}
Output: sealed method
INTERFACES: An interface is a collection of declaration of the members that may be implemented
by a given class.
1. Interface is a pure protocol. i.e.
a. It never defines data-type
b. It never provides a default implementation of the methods.
2. Interface never specifies as a base class
3. Never contains member that do not take an access-modifier (as all interface-members are
implicitly public).
Example: public interface IAmBadInterface
{
// Error, interfaces can't define data!
int myInt = 0;
// Error, only abstract members allowed!
void MyMethod()
{
Console.WriteLine("Hi!");
}
}
Declaring Interfaces: Interfaces are declared using the interface keyword. It is similar to class
declaration. Interface statements are public by default.
Declaration: interface interfacename
{
Method declarations
}
Where,
Interface - It is the keyword
Interfacename- It is valid C# identifier.
Method declarations- It will contain only list of methods without implementation.
Example: public interface ITransactions
{
// interface members
void showTransaction();
double getAmount();
}
Class Interface Interface Class

144 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Class Interface Class Interface

Valid Valid Valid InValid

Interface contain only abstract methods & properties.
By default members of an interface are abstract public.
We cannot create objects for interfaces.

Example: The following example demonstrates implementation of the above interface:

using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace InterfaceApplication
{
interface one
{
void mymethod();
}
interface two
{
void mymethod();
}
public class D : one,two
{
Public void mymethod()
{
Console.WriteLine(“Hi”);
}
Public void myothermethod()
{
Console.WriteLine(“Hello”);
}
}
class Program
{
static void Main(string[] args)
{
D o=new D();
o.mymethod();
o.myothermethod();
}
}
}
Multiple Inheritance using interfaces: C# does not support multiple inheritance. However, you can
use interfaces to implement multiple inheritance. The following program demonstrates this:
using System;
145 School of Computer Science & Engineering | RGMCET
 C# AND .NET

namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
public interface PaintCost
{
int getCost(int area);
}
class Rectangle : Shape, PaintCost
{
public int getArea()
{
return (width * height);
}
public int getCost(int area)
{
return area * 70;
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
int area;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
Console.WriteLine("Total area: {0}",
Rect.getArea());
Console.Write("Total paint cost: ${0}" , Rect.getCost(area));
Console.ReadKey();
}
}
}
Output: Total area: 35
Total paint cost: $2450

146 School of Computer Science & Engineering | RGMCET

 C# AND .NET

PARTIAL CLASS: partial classes are newly introduced in C# 2.0.

A class which code can be written in multiple locations with same name is called partial
classes. We can define partial classes using partial keyword.
Or
The process of splitting the definition of a class or a struct, or an interface over two or
more source files. Each source file contains a section of the class definition, and all parts
are combined when the application is compiled. To define a class as partial in all the
files, the class name must be same and also we need to use partial modifier to specify the
class is partial.
 Partial classes will be merged together at runtime and works like a single class.
 Partial classes allow multiple programmers to work on the same class at same time.
 Partial classes are only an approach of physically division of code in all the files is
treated as single class only.
Syntax: partial class test
{
public void m1()
{
---
---
}
}
partial class test
{
public void m2()
{
---
---
}
}
Example: using System;
namespace App
{
public partial class partialclass
{
private int x;
private int y;
public partialclass(int x,int y)
{
this.x=x;
this.y=y;
}
}
public partial class partialclass
{
public void print()

147 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
Console.WriteLine("output values{0},{1}", x, y);
}
}
class test
{
public static void Main()
{
partialclass p=new partialclass(10,15);
p.print();
Console.ReadLine();
}
}
}
Output: output values 10, 15
Note: we use partial classes in windows application development.
WHY DELEGATES: Delegates are used in the following cases:
 Delegates can be used to handle (call/invoke) multiple methods on a single event.
 Delegates can be used to define call-back (asynchronous) methods.
 Delegates can be used for decoupling and implementing generic behaviours.
 Delegates can be invoked method at runtime.
 Delegates can be used in LINQ for parsing the Expression Tree.
 Delegates can be used in different Design Pattern.

DELEGATES:
Definition: A delegate object is a special type of object that contains the details of a method
rather than data.
Or
Delegate is a class type object and is used to invoke a method that has been encapsulated into it
at the time of its creation.
Or
A delegate (known as function pointer in C/C++) is a references type that invokes
single/multiple method(s) through the delegate instance.
Or
Delegate is an object, which can be used to invoke the functionality of other object without
knowing its class name or method name.

148 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 In c# delegates means a method acting for another method.

 A delegate is a reference type variable that holds the reference to a method. The reference can
be changed at runtime
 Delegate types are sealed and immutable type.
 All delegates are implicitly derived from the System.Delegate class
 Delegates are especially used for implementing events and the call-back methods.
Delegate declaration: Delegate declaration determines the methods that can be referenced by the
delegate. A delegate can refer to a method, which has the same signature as that of the delegate.
Example: public delegate int MyDelegate (string s);
The preceding delegate can be used to reference any method that has a single string parameter and
returns an int type variable.
Syntax: modifier delegate return type delegate-name (parameter list);
Where,
Delegate: It is a keyword that specifies that the declaration represents a class type derived from
System.Delegate.
Return type: It indicates the return type of the delegate.
Parameter list: It identifies the signature of the delegate.
Delegate-name: It is any valid C# identifier and is the name of the delegate that will be used to call
delegate objects.
Modifier: It controls the accessibility of the delegate. It is optional depending upon the context in
which they are declared, delegate may take any of the following modifiers.
 new
 public
 protected
 internal
 private
The new modifier is only permitted on delegates declared within another type.It signifies that the
delegate hides an inherited member by the by the same name.
Examples: delegate void sampledelegate ();
delegate int mathoperation (int x, int y);
public delegate int compareitems (object b,object b1);
private delegate string getastring ();
The delegate may be defined in the following places

149 School of Computer Science & Engineering | RGMCET

 C# AND .NET

 inside a class
 outside all classes
 as the top level object in a namespace
Delegates are implicitly sealed and therefore it is not possible to derive any type from a delegate
type.
Delegate methods: the methods whose references are encapsulated into a delegate instance are
known as delegate methods (or) callable entities. The return type and signature of delegate methods
must exactly match the signature and return type of the delegate. Delegate methods do not care about
 What type of object the method is being called against.
 Whether the method is a static or an instance method.
Example: delegate string getastring ();
The above delegate can made to refer to the method ToString() using an int object N as follows
int N=100;
getastring s1=new getastring(N.ToString);
Example: delegate void delegate1 ();
The above delegate can encapsulate references to the following methods
public void F1()
{
Console.WriteLIne(“F1”);
}
static public void F2()
{
Console.WriteLIne(“F2”);
}
Example: delegate double mathop (double x, double y);
The above delegate can refer any one of the following methods.
public static double multiply(double a, double b)
{
return (a*b);
}
public double divide(double a, double b)
{
return (a/b);

}
Note: In example2 and example3, the signature and return type of methods match the signature and
type of the delegate.
Delegate instantiation: the syntax for delegate instantiation is
Syntax: new delegate-type (expression)
Where,
Delegate-type: It is the name of the delegate declared earlier whose object is to be created.
Expression: It must be a method name or a value of a delegate type. If it is a method name its

150 School of Computer Science & Engineering | RGMCET

 C# AND .NET

signature and return type must be the same as those of the delegate. If no matching method exists, or
more than one matching method exists, an error occurs. The matching method may be either an
instance method or a static method. If it is an instance method, we need to specify the instance as
well as the name of the method. It is a static one, then it is enough to specify the class name and
method name.
Example: delegate int productdelegate(int x,int y);
class delegate
{
static float product(float a, float b) //signature does not match
{
return (a*b);
}
static int product(int a,int b) //signature matches
{
return (a*b);
}
productdelegate p=new productdelegate(product);
}
Here, we have two methods with same name but with different signatures. The delegate p is
initialized with the reference to the second product method because that method exactly matches the
signature and return type of productdelegate. If this method is not present, an error will occur.
Note: The method and instantiation statement are within the same class, we simply use the method
name for creating the instance.
Example: delegate void displaydelegate();
class A
{
public void displayA()
{
Console.WriteLine(“DisplayA”);
}
}
class B
{
static public void display()
{
Console.WriteLine(“DisplayB”);
}
}
------
-------
A a=new A();
displaydelegate d=new displaydelegate(a.displayA);
displaydelegate d1=new displaydelegate(B.displayB);
The above code defines two delegate methods in two different classes. Since class A defines an

151 School of Computer Science & Engineering | RGMCET

 C# AND .NET

instance method, an A type object is created and used with the method name to initialize the delegate
object d.The delegate method defined in class B is static and therefore the class name is used directly
with the method name in creating the delegate object d1.
Delegate invocation: C# uses a special syntax for invoking a delegate. When a delegate is invoked,
it in turn invokes the method whose reference has been encapsulated into the delegate (only if their
signatures match).
Syntax: delegate_object (parameter list);
The parameters list provides values for the parameters of the method to be used
1. if the invocation invokes a method that returns void, the result is nothing and therefore it
cannot be used as an operand of any operator. It can be simply a statement_expression.
Example: delegate1(x,y); //void delegate: this delegate invokes a method that does
not return any value
2. If the method returns a value, then it can be used as an operand of any operator. Usually, we
assign the return value to an appropriate variable for further processing
Example: double result=delegate2 (2.56, 45.63); //this statement invokes a method
(that takes two double values as parameters and returns double type value) and then assigns
the returned value to the variable result.
Types of Delegates: There are three types of delegates that can be used in C#.
 Single Delegate
 Multicast Delegate
Single Delegate: single cast delegate can point to a single method at a time and used to invoke a
single method.
Example: demonstrates declaration, instantiation, and use of a delegate that can be used to reference
methods that take an integer parameter and returns an integer value.
using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
152 School of Computer Science & Engineering | RGMCET
 C# AND .NET

num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
//create delegate instances
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
//calling the methods using the delegate objects
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Output: Value of Num: 35
Value of Num: 175
Multicast Delegate (or) combinable delegates: Multicast delegate can point multiple methods in
order to invoke multiple methods at the time of invocation.
Or
A collection of single cast delegates are called multi cast delegate.
Multicast delegates must specify the following conditions.
 The return type of the delegate must be void
 None of the parameters of the delegate type can be declared as output parameters, using out
keyword.
If d is the delegate that satisfies the above conditions and d1, d2, d3 and d4 are the instances of d
then the statements.
d3=d1+d2; //d3 refers two methods
d4=d3-d2; // d4 refers only d1 method
The multicast delegates uses arithmetic operators such as + and -. + is used to add a method into
sequence and – is used to delete a method from sequence.
Example: using System;
delegate void mdelegate();
namespace DelegateAppl
{
class dm
{
static public void display()
{
Console.WriteLine(“new delhi”);
}
static public void print()
{
Console.WriteLine(“new york”);
153 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
}
class mtest
{
public static void Main()
{
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();
}
}
}
Output: new delhi
new york
new york
new delhi
new delhi
Example: using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
//create delegate instances
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
154 School of Computer Science & Engineering | RGMCET
 C# AND .NET

nc += nc2; //calling multicast

nc(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Output: Value of Num: 75
Errors: Debugging is the process of identifying and fixing errors in a software program.in software
development domain, such errors are called bugs.
 Fault or mistake in a program is called Error.
 Error is an abnormal condition whenever it occurs,Execution of the program is stoped.
 Error is an illegal operation performed by the user which results abnormal working of
program.
Types of errors:
Compile time error: An error that occurs in a program during the compilation of a program. These
types of errors occur due to syntax mistakes under the program. All syntax errors will be detected
and displayed by the c# compiler and therefore these errors are known as compile time error.
Whenever the compiler displays an error, it will not create the .exe file.
Example: /* this program contained an error */
using Sytem;
class Error1
{
static void Main()
{
Console.Write(“hello c#”);
}
}
In the above program we have misspelled the System namespace; the compiler will display the
following message.
Error1.cs (2.7): error CS0234: the type or namespace System does not exist in the
class or namespace.
Most of the compile time errors are due to typing mistakes. Typographical errors are hard to find. We
may have to check word by word or even character by character. The most common compile time
errors are
1. Missing semicolons.
2. Missing brackets in classes and methods.
3. Misspelling of identifiers and keywords.
4. Missing double quotes in strings.
5. Use of undeclared variables.

155 School of Computer Science & Engineering | RGMCET

 C# AND .NET

6. Incompatible types in assignments/initialization.

7. Bad references to objects.
8. Use of = in place of == operator.
Run time errors: An error that occurs in a program during the execution of the program is called
Run time errors. Sometimes, a program may compile successfully creating the .exe file but may not
run properly. Such programs may produce wrong results due to wrong logic or may terminate due to
errors such as stack overflow. Most common runtime errors are
1. Dividing an integer by zero.
2. Accessing an element that is out of the bounds of an array.
3. Trying to store a value into an array of an incompatible type or class.
4. Passing a parameter that is not in a valid range or value for a method.
5. Attempting to use negative size for an array.
6. Using a null object reference as a legitimate object reference to access method or a variable.
7. Converting an invalid string to a number or vice versa.
8. Accessing a character that is out of bounds of a string.
When such errors are encountered, C# typically generates an error message and aborts the program.
Example: using System;
class error2
{
static void Main()
{
int a=10;
int b=5;
int c=5;
int x=a/(b-c);
Console.WriteLine(“x=”+x);
int y=a/(b+c);
Console.WriteLine(“y=”+y);
}
}
The above program is syntactically correct and therefore does not cause any problem during
compilation. When C# run time tries to execute a division by zero, it generates an error condition
which causes the program stop after an appropriate message. The following statement is never
executed: int y=a/(b+c);
 An exception is unwanted (or) unexpected (condition) event,which occurs during the
execution of a program,that disrupts the normal flow of the program.
EXCEPTION HANDLING: An exception is a condition that is caused by a runtime error in the
program. When the c# compiler encounters an error such as dividing an integer by zero, it creates an

156 School of Computer Science & Engineering | RGMCET

 C# AND .NET

exception object and throws it(that is informs us that an error has occurred).
If the exception object not caught and handled properly, the compiler will display an error message
and will terminate the program. If we want the program to continue with the execution of remaining
code, then we should try to catch exception object thrown by the error condition and then display an
appropriate message for taking corrective actions. This task is known as exception handling.
C# exception handling is built upon four keywords: try, catch, finally, and throw.
Syntax for exception handling: The basic concepts of exception handling are throwing an exception
and catching it.
try: whenever an exception is expected from a block of statements, then write those statements in try
block..
catch: A catch block defined by the keyword catch. A catch block catches the exception thrown by
the try block and handles it appropriately. The catch block is added immediately after the try block.
Syntax: try
{
Statements; // generates an exception
}
catch (Exception e)
{
Statements; // process the exception
}
The try block can have one or more statements that could generate an exception. If anyone statement
generates an exception, the remaining statements in the block are skipped and execution jumps to the
catch block that is placed next to the try block. The catch block also can have one or more
statements that are necessary to process the exception (remember every try statement should be
followed by at least one catch statement; otherwise compilation error will occur. The catch statement
is passed a single parameter, which is the reference to the exception object thrown by the try block. If
the catch parameter matches with the type of exception object, then the exception is caught and
statements in the catch block will be executed. Otherwise, the exception is not caught and the default
exception handler will cause the execution to terminate.
Example: using System;
class error3
{
public static void Main()
{
int a=10;
int b=5;
int c=5;
int x,y;
try

157 School of Computer Science & Engineering | RGMCET

 C# AND .NET

{
x=a/(b-c);
}
catch(Exception e)
{
Console.WriteLine(“division by zero”);
}
y=a/(b+c);
}
}
Output: division by zero
y=1
Note that program did not stop at the point of exceptional condition. It catches the error condition,
prints the error message and then continues the execution as if nothing has happened.

Multiple catch statements: it is possible to have more than one catch statement in the catch block.
try
{
Statements; // generates an exception
}
catch(Exception-type1 e)
{
Statements; // process the exception1
}
catch(Exception-type2 e)
{
Statements; // process the exception2
}
.
.
.
catch(Exception-typeN e)
{
Statements; // process the exception N
}
When an exception in the try block is generated, the c# treats the multiple catch statements like cases
in a switch statement. The first statement whose parameter matches with the exception object will be
executed, and the remaining statements will be skipped.
Note: C# does not require any processing of the exception at all. We can simply have a catch
statement with an empty block to avoid the program abortion.
Example: catch(Exception e){}
The above statement will catch an exception and then ignore it.
Example: using System;
class error3
{

158 School of Computer Science & Engineering | RGMCET

 C# AND .NET

public static void Main()

{
int[] a={5,10};
int b=5;
try
{
int x=a[2]/b-a[1];
}
catch(ArithmeticException e)
{
Console.WriteLine(“division by zero”);
}
catch(IndexOutOfRangeException e)
{
Console.WriteLine(“array index error”);
}
catch(ArithmeticException e)
{
Console.WriteLine(“division by zero”);
}
catch(ArrayTypeMismatchException e)
{
Console.WriteLine(“wrong data type”);
}
int y=a[1]/a[0];
Console.WriteLine(“y=”+y);
}
}
Output: array index error
y=2
Exception Hierarchy: All exceptions are derived from the class Exception. When an exception
occurs, the proper catch handler is determined by matching the type of exception to the name of the
exception mentioned. If we are going to catch exceptions at different levels in the hierarchy, we need
to put them in the right order. The rule is that we must always put the handlers for the most derived
exception class first.
Example: try
{
// throws divide by zero exception
}
catch(Exception e)
{
-----
-----
}
catch(DivideByZeroException e)
{
-----

159 School of Computer Science & Engineering | RGMCET

 C# AND .NET

-----
}
The above code will generate a compile time error, because the exception is caught by the first catch
(which is more general one) and the second catch is therefore unreadable.In C#, having unreachable
code is always an error
Example: try
{
// throws divide by zero exception
}
catch(DivideByZeroException e)
{
-----
-----
}
catch(Exception e)
{
-----
-----
}
The order of catch blocks is important. We must start with catch blocks that are designed to trap very
specific exceptions and finish with more general blocks that will cover any other exceptions for
which we have not provided handlers.
General catch handler: A catch block will catch any exception is called a general catch handler. A
general catch handler does not specify any parameter.
Syntax: try
{
----//causes an exception
}
catch
{
---- // handles an error
----
}
Note that catch (Exception e) can handle all the exceptions thrown by the C# code and therefore can
be used as a general catch handler. However, if the program uses libraries written in other languages,
then there may be an exception that is not derived from the class Exception. Such exceptions can be
handled by parameter-less catch statement. This handler always placed at the end. Since there is no
parameter, it does not catch any information about the exception and therefore we do not know what
went wrong.
Using finally statement: C# supports another statement known as a finally statement that can be
used to handle an exception that is not caught by any of the previous catch statements. A finally
block can be used to handle any exception generated within a try block. It may be added immediately
160 School of Computer Science & Engineering | RGMCET
 C# AND .NET

after the try block or after the last catch block.

Syntax: try
{
----
----
}
finally
{
----
----
}

Or
try
{
----
----
}
catch(……)
{
----
----
}
catch(……)
{
----
----
}
.
.
.
finally
{
----
----
}
When finally block is defined, the program is guaranteed to execute, regardless of how control leaves
the try, whether it is due to normal termination, due to an exception occurring or due to a jump
statement.
Example: using System;
namespace ErrorHandlingApplication
{
class DivNumbers
{
int result;
DivNumbers()
{
result = 0;
161 School of Computer Science & Engineering | RGMCET
 C# AND .NET

}
public void division(int num1, int num2)
{
try
{

result = num1 / num2;

}
catch (DivideByZeroException e)
{
Console.WriteLine("Exception caught: {0}", e);
}
finally
{
Console.WriteLine("Result: {0}", result);
}
}
static void Main(string[] args)
{
DivNumbers d = new DivNumbers();
d.division(25, 0);
Console.ReadKey();
}
}
}
Output: Exception caught: System.DivideByZeroException: Attempted to divide by zero.
Result: 0
Nested try blocks: C# permits us to nest try blocks inside each other.
Example: try
{
----(point p1)
----
try
{
----(point p2)
----
catch
{
----(point p3);
----
}
finally
{
----
----
}
-----(point p4)
-----
}
catch
162 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
----
----
}
finally
{
----
----
}
When nested try blocks are executed, the exceptions that are thrown at various points are handled as
follows:
 The points p1 and p4 are outside the inner try block and therefore any exceptions thrown at
these points will be handled by the catch in the outer block.The inner block is simply ignored.
 Any exception thrown at point p2 will be handled by the inner catch handler and the inner
finally will be executed. The execution will continue at point p4 in the program.
 If there is no suitable catch handler to catch an exception thrown at p2, the control will leave
the inner block (after executing the inner finally) and look for a suitable catch handler in the
outer block. If a suitable one if found, then that handler is executed followed by the outer
finally code. Remember, the code at point p4 will be skipped.
 If an exception is thrown at point p3, it is treated as if it had been thrown by the outer try
block and, therefore, the control will immediately leave the inner block (of course, after
executing the inner finally) and search for a suitable catch handler in the outer block.
 In case, a suitable catch handler is not found, then the system will terminate program
execution with an appropriate message.
Example: using System;
class nestedtry
{
static int m=10;
static int n=0;
static void division()
{
try
{
int k=m/n;
}
catch(ArgumentException e)
{
Console.WriteLine(“caught an exception”);
}
finally
{
Console.WriteLine(“inside division method”);
}
}
public static void Main()
{
try
{
division();
}
163 School of Computer Science & Engineering | RGMCET
 C# AND .NET

catch(DivideByZeroException e)
{
Console.WriteLine(“caught an exception”);
}
finally
{
Console.WriteLine(“inside main method”);
}
}
}
Creating User-Defined Exceptions or throwing our own exceptions: You can also throw our own
exceptions. We can do this by using the keyword throw. User-defined exception classes are derived
from the System.ApplicationException class.
Syntax: throw new Throwable_subclass;
Examples: throw new ArithmeticException;
throw new FormatException;
Example: using System;
namespace ConsoleApplication8
{
class TestTemperature
{
static void Main(string[] args)
{
Temperature t = new Temperature();
try
{
t.showTemp();
}
catch (TempIsZeroException e)
{
Console.Write("TempIsZeroException:{0}", e.Message);
}
Console.ReadKey();
}
}
public class TempIsZeroException : ApplicationException
{
public TempIsZeroException(string message): base(message)
{
}
}
public class Temperature
{
int temperature = 0;
public void showTemp()
{
if (temperature == 0)
164 School of Computer Science & Engineering | RGMCET
 C# AND .NET

{
throw(newTempIsZeroException("ZeroTemperature
found"));
}
else
{
Console.WriteLine("Temperature: {0}", temperature);
}

}
}
}
Output: TempIsZeroException: ZeroTemperature found
Exception Classes in C#: C# exceptions are represented by classes. The exception classes in C# are
mainly directly or indirectly derived from the System.Exception class. Some of the exception
classes derived from The System.Exception class are the System.ApplicationException and
System.SystemException classes. The System.ApplicationException class supports exceptions
generated by application programs. Hence the exceptions defined by the programmers should derive
from this class. The System.SystemException class is the base class for all predefined system
exception. The following table provides some of the predefined exception classes derived from the
Sytem.SystemException class:
Exception Class Description
SystemException A failed run time check; used as a base class for other
exceptions
AccessException Failure to access a type member, such as a method or field
ArgumentException An argument to a method was invalid
ArgumentNullException A null argument was passed to a method that does not accept it
ArgumentOutOfRangeException Argument value is out of range
ArithmeticException Arithmetic over or underflow has occurred
ArrayTypeMismatchException Attempt to store the wrong type of object in an array
BadImageFormatException Image is in the wrong format
CoreException Base class for exceptions thrown by the runtime
System.IO.IOException Handles I/O errors.
IndexOutOfRangeException An array index is out of range.
DivideByZeroException Handles errors generated from dividing a dividend with zero
InvalidCastException Handles errors typecasting
InvalidOperationException A method was called at an invalid time
MissingMemberException An invalid version of a DLL was accessed
NotFiniteNumberException A number is not valid
NotSupportedException Indicates that a method is not implemented by a class,
NullReferenceException Handles errors generated from dereferencing a null object.
OutOfMemoryException Handles errors generated from insufficient free memory.
StackOverflowException Handles errors overflow

165 School of Computer Science & Engineering | RGMCET

 C# AND .NET

Why Delegates :
Delegates are used to call/invoke multiple methods on a single event.
Delegates can be used to define call-back(asynchronous) methods (A Callback function is a
function passed into another function as an arguments,s)

166 School of Computer Science & Engineering | RGMCET