Professional Documents
Culture Documents
Tutorial C#Notes
Tutorial C#Notes
1. What is .NET?
.NET provides a common set of class libraries, which can be accessed from any .NET
based programming language. There will not be separate set of classes and libraries for
each language. If you know any one .NET language, you can write code in any .NET
language!!
In future versions of Windows, .NET will be freely distributed as part of operating system
and users will never have to install .NET separately.
2. What is Not?
3. ".NET is a framework"
Confused with this definition?
When you write code in any language and compile, it will be converted to an
'Intermediate Language' (Microsoft Intermediate Language - MSIL).
So, your compiled executable contains the IL and not really ex ecutable machine
language.
When the .NET application runs, the .NET framework in the target computer take care of
the execution. (To run a .NET application, the target computer should have .NET
framework installed.)
The .NET framework converts the calls to .NET class libraries to the corresponding APIs
of the Operating system.
Whether you write code in C# or VB.NET, you are calling methods in the same .NET
class libraries.
The code you write is platform independent, because whatever you write is getting
compiled into MSIL.
There is no native code, which depends on your operating system or CPU. But when you
execute the MSIL, the .NET framework in the target system will convert the MSIL into
native platform code.
So, if you run your .NET exe in a Windows machine, the .NET framework for Windows
will convert it into Windows native code and execute.
If you run your .NET application in Unix or Linux, the .NET framework for Unix/Linux will
convert your code into Unix/Linux native code and execute.
But wait, we said it wrong... there is no .NET framework for UNIX or Linux available now.
Microsoft has written the .NET framework only for Windows.
If you or some one else write a .NET framework for other platforms in future, your code
will run there too. So, let us wait until someone write .NET framework for Linux before
you run your .NET code in Linux.
Application
.NET Framework
Libraries
Developer Tools
.NET
Enterprise
Servers
.NET
Building
Block
Services
CLR
C#, Visual Basic .NET
Windows OS (Win 32)
.NET Compliant
Languages
(VC++, VB.NET,
ASP.NET, C# and
other third party
languages)
Windows Forms
Web Forms
Web Services
Source Code
Compiler
Class Libraries
(IL & Metadata)
Class loader
JIT Compiler
Trusted preJIT code only
Managed
Native Code
Call to an uncompiled
method
Execution
Security
checks
Runtime Engine
Source code to native code and code execution
When compiling source code, the compiler translates it into an intermediate code represented in
MSIL. Before code can be run, MSIL code must be converted to CPU-specific code, usually by a
just-in-time (JIT) compiler. When a compiler produces MSIL, it also produces metadata. Metadata
includes following information: -
Description of the types in your code, including the definition of each type.
The signatures of each types members,
The members that your code references.
Other data that the runtime uses at execution time.
The MSIL and metadata are contained in a portable executable (PE) file that is based on and
extends the published Microsoft PE and Common object file format (COFF) used historically for
executable content. The file format, which accommodates MSIL or native code as well as
metadata, enables the operating system to recognize common language runtime images.
4.3 Compiling MSIL to Native Code
Before you can run Microsoft intermediate language (MSIL), it must be compiled against the
common language runtime to native code for the target machine architecture. The .NET
Framework provides two ways to perform this conversion:
A .NET Framework just-in-time (JIT) compiler.
The .NET Framework Ngen.exe (Native Image Generator).
4.4 Compilation by the JIT Compiler
JIT compilation converts MSIL to native code on demand at application run time, when the
contents of an assembly are loaded and executed. Because the common language runtime
supplies a JIT compiler for each supported CPU architecture, developers can build a set of MSIL
assemblies that can be JIT-compiled and run on different computers with different machine
architectures. However, if your managed code calls platform-specific native APIs or a platformspecific class library, it will run only on that operating system.
JIT compilation takes into account the possibility that some code might never be called during
execution. Instead of using time and memory to convert all the MSIL in a PE file to native code, it
converts the MSIL as needed during execution and stores the resulting native code in memory so
that it is accessible for subsequent calls in the context of that process. The loader creates and
attaches a stub to each method in a type when the type is loaded and initialized. When a method
is called for the first time, the stub passes control to the JIT compiler, which converts the MSIL for
that method into native code and modifies the stub to point directly to the generated native code.
Therefore, subsequent calls to the JIT-compiled method go directly to the native code.
Install-Time Code Generation Using NGen.exe
Because the JIT compiler converts an assembly's MSIL to native code when individual methods
defined in that assembly are called, it affects performance adversely at run time. In most cases,
that diminished performance is acceptable. More importantly, the code generated by the JIT
compiler is bound to the process that triggered the compilation. It cannot be shared across
multiple processes. To allow the generated code to be shared across multiple invocations of an
application or across multiple processes that share a set of assemblies, the common language
runtime supports an ahead-of-time compilation mode. This ahead-of-time compilation mode uses
the Ngen.exe (Native Image Generator) to convert MSIL assemblies to native code much like the
JIT compiler does. However, the operation of Ngen.exe differs from that of the JIT compiler in
three ways:
It performs the conversion from MSIL to native code before running the application instead of
while the application is running.
It compiles an entire assembly at a time, instead of one method at a time.
It persists the generated code in the Native Image Cache as a file on disk.
2.
3.
4.
5.
6.
7.
8.
9.
When you compile a program developed in a language that targets the CLR, instead of
compiling the source code into machine-level code, the compiler translates it into
Microsoft Intermediate Language (MSIL) or Intermediate language (IL). This ensures
language interoperability.
In addition to translating the code into IL, the compiler also produces metadata about the
program during the process of compilation. Metadata contains the description of the
program, such as classes and interfaces, the dependencies and the versions of the
components used in the program.
The IL and the metadata are linked in assembly.
The compiler creates the .EXE or .DLL file.
When you execute the .EXE or .DLL file, the code (converted to IL) and all the other
relevant information from the base class library is sent to the class loader. The class
loader loads the code in the memory.
Before the code can be executed, the .NET framework needs to convert the IL into native
or CPU-specific code. The Just-in-time (JIT) compiler translates the code from IL to
managed native code. The CLR supplies a JIT compiler for each supported CPU
architecture. During the process of compilation, the JIT compiler compiles only the code
that is required during execution instead of compiling the complete IL code. When an
uncompiled method is invoked during execution, the JIT compiler converts the IL for that
method into native code. This process saves the time and memory required to convert
the complete IL into native code.
During JIT compilation, the code is also checked for type safety. Type safety ensures that
objects are always accessed in a compatible way. Therefore, if you try to pass an 8-byte
value to a method that accepts a 4-byte value as a parameter, the CLR will detect and
trap such an attempt. Type safety also ensures that objects are safely isolated from each
other and are therefore safe from any malicious corruption.
After translating the IL into native code, the converted code is sent to the .NET runtime
manager.
The .NET runtime manager executes the code. While executing the code, a security
check is performed to ensure that the code has the appropriate permissions for
accessing the available resources.
The language interoperability and .NET Class Framework are not possible without all the
language sharing the same data type. CTS is an important part of the runtime support for crosslanguage integration. The CTS performs the following functions:
Establishes a framework that enables cross-language integration, type safety and high
performance code execution.
Metadata
A set of base rules to which any language targeting the CLI should conform in order to
interoperate with other CLS-compliant languages. The CLS rules define a subset of the Common
Type System.
The VES loads and executes CLI-compatible programs, using the metadata to combine
separately generated pieces of code at runtime.
The Common Language Runtime
The CLR is one of the most essential components of the .NET framework. The CLR or the
runtime provides functionality such as exception handling, security, debugging, and versioning
support to any language that targets it. The CLR can execute programs written any language.
You can use the compilers to write the code that runs in the managed execution environment
provided by the CLR. The code that is developed with a language compiler that targets the CLR
is managed code. On the other hand, the code that is developed without considering the
conventions and requirements of the common language run time is called unmanaged code.
CLR activates objects, performs security checks, lays them out in memory, executes them and
garbage collects these objects as well.
The CLR is a runtime engine that loads required classes, performs just in time compilations, and
enforces security checks and a bunch of other runtime functions.
Automatic Memory Management: The CLR provides the garbage collection feature for
managing the lifetime of an object. This process relieves a programmer of the task of
manual memory management by deallocating the blocks of memory associated with
objects that are no longer being used. The objects whose lifetime is managed by the
garbage collection process are called managed data.
Standard Type System: The CLR implements a formal specification called Common Type
System (CTS). The CTS is an important part of the support provided by the CLR for
cross-language integration because it provides a type system that is common across all
programming languages. It also defines the rules that ensure that objects written in
different languages can interact with each other.
Platform Independence: When you compile a program developed in language that targets
the CLR, the compiler translates the code into an intermediate language. This language
is CPU-independent. This means that the code can be executed from any platform that
supports the .NET CLR.
Type Safety: This feature ensures that objects are always accessed in compatible ways.
Therefore the CLR will prohibit a code from assigning a 10-byte value to an object that
occupies 8 bytes.
Abstraction
Encapsulation
Inheritance
Polymorphism
Abstraction is the ability to generalize an object as a data type that has a specific set of
characteristics and is able to perform a set of actions.
Object-oriented languages provide abstraction via classes. Classes define the properties and
methods of an object type.
Examples:
You can create an abstraction of a dog with characteristic s, such as color, height, and weight,
and actions such as run and bite. The characteristics are called properties, and the actions are
called methods.
A Recordset object is an abstract representation of a set of data.
Classes are blueprints for Object.
Objects are instance of classes.
Object References
When we work with an object we are using a reference to that object. On the other hand, when
we are working with simple data types such as Integer, we are working with the actual value
rather than a reference.
When we create a new object using the New keyword, we store a reference to that object in a
variable. For instance:
Draw MyDraw = new Draw;
This code creates a new instance of Draw. We gain access to this new object via the MyDraw
variable. This variable holds a reference to the object.
Now we have a second variable, which also has a reference to that same object. We can use
either variable interchangeably, since they both reference the exact same object. The thing we
need to remember is that the variable we have is not the object itself but, rather, is just a
reference or pointer to the object itself.
Early binding means that our code directly interacts with the object, by directly calling its
methods. Since the compiler knows the object's data type ahead of time, it can directly compile
code to invoke the methods on the object. Early binding also allows the IDE to use IntelliSense to
aid our development efforts; it allows the compiler to ensure that we are referencing methods that
do exist and that we are providing the proper parameter values.
Access Modifiers
Access Modifiers are keywords used to specify the declared accessibility of a member of a type.
Public is visible to everyone. A public member can be accessed using an instance of a class, by
a class's internal code, and by any descendants of a class.
Private is hidden and usable only by the class itself. No code using a class instance can access
a private member directly and neither can a descendant class.
Protected members are similar to private ones in that they are accessible only by the containing
class. However, protected members also may be used by a descendant class. So members that
are likely to be needed by a descendant class should be marked protected.
10
Internal/Friend is public to the entire application but private to any outside applications. Internal
is useful when you want to allow a class to be used by other applications but reserve special
functionality for the application that contains the class. Internal is used by C# and Friend by VB
.NET.
Protected Internal may be accessed only by a descendant class that's contained in the same
application as its base class. You use protected internal in situations where you want to deny
access to parts of a class functionality to any descendant classes found in other applications.
11
Composition of an OBJECT
We use an interface to get access to an object's data and behavior. The object's data and
behaviors are contained within the object, so a client application can treat the object like a black
box accessible only through its interface. This is a key object-oriented concept called
Encapsulation. The idea is that any programs that make use of this object won't have direct
access to the behaviors or data-but rather those programs must make use of our object's
interface.
There are three main parts of Object:
1. Interface
2. Implementation or Behavior
3. Member or Instance variables
Interface
The interface is defined as a set of methods (Sub and Function routines), properties (Property
routines), events, and fields (variables or attributes) that are declared Public in scope.
Implementation or Behavior
The code inside of a method is called the implementation. Sometimes it is also called behavior
since it is this code that actually makes the object do useful work.
Client applications can use our object even if we change the implementation-as long as we don't
change the interface. As long as our method name and its parameter list and return data type
remain unchanged, we can change the implementation all we want .
So Method Signature depends on:
Method name
12
It is important to keep in mind that encapsulation is a syntactic tool-it allows our code to continue
to run without change. However, it is not semantic-meaning that, just because our code continues
to run, doesn't mean it continues to do what we actually wanted it to do.
}
Above listing shows defines an interface named IMyInterface.
All the methods of Interface are public by default and no access modifiers (like private, public) are
allowed with any method of Interface.
Using an Interface: InterfaceImplementer.cs
class InterfaceImplementer : IMyInterface
{
public void MethodToImplement ()
{
Console.WriteLine("MethodToImplement() called.");
}
}
The InterfaceImplementer class in above listing implements the IMyInterface interface. Indicating
that a class inherits an interface is the same as inheriting a class. In this case, the following
syntax is used:
class InterfaceImplementer : IMyInterface
13
Note that this class inherits the IMyInterface interface; it must implement its all members. While
implementing interface methods all those needs to be declared public only. It does this by
implementing the MethodToImplement() method. Notice that this method implementation has the
exact same signature, parameters and method name, as defined in the IMyInterface interface.
Any difference will cause a compiler error.
Inheritance is the idea that one class, called a subclass, can be based on another cl ass,
called a base class. Inheritance provides a mechanism for creating hierarchies of objects.
Inheritance is an important object-oriented concept. It allows you to build a hierarchy of related
classes, and to reuse functionality defined in existing clas ses.
Inheritance is the ability to apply another class's interface and code to your own class.
Normal base classes may be instantiated themselves, or inherited. Derived classes can inherit
base class members marked with protected or greater access. The derived class is specialized to
provide more functionality, in addition to what its base class provides. Inheriting base class
members in derived class is not mandatory.
C# supports two types of Inheritance mechanisms: 1) Implementation Inheritance
2) Interface Inheritance
Types of Inheritance
1.
2.
3.
4.
Single Inheritance
Multilevel Inheritance
Multiple Inheritance
(Implementation is possible through
Hierarchical Inheritance
Interface)
14
Class A
Class B
Single Inheritance
Class A
Class A
Class B
Class D
Class C
Hierarchical Inheritance
Class A
Class B
Class B
Class C
Class C
Multilevel Inheritance
Multiple Inheritance
{ }
public class C : A, B
{ }
Polymorphism
Polymorphism is the ability to define a method or property in a set of derived classes with
matching method signatures but provide different implementations and then distinguish the
objects' matching interface from one another at runtime when you call the method on the base
class.
It is a feature to use one name in many forms. It can be achieved in following ways:
Method Overloading
Method Overriding
Method Hiding
15
new
virtual
override
1. When a derived class inherits from a base class, it gains all the methods, fields, properties and
events of the base class. To change the data and behavior of a base class, you have two
choices: you can replace the base member with a new derived member, or you can override a
virtual base member.
Replacing a member of a base class with a new derived member requires the new keyword. If a
base class defines a method, field, or property, the new keyword is used to create a new
definition of that method, field, or property on a derived class. The new keyword is placed before
the return type of a class member that is being replaced. For example:
public class BaseClass
{
public void DoWork() { }
public int WorkField;
public int WorkProperty
{
get { return 0; }
}
}
public class DerivedClass : BaseClass
{
public new void DoWork() { }
public new int WorkField;
public new int WorkProperty
{
get { return 0; }
}
}
DerivedClass B = new DerivedClass();
B.DoWork(); // Calls the new method.
BaseClass A = (BaseClass)B;
A.DoWork(); // Calls the old method.
2,3. In order for an instance of a derived class to completely take over a class member from a
base class, the base class has to declare that member as virtual. This is accomplished by adding
the virtual keyword before the return type of the member. A derived class then has the option of
using the override keyword, instead of new, to replace the base class implementation with its
own. For example:
public class BaseClass
{
public virtual void DoWork() { }
public virtual int WorkProperty
{
get { return 0; }
}
}
16
When a virtual method is invoked, the run-time type of the object is checked for an
overriding member. The overriding member in the most derived class is called, whic h
might be the original member, if no derived class has overridden the member.
You cannot use the virtual modifier with the static, abstract, private or override modifiers.
Virtual properties behave like abstract methods, except for the differences in declaration
and invocation syntax.
You cannot override a non-virtual or static method. The overridden base method must be
virtual, abstract, or override.
An override declaration cannot change the accessibility of the virtual method. Both the
override method and the virtual method must have the same access level modifier.
You cannot use the modifiers new, static, virtual, or abstract to modify an override
method.
An overriding property declaration must specify the exact same access modifier, type,
and name as the inherited property, and the overridden property must be virtual, abstract,
or override.
17
18
An abstract class cannot be instantiated directly, and it is a compile-time error to use the
new operator on an abstract class. While it is possible to have variables and values
whose compile-time types are abstract, such variables and values will necessarily either
be null or contain references to instances of non-abstract classes derived from the
abstract types.
An abstract class is permitted (but not required) to contain abstract methods and
members.
Abstract properties behave like abstract methods, except for the differences in decl aration and
invocation syntax.
19
20
Constructor
Constructor
Constructor
Constructor
external).
Constructor
Default Constructor
Parameterized constructor
Private Constructor
Static Constructor
Copy Constructor
Default Constructor
A constructor that takes no parameters is called a default constructor.
When a class is initiated default constructor is called which provides default values to different
data members of the class.
You need not to define default constructor it is implicitly defined.
21
class Program
{
class C1
{
int a, b;
public C1()
{
this.a = 10;
this.b = 20;
}
public void display()
{
Console.WriteLine("Value of a: {0}", a);
Console.WriteLine("Value of b: {0}", b);
}
}
static void Main(string[] args)
{
C1 ob1 = new C1();
ob1.display();
Console.ReadLine();
}
}
Output: - Value of a: 10
Value of b: 20
Parameterized constructor
Constructor that accepts arguments is known as parameterized constructor. There may be
situations, where it is necessary to initialize various data members of different objects with
different values when they are created. Parameterized constructors help in doing that task.
class Program
{
class C1
{
int a, b;
public C1(int x, int y)
{
this.a = x;
this.b = y;
}
public void display()
{
Console.WriteLine("Value of a: {0}", a);
Console.WriteLine("Value of b: {0}", b);
22
If you don't want the class to be inherited we declare its constructor private.
We can't initialize the class outside the class or the instance of class can't be created
outside if its constructor is declared private.
We have to take help of nested class (Inner Class) or static method to initialize a class
having private constructor.
23
Static Constructors
C# supports two types of constructor, a class constructor static constructor and an instance
constructor (non-static constructor).
Static constructors might be convenient, but they are slow. The runtime is not smart enough to
optimize them in the same way it can optimize inline assignments. Non-static constructors are
inline and are faster.
Static constructors are used to initializing class static data members.
Point to be remembered while creating static constructor:
1.
2.
3.
4.
Static members are preloaded in the memory. While instance members are post loaded into
memory.
Static methods can only use static data members.
Example:
class Program
{
public class test
{
static string name;
static int age;
static test()
{
Console.WriteLine("Using static constructor to initialize
static data members");
name = "John Sena";
age = 23;
}
public static void display()
{
Console.WriteLine("Using static function");
Console.WriteLine(name);
Console.WriteLine(age);
}
}
static void Main(string[] args)
{
test.display();
Console.ReadLine();
}}
24
Copy Constructor
If you create a new object and want to copy the values from an existing object, you use copy
constructor.
This constructor takes a single argument: a reference to the object to be copied.
Example:
class Program
{
class c1
{
int a, b;
public c1(int x, int y)
{
this.a = x;
this.b = y;
}
// Copy construtor
public c1(c1 a)
{
this.a = a.a;
this.b = a.b;
}
public void display()
{
int z = a + b;
Console.WriteLine(z);
}
}
static void Main(string[] args)
{
c1 ob1 = new c1(10, 20);
ob1.display();
// Here we are using copy constructor. Copy
constructor is
using the values already defined with ob1
c1 ob2 = new c1(ob1);
ob2.display();
Console.ReadLine();
}
}
Output:
30
30
25
Remember that a destructor can't have any modifiers like private, public etc. If we declare
a destructor with a modifier, the compiler will show an error.
Also destructor will come in only one form, without any arguments.
There is no parameterized destructor in C#.
Destructors are invoked automatically and can't be invoked explicitly. An object becomes eligible
for garbage collection, when it is no longer used by the active part of the program. Execution of
destructor may occur at any time after the instance or object becomes eligible for destruction.
Operator Overloading
Operator overloading permits user-defined operator implementations to be specified for
operations where one or both of the operands are of a user-defined class or struct type.
In another way, Operator overloading is a concept in which operator can define to work with the
user defined data types such as structs and classes in the same way as the pre-defined data
types.
There are many operators which can not be overloaded, which are listed below: Conditional Operator
&&, ||
Compound Assignment +=, -=, *=, /=, %=
Other Operators
[], ( ), =, ?:, ->, new, sizeof, typesof.
26
In C#, a special function called operator function is used for overloading purpose.
These special function or method must be public and static.
They can take only value arguments.
The ref and out parameters are not allowed as arguments to operator functions.
class Complex
{
private int x;
private int y;
public Complex()
{}
public Complex(int i, int j)
{
27
Namespace :
Namespaces are C# program elements designed to help you organize your programs. They also
provide assistance in avoiding name clashes between two s ets of code.
In Microsoft .Net, Namespace is like containers of objects. They may contain unions, classes,
structures, interfaces, enumerators and delegates. Main goal of using namespace in .Net is for
creating a hierarchical organization of program. In this case, you need not to worry about the
naming conflicts of classes, functions, variables etc., inside a project.
In Microsoft .Net, every program is created with a default namespace. This default namespace is
called as global namespace. But the program itself can declare any number of namespaces, each
of them with a unique name. The advantage is that every namespace can contain any number of
classes, functions, variables and also namespaces etc., whose names are unique only inside the
28
To declare namespace C# .Net has a reserved keyword namespace. If a new project is created in
Visual Studio .NET it automatically adds some global namespaces. These namespaces can be
different in different projects. But each of them should be placed under the base namespace
System. The names space must be added and used through the using operator, if used in a
different project.
A namespace has the following properties:
another namespace
class
interface
struct
enum
delegate
29
namespace MyCompany.Proj1
{
class MyClass1
{
}
}
Example: The following example shows how to call a static method in a nested
namespace:
using System;
namespace SomeNameSpace
{
public class MyClass
{
static void Main()
{
Nested.NestedNameSpaceClass.SayHello();
}
}
// a nested namespace
namespace Nested
{
public class NestedNameSpaceClass
{
public static void SayHello()
{
Console.WriteLine("Hello");
}
}
}
}
Output
Hello
30
Interface
An Interface is a reference type and it contains only abstract members. Interface's members can
be Events, Methods, Properties and Indexers. But the interface contains only declaration for i ts
members. Any implementation must be placed in class that realizes them. The interface can not
contain constants, data fields, constructors, destructors and static members. All the member
declarations inside interface are implicitly public and they cannot include any access modifiers.
An interface has the following properties:
An interface is like an abstract base class: any non-abstract type that implements the
interface must implement all its members.
interface IPoint
{
31
32
33
Delegates
In .NET, you use delegates to call event procedure. Delegates are objects that you use to call the
methods of other objects. Delegates are said to be object -oriented function pointers since they
allow a function to be invoked indirectly by using a reference to the function.
However, unlike function pointers, the delegates in .NET are reference types, based on the class
System.Delegate. In addition, delegates in .NET can reference both shared and instance
methods.
In another way, a delegate can be defined as a type safe function pointer. You use delegates
to call the methods of other objects. They are object-oriented function pointers since they allow a
function to be invoked indirectly by using a reference to the function.
Where are Delegates used?
The most common example of using delegates is in events.
You define a method that contains code for performing various tasks when an event (such as a
mouse click) takes place.
This method needs to be invoked by the runtime when the event occ urs. Hence this method, that
you defined, is passed as a parameter to a delegate.
Starting Threads/Parallel Processing:
You defined several methods and you wish to execute them simultaneously and in parallel to
whatever else the application is doing. This can be achieved by starting new threads. To start a
new thread for your method you pass your method details to a delegate.
Generic Classes: Delegates are also used for generic class libraries which have generic
functionality defined. However the generic class may need to call certain functions defined by the
end user implementing the generic class. This can be done by passing the user defined functions
to delegates.
Creating and Using Delegates:
Using delegates is a two step process..........1) Define the delegate to be used
..........2) Create one or more instances of the delegate
Syntax for defining a delegate:
delegate string reviewStatusofARegion();
to define a delegate we use a key word delegate followed by the method signature the delegate
represents. In the above example string reviewStatusofARegion(); represents any method that
returns a string and takes no parameters.
Syntax for creating an instance of the delegate:
34
C# provides support for Delegates through the class called Delegate in the System
namespace. Delegates are of two types.
Single-cast delegates
Multi-cast delegates
A Single-cast delegate is one that can refer to a single method whereas a Multi-cast
delegate can refer to and eventually fire off multiple methods that have the same signature.
The signature of a delegate type comprises are the following.
A delegate is either public or internal if no specifier is included in its signature. Further, you
should instantiate a delegate prior to using the same.
The following is an example of how a delegate is declared.
Listing 1: Declaring a delegate
public delegate void TestDelegate(string message);
The return type of the delegate shown in the above example is "void" and it accepts a string
argument. Note that the keyword "delegate" identifies the above declaration as a delegate to a
method. This delegate can refer to and eventually invoke a method that can accept a string
argument and has a return type of void, i.e., it does not return any value.
Listing 2: Instantiating a delegate
TestDelegate t = new TestDelegate(Display);
Implementing Delegates in C#
This section illustrates how we can implement and use delegates in C#.This section illustrate how
we can implement and use delegates in C#.
35
Multicast Delegate
A multi-cast delegate is basically a list of delegates or a list of methods with the same signature.
A multi-cast delegate can call a collection of methods instead of only a single method.
36
namespace Ex_MulticastDelegate
{
public delegate void TestDelegate();
class Program
{
public static void Display1()
{
Console.WriteLine("This is first method");
}
public static void Display2()
{
Console.WriteLine("This is second method");
}
static void Main(string[] args)
{
TestDelegate t1 = new TestDelegate(Display1);
TestDelegate t2 = new TestDelegate(Display2);
t1 = t1 + t2; // Make t1 a multi-cast delegate
t1(); //Invoke delegate
Console.Read();
}}}
In another way, You can also assign the references of multiple methods to a delegate and use it
to invoke multiple methods. Such a delegate is called a multi-cast delegate as multiple method
references are cast to it and then the delegate is used to invoke these methods.
What are Attributes?
An Attribute is a declarative tag which can be used to provide information to the compiler about
the behaviour of the C# elements such as classes and assemblies.
C# provides convenient technique that will handle tasks such as performing compile time
operations , changing the behaviour of a method at runtime or maybe even handle unmanaged
code.
C# Provides many Built-in Attributes.
Some Popular ones are
Obsolete
DllImport
Conditional
WebMethod
37
Why Attributes ?
The reason attributes are necessary is because many of the services they provide would be very
difficult to accomplish with normal code. You see, attributes add what is called metadata to your
programs. When your C# program is compiled, it creates a file called an assembly, which is
normally an executable or DLL library. Assemblies are self-describing because they have
metadata written to them when they are compiled. Via a process known as reflection, a program's
attributes can be retrieved from its assembly metadata. Attributes are classes that can be written
in C# and used to decorate your code with declarative information. This is a very powerful
concept because it means that you can extend your language by creating customized declarative
syntax with attributes.
How it is used in C#?
Attributes are elements that allow you to add declarative information to your programs. This
declarative information is used for various purposes during runtime and can be used at design
time by application development tools. For example, there are attributes such as
DllImportAttribute that allow a program to communicate with the Win32 libraries. Another
attribute, ObsoleteAttribute, causes a compile-time warning to appear, letting the developer know
that a method should no longer be used. When building Windows forms applications, there are
several attributes that allow visual components to be drag-n-dropped onto a visual form builder
and have their information appear in the properties grid. Attributes are also used extensively in
securing .NET assemblies, forcing calling code to be evaluated against pre-defined security
constraints. These are just a few descriptions of how attributes are used in C# programs.
Predefined .NET
Attribute
AttributeUsage
Valid Targets
Class
CLSCompliant
All
DllImport
Method
MTAThread
Method (Main)
NonSerialized
Field
Obsolete
ParamArray
Parameter
Serializable
STAThread
Method (Main)
ThreadStatic
Field (static)
Description
Specifies the valid usage of another attribute
class.
Indicates whether a program element is
compliant with the Common Language
Specification (CLS).
Specifies the DLL location that contains the
implementation of an external method.
Indicates that the default threading model for an
application is multithreaded apartment (MTA).
Applies to fields of a class flagged as
Serializable; specifies that these fields wont be
serialized.
Marks an element obsoletein other words, it
informs the user that the element will be
removed in future versions of the product.
Allows a single parameter to be implicitly treated
as a params (array) parameter.
Specifies that all public and private fields of this
type can be serialized.
Indicates that the default threading model for an
application is STA.
Implements thread-local storage (TLS)in other
words, the given static field isnt shared across
multiple threads and each thread has its own
copy of the static field.
38
Predefined attributes
Example:
Pre-defined attributes are used to store external information into metadata. For example, consider
the following piece of code:
39
4. Resuming Thread
To Resume a suspended thread, there is a Resume () method, thread resumes if earlier
suspended if not so then there is no effect of Resume () method on the thread.
eg. if (th.ThreadState = = ThreadState.Suspended)
th.Resume();
40
ThreadPriority.Highest
ThreadPriority.AboveNormal
ThreadPriority.Normal
ThreadPriority.BelowNormal
ThreadPriority.Lowest
41
Network programming in windows is possible with sockets. A socket is like a handle to a file.
Socket programming resembles the file IO as does the Serial Communication. You can use
sockets programming to have two applications communicate with each other. The application are
typically on the different computers but they can be on same computer. For the two applications
to talk to each either on the same or different computers using sockets one application is
generally a server that keeps listening to the incoming requests and the other application acts as
a client and makes the connection to the server application.
The server application can either accept or reject the connection. If the server accepts the
connection, a dialog can begin with between the client and the server. Once the client is done
with whatever it needs to do it can close the connection with the server. Connections are
expensive in the sense that servers allow finite connections to occur. During the time client has
an active connection it can send the data to the server and/or receive the data.
Socket programming in .NET is made possible by Socket class present inside the System.Net.
Sockets namespace.
Socket class has several method and properties and a constructor.
The first step is to create an object of this class. Since there is only one constructor we
have no choice but to use it.
Next we need to specify socket type: and we would use reliable two way connectionbased sockets (stream) instead of un-reliable Connectionless sockets ( datagrams) . So
we obviously specify stream as the socket type and finally we are using TCP/IP so we
would specify protocol type as TCP.
Once we have created a Socket we need to make a connection to the server since we
are using connection-based communication.
To connect to the remote computer we need to know the IP Address and port at which to
connect.
In .NET there is a class under System.Net namespace called IPEndPoint which
represents a network computer as an IP address and a port number.
42
The IPEndPoint has two constructors - one that takes a IP Address and Port number
and one that takes long and port number. Since we have computer IP address we would
use the former
public IPEndPoint(System.Net.IPAddress address, int port);
As you can see the first parameter takes a IPAddress object. If you examine the
IPAddress class you will see that it has a static method called Pars e that returns
IPAddress given a string ( of dot notation ) and second parameter will be the port
number. Once we have endpoint ready we can use Connect method of Socket class to
connect to the end point ( remote server computer ).
43
44
Exception Handling
Overview of Exception Handling
Exceptions are error conditions that arise when the normal flow of a code path-that is, a series of
method calls on the call stack-is impractical. Exception handling is an in built mechanism in .NET
framework to detect and handle run time errors. The exceptions are anomalies that occur during
the execution of a program. They can be because of user, logic or system errors. If a user
(programmer) do not provide a mechanism to handle these anomalies, the .NET run time
environment provide a default mechanism, which terminates the program execution. C# provides
three keywords try, catch and finally to do exception handling. The try encloses the statements
45
46
47
48
System.OutOfMemoryException
System.NullReferenceException
Syste.InvalidCastException
Syste.ArrayTypeMismatchException
System.IndexOutOfRangeException
System.ArithmeticException
System.DevideByZeroException
System.OverFlowException
User-Defined Exceptions
In C#, it is possible to create our own exception class. But Exception must be the ultimate base
class for all exceptions in C#. So the user-defined exception classes must inherit from either
Exception class or one of its standard derived classes.
//C#: Exception Handling: User defined exceptions
using System;
class MyException : Exception
{
public MyException(string str)
{ Console.WriteLine("User defined exception");}
}
class MyClient
{
public static void Main()
{
try
{ throw new MyException("RAJESH"); }
catch(Exception e)
{Console.WriteLine("Exception caught here" + e.ToString()); }
Console.WriteLine("LAST STATEMENT");
}
}
------------------x-------------------------x------------------------------x-------------------------x-----------------------
49
File Handling in C#
File handling is an unmanaged resource in your application system. It is outside your application
domain (unmanaged resource). It is not managed by CLR.
Data is stored in two ways, persistent and non-persistent manner.
When you open a file for reading or writing, it becomes stream.
Object
System.IO
System
MarshalByref
Object
System.IO
FileSystemInfo
System.IO
FileInfo
Directoryinfo
File
Path
Directory
DriveInfo
50
The following table describes some commonly used classes in the System.IO namespace: Class Name
Description
FileStream
BinaryReader
BinaryWriter
StreamReader
StreamWriter
StringReader
StringWriter
DirectoryInfo
FileInfo
Description
Close
Flush
Clears all buffers for the current writer and causes any buffered
data to be written to the underlying stream.
Write
WriteLine
using System;
using System.Text;
using System.IO;
namespace FileWriting_SW
{
class Program
{
51
class FileWrite
{
public void WriteData()
{
FileStream fs = new FileStream("c:\\test.txt", FileMode.Append, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
Console.WriteLine("Enter the text which you want to write to the file");
string str = Console.ReadLine();
sw.WriteLine(str);
sw.Flush();
sw.Close();
fs.Close();
}
}
static void Main(string[] args)
{
FileWrite wr = new FileWrite();
wr.WriteData();
}
}
}
StreamReader Class
The StreamReader class is inherited from the abstract class TextReader. The TextReader class
represents a reader, which can read series of characters.
The following table describes some methods of the StreamReader class: Methods
Description
Close
Closes the object of StreamReader class and the underlying stream, and
release any system resources associated with the reader
Peek
Read
Reads the next character or the next set of characters from the stream
ReadLine
Reads a line of characters from the current stream and returns data as a string
Seek
Allows the read/write position to be moved to any position with the file
52
using System;
using System.IO;
namespace FileReading_SR
{
class Program
{
class FileRead
{
public void ReadData()
{
FileStream fs = new FileStream ("c:\\test.txt", FileMode.Open, FileAccess.Read);
StreamReader sr = new StreamReader (fs);
Console.WriteLine("Program to show content of test file");
sr.BaseStream.Seek(0, SeekOrigin.Begin);
string str = sr.ReadLine();
while (str != null)
{
Console.WriteLine(str);
str = sr.ReadLine();
}
Console.ReadLine();
sr.Close();
fs.Close();
}
}
static void Main(string[] args)
{
FileRead wr = new FileRead();
wr.ReadData();
}
}
}
53
A common data representation format in order to ensure the interoperability of the data
exchanged by the client application and the Web service.
A standard method for sending messages from the client application to the Web service
and vice versa.
A standard format for describing the web service.
A mechanism to allow client applications to discover the Web services and their
locations.
To cater these requirements, various standards such as XML, SOAP and Web Services
Description Language (WSDL) are used.
XML
A client passes arguments to a method exposed by a Web service. The method performs some
action on the arguments and returns the results to the client application. The data returned by the
Web service can be used by the client application, regardless of the hardware and software
platform used to develop the application. To enable this kind of data interchange, you require a
standard data representation format that can be understood by any platform. Since XML is a
plain-text format that can be understood by any kind of device.
SOAP
To be able to communicate with each other, a Web service and a client application must agree
upon a common protocol. SOAP is a standard communication protocol for interchanging
information in a structured format in a distributed environment . The information exchanged
54
The
The
The
The
The
The
UDDI
Registry
Locates a Web
Service
Describes
Client
Application
Web
Service
Communication through
SOAP messages
55
It
It
It
It
It
Processing Instruction
An XML document usually begins with the XML declaration statement also called the Processing
Instruction (PI). The PI provides information regarding the way in which the XML file should be
processed. The PI statement can be written as:
<? Xml version=1.0 encoding UTF-8?>
The PI is optional. The PI uses the encoding property to specify the information about the
encoding scheme that is used to create the XML file. The encoding scheme is the standard
character set for a language. UTF-8 is the standard character set that is used to create pages
written in English. This character set uses eight bits of information to represent each character.
Therefore, UTF-8 stands for an 8-bit character set.
Tag
Tags are used to specify a name for a given piece of information. It is a means of identifying data.
Data is marked-up using tags. A tag consists of an opening and a closing angular bracket (<>).
These brackets enclose the name of the tag. Tags usually occur in pairs.
<P> Nick Peter </P>
In this example, <p> is a predefined HTML tag or mark -up. As XML allows you to create your own
tags, the same information can be stored in the following way:
<EMP_NAME> Nick Peter</EMP_NAME>
56
Elements
Elements are the basic units that are used to identify and describe data in XML. They are the
building blocks of an XML document. Elements are represented using tags.
XML allows you to provide meaningful names to elements, whic h helps improve the readability of
the code. For example: <Authorname> Vivek </Authorname>
In the example, the Authorname element is used to store the names of authors. In this case, the
element name provides a description of the content within the tags.
An XML document must always have a root element. A root element contains all other elements
in the document.
Content
The information that is represented by the elements of an XML document is referred to as the
content of that element. For example,
<BOOKNAME> the painted Hose</BOOKNAME>
The name of the book The Painted House is the content of the BOOKNAME element. XML
enables to declare and use elements that can contain different kinds of information. An element
can contain any of the following types of content:
Examples
Character content
<BOOKNAME> the painted Hose</BOOKNAME>
Element content
<Author>
<Fname> John </Fname>
<Lname> Smith </Lname>
</Author>
Mixed Content
<PRODUCTDESCRIP TION>
The product is available inn four colors.
<COLOR> RED
</COLOR>
<COLOR> BLUE
</COLOR>
<COLOR> GREEN </COLOR>
<COLOR> YELLOW </COLOR>
</PRODUCTDESCRIP TION>
57
Attributes
Attributes provide additional information about the elements for which they are declared. An
attribute consists of a name-value pair. Consider the following example: <PRODUCTNAME PROID=P001> DOLL</PRODUCTNAME>
In this example, the element PRODUCTNAME has an attribute called PROID. The value of this
attribute is set to 001.
Elements can have one or more attributes. Attributes or attribute values can be either mandatory
or optional.
In general, an element is used to represent a definable unit. An attribute is used to represent data
that further qualifies the element. For example, an element called font could have an attribute
called color that is used to specify the color of the font.
Entity
An entity can be described as a shortcut to a set of information. It is name that is associated with
a block of data. This data can be a chunk of text or a reference to an external file that contains
textual or binary information.
<DISPLAY> The price of the this toy is < 20 <DISPLAY>
In the example, < internal entity is used to display a less than (<) symbol.
Comment
Comments are statements that are used to explain the code. They are also used to provide
documentation information about an XML file or even the application to which the file belongs.
When the code is executed, comment entries are ignored by the parser.
Comments are created using an opening angular bracket followed by an exclamation mark and
two hyphens (<!--). This is followed by the text that comprises the comments. The comment entry
can be closed using two hyphens followed by a closing angular bracket (-->).
Example: -
58
An element can be empty, unrestricted, or a container element. The following table describes
each type of element:
Element Type
Empty
Unrestricted
Container
Description
Empty elements have no content and are marked up as <empty element/>
The opposite of an empty element is an unrestricted element, which can
contain any element declared elsewhere in the DTD.
Elements can contain character data and other elements
59
Value Type
PCDATA
ID
(enumerated)
Description
Used to represent plain text values
Used to assign a unique value to each element in the document. The ID must
begin with an alphabetic character.
Used to assign a specific range of values. These values are specified within
parenthesis
In addition to specifying the value type of an attribute, you also need to specify whether the
attribute is optional or mandatory. Look at the following table for attribute types: Attribute Type
REQUIRED
FIXED
IMPLIED
Description
If the attributes of an element is specified as #REQUIRED, then the value for
that attribute must be specified each time the element is used in the XML
document.
If the attribute of an element is specified as #FIXED, then the value of the
attribute can not be changed in XML document.
If the attribute of an element is specified as #IMPLIED, then the attribute is
optional. An IMPLIED attribute can take text strings as their values.
Non-validating parsers
60
Validating parsers
Non-validating parsers
A non-validating parser checks if a document follows the XML syntax rules. It builds a tree
structure from the tags used in an XML document and returns an error only when there is a
problem with the syntax of the document. Non-validating parsers process a document faster
because they do not have to check every element against a DTD. The Expat parser is an
example of a non-validating parser.
Validating parsers
A validating parser checks the syntax, builds the tree structure, and compares the structure of the
XML document with the structure specified in the DTD associated with the document. Microsoft
MSXML parser is an example of a validating parser.
XML Tags Examples
para
The para tag works like <br> or <p> in html to structure the text into paragraphs. It can be used to
break a line of continuous text, or to wrap a segment of text into a paragraph.
<para/> or <para>...</para>
/// The <c>para</c> tag works like <![CDATA[<br> or <p>]]> in html to
/// structure the text into paragraphs.<para/>It can be used to break a line
/// of continuous text, <para>or to wrap a segment of text into a paragraph.</para>
param
The param tag is used to describe the parameters of the method. Parameter tags are
automatically inserted into the header template if parameters are in the syntax. The name of the
parameter is automatically inserted into the parameter tag. The parameter description should be
brief.
<param name="...">...</param>
/// <param name="_value">
/// Used to demonstrate the usage of <c>param</c>
/// </param>
see
Assigns a hyperlink to the specified text.
61
Managed pointers: These pointers can point to data contained in the object heap
managed by the garbage collector. These pointers are not used explicitly by the C# code.
They are thus used implicitly by the C# compiler when it compiles methods with out and
ref arguments.
Unmanaged function pointers: The pointers are conceptually close to the notion of
delegate.
Unmanaged pointers: These pointers can point to any data contained in the user
addressing space of the process. The C# language allows to use this type of pointers in
zones of code considered unsafe.
62
Performance and flexibility, by using pointer you can access data and manipulate it in the
most efficient way possible.
Compatibility, in most cases we still need to use old windows APIs, which use pointers
extensively, or third parties may supply DLLs that some of its functions need pointer
parameters. Although this can be done by writing the DLLImport declaration in a way that
avoids pointers, but in some cases its just much simpler to use pointer.
Memory Addresses, there is no way to know the memory address of some data without
using pointers.
Disadvantages of UNSAFE in C#
Complex syntax, to use pointers you need to go through more complex syntax than we
used to experience in C#.
Harder to use, you need be more careful and logical while using pointers, miss -using
pointers might lead to the following: Overwrite other variables
Stack Overflow
Access areas of memory that doesnt contain any data as they do.
Overwrite some information of the code for the .net runtime, which will suerly
lead your application to crash.
Your code will be harder to debug. A simple mistake in using pointers might lead your
application to crash randomly and unpredictably.
63
Type-safety, using pointers will cause the code to fail in the .net type-safety checks, and
of course if your security police dont allow non type-safety code, then the .net framework
will refuse to execute your application.
Distributed Application in C#
Introduction
Distributed computing is an integral part of almost every software development. Before .Net
Remoting, DCOM was the most used method of developing distributed application on Microsoft
platform. Because of object oriented architecture, .NET Remoting replaces DCOM as .Net
framework replaces COM.
Remoting is a framework built into Common Language Runtime (CLR) in order to provide
developers classes to build distributed applications and wide range of network services.
Remoting provides various features such as Object Passing, Proxy Objects, Activation, Stateless
and Stateful Object, Lease Based LifeTime and Hosting of Objects in IIS.
Benefits of Distributed Application Development:
Fault Tolerance: Fault tolerance means that a system should be resilient when failures within the
system occur.
Scalability: Scalability is the ability of a system to handle increased load with only an incremental
change in performance.
Administration: Managing the system from one place.
In brief, .NET remoting is an architecture which enables communication between different
application domains or processes using different transportation protocols, serialization formats,
object lifetime schemes, and modes of object creation. Remote means any object which executes
outside the application domain. The two processes can exist on the same computer or on two
computers connected by a LAN or the Internet. This is called marshalling (This is the process of
passing parameters from one context to another.), and there are two basic ways to marshal an
object:
Marshal by value: the server creates a copy of the object passes the copy to the client.
Marshal by reference: the client creates a proxy for the object and then uses the proxy to access
the object.
Comparison between .NET Remoting and Web services:
S.No
1
2
3
4
ASP.NET WebService
Easy to develop and deploy
Gives extensibility by allowing us
to intercept the SOAP messages
during the serialization and
deserialization stages.
Accessed only over HTTP
Webservices support only the
data types defined in the XSD
type system, their by limiting the
.NET Remoting
Involves complex programming
Highly extensible by allowing us to
customize the different components of
the .NET remoting framework.
Can be accessed over any of the
protocol like HTTP, SMPT, TCP etc.
By Using binary communication, .NET
Remoting can provide support for rich
type system
64
Architecture:
Remote objects are accessed through channels. Channels are Transport protocols for passing
the messages between Remote objects. A channel is an object that makes communication
between a client and a remote object, across app domain boundaries. The .NET Framework
implements two default channel classes, as follows:
Channel take stream of data and creates package for a transport protocol and sends to other
machine. A simple architecture of .NET remoting is as in below Figure.
Server Object
Client Object
Proxy
Remoting
System
Remoting System
Channel
Figure shows, Remoting system creates a proxy for the server object and a reference to the
proxy will be returned to the client. When client calls a method, Remoting system sends request
thro the channel to the server. Then client receives the response sent by the server process thro
the proxy.
Example:
Let us see a simple example which demonstrates .Net Remoting. In This example the Remoting
object will send us the maximum of the two integer numbers sent.
Creating Remote Server and the Service classes on Machine 1:
65
Please note for Remoting support your service (Remote object) should be derived from
MarshalByRefObject.
using System;
using System.Runtime.Remoting.Channels; //To support and handle Channel and channel sinks
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels.Http; //For HTTP channel
using System.IO;
namespace ServerApp
{
public class RemotingServer
{
public RemotingServer()
{
//
// TODO: Add constructor logic here
//
}
}
//Service class
public class Service: MarshalByRefObject
{
public void WriteMessage (int num1,int num2)
{
Console.WriteLine (Math.Max(num1,num2));
}
}
//Server Class
public class Server
{
public static void Main ()
{
HttpChannel channel = new HttpChannel(8001);
//Create a new channel
ChannelServices.RegisterChannel (channel);
//Register channel
RemotingConfiguration.RegisterWellKnownServiceType(typeof
Service),"Service",WellKnownObjectMode.Singleton);
Console.WriteLine ("Server ON at port number:8001");
Console.WriteLine ("Please press enter to stop the server.");
Console.ReadLine ();
}
}
}
Save the above file as ServerApp.cs. Create an executable by using Visual Studio.Net command
prompt by,
csc /r:system.runtime.remoting.dll /r:system.dll ServerApp.cs
A ServerApp.Exe will be generated in the Class folder.
Run the ServerApp.Exe will give below message on the console
Server ON at port number:8001
66
Machine
Name
where
service
is
running>:8001/Service?WSDL
This will generates a proxy dll by name Server.dll. This will be used to access remote object.
Client Code:
using System;
using System.Runtime.Remoting.Channels; //To support and handle Channel and channel sinks
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels.Http; //For HTTP channel
using System.IO;
using ServerApp;
namespace RemotingApp
{
public class ClientApp
{
public ClientApp()
{
}
public static void Main (string[] args)
{
HttpChannel channel = new HttpChannel (8002); //Create a new channel
ChannelServices.RegisterChannel (channel); //Register the channel
//Create Service class object
Service svc = (Service) Activator.GetObject (typeof (Service),"http://<Machine name where
Service running>:8001/Service"); //Localhost can be replaced by
//Pass Message
svc.WriteMessage (10,20);
}
}
}
Save the above file as ClientApp.cs. Create an executable by using Visual Studio.Net command
prompt by,
csc /r:system.runtime.remoting.dll /r:system.dll ClientrApp.cs
A ClientApp.Exe will be generated in the Class folder. Run ClientApp.Exe , we can see the result
on Running ServerApp.EXE command prompt.
67
ADO.NET
ADO.NET is a model used by .NET applications to communicate with a database for retrieving,
accessing and updating data.
Features of ADO.NET
Some of the features of ADO.NET are given below:
1.
2.
3.
4.
68
Data Provider
.NET
Application
Accessing
Retrieved data
Establish connection
Connection
Retrieve data in a readonly, forwarded only
Data Reader
Accessing retrieved data
Database
Executes a command
to retrieve data
Command
DataSet
Data Adapter
Data Access in ADO.NET relies on two components: DataSet and Data Provider.
DataSet
The dataset is a disconnected, in-memory representation of data. It can be considered as a local
copy of the relevant portions of the database. The DataSet is persisted in memory and the data in
it can be manipulated and updated independent of the database. When the use of this DataSet is
finished, changes can be made back to the central database for updating. The data in DataSet
can be loaded from any valid data source like Microsoft SQL server database, an Oracle
database or from a Microsoft Access database.
Data Provider
The Data Provider is responsible for providing and maintaining the connection to the database. A
DataProvider is a set of related components that work together to provide data in an efficient and
performance driven manner.
The .NET Framework currently comes with two DataProviders: the SQL Data Provider which is
designed only to work with Microsoft's SQL Server 7.0 or later and the OleDb DataProvider which
allows us to connect to other types of databases like Access and Oracle. Each DataProvider
consists of the following component classes:
69
SelectCommand
InsertCommand
DeleteCommand
UpdateCommand
When the Update method is called, changes in the DataSet are copied back to the database and
the appropriate InsertCommand, DeleteCommand, or UpdateCommand is executed.
70
Connection methods:
71
Execute Reader- Simply executes the SQL query against the database using Read().
ExecuteNonQuery- Used whenever you work with SQL stored procedures with
parameters.
Execute Scalar-Returns a lightining fast signle value as an object from your database.
Ex: - object val = Command.ExecuteScalar();
Prepare- Equivalent to ADOs Command.Prepare= TRUE property. Useful in caching the
SQL command so it runs faster when called more than one.
Ex: - Commad.Prepare();
Dispose- Release the resources on the command object.
Read-Means the record pointer to the first row, which allows the data to be read by
column Name of index position
Ex: - If (Reader.Read()==true);
IsClosed- A method that can determine if the Datareader is closed
If (DataReader.Isclosed==false);
Next Result-Equivalent to ADOs NextRecordset method, where a batch of SQL
statement are executed with this method before advancing to the next set of data results.
Ex: - DataReader.NextResult();
Close- close the Data Reader.
72
73
74
Generics Overview
Use generic types to maximize code reuse, type safety, and performance.
The .NET Framework class library contains several new generic collection classes in the
System.Collections.Generic namespace. These should be used whenever possible in
place of classes such as ArrayList in the System.Collections namespace.
You can create your own generic interfaces, classes, methods, events and delegates.
Information on the types used in a generic data type may be obtained at run-time by
means of reflection.
75
76
// GenericMethod.cs
// Using overloaded methods to print arrays of different types.
using System;
using System.Collections.Generic;
class GenericMethod
{
static void Main( string[] args )
{
// create arrays of int, double and char
int[] intArray = { 1, 2, 3, 4, 5, 6 };
double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
char[] charArray = { 'H', 'E', 'L', 'L', 'O' };
Console.WriteLine( "Array intArray contains:" );
PrintArray( intArray );
// pass an int array argument
Console.WriteLine( "Array doubleArray contains:" );
PrintArray( doubleArray );
// pass a double array argument
Console.WriteLine( "Array charArray contains:" );
PrintArray( charArray );
// pass a char array argument
}
// end Main
// output array of all types
static void PrintArray< E >( E[] inputArray )
{
foreach ( E element in inputArray )
Console.Write( element + " " );
Console.WriteLine( "\n" );
}
}
Output:
Array intArray contains:
123456
Array doubleArray contains:
1.1 2.2 3.3 4.4 5.5 6.6 7.7
Array charArray contains:H E L L O
77
78
Type Metadata
Manifest
Manifest
Type Metadata
Type Metadata
MSIL Code
MSIL Code
Resources
Resources
MSIL Code
Type Metadata
MSIL Code
Structure of Assembly
Assembly name
Version number of the assembly, which has four numbers in the format
major.minor.revison.build
Culture - language assembly supports
Strong name - required only for global assemblies
List of files in the assembly. An assembly can be made up of multiple files
Type reference information - informs which type is in which file of the assembly
Information about referenced assemblies - Contains list of other assemblies referenced
by this assembly. For each assembly referenced we have assembly name, version,
culture and public key (if assembly is a global assembly)
Type metadata
This section of an assembly contains information about all classes, structure etc. created in the
assembly along with the data types for their parameters and return values .
MSIL Code
MSIL is the CPU-independent instruction set into which .NET Framework programs are compiled.
MSIL include instructions for loading, storing, intitializing and calling methods on objects, as well
as instructions for arithmetic and logical operations, control flow, direct memory access, exception
handling and other operations.
79
Types of Assembly
1.Private assembly (.dll and .exe are at same place)
2.Shared assembly (.dll and .exe are at different place)
3.Dynamic assembly (dynamically create )
4.Distributed assembly (in different parts)
5.Satellite assembly (on network)
Private Assembly
A private assembly is an assembly that is deployed with an application and is available for the
exclusive use of that application. That is, other applications do not share the private assembly.
Private assemblies are one of the methods that can be used to create isolated applications.
How to create an assembly in C#
The following are the steps to create a private assembly (by default all assembl ies are private)
using Visual C#.
Step-1 Select File->New Project
Step-2 From Templates, select Class Library
Step-3 Enter name CounterLibrary
A class library is created using a single class Class1
Step-4 Rename class to Counter and add the following code.
namespace CounterLibrary
{
public class Counter
{
protected int v = 0;
public Counter(int v)
{
this.v = v;
}
public int Value
{
get
{
return v;
}
}
}
}
Step-5 Save project using File->Save All. When prompted to enter location for project, select the
folder where you want to save your project. I use c:\csharp. Do not select checkbox for Create
directory for solution
Step-6 Build (not run) the project using Build->Build Solution
80
81
82
83
User makes a request for accessing application resource, a page. Browser sends this
request to the web server.
A unified pipeline receives the first request and the following events take place:
Response objects are created . the application objects: HttpContext, HttpRequest and
HttpResponse are created and initialized.
An instance of the HttpApplication object is created and assigned to the request. The
request is processed by the HttpApplication class. Different events are raised by this
class for processing the request.
When an ASP page is requested, it is loaded into the server memory, processed and sent to the
browser. Then it is unloaded from the memory. At each of this steps, methods and events are
available, which could be overridden according to the need of the application. In other words, you
can write your own code to override the default code.
84
Start
Initialization
Load
Postback Event
Handling
Rendering
Unload
Description
The page request occurs before the page life cycle begins. W hen the page is
requested by a user, ASP.NET determines whether the page needs to be
parsed and compiled (therefore beginning the life of a page), or whether a
cached version of the page can be sent in response without running the page.
In the start stage, page properties such as Request and Response are set. At
this stage, the page also determines whether the request is a postback or a
new request and sets the IsPostBack property. The page also sets the
UICulture property.
During page initialization, controls on the page are available and each control's
UniqueID property is set. A master page and themes are also applied to the
page if applicable. If the current request is a postback, the postback data has
not yet been loaded and control property values have not been restored to the
values from view state.
During load, if the current request is a postback, control properties are loaded
with information recovered from view state and control state.
If the request is a postback, control event handlers are called. After that, the
Validate method of all validator controls is called, which sets the IsValid
property of individual validator controls and of the page.
Before rendering, view state is saved for the page and all controls. During the
rendering stage, the page calls the Render method for each control, providing
a text writer that writes its output to the OutputStream object of the page's
Response property.
The Unload event is raised after the page has been fully rendered, sent to the
client, and is ready to be discarded. At this point, page properties such as
Response and Request are unloaded and cleanup is performed.
85
Session
Application
Request Object
Response Object
Server Object
Session Object
Description
Describes the methods, properties, and collections of the object that stores
information related to the entire Web application, including variables and
objects that exist for the lifetime of the application.
Describes the methods, properties, and collections of the object that stores
information related to the HTTP request. This includes forms, cookies,
server variables, and certificate data.
Describes the methods, properties, and collections of the object that stores
information related to the server's response. This includes displaying
content, manipulating headers, setting locales, and redirecting requests.
Describes the methods and properties of the object that provides methods
for various server tasks. With these methods you can execute code, get
error conditions, encode text strings, create objects for use by the Web
page, and map physical paths.
Describes the methods, properties, and collections of the object that stores
information related to the user's session, including variables and objects
that exist for the lifetime of the session.
Description
Compares the value of one input control to the value of another
input control or to a fixed value
Allows you to write a method to handle the validation of the value
entered
Checks that the user enters a value that falls between two values
Ensures that the value of an input control matches a specified
pattern
Makes an input control a required field
Displays a report of all validation errors occurred in a Web page
86