NET_BOOK

1 | P a g e

.Net Framework

The Microsoft .NET Framework is a software framework that can be installed on computers running

Microsoft Windows operating systems. It includes a large library of coded solutions to common

programming problems and a virtual machine that manages the execution of programs written specifically

for the framework. The .NET Framework is a Microsoft offering and is intended to be used by most new

applications created for the Windows platform.

.Net is a newly product of the Microsoft which consists of multiple language like C#,VB,J#,VC++ and

many more. The framework's Base Class Library provides a large range of features including user

interface, data and data access, database connectivity, cryptography, web application development,

numeric algorithms, and network communications. The class library is used by programmers, who ine it

with their own code to produce applications.

Programs written for the .NET Framework execute in a software environment that manages the program's

runtime requirements. Also part of the .NET Framework, this runtime environment is known as the

Common Language Runtime (CLR). The CLR provides the appearance of an application virtual machine

so that programmers need not consider the capabilities of the specific CPU that will execute the program.

The CLR also provides other important services such as security, memory management, and exception

handling. The class library and the CLR together constitute the .NET Framework. And the .Net run on the

framework and framework is run on the OS.

Framework

Compile The Program Execute The Program

Architecture of Framework

Compile (.CSC)

Component of the Framework

Language like

C#, J#,VB..

Manifest

Resource

IL

Metadata

F

R

A

M

E

W

O

R

K

OS

C

L

R

2 | P a g e

The .NET Framework is dividing into three layer.

Common Language Runtime ( CLR)

CLR is a environment where a .Net application is executes. It is act as a platform for all .Net application

and it is responsible for providing execution environment to application, allocating memory , garbage

collection and implementing type safety

The CLR allow the execution of code across the different platforms by translating code into intermediate

language (IL). IL is a low level language that the CLR understand. The purpose of the Common

Language Infrastructure, or CLI, is to provide a language-neutral platform for application development

and execution, including functions for exception handling, garbage collection, security, and

interoperability. By implementing the core aspects of the .NET Framework within the scope of the CLI,

this functionality will not be tied to a single language but will be available across the many languages

supported by the framework. Microsoft's implementation of the CLI is called the Common Language

Runtime, or CLR.

CLR consists of a set of the common rules and regulation followed by the all language of the .Net

framework. This set of rules is known as the Common Language Specification (CLS). CLS enable an

object or application to interact with the object or application of other language. The classes that follow

the rules specified by the CLS are termed as CLS compliant classes. The classes defined in the .NET

Framework class library are CLS compliant.

Layer 1 (User and Programs Interface)

Windows Form Console Application Web Forms and Web Services

Layer 2

.NET Frameworks and Base Class Libraries

Layer 3

Common Language Runtime

3 | P a g e

One of the specification is defined in CLS is Common Type System (CTS) , which provides a type system

that is common across all language. CTS defined how to data type are declared, used and managed in the

code at runtime.

CTS also define the rules the ensure that the data types of the object written into various language are able

to interact to each other. For example, the size of the integer and long variables is the same across all CLS

compliant programming language.

The .NET Framework Class Library

The .NET Framework class library work with any .NET language, such as VB.NET, VC++.NET,

C#.NET etc .This class library is built on the object oriented nature of the runtime. The library provides

classes that can be used in the code to accomplish a range of common programming tasks. Such as string

management, data allocation, database connectivity, and file access.

One of the most important feature of the .NET Framework class library is that it can be used in a

consistent manner across multiple language. This means that you can use the same set of class of

performing a specific task in VC# as well as in VC++.

The .NET framework class library comprises namespaces and assemblies.

Namespaces

Name space help you to create the logical group of the related classes and interface which can be used by

any language targeting the .NET Framework. Namespace allow you to organize your class so that they

can be eassly accociated with application . Namespace can be used to avoid any naming conflicts

between classes , which have the same name , For example, you can use two class with the same name in

the application providing the belong to different namespaces.

There are some namespaces are

using System;

using System.Web;

using System.Linq;

using System.Text;

using System.Security;

using System.Collections.Generic;

using System.Reflection;

using System.Reflection.Emit;


you can acess the classes beloging to the namespace by simpling importing the namespace in to the

application.The .NET Framework uses (.) dot as a delimeter between classes and namespace . For

example, System.Console represent the Console class of the System namespace. Namespace are also in

stored in the Assebblies.

Assemblies

4 | P a g e

An assembly is a single deployable unit that contain, all the information about the implementation of the

classes, structure, and interface. The assembly store all the information about itself. This information is

called metadata and include the name and version number of the assembly, security

information,information about the dependencies ,and a list of the files that constitute the assembly.

All the application developed using the .net framework are made up of the assemblies. Assemblies and

meta data are provide the CLR with the information required for execute the application.

Compiler (.CSC)

Languages

Assembly

Component of the Assemblies

As we know that assembly is a file that contain the information about the application that is required for

the CLR. So the assembly contain this information in 4 field .

The fields are

1. Manifest

2. Metadata

3. Intermediate Language (IL)

4. Resource

Manifest File

Metadata

Intermediate

Language Code

Resource

C#,

VC++,

VB.NET

5 | P a g e

1. Manifest file An assembly manifest contains all the metadata needed to specify the assembly's

version requirements and security identity, and all metadata needed to define the scope of the

assembly and resolve references to resources and classes. The assembly manifest can be stored in

either a PE file (an .exe or .dll) with Microsoft intermediate language (MSIL) code or in a

standalone PE file that contains only assembly manifest information.

The following table shows the information contained in the assembly manifest. The first four itemsthe assembly name, version number, culture, and strong name informationmake up the assembly's identity.

Information Description

Assembly name A text string specifying the assembly's name.

Version number A major and minor version number, and a revision and build number. The common

language runtime uses these numbers to enforce version policy.

Culture Information on the culture or language the assembly supports. This information should be

used only to designate an assembly as a satellite assembly containing culture- or language-

specific information. (An assembly with culture information is automatically assumed to

be a satellite assembly.)

Strong name

information

The public key from the publisher if the assembly has been given a strong name.

List of all files in

the assembly

A hash of each file contained in the assembly and a file name. Note that all files that make

up the assembly must be in the same directory as the file containing the assembly manifest.

Type reference

information

Information used by the runtime to map a type reference to the file that contains its

declaration and implementation. This is used for types that are exported from the

assembly.

Information on

referenced

assemblies

A list of other assemblies that are statically referenced by the assembly. Each reference

includes the dependent assembly's name, assembly metadata (version, culture, operating

system, and so on), and public key, if the assembly is strong named

2. Metadata Metadata contain the all about structure of the class ,it represent the class, member , variables,method, type information of the class.

3. Intermediate Language IL is a code that is independent for the operating system. It is a symbolic code. Microsoft Intermediate Language (MSIL) is a platform independent language that

gets compiled into platform dependent executable file or dynamic link library. It means .NET

compiler can generate code written using any supported languages and finally convert it to the

required machine code depending on the target machine.

6 | P a g e

To get some clarity in this language we need to write some code. In this tutorial we?ll use a

very simple piece of source code in C# .Net. Now we need to compile this code using csc

command in Microsoft .NET on the command line. To do this, please type next string: csc IL

Sample.cs. After it compiler will create an executable file named ILSample.exe. After this type

the command called ILDasm. It will open application called Intermediate Language

Disassembler. In file menu choose open and find our executable file.This application opens our

assembly showing all structural units viz., classes, methods, data fields and all global and local

application data. Now if you click on the method it shows code in intermediate language. This

code is most like at language with independent set of instructions.

4. Resource if in your application contain an image, Resource contain the path of the image that is used in application.

Note:

.DLL .EXE

If any program contain the main () it generate the .exe file , otherwise it create .dll file

Steps To extract the Assembly:

Step 1: Open the command prompt of the visual studio 2008. and write the command

ILDASM (intermediate language dissembler).

Assembly

7 | P a g e

Step 2: Open the ILDASM Window like

Step-3 : Now choose the .dll (Dynamic link library) or .exe file . now u can see the all information about

the applications dll or exe.

8 | P a g e

9 | P a g e

10 | P a g e

11 | P a g e

Symbol Meaning

More info

Namespace

Class

Interface

Value Class

Enum

Method

Static method

Field

Static field

Event

Property

Manifest or a class info item

12 | P a g e

OBJECT ORIENTED PARADIGMS (CLASSIFICATION)

C language was developed by Ken Thomson & Denis Ritchie in 1972. C was based on

procedural or structured based programming language.In 1983 C++ was developed by Bjarne.

C++ was based on Object Oriented.

In 1995 James Gostling developed Java. Java is also based on Object Oriented.

System defines data types or primitive data type:-

Whenever we declare system define data type like int, float, char e.t.c. every system define data

type has some certain nature like(Int x ;) X is a variable of integer type. Now this x will take

integer value like 1,2,3,4,5,e.t.c. similarly this rule is applicable for every system define

data type.To remove this barrier we will create my own data type or it is said to be user defined

Whenever we declare system define data type like int, float, char e.t.c. every system define data

type has some certain nature like(Int x ;) X is a variable of integer type. If we create a variable of

ADT that variable is said to be an object.

1. Variable are specific where as object are not specific. 2. Object is a collection of variable. 3. Object compiler creates an object at run time. 4. Class sis the keyword to create ADT. 5. We are declaring all the variables with in the class.

EXAMPLE:

#include

class employee

{

char emp_code[10];

char emp_name[20];

char emp_desig[10];

};

void main()

{

employee vivek;

cout

13 | P a g e

#include

class employee

{

char emp_code[10];

char emp_name[20];

public:

void accept()

{

coutemp_code;

coutemp_name;

}

void display()

{

cout

14 | P a g e

EXAMPLE:

#include

Class employee

{

private:

char emp_code[10];

char emp_name[20];

public:

void data_entry();

void data_display();

};

void employee::data_entry()

{

coutemp_code;

coutemp_name;

}

void employee::data_display()

{

cout

15 | P a g e

void main()

{

employee e1;

e1.get1();

employee::get();

}

FRIEND FUNCTION

It is possible to grant a nonmember function access to the private members of a class by using a

friend. A friend function has access to all private and protected members of the class for which it

is a friend. To declare a friend function, include its prototype within the class, preceding it with

keyword friend. If a class is having a friend function and if you want to call this function from

the main, then we do not need an object call this function.

EXAMPLE:-

#include < iostream.h >

Class myclass

{

int a, b ;

public:

friend int sum ( myclass x ) ;

void set_b ( int I, int j ) ;

} ;

Void myclass : : set_ab ( int I, int j )

{

a = i ;

b = j ;

}

Int sum ( myclass x )

{

return x.a + x.b ;

}

Int main ( )

{

myclass n ;

n.set_ab ( 3, 4 ) ;

cout

16 | P a g e

class TwoValues

{

int a ;

int b ;

public :

TwoValues ( int i, int j )

{

a = i ;

b = j ;

}

friend class Min ;

} ;

class Min

{

public :

int min ( TwoValues x ) ;

} ;

int Min :: min ( TwoValues x )

{

return x.a < x.b ? x.a : x.b ;

}

int main ( )

{

TwoValues ob( 10, 20 ) ;

Min m ;

cout

17 | P a g e

};

};

void main()

{

employee::leave l;

l.get1();

}

PRINCIPAL OF INHARITANCE:-

Inheritance is the process where object of one class can acquired the properties of the object of

another class, this process said to be INHARITANCE.

ARCHITECTURE OF INHARITANCE:-

PROCESS:-

There are two class called A and B. Class B is inherited from Class A. In this case Class B is said

to be derived class and Class A is said to be base class. Both classes are having constructor.

When we create an object of class B, compiler calls the base class constructor. Because compile

create base class object and that object hidden to us, that object is also said to be Virtual Object.

Thats why, compiler called base class constructor, then derived class constructor.

TYPE OF INHARITANCE:-

1. Private Inheritance 2. Protected Inheritance

Person

Employee Student

Technical Secretary Manager

Programmer Analyst Undergrad Graduate

18 | P a g e

PRIVATE INHERITANCE:-

Private part of the base class cannot be accessible the derived class.

Public parts of the base class become private part of the derived class.

Protected part of the base class become protected part of the derived class.

ARCHITECTURE OF PRIVATE INHERITANCE:-

EXAMPLE:-

#include

class employee

{

private:

int x;

public:

void get()

{

cout

19 | P a g e

private:

public:

void get1()

{

get();

age=20;

cout

20 | P a g e

EXAMPLE:-

#include

class employee

{

private:

int x;

public:

void get()

{

cout

21 | P a g e

EXAMPLE:-

#include

class A

{

public:

void get()

{

cout

22 | P a g e

}

};

class C:public A,public B

{

public:

void display()

{

cout

23 | P a g e

Syntex is:-

Object.Classname::functionname In case of inheritance compiler execute the constructor in order

of inheritance.

PRINCIPLE OF OVERRIDDING:-

If there are two class A and B and in both classes we have some function.

EXAMPLE:-

#include

class A

{

public:

void get()

{

cout

24 | P a g e

void data_entry();

void data_display();

};

void employee::data_entry()

{

coutemp_code;

coutemp_name;

}

void employee::data_display()

{

cout

25 | P a g e

void display();

}emp;

void employee::accept()

{

ofstream o;

o.open("c:\\emp.txt",ios::app);

coutn;

for(i=0;i

26 | P a g e

EXAMPLE:

#include Class employee

{

Private:

Char emp_code [10];

Char emp_name[10];

int emp_salary;

public:

void accept();

void display();

employee operator+(employee);

};

void employee::accept()

{

coutemp_code;

coutemp_name;

coutemp_salary;

}

void employee::display()

{

cout

27 | P a g e

An Introduction of C# Language

C# is an object-oriented programming language and uses classes and structs to implement types

such as Windows Forms, user interface controls, and data structures. A typical C# application

consists of classes defined by the programmer, combined with classes from the .NET

Framework.

C# provides many powerful ways of defining classes, such as providing different access levels,

inheriting features from other classes, and enabling the programmer to specify what occurs when

types are instantiated or destroyed.

Classes can also be defined as generic by using type parameters that enable client code to

customize the

Class in a type-safe and efficient manner. A single generic class, for example

System.Collections.Generic.List(T) in the .NET Framework can be used by client code to store

integers, strings, or any other type of object.

Objects, classes, and structs have the following properties:

Objects are instances of a given data type. The data type provides a blueprint for the object

that is created, or instantiated, when the application is executed.

New data types are defined by using classes and structs.

Classes and structs form the building blocks of C# applications that contain code and data.

A C# application will always contain of at least one class.

A struct can be considered a lightweight class, ideal for creating data types that store small

amounts of data, and does not represent a type that might later be extended through

inheritance.

C# classes support inheritance; classes can derive from a previously defined class.

Objects

Objects are programming constructs that have data, behavior, and identity. Object data is

contained in the fields, properties, and events of the object, and object behaviors are defined by

the methods and interfaces of the object.

Objects have identity two objects with the same set of data are not necessarily the same object.

Objects in C# are defined through classes and structs these form the single blueprint from which all objects of that type operate.

Objects Overview

Objects have the following properties:

Everything you use in C# is an object, including Windows Forms and controls.

Objects are instantiated; that is, they are created from templates defined by classes and

structs.

Objects use Properties to obtain and change the information they contain.

Objects often have methods and events that allow them to perform actions.

28 | P a g e

Visual Studio provides tools for manipulating objects: the Properties Window allows you to

change the attributes of objects such as Windows Forms. The Object Browser allows you to

examine the contents of an object.

All C# objects inherit from the Object.

Classes A class is the most powerful data type in C#. Like structures, a class defines the data and

behavior of the data type. Programmers can then create objects that are instances of this class.

Unlike structures, classes support inheritance, a fundamental part of object-oriented

programming. For more information.

Classes Overview

Classes have the following properties:

Unlike C++, only single inheritance is supported: a class can inherit implementation from

only one base class.

A class can implement more than one interface. For more information,.

Class definitions can be split between different source files. For more information,.

Static classes are sealed classes that contain only static methods. For more information,.

Declaring Classes

Classes are defined by using the class keyword, as shown in the following example:

public class Customer

{

//Fields, properties, methods and events go here...

}

The class keyword is preceded by the access level. Because public is used in this case, anyone

can create objects from this class. The name of the class follows the class keyword. The

remainder of the definition is the class body, where the behavior and data are defined. Fields,

properties, methods, and events on a class are collectively referred to as class members.

Creating Objects of the class

Although they are sometimes used interchangeably, a class and an object are different things. A

class defines a type of object, but it is not an object itself. An object is a concrete entity based on

a class, and is sometimes referred to as an instance of a class.

Objects can be created by using the new keyword followed by the name of the class that the

object will be based on, like this:

Customer object1 = new Customer();

29 | P a g e

When an instance of a class is created, a reference to the object is passed back to the

programmer. In the previous example, object1 is a reference to an object that is based on

Customer. This reference refers to the new object but does not contain the object data itself. In

fact, you can create an object reference without creating an object at all:

Customer object2;

We do not recommend creating object references such as this one that does not refer to an object

because trying to access an object through such a reference will fail at run time. However, such a

reference can be made to refer to an object, either by creating a new object, or by assigning it to

an existing object, such as this:

Customer object3 = new Customer();

Customer object4 = object3;

This code creates two object references that both refer to the same object. Therefore, any

changes to the object made through object3 will be reflected in subsequent uses of object4.

Because objects that are based on classes are referred to by reference, classes are known as

reference types.

Structs

Structs share most of the same syntax as classes, although structs are more limited than classes:

Within a struct declaration, fields cannot be initialized unless they are declared as const or

static.

A struct may not declare a default constructor (a constructor without parameters) or a

destructor.

Because copies of structs are created and destroyed automatically by the compiler, a default

constructor and destructor are unnecessary. In effect, the compiler implements the default

constructor by assigning all the fields of their default values). Structs cannot inherit from classes

or other structs.

Structs Overview

Structs have the following properties:

Structs are value types and classes are reference types.

Unlike classes, structs can be instantiated without using a new operator.

Structs can declare constructors, but they must take parameters.

A struct cannot inherit from another struct or class, and it cannot be the base of a class. All structs inherit directly from System.ValueType, which inherits from System.Object.

A struct can implement interfaces.

A struct can be used as a nullable type and can be assigned a null value.

The struct type is suitable for representing lightweight objects such as Point, Rectangle, and

Color. Although it is possible to represent a point as a class, a struct is more efficient in some

30 | P a g e

scenarios. For example, if you declare an array of 1000 Point objects, you will allocate

additional memory for referencing each object; in this case, a struct would be less expensive.

Since the .NET Framework contains an object called Point, we'll call our struct "CoOrds"

instead.

public struct CoOrds

{

public int x, y;

public CoOrds(int p1, int p2)

{

x = p1;

y = p2;

}

}

It is an error to declare a default (parameterless) constructor for a struct. A default

constructor is always provided to initialize the struct members to their default values. It is

also an error to initialize an instance field in a struct.

When you create a struct object using the new operator, it gets created and the

appropriate constructor is called. Unlike classes, structs can be instantiated without using

the new operator. If you do not use new, the fields will remain unassigned and the object

cannot be used until all of the fields are initialized.

There is no inheritance for structs as there is for classes. A struct cannot inherit from

another struct or class, and it cannot be the base of a class. Structs, however, inherit from

the base class Object . A struct can implement interfaces, and it does that exactly as

classes do.

Unlike C++, you cannot declare a class using the keyword struct. In C#, classes and

structs are semantically different. A struct is a value type, while a class is a reference

type. For more information, see Value Types.

Unless you need reference-type semantics, small classes may be more efficiently handled

by the system as a struct.

31 | P a g e

Example

This example demonstrates struct initialization using both default and parameterized

constructors.

using System;


using System.Linq;

using System.Text;

namespace ConsoleApplication3

{

public struct CoOrds

{

public int x, y;

public CoOrds(int p1, int p2)

{

x = p1;

y = p2;

}

}

// Declare and initialize struct objects.

class TestCoOrds

{

static void Main()

{

// Initialize:

CoOrds coords1 = new CoOrds();

CoOrds coords2 = new CoOrds(10, 10);

// Display results:

System.Console.Write("CoOrds 1: ");

System.Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);

System.Console.Write("CoOrds 2: ");

System.Console.WriteLine("x = {0}, y = {1}", coords2.x, coords2.y);

Console.ReadLine();

}

}

}

Output

CoOrds 1: x = 0, y = 0

CoOrds 2: x = 10, y = 10

32 | P a g e

Methods

A method is a code block that contains a series of statements. In C#, every executed

instruction is performed in the context of a method. This topic discusses named methods.

Another kind of method, called an anonymous function, is discussed elsewhere in the

documentation.

Methods are declared in a class or struct by specifying the access level, the return value, the

name of the method, and any method parameters. These parts together are the signature of

the method. Method parameters are enclosed in parentheses and are separated by commas.

Empty parentheses indicate that the method requires no parameters. This class contains three

methods:

class Motorcycle

{

public void StartEngine() { }

public void AddGas(int gallons) { }

public int Drive(int miles, int speed) { return 0; }

}

Calling a method on an object is like accessing a field. After the object name, add a period,

the name of the method, and parentheses. Arguments are listed within the parentheses, and

are separated by commas. The methods of the Motorcycle class can therefore be called as in

the following example:

Motorcycle moto = new Motorcycle();

moto.StartEngine();

moto.AddGas(15);

moto.Drive(5, 20);

Method Parameters

As shown in the previous example, passing arguments to a method is just a matter of

providing them in the parentheses when you call a method. To the method being called, the

incoming arguments are called parameters.

The parameters that a method receives are also provided in a set of parentheses, but the type

and a name for each parameter must be specified. The name does not have to be the same as

the argument. For example:

public static void PassesInteger()

33 | P a g e

{

int fortyFour = 44;

TakesInteger(fortyFour);

}

static void TakesInteger(int i)

{

i = 33;

}

Here a method named PassesInteger passes an argument to a method named TakesInteger.

Within PassesInteger, the argument is named fortyFour, but in TakeInteger, this is a

parameter named i. This parameter exists only in the TakesInteger method. Any number of

other variables can be named i, and they can be of any type as so long as they are not

parameters or variables declared inside this method.

Notice that TakesInteger assigns a new value to the provided argument. One might expect

this change to be reflected in the PassesInteger method after TakeInteger returns, but in fact

the value in the variable fortyFour remains unchanged. This is because int is a value type. By

default, when a value type is passed to a method, a copy is passed instead of the object itself.

Because they are copies, changes to the parameter have no effect within the calling method.

Value types get their name from the fact that a copy of the object is passed instead of the

object itself. The value is passed, but not the same object.

This differs from reference types, which are passed by reference. When an object that is

based on a reference type is passed to a method, no copy of the object is made. Instead, a

reference to the object that is being used as a method argument is made and passed. Changes

made through this reference will therefore be reflected in the calling method. A reference

type is created by using the class keyword as in the following example:

public class SampleRefType

{

public int value;

}

Now, if an object that is based on this type is passed to a method, the object will be

passed by reference. For example:

public static void TestRefType()

{

SampleRefType rt = new SampleRefType();

rt.value = 44;

ModifyObject(rt);

System.Console.WriteLine(rt.value);

}

static void ModifyObject(SampleRefType obj)

{

obj.value = 33;

34 | P a g e

}

This example essentially does the same thing as the previous example. But, because a

reference type is used, the modification made by ModifyObject is made to the object that is

created in the TestRefType method. The TestRefType method will therefore display the

value 33.

Return Values

Methods can return a value to the caller. If the return type, the type listed before the method

name, is not void, the method can return the value by using the return keyword. A statement

with the return keyword followed by a value that matches the return type will return that

value to the method caller. The return keyword also stops the execution of the method. If the

return type is void, a return statement without a value is still useful to stop the execution of

the method. Without the return keyword, the method will stop executing when it reaches the

end of the code block. Methods with a non-void return type are required to use the return

keyword to return a value. For example, these two methods use the return keyword to return

integers:

class SimpleMath

{

public int AddTwoNumbers(int number1, int number2)

{

return number1 + number2;

}

public int SquareANumber(int number)

{

return number * number;

}

}

To use a value returned from a method, the calling method can use the method call itself

anywhere a value of the same type would be sufficient. You can also assign the return

value to a variable. For example, the following two code examples accomplish the same

goal:

int result = obj.AddTwoNumbers(1, 2);

obj.SquareANumber(result);

obj.SquareANumber(obj.AddTwoNumbers(1, 2));

Using an intermediate variable, in this case, result, to store a value is optional. It may

help the readability of the code, or it may be necessary if the value will be used more than

one time.

35 | P a g e

Note

A return type of a method is not part of the signature of the method for the purposes of method

overloading. However, it is part of the signature of the method when determining the

compatibility between a delegate and the method that it points to.

Partial Classes and Methods

It is possible to split the definition of a class or a struct, an interface or a method over two or

more source files. Each source file contains a section of the type or method definition, and all

parts are combined when the application is compiled.

Partial Classes

There are several situations when splitting a class definition is desirable:

When working on large projects, spreading a class over separate files enables multiple

programmers to work on it at the same time.

When working with automatically generated source, code can be added to the class without

having to recreate the source file. Visual Studio uses this approach when it creates Windows

Forms, Web service wrapper code, and so on. You can create code that uses these classes without

having to modify the file created by Visual Studio.

To split a class definition, use the partial keyword modifier, as shown here:

public partial class Employee

{

public void DoWork()

{

}

}

public partial class Employee

{

36 | P a g e

public void GoToLunch()

{

}

}

The partial keyword indicates that other parts of the class, struct, or interface can be defined in

the namespace. All the parts must use the partial keyword. All the parts must be available at

compile time to form the final type. All the parts must have the same accessibility, such as

public, private, and so on.

If any part is declared abstract, then the whole type is considered abstract. If any part is declared

sealed, then the whole type is considered sealed. If any part declares a base type, then the whole

type inherits that class.

All the parts that specify a base class must agree, but parts that omit a base class still inherit the

base type. Parts can specify different base interfaces, and the final type implements all the

interfaces listed by all the partial declarations. Any class, struct, or interface members declared in

a partial definition are available to all the other parts. The final type is the combination of all the

parts at compile time.

Note

The partial modifier is not available on delegate or enumeration declarations.

Restrictions

There are several rules to follow when you are working with partial class definitions:

All partial-type definitions meant to be parts of the same type must be modified with partial. For

example, the following class declarations generate an error:

public partial class A { }

//public class A { } // Error, must also be marked partial

The partial modifier can only appear immediately before the keywords class, struct, or

interface.

37 | P a g e

Nested partial types are allowed in partial-type definitions as illustrated in the following example:

partial class ClassWithNestedClass

{

partial class NestedClass { }

}

partial class ClassWithNestedClass

{

partial class NestedClass { }

}

All partial-type definitions meant to be parts of the same type must be defined in the same

assembly and the same module (.exe or .dll file). Partial definitions cannot span multiple modules.

The class name and generic-type parameters must match on all partial-type definitions. Generic

types can be partial. Each partial declaration must use the same parameter names in the same

order.

The following keywords on a partial-type definition are optional, but if present on one partial-type

definition, cannot conflict with the keywords specified on another partial definition for the same

type:

public

private

protected

internal

Example

In the following example, the fields and the constructor of the class, CoOrds, are declared in one

partial class definition, and the member, PrintCoOrds, is declared in another partial class

definition.

using System;


using System.Linq;

using System.Text;


{

public partial class CoOrds

{

38 | P a g e

private int x;

private int y;

public CoOrds(int x, int y)

{

this.x = x;

this.y = y;

}

}

public partial class CoOrds

{

public void PrintCoOrds()

{

System.Console.WriteLine("CoOrds: {0},{1}", x, y);

}

}

class TestCoOrds

{

static void Main()

{

CoOrds myCoOrds = new CoOrds(10, 15);

myCoOrds.PrintCoOrds();

Console.ReadLine();

}

}

}

Output

CoOrds: 10,15

Partial Methods

A partial class or struct may contain a partial method. One part of the class contains the signature

of the method. An optional implementation may be defined in the same part or another part. If

the implementation is not supplied, then the method and all calls to the method are removed at

compile time.

Partial methods enable the implementer of one part of a class to define a method, similar to an

event. The implementer of the other part of the class can decide whether to implement the

method or not. If the method is not implemented, then the compiler removes the method

signature and all calls to the method. Therefore, any code in the partial class can freely use a

39 | P a g e

partial method, even if the implementation is not supplied. No compile-time or run-time errors

will result if the method is called but not implemented.

Partial methods are especially useful as a way to customize generated code. They allow for a

method name and signature to be reserved, so that generated code can call the method but the

developer can decide whether to implement the method. Much like partial classes, partial

methods enable code created by a code generator and code created by a human developer to

work together without run-time costs.

A partial method declaration consists of two parts: the definition, and the implementation. These

may be in separate parts of a partial class, or in the same part. If there is no implementation

declaration, then the compiler optimizes away both the defining declaration and all calls to the

method.

// Definition in file1.cs

partial void onNameChanged();

// Implementation in file2.cs

partial void onNameChanged()

{

// method body

}

Partial method declarations must begin with the contextual keyword partial and the

method must return void.

Partial methods can have ref but not out parameters.

Partial methods are implicitly private, and therefore they cannot be virtual.

Partial methods cannot be extern, because the presence of the body determines whether

they are defining or implementing.

Partial methods can have static and unsafe modifiers.

Partial methods can be generic. Constraints are put on the defining partial method

declaration, and may optionally be repeated on the implementing one. Parameter and type

parameter names do not have to be the same in the implementing declaration as in the

defining one.

You cannot make a delegate to a partial method.

40 | P a g e

Comments

The first line contains a comment:

// A "Hello World!" program in C#

The characters // convert the rest of the line to a comment. You can also comment a block of text

by enclosing it between the /* and */ characters, for example:

/* A "Hello World!" program in C#.

This program displays the string "Hello World!" on the screen. */

The Main Method

The C# program must contain a Main method, in which control starts and ends. The Main

method is where you create objects and execute other methods.

The Main method is a static method that resides inside a class or a struct. In the previous "Hello

World!" example, it resides in a class named Hello. Declare the Main method in one of the

following ways:

It can return void:

static void Main()

{

//...

}

It can also return an int:

static int Main()

{

//...

return 0;

}

With both of the return types, it can take arguments:

static void Main(string[] args)

{

//...

}

static int Main(string[] args)

{

//...

return 0;

}

41 | P a g e

The parameter of the Main method is a string array that represents the command-line arguments

used to invoke the program. Notice that, unlike C++, this array does not include the name of the

executable (exe) file.

Input and Output

C# programs generally use the input/output services provided by the run-time library of the .NET

Framework. The statement, System.Console.WriteLine("Hello World!"); uses the WriteLine

method, one of the output methods of the Console class in the run-time library. It displays its

string parameter on the standard output stream followed by a new line. Other Console methods

are used for different input and output operations. If you include the using System; directive at

the beginning of the program, you can directly use the System classes and methods without fully

qualifying them. For example, you can call Console.WriteLine instead, without specifying

System.Console.Writeline:

using System;

Console.WriteLine("Hello World!");

For more information about input/output methods, see System.IO.

Compilation and Execution

You can compile the "Hello World!" program either by creating a project in the Visual Studio

IDE, or by using the command line. Use the Visual Studio Command Prompt or invoke

vsvars32.bat to put the Visual C# tool set on the path in your command prompt.

To compile the program from the command line:

Create the source file by using any text editor and save it using a name such as Hello.cs. C#

source code files use the extension .cs.

To invoke the compiler, enter the command:

csc Hello.cs

If your program does not contain any compilation errors, a Hello.exe file will be created.

To run the program, enter the command:

A simple Example of input and output library to fetch the definition.

Trivial question:

What should be the output of the following code?


{

Console.WriteLine("Hello (crazy) World!");

}

42 | P a g e

DEMO lets run this code

Main() and Command Line Arguments

The Main method is the entry point of your program, where you create objects and invoke other

methods. There can only be one entry point in a C# program.

class TestClass

{


{

// Display the number of command line arguments:

System.Console.WriteLine(args.Length);

}

}

43 | P a g e

Overview

The Main method is the entry point of your program, where the program control starts and

ends.

It is declared inside a class or struct. It must be static and it should not be public. (In the

example above it receives the default access of private.)

It can either have a void or int return type.

The Main method can be declared with or without parameters.

Parameters can be read as zero-indexed command line arguments.

Unlike C and C++, the name of the program is not treated as the first command line

argument.

Types

Their r two type of types

1. Value Types

2. Reference Types

1. Value Types

The value types consist of two main categories:

Structs

Enumerations

Structs fall into these categories:

Numeric types

Integral types

Floating-point types

decimal

bool

User defined structs.

Main Features of Value Types

Variables that are based on value types directly contain values. Assigning one value type

variable to another copies the contained value. This differs from the assignment of reference type

variables, which copies a reference to the object but not the object itself.

All value types are derived implicitly from the System.ValueType.

Initializing Value Types

44 | P a g e

Local variables in C# must be initialized before they are used. For example, you might declare a

local variable without initialization as in the following example:

int myInt;

You cannot use it before you initialize it. You can initialize it using the following statement:

myInt = new int(); // Invoke default constructor for int type.

This statement is equivalent to the following statement:

myInt = 0; // Assign an initial value, 0 in this example.

You can, of course, have the declaration and the initialization in the same statement as in the

following examples:

int myInt = new int();

or

int myInt = 0;

2. Reference Types

Variables of reference types, referred to as objects, store references to the actual data. This

section introduces the following keywords used to declare reference types:

class

interface

delegate

This section also introduces the following built-in reference types:

object

string

45 | P a g e

Array

An array is a data structure that contains several variables of the same type. Arrays are declared

with a type:

type[] arrayName;

The following examples create single-dimensional, multidimensional, and jagged arrays:

using System;


using System.Linq;

using System.Text;


{

class TestArraysClass

{

static void Main()

{

// Declare a single-dimensional array

int[] array1 = new int[5];

// Declare and set array element values

int[] array2 = new int[] { 1, 3, 5, 7, 9 };

// Alternative syntax

int[] array3 = { 1, 2, 3, 4, 5, 6 };

// Declare a two dimensional array

int[,] multiDimensionalArray1 = new int[2, 3];

// Declare and set array element values

int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

// Declare a jagged array

int[][] jaggedArray = new int[6][];

// Set the values of the first array in the jagged array

structure

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

Console.ReadLine();

}

}

}

Array Overview

An array has the following properties:

An array can be Single-Dimensional, Multidimensional or Jagged.

46 | P a g e

The default value of numeric array elements are set to zero, and reference elements are set

to null.

A jagged array is an array of arrays, and therefore its elements are reference types and are

initialized to null.

Arrays are zero indexed: an array with n elements is indexed from 0 to n-1.

Array elements can be of any type, including an array type.

Array types are reference types derived from the abstract base type Array. Since this type

implements IEnumerable and IEnumerable(T), you can use foreach iteration on all arrays in

C#.

Arrays as Objects

In C#, arrays are actually objects, and not just addressable regions of contiguous memory as in C

and C++. Array is the abstract base type of all array types. You can use the properties, and other

class members, that Array has. An example of this would be using the Length property to get the

length of an array. The following code assigns the length of the numbers array, which is 5, to a

variable called lengthOfNumbers:

int[] numbers = { 1, 2, 3, 4, 5 };

int lengthOfNumbers = numbers.Length;

The System.Array class provides many other useful methods and properties for sorting,

searching, and copying arrays.

Example

This example uses the Rank property to display the number of dimensions of an array.

using System;


using System.Linq;

using System.Text;


{

class TestArraysClass

{

static void Main()

{

// Declare and initialize an array:

int[,] theArray = new int[5, 10];

System.Console.WriteLine("The array has {0} dimensions.",

theArray.Rank);

Console.ReadLine();

}

}

}

47 | P a g e

Output

The array has 2 dimensions.

Passing Arrays as Parameters

Arrays may be passed to methods as parameters. As arrays are reference types, the method

can change the value of the elements.

Passing single-dimensional arrays as parameters

You can pass an initialized single-dimensional array to a method. For example:

PrintArray(theArray);

The method called in the line above could be defined as:

void PrintArray(int[] arr)

{

// method code

}

You can also initialize and pass a new array in one step. For example:

PrintArray(new int[] { 1, 3, 5, 7, 9 });

Example 1

In the following example, a string array is initialized and passed as a parameter to the

PrintArray method, where its elements are displayed:

using System;


using System.Linq;

48 | P a g e

using System.Text;


{

class ArrayClass

{

static void PrintArray(string[] arr)

{

for (int i = 0; i < arr.Length; i++)

{

System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " "

: "");

}

System.Console.WriteLine();

}

static void Main()

{

// Declare and initialize an array:

string[] weekDays = new string[] { "Sun", "Mon", "Tue", "Wed",

"Thu", "Fri", "Sat" };

// Pass the array as a parameter:

PrintArray(weekDays);

Console.ReadLine();

}

}

}

Output 1

Sun Mon Tue Wed Thu Fri Sat

Passing multidimensional arrays as parameters

You can pass an initialized multidimensional array to a method. For example, if theArray is a

two dimensional array:

PrintArray(theArray);

The method called in the line above could be defined as:

void PrintArray(int[,] arr)

49 | P a g e

{

// method code

}

You can also initialize and pass a new array in one step. For example:

PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });

Example 2

In this example, a two-dimensional array is initialized and passed to the PrintArray method,

where its elements are displayed.

using System;


using System.Linq;

using System.Text;


{

class ArrayClass2D

{

static void PrintArray(int[,] arr)

{

// Display the array elements:

for (int i = 0; i < 4; i++)

{

for (int j = 0; j < 2; j++)

{

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

}

}

}

static void Main()

{

// Pass the array as a parameter:

PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });

Console.ReadLine();

}

}

}

50 | P a g e

Output 2

Element(0,0)=1

Element(0,1)=2

Element(1,0)=3

Element(1,1)=4

Element(2,0)=5

Element(2,1)=6

Element(3,0)=7

Element(3,1)=8

String

A C# string is an array of characters that is declared by using the string keyword. A string literal

is declared by using quotation marks, as shown in the following example:

string s = "Hello, World!";

You can extract substrings, and concatenate strings as in the following example:

string s1 = "orange";

string s2 = "red";

s1 += s2;

System.Console.WriteLine(s1); // outputs "orangered"

s1 = s1.Substring(2, 5);

System.Console.WriteLine(s1); // outputs "anger"

String objects are immutable: they cannot be changed after they have been created. Methods that

act on strings actually return new string objects. In the previous example, when the contents of s1

and s2 are concatenated to form a single string, the two strings that contain "orange" and "red"

are both unmodified. The += operator creates a new string that contains the combined contents.

The result is that s1 now refers to a different string completely. A string that contains just

"orange" still exists, but is no longer referenced when s1 is concatenated.

51 | P a g e

Note

Use caution when you create references to strings. If you create a reference to a string, and then

"modify" the string, the reference will continue to point to the original object, not the new

object that was created when the string was modified. The following code illustrates the danger:

string s1 = "Hello";

string s2 = s1;

s1 += " and goodbye.";

Console.WriteLine(s2); //outputs "Hello"

Because modifications to strings involve creating new string objects, for performance reasons,

large amounts of concatenation or other involved string manipulation should be performed with

the StringBuilder class, as in the following example:

System.Text.StringBuilder sb = new System.Text.StringBuilder();

sb.Append("one ");

sb.Append("two ");

sb.Append("three");

string str = sb.ToString();

System.Console.WriteLine(str);

// Outputs: one two three

The StringBuilder class is discussed in the "Using Stringbuilder" section.

Working with Strings

Escape Characters

Escape characters such as "\n" (new line) and "\t" (tab) can be included in strings. The line:

string hello = "Hello\nWorld!";

is the same as:

Hello

World!

If you want to include a backward slash, it must be preceded with another backward slash. The

following string:

string filePath = "\\\\My Documents\\";

is actually the same as:

\\My Documents\

52 | P a g e

Verbatim Strings: The @ Symbol

The @ symbol tells the string constructor to ignore escape characters and line breaks. The

following two strings are therefore identical:

string p1 = "\\\\My Documents\\My Files\\";

string p2 = @"\\My Documents\My Files\";

In a verbatim string, you escape the double quotation mark character with a second double

quotation mark character, as in the following example:

string s = @"You say ""goodbye"" and I say ""hello""";

Accessing Individual Characters

Individual characters that are contained in a string can be accessed by using methods such as

SubString() and Replace().

string s3 = "Visual C# Express";

System.Console.WriteLine(s3.Substring(7, 2)); // outputs "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic")); // outputs "Visual Basic Express"

It is also possible to copy the characters into a character array, as in the following example:

string s4 = "Hello, World";

char[] arr = s4.ToCharArray(0, s4.Length);

foreach (char c in arr)

{

System.Console.Write(c); // outputs "Hello, World"

}

Individual characters from a string can be accessed with an index, as in the following example:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)

{

System.Console.Write(s5[s5.Length - i - 1]); // outputs "sdrawkcab gnitnirP"

}

Changing Case

To change the letters in a string to uppercase or lowercase, use ToUpper() or ToLower(), as in

the following example:

string s6 = "Battle of Hastings, 1066";

53 | P a g e

System.Console.WriteLine(s6.ToUpper()); // outputs "BATTLE OF HASTINGS 1066"

System.Console.WriteLine(s6.ToLower()); // outputs "battle of hastings 1066"

Comparisons

The simplest way to compare two strings is to use the == and != operators, which perform a

case-sensitive comparison.

string color1 = "red";

string color2 = "green";

string color3 = "red";

if (color1 == color3)

{

System.Console.WriteLine("Equal");

}

if (color1 != color2)

{

System.Console.WriteLine("Not equal");

}

String objects also have a CompareTo() method that returns an integer value that is based on

whether one string is less-than () another. When comparing

strings, the Unicode value is used, and lowercase has a smaller value than uppercase. For more

information about the rules for comparing strings, see CompareTo().

// Enter different values for string1 and string2 to

// experiement with behavior of CompareTo

string string1 = "ABC";

string string2 = "abc";

int result = string1.CompareTo(string2);

if (result > 0)

{

System.Console.WriteLine("{0} is greater than {1}", string1, string2);

}

else if (result == 0)

{

System.Console.WriteLine("{0} is equal to {1}", string1, string2);

}

else if (result < 0)

{

System.Console.WriteLine("{0} is less than {1}", string1, string2);

}

// Outputs: ABC is less than abc

54 | P a g e

To search for a string inside another string, use IndexOf(). IndexOf() returns -1 if the search

string is not found; otherwise, it returns the zero-based index of the first location at which it

occurs.

string s9 = "Battle of Hastings, 1066";

System.Console.WriteLine(s9.IndexOf("Hastings")); // outputs 10

System.Console.WriteLine(s9.IndexOf("1967")); // outputs -1

Splitting a String into Substrings

Splitting a string into substrings, such as splitting a sentence into individual words, is a common

programming task. The Split() method takes a char array of delimiters, for example, a space

character, and returns an array of substrings. You can access this array with foreach, as in the

following example:

char[] delimit = new char[] { ' ' };

string s10 = "The cat sat on the mat.";

foreach (string substr in s10.Split(delimit))

{

System.Console.WriteLine(substr);

}

This code outputs each word on a separate line, as in the following example:

The

cat

sat

on

the

mat.

Null Strings and Empty Strings

An empty string is an instance of a System.String object that contains zero characters. Empty

strings are used often in various programming scenarios to represent a blank text field. You can

call methods on empty strings because they are valid System.String objects. Empty strings are

initialized as follows:

string s = "";

By contrast, a null string does not refer to an instance of a System.String object and any attempt

to call a method on a null string causes a NullReferenceException. However, you can use null

strings in concatenation and comparison operations with other strings. The following examples

illustrate some cases in which a reference to a null string does and does not cause an exception to

be thrown:

55 | P a g e

string str = "hello";

string nullStr = null;

string emptyStr = "";

string tempStr = str + nullStr; // tempStr = "hello"

bool b = (emptyStr == nullStr);// b = false;

emptyStr + nullStr = ""; // creates a new empty string

int len = nullStr.Length; // throws NullReferenceException

Using String Builder

The String Builder class creates a string buffer that offers better performance if your program

performs many string manipulations. The String Builder string also enables you to reassign

individual characters, something the built-in string data type does not support. This code, for

example, changes the content of a string without creating a new string:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");

sb[0] = 'C';

System.Console.WriteLine(sb.ToString());

System.Console.ReadLine();

//Outputs Cat: the ideal pet

In this example, a StringBuilder object is used to create a string from a set of numeric types:

using System;


using System.Linq;

using System.Text;


{

class TestStringBuilder

{

static void Main()

{

System.Text.StringBuilder sb = new System.Text.StringBuilder();

// Create a string composed of numbers 0 - 9

for (int i = 0; i < 10; i++)

{

sb.Append(i.ToString());

}

System.Console.WriteLine(sb); // displays 0123456789

// Copy one character of the string (not possible with a

System.String)

sb[0] = sb[9];

56 | P a g e

System.Console.WriteLine(sb); // displays 9123456789

Console.ReadLine();

}

}

}

The following code example demonstrates how a string can be parsed using the String.Split

method. This method works by returning an array of strings, where each element is a word. As

input, Split takes an array of chars that indicate which characters are to be used as delimiters. In

this example, spaces, commas, periods, colons, and tabs are used. An array containing these

delimiters is passed to Split, and each word in the sentence is displayed separately using the

resulting array of strings.

Example

using System;


using System.Linq;

using System.Text;


{

class TestStringSplit

{

static void Main()

{

char[] delimiterChars = { ' ', ',', '.', ':', '\t' };

string text = "one\ttwo three:four,five six seven";

System.Console.WriteLine("Original text: '{0}'", text);

string[] words = text.Split(delimiterChars);

System.Console.WriteLine("{0} words in text:", words.Length);

foreach (string s in words)

{

System.Console.WriteLine(s);

}

Console.ReadLine();

}

}

}

Original text: 'one two three:four,five six seven'

7 words in text:

one

two

57 | P a g e

three

four

five

six

seven

Property

Properties are members that provide a flexible mechanism to read, write, or compute the values

of private fields. Properties can be used as if they are public data members, but they are actually

special methods called accessors. This enables data to be accessed easily and still helps promote

the safety and flexibility of methods.

In this example, the TimePeriod class stores a time period. Internally the class stores the time in

seconds, but a property named Hours enables a client to specify a time in hours. The accessors

for the Hours property perform the conversion between hours and seconds.

Example

using System;


using System.Linq;

using System.Text;


{

class TimePeriod

{

private double seconds;

public double Hours

{

get

{

return seconds / 3600;

}

set

{

seconds = value * 3600;

}

}

}

class Program

{

static void Main()

{

58 | P a g e

TimePeriod t = new TimePeriod();

// Assigning the Hours property causes the 'set' accessor to be called.

t.Hours = 24;

// Evaluating the Hours property causes the 'get' accessor to be called.

System.Console.WriteLine("Time in hours: " + t.Hours);

Console.ReadLine();

}

}

}

Output

Time in hours: 24

Properties Overview

Properties enable a class to expose a public way of getting and setting values, while hiding

implementation or verification code.

A get property accessor is used to return the property value, and a set accessor is used to

assign a new value. These accessors can have different access levels. For more information,

The value keyword is used to define the value being assigned by the set indexer.

Properties that do not implement a set method are read only.

For simple properties that require no custom accessor code, consider the option of using

auto-implemented properties. For more information,

Properties combine aspects of both fields and methods. To the user of an object, a property

appears to be a field, accessing the property requires the same syntax. To the implementer of a

class, a property is one or two code blocks, representing a get accessor and/or a set accessor. The

code block for the get accessor is executed when the property is read; the code block for the set

accessor is executed when the property is assigned a new value. A property without a set

accessor is considered read-only. A property without a get accessor is considered write-only. A

property that has both accessors is read-write.

Properties have many uses: they can validate data before allowing a change; they can

transparently expose data on a class where that data is actually retrieved from some other source,

such as a database; they can take an action when data is changed, such as raising an event, or

changing the value of other fields.

Properties are declared in the class block by specifying the access level of the field, followed by

the type of the property, followed by the name of the property, and followed by a code block that

declares a get-accessor and/or a set accessor. For example:

59 | P a g e

public class Date

{

private int month = 7; //"backing store"

public int Month

{

get

{

return month;

}

set

{

if ((value > 0) && (value < 13))

{

month = value;

}

}

}

}

In this example, Month is declared as a property so that the set accessor can make sure that the

Month value is set between 1 and 12. The Month property uses a private field to track the actual

value. The real location of a property's data is often referred to as the property's "backing store."

It is common for properties to use private fields as a backing store. The field is marked private in

order to make sure that it can only be changed by calling the property. For more information

about public and private access restrictionsAuto-implemented properties provide simplified

syntax for simple property declarations. For more information.

60 | P a g e

The get Accessor

The body of the get accessor resembles that of a method. It must return a value of the property

type. The execution of the get accessor is equivalent to reading the value of the field. For

example, when you are returning the private variable from the get accessor and optimizations are

enabled, the call to the get accessor method is inlined by the compiler so there is no method-call

overhead. However, a virtual get accessor method cannot be inlined because the compiler does

not know at compile-time which method may actually be called at run time. The following is a

get accessor that returns the value of a private field name:

class Person

{

private string name; // the name field

public string Name // the Name property

{

get

{

return name;

}

}

}

When you reference the property, except as the target of an assignment, the get accessor is

invoked to read the value of the property. For example:

Person p1 = new Person();

//...

System.Console.Write(p1.Name); // the get accessor is invoked here

61 | P a g e

The get accessor must end in a return or throw statement, and control cannot flow off the

accessor body.

It is a bad programming style to change the state of the object by using the get accessor. For

example, the following accessor produces the side effect of changing the state of the object every

time that the number field is accessed.

private int number;

public int Number

{

get

{

return number++; // Don't do this

}

}

The get accessor can be used to return the field value or to compute it and return it. For example:

class Employee

{

private string name;

public string Name

{

get

{

return name != null ? name : "NA";

}

}

}

62 | P a g e

In the previous code segment, if you do not assign a value to the Name property, it will return the

value NA.

The set Accessor

The set accessor resembles a method whose return type is void. It uses an implicit parameter

called value, whose type is the type of the property. In the following example, a set accessor is

added to the Name property:

class Person

{

private string name; // the name field

public string Name // the Name property

{

get

{

return name;

}

set

{

name = value;

}

}

}

When you assign a value to the property, the set accessor is invoked by using an argument that

provides the new value. For example:

Person p1 = new Person();

63 | P a g e

p1.Name = "Joe"; // the set accessor is invoked here

System.Console.Write(p1.Name); // the get accessor is invoked here

It is an error to use the implicit parameter name, value, for a local variable declaration in a set

accessor.

Example 1

Description

This example demonstrates instance, static, and read-only properties. It accepts the name of the

employee from the keyboard, increments NumberOfEmployees by 1, and displays the Employee

name and number.

using System;


using System.Linq;

using System.Text;


{

public class Employee

{

public static int NumberOfEmployees;

private static int counter;

private string name;

// A read-write instance property:

public string Name

{

get { return name; }

set { name = value; }

}

// A read-only static property:

public static int Counter

{

get { return counter; }

}

// A Constructor:

public Employee()

{

// Calculate the employee's number:

counter = ++counter + NumberOfEmployees;

}

}

64 | P a g e

class TestEmployee

{

static void Main()

{

Employee.NumberOfEmployees = 100;

Employee e1 = new Employee();

e1.Name = "Claude Vige";

System.Console.WriteLine("Employee number: {0}", Employee.Counter);

System.Console.WriteLine("Employee name: {0}", e1.Name);

Console.ReadLine();

}

}

}

Output 1

Employee number: 101

Employee name: Claude Vige

Indexer

Indexers allow instances of a class or struct to be indexed just like arrays. Indexers resemble

properties except that their accessors take parameters.

In the following example, a generic class is defined and provided with simple get and set

accessor methods as a means of assigning and retrieving values. The Program class creates an

instance of this class for storing strings.

class SampleCollection

{

private T[] arr = new T[100];

public T this[int i]

{

get

{

return arr[i];

}

set

{

arr[i] = value;

}

65 | P a g e

}

}

// This class shows how client code uses the indexer

class Program

{


{

SampleCollection stringCollection = new SampleCollection();

stringCollection[0] = "Hello, World";

System.Console.WriteLine(stringCollection[0]);

}

}

Indexers Overview

Indexers enable objects to be indexed in a similar manner to arrays.

A get accessor returns a value. A set accessor assigns a value.

The this keyword is used to define the indexers.

The value keyword is used to define the value being assigned by the set indexer.

Indexers do not have to be indexed by an integer value; it is up to you how to define the

specific look-up mechanism.

Indexers can be overloaded.

Indexers can have more than one formal parameter, for example, when accessing a two-

dimensional array.

Indexers are a syntactic convenience that enable you to create a class, struct, or interface that

client applications can access just as an array. Indexers are most frequently implemented in types

whose primary purpose is to encapsulate an internal collection or array. For example, suppose

you have a class named TempRecord that represents the temperature in Farenheit as recorded at

10 different times during a 24 hour period. The class contains an array named "temps" of type

float to represent the temperatures, and a DateTime that represents the date the temperatures

were recorded. By implementing an indexer in this class, clients can access the temperatures in a

TempRecord instance as float temp = tr[4] instead of as float temp = tr.temps[4]. The indexer

notation not only simplifies the syntax for client applications; it also makes the class and its

purpose more intuitive for other developers to understand.

To declare an indexer on a class or struct, use the this keyword, as in this example:

public int this[int index] // Indexer declaration

{

66 | P a g e

// get and set accessors

}

The type of an indexer and the type of its parameters must be at least as accessible as the indexer

itself. For more information about accessibility levels, see Access Modifiers.

For more information about how to use indexers with an interface, see Interface Indexers.

The signature of an indexer consists of the number and types of its formal parameters. It does not

include the indexer type or the names of the formal parameters. If you declare more than one

indexer in the same class, they must have different signatures.

An indexer value is not classified as a variable; therefore, you cannot pass an indexer value as a

ref or out parameter.

To provide the indexer with a name that other languages can use, use a name attribute in the

declaration. For example:

[System.Runtime.CompilerServices.IndexerName("TheItem")]

public int this [int index] // Indexer declaration

{

}

This indexer will have the name TheItem. Not providing the name attribute would make Item the

default name.

public class Customer

{

//Fields, properties, methods and events go here...

}

Example 1

The following example shows how to declare a private array field, temps, and an indexer. The

indexer enables direct access to the instance tempRecord[i]. The alternative to using the indexer

is to declare the array as a public member and access its members, tempRecord.temps[i],

directly.

67 | P a g e

Notice that when an indexer's access is evaluated, for example, in a Console.Write statement,

the get accessor is invoked. Therefore, if no get accessor exists, a compile-time error occurs.

using System;


using System.Linq;

using System.Text;


{

class TempRecord

{

// Array of temperature values

private float[] temps = new float[10] { 56.2F, 56.7F, 56.5F, 56.9F,

58.8F,

61.3F, 65.9F, 62.1F, 59.2F, 57.5F

};

// Auto-Implemented Property

System.DateTime date { get; set; }

// To enable client code to validate input

// when accessing your indexer.

public int Length

{

get { return temps.Length; }

}

// Indexer declaration.

// Input parameter is validated by client

// code before being passed to the indexer.

public float this[int index]

{

get

{

return temps[index];

}

set

{

temps[index] = value;

}

}

}

class MainClass

{

static void Main()

{

TempRecord tempRecord = new TempRecord();

// Use the indexer's set accessor

tempRecord[3] = 58.3F;

tempRecord[5] = 60.1F;

// Use the indexer's get accessor

for (int i = 0; i < 10; i++)

{

// This example validates the input on the client side. You

may

// choose to validate it in the class that implements the

68 | P a g e

indexer, and throw an

// exception or return an error code in the case of invalid

input.

if (i < tempRecord.Length)

{

System.Console.WriteLine("Element #{0} = {1}", i,

tempRecord[i]);

}

else

{

System.Console.WriteLine("Index value of {0} is out of

range", i);

}

Console.ReadLine();

}

//Uncomment this code to see how the .NET Framework handles

indexer exceptions

//try

//{

// System.Console.WriteLine("Element #{0} = {1}",

tempRecord[tempRecord.Length]);

//}

//catch (System.ArgumentOutOfRangeException e)

//{

// System.Console.WriteLine(e);

//}

}

}

}

Indexing Using Other Values

C# does not limit the index type to integer. For example, it may be useful to use a string with an

indexer. Such an indexer might be implemented by searching for the string in the collection, and

returning the appropriate value. As accessors can be overloaded, the string and integer versions

c

NET_BOOK

Documents

framework language

microsoft net framework

net application

software framework

g e net framework

common language infrastructure

multiple language

single language