C Sharp QR

C#
Source :
http://www.visualbuilder.com/csharp/tutorial/
Introduction to C sharp
C# (pronounced "C sharp") is a simple, modern, object-oriented, and type-safe
programming language. It will immediately be familiar to C and C++ programmers.
C# combines the high productivity of Rapid Application Development (RAD)
languages. The following are the advantages C# provides :-
• Interactive Development Environment.

• Visual designers for building Windows and Web applications.
• Compiler.
• Debugger.
Features of C# language:
• Simple
• Type safe
• Versioning: making new version of an application from existing
• One to work .
• Follows all OOPs paradigm
• Automatic garbage collection
• Flexible
Application Types in C#
1. Class Library:- Creates a project for creating classes that can be used in
other applications.
2. Console Application:- Creates a Visual C# application with a command-line
interface.
3. Asp.Net Web Application:- Creates a Visual C# application with a Web user
interface.
4. Asp.Net Web Service:- Creates an XML Web service with Visual C# that
other applications can access.
5. Asp.Net Mobile Web Application:- Creates an application viewable on
PDAs, cell phones, and other mobile devices.
Starting C#
using System;
using System.Collections.Generic;
using System.Windows.Forms;
namespace cSHARPEXAMPLES
static class Program
/// <summary>
/// The main entry point for the application.
/// </summary>
[ STAThread ]
static void Main ()
Application .EnableVisualStyles();
Application .SetCompatibleTextRenderingDefault( false );
Application .Run( new Form1 ());
A C# program is divided into 4 parts:

1. Namespace declaration:- This specifies the namespaces that we are going
to use in the application. E.g. Using System;
2. Class declaration:- Here we mentioned the starting class forthis project or
we can say that this is the entry point for ourapplication.
3. Main method:- The main method is the entry point of this application and
here we can specify the form that we need to open first from this application
Application .Run( new Form1 ()); // This line indicates that the control is
passed to the instance of Form1() in the application once we start with the
application.
4. Comments:- The comments are given by // and /* */ block in the C#
programs.
Compilation:- This project can be compiled through command prompt using the
following command. The command will create a file called “Program.exe”, which we
can execute.
Csc.exe Program.cs
Types in C#:-
C# supports two kinds of types: value types and reference types. Value types
include simple types (e.g., char, int, and float), enum types, and struct types.
Reference types include class types, interface types, delegate types, and array
types.
Value Types Reference Types
Allocated on stack Allocated on heap
A value type variable contains Reference type variable contains the address of
the data itself memory location where data is actually stored
When we copy a value type When copying a reference type variable to another
variable to another one, the variable, only the memory address is copied. Both
actual data is copied and each variables will still point to the same memory
variable can be independently location, which means, if we change one variable,
manipulated. the value will be changed for the other variable too.
Integer, float, Boolean, double

String and object are reference types.
etc are value types.
Struct is value type.

Classes and interfaces are reference types.
Control Statement: Selection Statement in C sharp

Control statements are used to process some conditional code which only runs if the
condition is true otherwise some alternate code may be processed. The following are
two control statements used in C#.
1. if-else statement
2. switch statement
IF-ELSE Statement:
If Statement allows you to take different path depending on the decision condition.
The condition must return boolean. When the condition evaluates to a boolean true,
a block for that true condition will be executed.
Syntax:
• If (condition) {
// Single if statement
//execute block if condition, returns true.}
• If (condition) {
// execute block if condition, return false
} else {
// execute block if condition, return false
}
• If (condition1) {
// execute block if condition1 is true
} else if (condition2) {
} else if (condition 3) {
} else {
// otherwise if none condition satisfied then, this block will execute.
}
Switch Statement:
Another selection statement is the switch statement, which executes a set of logic
depending on the value of a given parameter that is evaluated by switch statement.
The type of values a switch statement operates on can be Boolean, Enums, Integral
Type and Strings.
Syntax:
Switch (Evaluated Value can be Boolean or Enums or integral type or strings) {
//switch with integer type
Case 1: // Block of statement
Break;
Break;

Break;
Break;
Default: // Block of statement
Break;
Note:- The switch block follows the switch expression, where one or more choices
are evaluated for a possible match with the switch expression. Each choice is
labeled with the case keyword, followed by an example that is of the same type as
the switch expression and followed by a colon (:). When the result evaluated in the
switch expression matches one of these choices, the statement immediately
following the matching choice is executed. The block ends with either break,
continue, goto, return or throw statement.
Example: Demonstrate Selection Statement
using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
public partial class Form2 : Form
public Form2()
InitializeComponent();
private void Form2_Load( object sender, EventArgs e)
Console.WriteLine( "FORM 2" );
private void button1_Click( object sender, EventArgs e)
{ // Here we can go through the example on IF
int _value = Int32 .Parse(txtEnter.Text);

if (_value > 100)
MessageBox .Show( "Value is greater than 100" );
txtEnter.Text = "" ;
} else if (_value < 100 && _value > 200){
MessageBox .Show( "Value is greater than 100 but less than 200" );
} else {
MessageBox .Show( "Value is less than 100" );
{ // Here we can go through the example on Switch
int _value = Int32 .Parse(txtEnter.Text);
switch (_value) // switch example with integer type
case 1:
case 4:
case 5: //Here the case 1 and 4 has no break, this will falls to this statement
MessageBox .Show( "Value is 1 or 4 or 5" );
break ;
case 2:
MessageBox .Show( "Value is 2" ); txtEnter.Text = "" ;
break ;
case 3:
MessageBox .Show( "Value is 3" ); txtEnter.Text = "" ;
break ;
default :
MessageBox .Show( "Value is greater than 3" );
break ;
}
Output:
Click on: IF Example Button
This print value is less than 100
Click on: switch Example Button
This print value is greater than 3
LOOPS……
………………………
Methods
Methods help you to separate code into modules that perform a given task. Every
program or application have a starting entry point to there application that decide
the path execution and all. We already come across different application where the
starting point or entry point is main ( ) method. Methods provide the flexibility
where we can separate the code into modules. This will make easy understanding of
code, more reusability and increase performance. The method can pass parameters
to another method and return the value that is optional. If the method contains
“void” keyword, this means method will not return any thing.
Syntax:
access specifier return-type methodname (parameter list) {
//Statement
}
Method Chaining:- The method chaining is the process by which one method calls
another method. The caller method can pass parameters to the called method and in
return the called method return some value (this is optional).
Example
The following example will demonstrate the method concepts along with the method
chaining.
using System;
/// <summary>
/// </summary>
[ STAThread ]
static void Main ()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault( false );
Application.Run( new Form1 ());
Method Chaining: Here we can add two values to the form and User can select the
options i.e. 1 Add, 2 Subtract, 3 Multiply and 4 Divide. And result will be displayed
when the user click Execute.
using System;
using System.Data;
using System.Text;
public Form4()
lblEnter.Text = "" ;
lblEnter.Text = lblEnter.Text + "Enter 1 to Add" + "\n" ;
lblEnter.Text = lblEnter.Text + "Enter 2 to Sub" + "\n" ;
lblEnter.Text = lblEnter.Text + "Enter 3 to Multiply" + "\n" ;

lblEnter.Text = lblEnter.Text + "Enter 4 to Divide" + "\n" ;
private void btnExecute_Click( object sender, EventArgs e)
int _valDec = Int32 .Parse(txtdecision.Text);
int _firstVal = Int32 .Parse(textBox1.Text);
int _secondVal = Int32 .Parse(textBox2.Text);
switch (_valDec)
case 1: fxadd(_firstVal, _secondVal); break ;
case 2: fxsubtract(_firstVal, _secondVal); break ;
case 3: fxmultiply(_firstVal, _secondVal); break ;
case 4: fxdivide(_firstVal, _secondVal); break ;
default :
MessageBox .Show( "Please Enter Specified Value.." );
break ;
}
void fxadd( int firstarg, int secondarg) {
int _add = firstarg + secondarg;
txtResult.Text = _add.ToString();
void fxsubtract( int firstarg, int secondarg) {
int _sub = (firstarg - secondarg);
txtResult.Text = _sub.ToString();
void fxmultiply( int firstarg, int secondarg){
int _mul = firstarg * secondarg;
txtResult.Text = _mul.ToString();
void fxdivide( int firstarg, int secondarg){
int _div = firstarg / secondarg;
txtResult.Text = _div.ToString();
}
Output
Namespaces
Namespaces are C# program elements that are used for logical grouping of the
classes. They also provide assistance in avoiding name clashes between two sets of
codes. Namespaces doesn't corresponds to file or directory names. The using
directives e.g.
Using System;
This contains number of classes, by including this namespace we can access those
classes that are there in the System namespace.
Example:- Demonstrate Namespace
using System;
using System.Data;
using System.Text;
using Test = rootnamespace.firstlevelnamespace;
public Form5()
rootnamespace.firstlevelnamespace. TestDemo .fxTest();
rootnamespace.firstlevelnamespace. TestDemo11 .fxDisplay();

Test. TestDemo11 .fxDisplay();
secondnamespace.firstlevelnamespace. TestDemo1 .fxTest1();
secondnamespace.firstlevelnamespace. TestDemo1 .fxTest();
namespace rootnamespace
// nested namespace
namespace firstlevelnamespace
class TestDemo
public static void fxTest()

{
MessageBox .Show( "Fire UP rootnamespace " );
class TestDemo11
public static void fxDisplay()
MessageBox .Show( "Display under rootnamespace " );
namespace secondnamespace
// nested namespace
namespace firstlevelnamespace
{
class TestDemo1
public static void fxTest1()
MessageBox .Show( "Fire UP secondnamespace" );
public static void fxTest()
MessageBox .Show( "Fire UP secondnamespace.firstlevelnamespace.fxTest" );
Example Explanation:
In above example we have 3 namespaces i.e. cSHARPEXAMPLES, rootnamespace,
secondnamespace.Rootnamespace contains irstlevelnamespace namespace,2 classes
i.e TestDemo, TestDemo11 and these classes contains methods i.e.
fxTest(),fxDisplay(). Secondnamespace contains nested namespace i.e.
firstlevelnamespace, 1 class i.e. TestDemo1 and the class contains methods i.e
fxTest1(),fxTest().
Introduction to Classes
Classes are the core of OOP's. Classes are declared by using the keyword classes.
Classes contain data members that represent the class. We can create object of the
class, objects are entities and we can create as many number of objects of a given
class.
Syntax:
Class classname {
//Variable declaration
// Method declaration
}
Classes can contain the following entities inside its declaration:
• Constructors
• Destructors
• Fields
• Methods
• Properties
• Indexers
• Delegates
• Events
• Nested Classes.
Constructors:- Constructors are called or initialized automatically whenever an

object of the class is created. The purpose of the constructors is to initialize the class
members whenever an object of the class is created.
• Constructor name is same as of class name.

• Constructor doesn't return any value, nor even void
• Constructor initialize the class members at the time of its creation
There are different types of constructor:
• Default Constructor
• Parameterized Constructor
• Copy Constructor
Destructor:- Destructor is used to deallocate any memory that is allocated to the

object at the time of its creation. Destructor is used for memory management and
avoids any memory leaks that occur in the case of reference variables that store on
heap memory.
Destructor keeps tracks of all the unwanted and unused memory and frees it when
we are not using it.
• In .net the memory management is automatically done through GC i.e. garbage

collection, this is responsible for deallocation of memory.
• The reference variable memory allocated on heap and here the job of GC comes into
picture, it will deallocate the memory that is not in used.
• The value type variables allocated memory on stack, here the variable doesn't
require any GC, they just fall from the stack if there are not in used.
Example: Demonstrate Constructor, Destructor and used of Static method .
TestDemo.cs
using System;
using System.Text;
{
public class TestDemo
{
String str;
static String str2 = "default" ;
public TestDemo() {
//Constructor
str = "Hi" ;
}
public TestDemo( String strdefault) {
//Parameterized Constructor
str = strdefault;
}
public String display(){
return str;
}
public static String staticfx() {
return str2 + " This comes from Static fx" ;
}
~TestDemo() {
// Clean Up Code Here.
}
}
}
Form6.cs
using System;
using System.Data;
using System.Text;
{
{
public Form6()
{
}

{ //Calling Default Constructor
TestDemo obj = new TestDemo ();
MessageBox .Show( "default Constructor :: " +obj.display());
}
{ //Calling Parameterized Constructor
TestDemo obj1 = new TestDemo ( "Vikrant" );
MessageBox .Show( "Parameterized Constructor :: " +obj1.display());
}
{ //Calling Static method of the class
MessageBox .Show( "Static method :: " + TestDemo .staticfx());
}
}
}
Output:
Click on: Default Constructor Button
Click on: Parameterized Constructor Button
Click on: Static method Button
Inheritance
Inheritance is one of the primary concepts of object-oriented programming.
Inheritance is the process by which we can inherits the properties or methods of one
class into the other class. The concept behind inheritance, take the base class that
contains methods and properties and inherits it into the derived class, that now
contains all the members and properties of the base class as well as its own newly
added members or properties. The following are the advantages of Inheritance:-
• Reuse the existence code
• Save time, we need not do the code verification and testing.
• Here, we can add and modify the methods of the existing class.
• Help in modularization of code.
Types of Inheritance:
The following are the types of inheritance exist in C# programming.
Single Inheritance:
Here we have single base class that is inherited by the derived class. Here the
derived class has all the features of the base class and can add new features or
modify existing features. The inheritance also depends on the access specifier that is
used at the time of base class inheritance.
Multi-level Inheritance:
In the multi-level inheritance, here we having a chain of inheritance i.e. the base
class A is inherited by derived class B, and it is further inherited by another derived
class C. So, the feature we have in base class A, is also there in Derived class B, and
all the combination features of class A and class B are there in derived class C.
Multiple Inheritance:
In C#, we don't have multiple inheritance where one class can inherit two base
classes. So, the multiple inheritance can be done by using the concept of interfaces.
Here one class can inherit one class and can implements more than one interface.
Hybrid Inheritance:
The hybrid inheritance can also be done through with the help of interface. Here the
derived class cans implements more than two interfaces and only one class.
Example: Demonstrate Inheritance
DerivedClass7.cs
using System;
using System.Text;
{
public class parentClass7
{
String str = "Parent:::" ;
public parentClass7() {
str = "Parent Constructor" ;
}
public String display() {

return str;
}
public String Show() {
return "Base Show" ;
}
}
public class DerivedClass7 : parentClass7
{
String testStr = "Derived::" ;
public DerivedClass7() {
testStr = "Derived Constructor" ;
}
public String display1() {
return testStr;
}
public String Show1()
{
return base.Show();
}
}
}
Form7.cs
using System;
using System.Data;
using System.Text;
{
{
public Form7()
{
}
{
DerivedClass7 obj = new DerivedClass7 ();
MessageBox.Show( "Call to Parent Method :: " + obj.display());
MessageBox.Show( "Call to Derived Method :: " + obj.display1());
}
{
DerivedClass7 obj = new DerivedClass7 ();
MessageBox.Show( "Call in Derived method that further call Base method
===>" + obj.Show1());
}
}
}
OutPut:
When User Clicks On :Simple Inheritance Button
When User Clicks On :Calling Base Method in Derived Method Button
Polymorphism
Polymorphism is the core concept of OOP's. Polymorphism means one name many
forms.
Types of polymorphism
1. Compile Time Polymorphism

2. Run Time Polymorphism
Compile Time Polymorphism

The compile time polymorphism, here the polymorphism is implemented during
compile time, that means at the time of compilation the compiler knows where to
bind the method. The compile time polymorphism can be implemented through:
• Method Overloading
• Operator Overloading
Method Overloading:
In complex applications written in C#, we may need many methods which do
essentially similar functions but are just different enough to be considered unique.
So, we can define method overloading as if two or three method in a class has same
name but they differ by number of arguments or type of argument.
Operator Overloading:
This provides a meaningful understanding of the operation by using operator
overloading. Here what we did is we overload an operator and change its meaning,
so that a valuable information is send to the programmer and this help in reducing
the complexity.
E.g.
If we need to add two matrix of 3X3
Matrix result = Matrix.Add(mat1, mat2); // this doesn't give any relevant
information
Run Time Polymorphism
The run time polymorphism, here the compiler doesn't know which method to call at
runtime. Here we can call the derived method through base class pointer at runtime.
The run time polymorphism can be implemented through: Virtual – Override
Keyword.
Vitual function:
The virtual function is used to implement runtime polymorphism; here we have
same name method in the base class as well as in the derived class. We can access
the derived method using the base pointer. The virtual keyword should be write in
front of the base class method and in the derived class we have to write override in
front of the method. For Example:-
Class BaseClass {
Virtual void display () {//statements}
}
Class DerivedClass {
Override void display () {//statements}
}
Example: Demonstrate Polymorphism

BaseClass8.cs
using System;
using System.Text;
{
class BaseClass8
{
String str = "Base" ;
public BaseClass8() { }
public String display() {
return str + ": BaseClass Display" ;
}
public virtual String show() {
return str + ": BaseClass Show" ;
}
}
}
DerivedClass8.cs
using System;
using System.Text;
{
class DerivedClass8 : BaseClass8
{
String str = "Derived" ;
public DerivedClass8() { }
public new String display() { //NEW KEYWORD is USE TO HIDE THE
//SAME METHOD IN TH BASE CLASS
return str + ": Display Derived" ;
}
public override String show() { //OVERRIDE KEYWORD IS USED IF
//THE METHOD IN THE BASE CLASS IS VIRTUAL
return str + ": SHOW Derived:" ;
}
}
}
Form8.cs
using System;
using System.Data;
using System.Text;
{
{
public Form8()
{
}
{ //Virtual: Polymorphism at RunTime
BaseClass8 objBase = new DerivedClass8 ();
label5.Text = objBase.display();
label6.Text = objBase.show();
}
{
BaseClass8 objBase = new BaseClass8 ();
label1.Text = objBase.display();
label2.Text = objBase.show();
}
{
DerivedClass8 objDer = new DerivedClass8 ();
label3.Text = objDer.display();
label4.Text = objDer.show();
}
}
}
Output
Properties
Properties are used to protect the field in a class by reading and writing it through
the property. Here the field consists of one getter and one setter that are associated
with a given field. We can access this field through this getter/setter combination.
Two ways to declare property in the class
1. One way to declare:
class PropertyDemo {
private String name; //Declare a field
public String getName() { //Getter
return name;
}
public void setName( String Value) {//Setter
name = value;
}
}
2. Another way to declare:
class PropertyDemo {
private String name; //Declare a field
public String Name{
get{ return name;} //Getter
set{ name = value;} // Setter
}
}
Read-Only property:
We can declare a property as read-only; by only have its getter. So that the user
can't set the value of the field, because there is no setter for the field. Hence we
restrict the user to change the value of the field at any given time.
Write-Only property:
We can declare a property as write-only, by only have its setter. Here the user can't
access the value that is there in the field. We can manipulate the value of the field
by using its setter, but we can't get the value of this field.
Example: Demonstarte propery, Read-Only Property, Write Only Property.
ClsProperty9.cs
using System;
usingusing System.Collections.Generic;
using System.Text;
{
class ClsProperty9
{
private int age;
private String name;
private String lastName = "Dogra" ;
private String address;
public int getAge() {
return age;
}
public void setAge( int Value) {
age = Value;
}
public String getName()
{
return name;
}
public void setName( String Value)
{
name = Value;
}
//Read-Only property:Only Getter
public String getLastName()
{
return lastName;
}
//Write-Only Property: Only Setter

public void setAddress( String Value)
{
address = Value;
}
public String displayAddress()
{
return address;
}
}
}
Form9.cs
using System;
using System.Data;
using System.Text;
{
{
ClsProperty9 obj = new ClsProperty9 ();
public Form9()
{
}
{ //Setters Calls
obj.setAge( Int16 .Parse(textBox1.Text));
obj.setName(textBox2.Text);
obj.setAddress( " Chandigarh " ); //Write Only Property

}
{ //Getters Calls
MessageBox .Show( "Name: " + obj.getName());
MessageBox .Show( "Age: " + obj.getAge());
MessageBox .Show( "Last Name: " + obj.getLastName());//Read
//Only property
MessageBox .Show( "Address: " + obj.displayAddress());
}
}
}
Output:
Click On: Set the Value
This will set the values in the class fields i.e. name, address
Click On: Get the Value
This will display the values that are set by the setters.
First value that we get is the name.
Second is the age value.
This field only has getter associated to it.
This field only has setter associated with it, we can

Indexers
If properties are 'virtual fields', indexers are more like 'virtual arrays' . They allow
a class to emulate an array, where the elements of this array are actually
dynamically generated by function calls. They allow a class to be used just like an
array. On the inside of a class, you manage a collection of values any way you want.
These objects could be a finite set of class members, another array, or some
complex data structure. The following are the advantages of the Indexers.
• Regardless of the internal implementation of the class, its data can be obtained
consistently through the use of indexers.
• Indexers aren't differentiated by name, and a class cannot declare two indexers with
the same signature. However, this does not entail that a class is limited to just one
indexer. Different indexers can have different types and numbers of indexing
elements (these being equivalent to method parameters, except that each indexer
must have at least one indexing element, and the 'ref' and 'out' modifiers cannot be
used).
Example: Demonstrate Indexers
ClsIndexers10.cs
using System;
using System.Text;
{
class ClsIndexers10
{
private String [] arrString;
private int arrSize;
public ClsIndexers10( int sizeofArray) { //Constructor
arrSize = sizeofArray;
arrString = new String [arrSize];
for ( int i=0;i<arrSize;i++){
arrString[i] = "No Value" ;
}
}
public string this [ int indexValue]
{
get {
return arrString[indexValue];
}
set {
arrString[indexValue] = value ;
}
}
public string [] this [ string data]
{
get {
for ( int i = 0; i < arrSize; i++)
{
if (arrString[i] == data)
{
arrString[i] = "Hi" ;
}
}
return arrString;
}
set
{
{
if (arrString[i] == data)
{
arrString[i] = "Hi" ;
}
}
}
}
}
}
Form10.cs
using System;
using System.Data;
using System.Text;
{
{
static int arrSize = 10;
ClsIndexers10 obj = new ClsIndexers10 (arrSize);
public Form10()
{
}
{ //Indexers Implementation : Using Integer
label1.Text = "" ;
obj[2] = "HHHI" ;
obj[5] = "Vikrant" ;
obj[9] = "Amit" ;
{
label1.Text = label1.Text + "Indexer at " + i + obj[i] + "\n" ;
}
}
{ //Indexers Implementation : Using String
label1.Text = "" ;
String [] arrString = obj[ "No Value" ];
for ( int i = 0; i < arrString.Length; i++)
{
label1.Text = label1.Text + "Indexer at " + i + obj[i] + "\n" ;
}
}
}
}
Output:
Click On: Indexer Implementation
Click On: Indexer – With String

Structs
Structs is value-type user defined data type same as int, float, bool etc.
Structs features:
• structs are value-type

• In structs memory allocation can be done on stack.
• No garbage collector required to remove structs variable because as they are value
type, the memory allocated is on stack and so no memory allocated on heap, when
structs variable are not in used they just fall from the stack.
• Structs can't have destructors.
• Structs can't inherit another class or structs. This means there is no concept of
inheritance in structs.
• Structs may inherit multiple interfaces. Interface is a reference type and any class or
structs that implements interface must override all the methods that are there in the
interface.
Example: Demonstrate Structs

ClsStruct11.cs
using System;
using System.Text;
{
interface ITest
{
string Test();
}
struct Rectangle : ITest
{
public int length;
public int breath;
public int height;
public Rectangle( int length, int breath, int height)
{
this .length = length;
this .breath = breath;
this .height = height;
}
public Rectangle Add( Rectangle rect)

{
Rectangle newRect;
newRect.length = length + rect.length;
newRect.breath = breath + rect.breath;
newRect.height = height + rect.height;
return newRect;
}
public string Test()
{
return "Implements Interface in structs" ;
}
}
class ClsStruct11
{
public String display()
{
Rectangle rect1 = new Rectangle (10, 20, 30);
Rectangle rect3;
rect3 = rect1.Add(rect2);
return "Length :: " + rect3.length + "\n Breadth :: " + rect3.breath + "\n Height
:: " + rect3.height;
}
public string print()
{
return rect1.Test();
}
}
}
Form11.cs
using System;
using System.Data;
using System.Text;
{
{
public Form11()
{
}
{
// Structs Implementation
label1.Text = "" ;
ClsStruct11 obj = new ClsStruct11 ();
label1.Text = obj.display();
}
{ // Structs Implementing Interface
label2.Text = "" ;
ClsStruct11 obj = new ClsStruct11 ();
label2.Text = obj.print();
}
}
}
Output:
Clicking On Both the Buttons: The concept behind the structs will be
executed and displayed.
Interfaces
An interface looks like a class, but has no implementation. Aninterface is a C#
reference type with members that do not have implementations. Interfaces only
have method signatures. The following are the properties of the interfaces:-
• It contains definitions of events , indexers , methods and/orproperties .

• The reason interfaces only provide definitions is because they are inherited
by classes and structs , which must provide an implementation for each interface
member defined.
• Interfaces are like protocol or standard that needs to be maintained by the classes or
structs that are implementing that interface.
• We can have final variables and abstract methods in interface. This means the
classes or structs that are implementing interfaces need to provide the body for all
the methods that are there in interfaces.
• No need to provide the access specifier for method that is there in interface, all the
methods are public.
• We have the concept of inheritance in interface. One interface can extends another
interface.
Syntax:
Interface InterfaceName {
// method signature
}
Class implementing the Interfaces.
Class clsTest: ITestInterface
{
// method defined here
}
Structs Implementing Interface.
struct strTest: IstructsInterface
{
// method defined here
}
Interfaces may inherit other interfaces.
Example: Demonstrate Interfaces
ClsInterface12.cs
using System;
using System.Text;
{
interface IParentInterace
{
String display();
}
interface IChildInterface : IParentInterace
{
String Show();
}
class ClsInterface12 : IChildInterface
{
String str = "Hi" ;
public ClsInterface12( String pStr) {
str = pStr;
}
public String Test() {
return str;
}
public String display()
{
return str + " : Display Of Base Interface" ;
}
public String Show()
{
return str + " : Show Of Child Interface" ;
}
}
}
Form12.cs
using System;
using System.Data;
using System.Text;
{
{
public Form12()
{
}
{
ClsInterface12 obj = new ClsInterface12 ( "Hello" );
label1.Text = obj.Test();
label2.Text = obj.display();
label3.Text = obj.Show();
}
{
label1.Text = "" ;
label2.Text = "" ;
label3.Text = "" ;
}
}
}
Output:
Click On: Interface Executed Button
Delegates
A delegate in C# language allows us to reference a method. The other way to say
this delegate is a function pointer. The function pointer is same as we have pointer
to an address now in this case we have pointer to a method address. There are two
types of delegates :-
• Single-Cast Delegate:- Here the delegate will refer to or point to single method or
we can Say that the pointer is to single method from the delegate.
• Multi-Cast Delegate:-In the multi-cast delegate, the delegate refer to or point to
more than One method at runtime.
Delegates features:
• Delegate is a function pointer.
• Delegate declaration is same as method declaration, except they have delegate
modifier in front of it.
• The method that a delegate refers or pointing to must have same signature as of
delegate method.
• To use a delegate, we have to create the instance of the delegate and pass the
method that it is pointing too or referring to.
• Invoke (), This method can be used to invoke the delegate.
The delegates can be declared by adding a delegate keyword in front of any method.
For Example- delegate void Mydelegate();
Note:- This is declaration of the delegate and it specifies the method signature that
it is pointing or referring. This means the signature of the method that a delegate
pointing has no parameter and will not return any thing. But this is an example and
we can say the delegate can refer to any type of method.
Example: Demonstrate Delegates
ClsDelegate13.cs
using System;
using System.Text;
{
class ClsDelegate13
{
delegate void Mydelegate ();
static String str = "" ;
static String sd = "" ;
public String singlecastfx()
{
sd = "" ;
sd = "Single Cast Delegate ==> " ;
Mydelegate d = null ;
d += new Mydelegate (singlecastdelegatefx);
d.Invoke();
sd = sd + " :: appender" ;
return sd;
}
public String multicastfx() {
str = "" ;
str = "starting Value ==> " ;
Mydelegate d = null ;
d += new Mydelegate (firstfx);
d += new Mydelegate (secondfx);
d();
str = str + " :: appender" ;
return str;
}
public void firstfx()
{
str = str + " :: firstfx" ;
}
public void secondfx()
{
str = str + " :: secondfx" ;
}
public void singlecastdelegatefx()
{
sd = sd + " ::singlecastdelegatefx" ;
}
}
}
Form13.cs
using System;
using System.Data;
using System.Text;
{
{
public Form13()
{
}
{ //Multi-cast delegate
ClsDelegate13 objDelegate = new ClsDelegate13 ();
MessageBox .Show(objDelegate.multicastfx());
}
{ //Single-cast delegate
ClsDelegate13 objDelegate = new ClsDelegate13 ();
MessageBox .Show(objDelegate.singlecastfx());
}
}
}
Output:
Clicking On: Single-cast Delegate Button
Clicking On: Mutil-cast Delegate Button

Exception Handling
Exception
Exceptions are unforeseen errors that happen in your programs. Programmers
always detect and most of the time writes correct code to avoid all the errors or
exceptions that can distract the execution of the code and cause unwanted results.
However, there are times when you don't know if an error will occur. For example,
you can't predict when you'll receive a file I/O error, run out of system memory, or
encounter a database error. These things are generally unlikely, but they could still
happen and you want to be able to deal with them when they do occur. This is where
exception handling comes in. When exceptions occur, they are said to be "thrown".
What is actually thrown is an object that is derived from the “S ystem. Exception”
class
Try/catch and Finally Block:
This is a way we can handle exceptions in C#.
• Try Block:- In this block, we include all the suspected code. This means the code that
is most likely to cause exception.
• Catch Block:- In this block we include all handlers that will be take care of
exception that occurs. We can have number of catch blocks associated to single try
block.
• Finally Block : The finally block contains the cleanup code that we needed whether
the code is succeed or not. Most of the time we write a code that will deal locate the
memory that we associated in the beginning like memory allocated to connection
object.
Example: Exception Handling

Form14.cs
using System;
using System.Data;
using System.Text;
using System.IO;
{
{
public Form14()
{
}
{ //Simple Try/Catch Block
int dividebyZero = 0;
int a = 20;
int b = 0;
try
{
dividebyZero = (a / b);
}catch ( DivideByZeroException ex)
{
MessageBox .Show( "2nd EXCEPTION :: " + ex.ToString());
}catch ( Exception ex) {
MessageBox .Show( "EXCEPTION :: " +ex.ToString());
}
}

{ //Try,Catch and Finally Block
FileStream outputStream = null ;
FileStream inputStream = null ;
try {
outputStream = File.OpenWrite( "DestinationFile.txt" );
inputStream = File.OpenRead( "BogusInputFile.txt" );
}catch ( Exception ex) {
MessageBox .Show(ex.ToString());
}finally {
if (outputStream != null ) {
outputStream.Close();
MessageBox .Show( "OutputStream Closed." );
}
if (inputStream != null ) {
inputStream.Close();
MessageBox .Show( "InputStream Closed." );
}
}
}
}
}
Output:
Click On: Simple Try/catch Block Button
Click On: Try/catch and Finally Block Button
Attributes
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. Attributes are also
used extensively in securing .NET assemblies, forcing calling code to be evaluated
against pre-defined security constraints. Attribute declared using the ‘[‘and ‘]'
brackets before any type declaration.
The following are the advantages the attributes provide:
• Declarative information to your program
• This information can be used at runtime or at compile time by programmers.

• DllImportAttribute: This attribute provide information to communicate with the
Win32 libraries.
• ObsoleteAttribute: This provides compile time information to the developer that this
method is now deprecated.
• Attribute add what is called metadata to your program.
• Attributes are classes that can be written in C# and used to decorate your code with
declarative information.
• Many attributes have parameter lists that allow inclusion of additional information
that customizes a program even further.
Examples of Attributes:-
[ Obsolete ]
public String firstDeprecatedFX(){}
[ ObsoleteAttribute ]
public String secondDeprecatedFX(){}
Obsolete ( "Don't Use This Method." )]
public String thirdDeprecatedFX()
[ STAThread ]
static void Main () {}
Note:- This attribute declare that this is the entry point for the application. This
indicates that C# program should communicate with unmanaged COM code using
the single threading apartment. The parameter provide additional information about
the attribute
Example To Demonstrate Attributes
The following is the screen appeared when run the form 15 program in the source.
ClsAttribute15.cs
using System;
using System.Text;
{
class ClsAttribute15
{
[ Obsolete ]
public String firstDeprecatedFX()
{
return "Call firstDeprecatedFX" ;
}
[ ObsoleteAttribute ]
public String secondDeprecatedFX()
{
return "Call secondDeprecatedFX" ;
}
[ Obsolete ( "Don't Use This Method." )]
public String thirdDeprecatedFX()
{
return "Call thirdDeprecatedFX" ;
}
}
}
Form15.cs
using System;
using System.Data;
using System.Text;
{
{
public Form15()
{
}
{ //Attribute : use to create method deprecated
ClsAttribute15 obj = new ClsAttribute15 ();
obj.firstDeprecatedFX();
//Deprecated Methods
obj.secondDeprecatedFX();
MessageBox .Show(obj.thirdDeprecatedFX());
}
}
}
Output:
Clicking On: Attribute fire up Button
Enums
An enumeration is a special kind of value type limited to a restricted and
unchangeable set of numerical values. Enums are strongly typed constants. They
are essentially unique types that allow you to assign symbolic names to integral
values.
Advantages of Enums:-
• In the C# tradition, they are strongly typed, meaning that an enum of one type may
not be implicitly assigned to an enum of another type even though the underlying
value of their members are the same.
• By default, these numerical values are integers, but they can also be longs, Bytes,
etc.
• When you define an enumeration you provide literals which are then used as
Constants for their corresponding values.
• Values specified in enumeration are static.
• These values are final and you can't change the value at runtime.
• The System.Enum BCL type is the base class of enum types and contains methods
that allow you to work with enums in different ways, such as working with a list of
names or values, converting from value to name, and converting from name to
value.
Syntax
enum enumname { //values}
Example:-
enum DayOfWeek {
Monday=2,
Tuesday,
Wednesday,
Thursday=10,
Friday,
Saturday,
Sunday
}
Note:-
• The first literal, is unassigned then it value is set to 0.

• For any other literal, if the value is unassigned then the value set is greater than the
value of the preceding literal.
• By this the value of Monday is set to 0 and the value of Sunday is 6.
• We can also specify the value to the literal in the enums.
Note:- Here the value will be Monday-2, Tuesday-3, Wednesday-4 and Thursday-
10, Friday-11, Saturday-12, Sunday-13.
Example: Demonstrate Enums
ClsEnum16.cs
using System;
using System.Text;
{
enum DayOfWeek {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
enum ValuesEnum : byte
{
One = 1,
two,
three=5,
four,
five
}
class ClsEnum16
{
public String GetvalueEnteredByUser( int enteredValue) {
//user entered value
ValuesEnum valuesEnum = ( ValuesEnum )enteredValue;
String str = "" ;
switch (valuesEnum)
{
case ValuesEnum .One: str = "FIRST" ;
break ;
case ValuesEnum .two: str = "SECOND" ;
break ;
case ValuesEnum .three: str = "THIRD" ;
break ;
case ValuesEnum .four: str = "FOURTH" ;
break ;
case ValuesEnum .five: str = "FIFTH" ;
break ;
default : str = "default" ; break ;
}
return str;
}
public String CreateAndUseEnumType(){
DayOfWeek dayofWeek = DayOfWeek .Thursday;
//DayOfWeek dayofWeek = (DayOfWeek)4;
String strDay = "" ;
switch (dayofWeek)
{
case DayOfWeek .Monday: strDay = "Monday" ;
break ;
case DayOfWeek .Tuesday: strDay = "Tuesday" ;
break ;
case DayOfWeek .Wednesday: strDay = "Wednesday" ;
break ;
case DayOfWeek .Thursday: strDay = "Thursday" ;
break ;
case DayOfWeek .Friday: strDay = "Friday" ;
break ;
case DayOfWeek .Saturday: strDay = "Saturday" ;
break ;
case DayOfWeek .Sunday: strDay = "Sunday" ;
break ;
}
return strDay;
}
}
}
Form16.cs
using System;
using System.Data;
using System.Text;
{
{
public Form16()
{
}
{ //Create and use Enums

ClsEnum16 obj = new ClsEnum16 ();
MessageBox .Show(obj.CreateAndUseEnumType());
}
{ //Enter Enum Value From User
int _userEnterValue = Int32 .Parse(textBox1.Text);
ClsEnum16 obj = new ClsEnum16 ();
MessageBox.Show(obj.GetvalueEnteredByUser(_userEnterValue);
}
}
}
Output
Click On: Enter Enum value from user Button
Click On: Create and Use Enums Type

Encapsulation
Encapsulation is the process of wrapping up of data and members in a class.
Encapsulation provides the way to hide data from the external usage. This is
important in the scenario when we don't want our precious data to be used or
manipulated by external user. Encapsulation is an object-oriented principle of hiding
the internal state and behavior of an object, making your code more maintainable.
Advantages of Encapsulation
• Data-hiding through the access specifier private.

• Reduce coupling between objects.
• Increases the maintainability of code.
• Wrapping up of data variables and members inside the class.
The following table will give the description of the Access modifiers
available in C#.
Access Modifier Description (who can access)
Private Private members can be accessed within the class where

they are declared. We can't access private members outside
the class, not even with the object of the class.
This basically provides the concept of Data-Hiding.
Protected Protected members scope can be outside the class but only
limited to the immediate derived class that is inheriting the
base class where the protected members resides.
The protected can be used by the members of same class or

the members of derived class.
Internal Here the internal members are accessible within the same
assembly.
If you don't specify any modifier, by default it is of internal

type.
Protected Internal Here either accessed in the same assembly or the derived
assembly also. This is basically a combination of protected
and internal access modifiers.
Public Public members can be accessed anywhere. No restriction

associated with this access modifier.
Sealed Class
The sealed keyword provides the restriction that no other class in the context can
inherit this class. By this, we can make our class not to be inherited by other class.
If the class tries to inherit the class that is declared as sealed, the compile time
error occurs.
1] Class declared as sealed
sealed class ClsSealed17 {// Any members }
Abstract Class
The class declared with abstract keyword, this means the class is only provide the
essential elements and not including the background details. Abstraction is the
process of including the essential elements and hiding the details. In layman terms,
we can say that a computer is the abstract form, because we are not aware of the
internal technicality.
If the class is declared as abstract, we have to give the body to all the methods that
are declared as abstract.
1] Class declared as abstract
abstract class clsAbstractDemo{
// This can contains abstract or concrete methods.
}
2] Abstract Members
public abstract string displayname();
Note:- The abstract methods can only include the signature of the method.
Example: Demonstrate Encapsulation
ClsEncapsulation17.cs
using System;
using System.Text;
{
class Customer
{
public void CustomerRecord()
{
AddNewRecord();
UpdateExistingRecord();
DeleteRecord();
}
protected virtual string AddNewRecord()
{ return "Base: AddNewRecord" ; } //ADD NEW RECORD
protected virtual string UpdateExistingRecord()
{ return "Base: UpdateExistingRecord" ; } //UPDATE EXISTING RECORD
protected virtual string DeleteRecord()
{ return "Base: DeleteRecord" ; } //DELETE EXISTING RECORD
}
class ClsEncapsulation17 : Customer
{
private string name = "" ; //Can't Access Outside the Class
private string address = "" ; //Can't Access Outside the Class
private string pri_Display() //Can't Access Outside the Class
{
return "This method can't be access outside the class" ;
}
public string CustomerName { //Public Property
get { return name; }
set { name = value ; }
}
public string CustomerAddress //Public property
{
get { return address; }
set { address = value ; }
}
public string CombineDisplay() //Public Method
{
return CustomerName + " :::" + CustomerAddress;
}
protected override string AddNewRecord() //Protected Method
{
return "protected method :: AddNewRecord" ;
}
protected override string UpdateExistingRecord() //Protected Method
{
return "protected method :: UpdateExistingRecord" ;
}
protected override string DeleteRecord() //Protected Method
{
base .DeleteRecord();
return "protected method :: DeleteRecord" ;
}
public string combineString()
{
string cmbStr = "" ;
cmbStr = cmbStr + AddNewRecord() + "\n" ;
cmbStr = cmbStr + UpdateExistingRecord() + "\n" ;
cmbStr = cmbStr + DeleteRecord();
return cmbStr;
}
}
}
ClsSealed17.cs
using System;
using System.Text;
{
sealed class ClsSealed17
{
private string name = "" ;
public string CustomerName
{
get { return name; }
set { name = value ; }
}
public string displayName()
{
return name;
}
}
//Can't inherited a Sealed Class
class derivedClass //: ClsSealed17
{
}
}
ClsAbstract17.cs
using System;
using System.Text;
{
abstract class clsAbstractDemo
{
private int _number = 10;
public string _name = "" ;
public abstract string displayname(); // Abstract method
public int calcTotal() //Concreate Method
{
return (_number * 10);
}
}
class ClsAbstract17 : clsAbstractDemo
{
public override string displayname() { //Abstract Method
return "Abstract Method Provide Body in Derived Class" ;
}
}
}
Output
Click On: Private Members Button
Click On: Public Members Button
Click On: Protected Members Button
Click On: Sealed

Click On: Abstract
Parameter Passing in C sharp

A method's parameters are the types that get passed to it when the method is
called. The list of parameters begins by specifying zero or more 'fixed parameters',
and it may finish by specifying a single parameter-array. This latter element -
declared using the 'params' keyword - means that it is possible to pass an arbitrary
number of types to a single method.
Syntax: [Modifier] parameter-type parameter-identifier
• [Modifier]: This is optional and can be either 'ref' or 'out'.

• Parameter-type: This declares the type of the parameter.
• Parameter-identifier: The name of the parameter.
There are 3 type of parameter that are passed to the method
• Passing by Value
• Passing by Reference
• ‘Output' Parameter.
Passing By Value:
The parameter modifiers 'ref' and 'out' relate to how the parameter is passed into
the method. Where neither of these modifiers is used, the parameter is passed in 'by
value'. By default we are passing variable by value. Here the new copy of the
variable is send to the called method. So changes done to the variables are not
reflected on the actual parameter.
Syntax:
passValueByValueType(_initialValue); //Call a method
private void passValueByValueType( int iV)
{ iV = 20; }
Passing By Reference:
In C# we can pass variables into methods 'by reference'. Where a variable is passed
by reference, the 'ref' modifier must be used both in the method head and the
method invocation (illustrated by the next code block). The changes made to the
formal argument will reflect on the actual argument.
Syntax:
passValueByReferenceType( ref _initialValue); //Calling Method
private void passValueByReferenceType( ref int iV)
{ iV = 20; }
‘Output' parameter:
Where a method parameter is defined (and invoked) using the 'out' modifier, it is
passed by reference. The difference between the 'out' and the 'ref' modifier is this: a
parameter modified by the 'out' keyword need not be assigned a value before being
passed into the method, but must be assigned a value in the method.
Syntax:
passValueByOutParameter( out _initialValue, out _bValue);//Calling
‘Params' Modifier
One can pass an arbitrary number of types to a method by declaring a parameter
array with the 'params' modifier.
Syntax:
public int getTheTotalUsingParam( params int [] intArr)
Example: Demonstrate Parameter Passing in C#
Form18.cs:
using System;
using System.Data;
using System.Text;
{
{
public Form18()
{
}
private void btnValue_Click( object sender, EventArgs e)
{ //Value
int _initialValue = Int16 .Parse(textBox1.Text);
MessageBox .Show( "Before Calling " +
_initialValue.ToString());
passValueByValueType(_initialValue);
textBox1.Text = _initialValue.ToString();
MessageBox .Show( "After Calling " +
}
private void btnReference_Click( object sender, EventArgs e)
{ //Reference
MessageBox .Show( "Before Calling " +
passValueByReferenceType( ref _initialValue);
MessageBox .Show( "After Calling " +
}
private void btnOut_Click( object sende r, EventArgs e)

{ //Out
bool _bValue;
MessageBox .Show( "Before Passing " +
passValueByOutParameter( out _initialValue, out _bValue);
MessageBox .Show( "After getting the value " +
}
private void passValueByReferenceType( ref int iV)
{
iV = 20;
}
private void passValueByValueType( int iV)
{
iV = 20;
}
private void passValueByOutParameter( out int iV, out bool bValue)
{
bValue = false ;
iV = 2;
if (iV > 40)
bValue = true ;
else
bValue = false ;
iV = iV * 20;
}
}
}
OutPut:
Clicking On:- Passing Parameter By Value

Clicking On:- Passing Parameter By Reference
Clicking On:- Passing Parameter By Out
Method Overloading
Each method has a signature. The signature comprises the method's name and its
parameters (excepting their names), but not the method's return type. Method
Overloading is one of the forms of polymorphism. This is compile time polymorphism
because at compile time the compiler able to distinguish between the methods that
is declared with same name but different number of arguments.
Conditions which should be fulfilled for Method overloading:
• Method Name should be same for all the methods that are participating in method
Overloading.
• The number of arguments or type of arguments should be different.
• No class allowed two methods to have same signature.
Note:- Like methods constructors can also be overloaded.

Example: Demonstrate Method Overloading
ClsOverLoading19.cs
using System;
using System.Text;
{
class ClsOverLoading19
{
int a;
int b;
//Constructor OverLoading
public ClsOverLoading19() { a = 10; b = 20; }
public ClsOverLoading19( int a, int b) { this .a = a; this .b = b;}
public ClsOverLoading19( ClsOverLoading19 obj) { this .a = obj.a;
this .b = obj.b; }
public int result() { return a + b; }
//Method OverLoading
public string display() { return "single method with no parameter" ; }
public string display( string strA) { return strA; }
public string display( string strA, string strB) { return strA + ":: "+ strB ; }
public string display( string strA, int intA) { return strA + " :: " + intA.ToString()
;}
}
}
Form19.cs
using System;
using System.Data;
using System.Text;
{
{
public Form19()
{
}
{ // Call Single Parameter Method
ClsOverLoading19 obj = new ClsOverLoading19 ();
MessageBox .Show(obj.display());
}
{ //Call Parameterized Method
ClsOverLoading19 obj = new ClsOverLoading19 ();
MessageBox .Show(obj.display( "vikrant" ));
MessageBox .Show(obj.display( "Vikrant" , "Dogra" ));
MessageBox .Show(obj.display( "Hi I am " ,27));
}
{ //Constructor overloading
ClsOverLoading19 obj = new ClsOverL oading19 ();
ClsOverLoading19 obj1 = new ClsOverLoading19 (30,40);
ClsOverLoading19 obj2 = obj1;
MessageBox .Show( "Default Constructor result " +obj.result());
MessageBox .Show( "Parameterized Constructor result " +obj1.result());
MessageBox .Show( "Copy Constructor result " + obj2.result());
}
}
}
Output:
Click On: Calling Single Parameter Method
Click On: Call Parameterized Method
Click On: Constructor Overloading
Database Interaction Using C sharp

C# is a language. The classes defined in the class libraries are used to communicate
with the database and we are using C# language to interact with the database.
In Ado.Net components we have number of classes that are responsible to
communicate with the database.
Introducing ADO.NET
Ado.Net is an Object-oriented set of libraries that allows you to interact with data
sources. Following are the data providers in ado.net.
1. System.Data.SqlClient:- contains classes that communicate with Ms
SQLServer.
2. System.Data.OracleClient:- communicate with Oracle.
3. System.Data.Oledb:- communicate to a data source that has an OLEDB
provider.
4. System.Data.Odbc:- communicate to a data source that has an ODBC
provider
ADO.NET OBJECTS
Ado.net includes many objects you can use to work with data. Some of the primary
objects are as follows:-
1. SqlConnection:- To interact with a database, you must have a connection to

it. The connection objects helps identifying the database server, database
name, user name and password. The connection object is used by command
objects.
2. SqlCommand:- You can use this object to send SQL statements to the
database. This can represent a SQL Statement or stored procedure.
3. SqlDataReader:- The data reader object allows you to obtain the results of a
Select statement from a command object. The data returned from a data
reader is a fast forward-only stream of data. This fetch data in a sequential
manner.
4. DataSet:- You can imagine dataset as a database. This contain multiple
datatable objects, which further contains columns and rows objects. We can
also define relationship among tables in the dataset. This is disconnected
approach.
5. SqlDataAdapter:- The SqlDataAdapter is used to fill dataset object when
reading the data and writes in a single batch when persisting changes back to
the database. A data adapter contains a reference to the connection object
and opens and closes the connection automatically when reading from or
writing to the data base. The data adapter contains 4 command objects i.e.
SELECT, UPDATE, DELETE, and INSERT
Example: Demonstrate Database Interaction

This example will provide the interaction with the database. The user will enter his
credentials, if the user is valid and the credentials matched with the database, he is
able to view all the other users' credentials that are valid.
Form20.cs
using System;
using System.Data;
using System.Text;
using System.Data.SqlClient;
{
{
public Form20()
{
}
private void btnLogin_Click( object sender, EventArgs e)
{ //Login
try
{
SqlConnection con = null ;
string conStr = "" ;
int _ExistFlag = 0;
conStr = "Data Source=localhost;initial
catalog=TestDB;uid=sa;pwd=sa";
con = new SqlConnection (conStr);
_ExistFlag = fnUserExists(con,txtName.Text,txtPassword.Text);
if (_ExistFlag == 0)
{ //Not A Valid User
MessageBox .Show( "Not A Valid User" );
}
else
{ // If Valid user Than Display all the Valid User that are there in the
DataBase
MessageBox .Show( "Valid User :: Display All the Valid User" );
fillgridWithValidUser(con);
}
}
catch ( Exception ex)
{
MessageBox .Show( "Exception Occurs.........." +ex.Message);
}
finally
{
txtName.Text = "" ;
txtPassword.Text = "" ;
}
}
/*
* Function: Whether a Valid User or Not
* Depending on the creadentials enter by user
*/
private int fnUserExists( SqlConnection con, string strUserName, string
strPassword)
{
SqlCommand cmd = null ;
int _ExistFlag = 0;
cmd = new SqlCommand ( "select count(*) from tblLogin where
UserName=@UserName and password=@Password " , con);
cmd.Parameters.Add( "@UserName" ,SqlDbType.NVarChar).Value =
strUserName;
cmd.Parameters.Add( "@Password" ,SqlDbType.NVarChar).Value =
strPassword;
cmd.CommandType = CommandType .Text;
con.Open();
_ExistFlag = Int16 .Parse(cmd.ExecuteScalar().ToString());
con.Close();
return _ExistFlag;
}
/*
* if the Credentials Enter By user is Valid:
* Then Display List Of all The Other Valid Users.
*/
private void fillgridWithValidUser( SqlConnection con)
{
SqlDataAdapter ada = null ;
DataSet dst = null ;
ada = new SqlDataAdapter ( "select * from tblLogin" , con);
dst = new DataSet ();
ada.Fill(dst, "Login" );
dataGridView1.DataSource = dst.Tables[0].DefaultView;
}
}
}
Output:
On Click: Login Button
Operator Overloading in C sharp –1
There are varieties of operators available for use in C#. The C# language defines the
behavior of these operators when used in an expression with the C# built-in data
types. C# gives user the flexibility to change the default behaviour of the operators
that means, user can define the behavior of many of the standard operators with his
own structures and classes.
Suppose, for example, that you're writing a class that manages a set of records read
from a database. If another piece of code has two objects of your class, it may want
to write an expression that joins the records together into a third object. This
sounds like an addition operation, and it seems natural for other pieces of code to
write code like the following:
Records Records1;
Records Records2;
Records Records3;
Records3 = Records1 + Records2;
Your Records class would include a method that specifies "how objects of the class
will behave when used in an expression with the addition operator. These methods
are called user-defined operator implementations , and the object-oriented
terminology for defining operator behavior in a class is called operator overloading .
Note: All operator overloading methods must be declared with both the static and
public keywords.
Overloading Unary Plus /Unary Minus:
If you need to overload the unary plus operator, the following characteristics must
be enjoyed by the method that is used to overload the unary plus.
• A return type of your choice

• The keyword operator
• The operator being overloaded
• A parameter list specifying a single parameter of the type of class or structure
containing the overloaded operator method
Overloading Prefix Increment and Decrement Operator:

If you need to overload the prefix increment or prefix decrement operators in your
class or structure, define a method with the following characteristics:
• A return type specifying the type of class or operator method

• A parameter list specifying a single parameter containing the overloaded operator
method
Example: Demonstrate Overloading of Unary Plus, Unary Minus, Prefix

Increment, Prefix Decrement.
Overloading Unary Plus
using System;
using System.Text;
namespace _CSharpApplication
{
class ClsOverLoadUnaryPlus
{
public int X;
public int Y;
public static ClsOverLoadUnaryPlus operator +(ClsOverLoadUnaryPlus RValue)
{
ClsOverLoadUnaryPlus NewObj = newClsOverLoadUnaryPlus ();
if (RValue.X < 0)
NewObj.X = -(RValue.X);
else
NewObj.X = RValue.X;
if (RValue.Y < 0)
NewObj.Y = -(RValue.Y);
else
NewObj.Y = RValue.Y;
return NewObj;
}
}
}
Overloading Unary Minus
using System;
using System.Text;
{
class ClsOverLoadingUnaryMinus
{
public int X;
public int Y;
public static ClsOverLoadingUnaryMinus operator –
(ClsOverLoadingUnaryMinus RValue)
{
ClsOverLoadingUnaryMinus objNew = newClsOverLoadingUnaryMinus ();
if (RValue.X > 0)
objNew.X = -(RValue.X);
else
objNew.X = RValue.X;
if (RValue.Y > 0)
objNew.Y = -(RValue.Y);
else
objNew.Y = RValue.Y;
return objNew;
}
}
}
Overloading Prefix Increment
using System;
using System.Text;
{
class ClsOverloadingIncrement
{
public int X;
public int Y;
public static ClsOverloadingIncrement operator
++(ClsOverloadingIncrement RValue)
{
ClsOverloadingIncrement objIncrement = new ClsOverloadingIncrement ();
objIncrement.X = RValue.X + 1;
objIncrement.Y = RValue.Y + 1;
return objIncrement;
}
}
}
Overloading Prefix Decrement
using System;
using System.Text;
{
class ClsOverLoadingDecrement
{
public int X;
public int Y;
public static ClsOverLoadingDecrement operator – ( ClsOverLoadingDecrement
RValue)
{
ClsOverLoadingDecrement objDecrement = new ClsOverLoadingDecrement ();
objDecrement.X = RValue.X - 1;
objDecrement.Y = RValue.Y - 1;
return objDecrement;
}
}
}
Form2.cs
using System;
using System.Data;
using System.Text;
{
{
public Form2()
{
}
{ //Overloading Unary Plus
ClsOverLoadUnaryPlus objUnaryPlus = new ClsOverLoadUnaryPlus ();
objUnaryPlus.X = -100;
objUnaryPlus.Y = 200;
MessageBox.Show((objUnaryPlus.X).ToString());
MessageBox.Show((objUnaryPlus.Y).ToString());
objUnaryPlus = +objUnaryPlus;
MessageBox.Show((objUnaryPlus.X).ToString());
MessageBox.Show((objUnaryPlus.Y).ToString());
}
{ //Overloading Unary Minus
ClsOverLoadingUnaryMinus objUnaryMinus = new ClsOverLoadingUnaryMinus
();
objUnaryMinus.X = -10;
objUnaryMinus.Y = 20;
MessageBox.Show((objUnaryMinus.X).ToString());
MessageBox.Show((objUnaryMinus.Y).ToString());
objUnaryMinus = -objUnaryMinus;
MessageBox.Show((objUnaryMinus.X).ToString());
MessageBox.Show((objUnaryMinus.Y).ToString());
}
{ //Overlading Prefix Increment
ClsOverloadingIncrement objIncrement = new ClsOverloadingIncrement ();
objIncrement.X = 100;
objIncrement.Y = 200;
MessageBox.Show((objIncrement.X).ToString());
MessageBox.Show((objIncrement.Y).ToString());
objIncrement = ++objIncrement;
MessageBox.Show((objIncrement.X).ToString());
MessageBox.Show((objIncrement.Y).ToString());
}
{ //Overloading Prefix Decrement
ClsOverLoadingDecrement objDecrement = new ClsOverLoadingDecrement ();
objDecrement.X = 100;
objDecrement.Y = 200;
MessageBox.Show((objDecrement.X).ToString());
MessageBox.Show((objDecrement.Y).ToString());
objDecrement = --objDecrement;
MessageBox.Show((objDecrement.X).ToString());
MessageBox.Show((objDecrement.Y).ToString());
}
}
}
Output:
Click on Overloading Unary Plus:
Click on Overloading Unary Minus:

Click on Prefix Increment:
Click on Prefix Decrement:
Operator Overloading in C sharp –2

Overloading Boolean Operator:
If you need to overload the true or false operators in your class or structure, define
a method with the following characteristics:
• A return type of bool

• A parameter list specifying a single parameter of the type of class or structure
containing the overloaded operator method
Overloading Conversion Operator:

You can also write operator overload methods that convert one type into another
type. If you need to define a new conversion operator in your class or structure,
define a method with the following characteristics:
• The keyword implicit if the conversion is to be treated as an implicit conversion, or

the keyword explicit if the conversion is to be treated as an explicit conversion
• A type specifying the target type of the conversion
• A parameter list specifying the source type of the conversion
Overloading Binary Operators:

The operators that fall under this category are : Addition, Subtraction, Division,
Multiplication, Remainder, AND, OR, Exclusive OR, Shift left, Shift Right, Equality,
Inequality, Greater than, less than. If you need to overload any of the binary
operators in your class or structure, define a method with the following
characteristics:
• A return type of your choice

• A parameter list specifying two parameters, at least one of which must be of the type
of class or structure containing the overloaded operator method
Example: Demonstrate Boolean Overloading, Conversion Overloading and

Binary Operators Overloading
ClsOverloadingBooleanOpertors.cs
using System;
using System.Text;
{
class ClsOverloadingBooleanOpertors
{
public int X;
public int Y;
public static bool operator true ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return true ;
return false ;
}
public static bool operator false ( ClsOverloadingBooleanOpertors RValue)
{
if ((RValue.X == 0) && (RValue.Y == 0))
return false ;
return true ;
}
}
}
ClsOverloadingConversion.cs
using System;
using System.Text;
{
class ClsOverloadingConversion
{
public int X;
public int Y;
public static implicit operator double ( ClsOverloadingConversion RValue)
{
double total_Distance;
double total_Sum;
total_Sum = (RValue.X * RValue.X) + (RValue.Y * RValue.Y);
total_Distance = System. Math .Sqrt(total_Sum);
return total_Distance;
}
}
}
ClsOverloadingEqualityInequality.cs
using System;
using System.Text;
{
class ClsOverloadingEqualityInequality
{
public int X;
public int Y;
public static bool operator ==( ClsOverloadingEqualityInequality objFirst,
ClsOverloadingEqualityInequality objSecond)
{
if (objFirst.X != objSecond.X)
return false ;
if (objFirst.Y != objSecond.Y)
return false ;
return true ;
}
public override bool Equals( object o)
{
return true ;
}
public override int GetHashCode()
{
return 0;
}
public static bool operator !=( ClsOverloadingEqualityInequality objFirst,
ClsOverloadingEqualityInequality objSecond)
{
if (objFirst.X != objSecond.X)
return true ;
if (objFirst.Y != objSecond.Y)
return true ;
return false ;
}
}
}
Form3.cs
using System;
using System.Data;
using System.Text;
{
{
public Form3()
{
}
{ //Overloading True and False operator
ClsOverloadingBooleanOpertors objBoolean = new
ClsOverloadingBooleanOpertors ();
objBoolean.X = 20;
objBoolean.Y = 30;
if (objBoolean)
MessageBox.Show( "The point is at the origin." );
else
MessageBox.Show( "The point is not at the origin." );
}
{ //Overloadable Conversion Operator
double conDistance;
ClsOverloadingConversion objConversion = new ClsOverloadingConversion
();
objConversion.X = 100;
objConversion.Y = 200;
conDistance = objConversion;
MessageBox.Show(conDistance.ToString());
}
{ //Overloading Equality/Inequality Operator
ClsOverloadingEqualityInequality MyFirstPoint = new
ClsOverloadingEqualityInequality ();
ClsOverloadingEqualityInequality MySecondPoint = new
ClsOverloadingEqualityInequality MyThirdPoint = new
MyFirstPoint.X = 100;
MyFirstPoint.Y = 200;
MySecondPoint.X = 500;
MySecondPoint.Y = 750;
MyThirdPoint.X = 100;
MyThirdPoint.Y = 200;
if (MyFirstPoint == MySecondPoint)
MessageBox.Show( "MyFirstPoint and MySecondPoint are at the same
coordinates." );
else
MessageBox.Show( "MyFirstPoint and MySecondPoint are not at the same
coordinates." );
if (MyFirstPoint == MyThirdPoint)
MessageBox.Show( "MyFirstPoint and MyThirdPoint are at the same
coordinates." );
else
MessageBox.Show( "MyFirstPoint and MyThirdPoint are not at the same
coordinates." );
}
}
}
Output:
Clicking on Overloading True/False Operator
Clicking on Overloading Conversion Operator
Clicking on Overloading Equality/Inequality Operator
Sockets
In socket-based network programming, you do not directly access the network
interface device to send and receive packets. Instead, an intermediary file descriptor
is created to handle the programming interface to the network. The special file
descriptors used to reference network connections are called sockets . The socket
defines the following:
• A specific communication domain, such as a network connection or a Unix

Interprocess Communication (IPC) pipe
• A specific communication type, such as stream or datagram
• A specific protocol, such as TCP or UDP
After the socket is created, it must be bound to either a specific network address or
port on the system, or to a remote network address and port. Once the socket is
bound, it can be used to send and receive data from the network.
Network Addresses
After the socket is created, it must be bound to a network address/port pair. UNIX
offers an IP-specific address structure, sockaddr_in , which uses the following
elements. Using the sockaddr_in structure requires placing the appropriate IP
address and port values in the proper data element.
1. sin_family An address family, defined as a short type

2. sin_port A port number, defined as a short type
3. sin_addr An address, defined as a long type (4-byte) IP address
4. sin_data 8 bytes of padding.
.NET defines two classes in the System.Net namespace to handle various types of IP
address information.The classes are IPAddress and IPEndPoint IPAddress object is
used to represent a single IP address. This value can be used in the various socket
methods to represent the IP address.
IPAddress Methods:-
Description
Method
Compares two IP addresses.

Equals
Returns a hash value for an IPAddress object.

GetHashCode
Returns the type of the IP address instance.

GetType
Converts an IP address from host byte order to network byte

HostToNetworkOrder order.
Indicates whether the IP address is considered the loopback

IsLoopBack address.
Converts an IP address from network byte order to host byte

NetworkToHostOrder order.
Converts a string to an IPAddress instance.

Parse
Converts an IPAddress to a string representation of the dotted
ToString decimal format of the IP address.
IPEndPoint: object is used when binding sockets to local addresses, or when

connecting sockets to remote addresses. The following two constructors are used to
create IPEndPoint instances:
• IPEndPoint (long address , int port )

• IPEndPoint(IPAddress address , int port )
PEndPoint Methods:
Description
Method
Creates an EndPoint object from a SocketAddress object

Create
Returns the type of the IPEndPoint instance

GetType
Compares two IPEndPoint objects

Equals
Creates a SocketAddress instance of the IPEndPoint instance

Serialize
Creates a string representation of the IPEndPoint instance

ToString
Returns a hash value for an IPEndPoint object

GetHashCode
Example: Demonstrate Socket Programming
Form4.cs
using System;
using System.Data;
using System.Text;
using System.Net;
{
{
public Form4()
{
}
{ //Introduction to IP Addresses.
IPAddress _address1 = IPAddress .Parse( "192.168.1.1" );
IPAddress _address2 = IPAddress .Broadcast;
IPAddress _address3 = IPAddress .Loopback;
IPAddress _address4 = IPAddress .None;
IPAddress _address5 = IPAddress .Any;
IPHostEntry _hostName = Dns .GetHostEntry( Dns .GetHostName());
IPAddress _myMachine = _hostName.AddressList[0];
if ( IPAddress .IsLoopback(_address3))
lstAddresses.Items.Add( "Loopback address is: " + _address3.ToString());
else
lstAddresses.Items.Add( "Error obtaining the LoopbackAddress" );
lstAddresses.Items.Add( "Local IP address is: " + _myMachine.ToString());
if (_myMachine == _address3)
lstAddresses.Items.Add( "Loopback Address Is Same AsLocal Address.\n" );
else
lstAddresses.Items.Add( "The loopback address is not the local address.\n" );
lstAddresses.Items.Add( "Given Address is: " + _address1.ToString());
lstAddresses.Items.Add( "Broadcast address: " + _address2.ToString());
lstAddresses.Items.Add( "ANY address is: " + _address5.ToString());
lstAddresses.Items.Add( "NONE address is: " + _address4.ToString());
}
{ //Introduction To IPEndPoint
IPAddress test1 = IPAddress .Parse( "192.168.1.1" );
IPEndPoint _endPoint = new IPEndPoint (test1, 8000);
lstIPEndPoint.Items.Add( "IPEndPoint is ::" +_endPoint.ToString());
lstIPEndPoint.Items.Add( "AddressFamily is ::" +_endPoint.AddressFamily);
lstIPEndPoint.Items.Add( "Address is :: " + _endPoint.Address);
lstIPEndPoint.Items.Add( "Port is :: " + _endPoint.Port);
lstIPEndPoint.Items.Add( "Min port number is :: " + IPEndPoint.MinPort);
lstIPEndPoint.Items.Add( "Max port number is :: " +IPEndPoint .MaxPort);
_endPoint.Port = 80;
lstIPEndPoint.Items.Add( "Changed IPEndPoint is :: " +_endPoint.ToString());
SocketAddress _socketAddress = _endPoint.Serialize();
lstIPEndPoint.Items.Add( "SocketAddress is :: " + _socketAddress.ToString());
}
}}
Output:
DNS [Domain Name System]

To simplify the unwieldy state of computer naming, the Domain Name System (DNS)
was created. It allows the master host database to be split up and distributed
among multiple systems on the Internet. DNS uses a hierarchical database
approach, creating levels of information that can be split and stored on various
systems throughout the Internet.
DNS Structure
The structure of a hierarchical database is similar to an organization chart with nodes

connected in a treelike manner (that's the hierarchical part). The top node is called
the root . The root node does not explicitly show up in Internet host addresses, so it
is often referred to as the “nameless” node. Multiple categories were created under
the root level to divide the database into pieces called domains . Each domain
contains DNS servers that are responsible for maintaining the database of computer
names for that area of the database (that's the distributed part).
The first (or top) level of distribution is divided into domains based on country codes.
Additional top-level domains for specific organizations were created to prevent the
country domains from getting overcrowded.
Domain Description
U.S. military sites

.mil
Commercial organizations
.com
Educational institutions
.edu
U.S. government organizations

.gov
Internet Service Providers (ISPs)

.net
Other U.S. organizations (such as local governments)

.us
Nonprofit organizations
.org
Canadian organizations
.ca
German organizations
.de
Organizations from other countries

[other countries]
Using DNS
The last way to determine system IP information is to utilize the C# DNS (Domain
Name System) classes. DNS can be used to obtain Internet hostnames and IP
Addresses. The C# System.Net namespace contains the DNS class, which comprises
several methods that allow you to obtain DNS information about hosts. The
GetHostName() method retrieves the hostname of the local system. The
GetHostByName() method attempts to find the IP address of a hostname.
DNS Configuration
When your C# application is running on a customer's system, you have no
guarantee that there are any DNS servers configured. You can find out what (if any)
DNS servers are configured by using the .NET Registry class methods to examine
the DNS Registry values.
Fortunately, all Windows platforms store the DNS server information in the same
place:
HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters
Registry Data Values for DNS Servers
Data Value Description
DatabasePath The location of the host's file
Domain The name of the system's domain
NameServer The list of DNS servers
Hostname The name of the system's DNS host
SearchList A list of DNS domains to append to the

end of hostnames in DNS name searches
The value of most interest here is NameServer . This should contain a single string
value representing all the configured DNS servers, separated by spaces. The primary
DNS server will be listed first, followed by the alternate servers.
Example: Demonstrate DNS and its Configuration in Registry

using System;
using System.Data;
using System.Text;
using System.Net;
using Microsoft.Win32;
{
{
public Form6()
{
}
{ //Demonstrate DNS..
string _hostName = Dns .GetHostName();
lstDNS.Items.Add( "Local hostname :: " + _hostName);
IPHostEntry _ipHostEntry = Dns .GetHostByName(_hostName);
foreach ( IPAddress _address in _ipHostEntry.AddressList)
{
lstDNS.Items.Add( "IP Address ::" + _address.ToString());
}
}
{ //DNS Configuration in Registry
RegistryKey start = Registry .LocalMachine;
string DNSservers =
@"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters" ;
RegistryKey DNSserverKey = start.OpenSubKey(DNSservers);
if (DNSserverKey == null )
{
lstDNSConfiguration.Items.Add( "Unable to open DNS servers key" );
return ;
}
string serverlist = ( string )DNSserverKey.GetValue( "NameServer" );
lstDNSConfiguration.Items.Add( "DNS Servers: " + serverlist);
DNSserverKey.Close();
start.Close();
char [] token = new char [1];
token[0] = ' ' ;
string [] servers = serverlist.Split(token);
foreach ( string server in servers)
{
lstDNSConfiguration.Items.Add( "DNS server: " + server);
}
}
}
}
Output:
Click on both the buttons will display the respective outputs in the list box
specified below
Working with Files

File access in .NET is generally handled with stream objects. In this section, we will
discuss about the two classes BinaryWriter and BinaryReader to demonstrate the file
handling in C#. The BinaryReader and BinaryWriter classes support binary file
access. These classes permit binary operations to and from streams.
BinaryWriter
The BinaryWriter class allows primitive data types to be written to streams; and with
the use of subclassing, you can override the methods of this class and fulfill your
own unique character encoding requirements. The following table will summarize the
properties of the class:-
Name Type Purpose
BaseStream Property Allow access to binary writer underlying stream.
Close Method Close the Binary writer class and the underlying stream.
Flush Method Flushes out all data to the underlying stream and then
clears buffers.
Seek Method Sets the current position within the current stream.
Write Method This overloaded method writes a value out to the current
stream.
BinaryReader
The BinaryReader class, much like the BinaryWriter class, relies on a FileStream
object to read files .
Method Description
Close Close the binary reader object and the base stream.
PeekChar Reads the next available byte from the stream but does not
advance the byte or character position within the file.
ReadBoolean Reads a Boolean [True/False] value from the stream.
ReadByte Reads a single byte from the stream. There is also a readbytes
method for specifying the number of bytes to read.
ReadChar Reads a single char value from the stream. There is also a
readchars method for specifying the number of chars to read.
ReadInt16 Reads an integer value (2 bytes).
ReadInt32 Reads a long value (4 bytes).

ReadInt64 Reads an eight-byte signed integer.
Example: Demonstrate working with files

using System;
using System.Data;
using System.Text;
using System.IO;
{
{
public Form4()
{
}
{ //Writing to the file
FileStream myFStream = new FileStream ( "G:\\2CSharpApplication\\Test.txt" ,
FileMode .OpenOrCreate, FileAccess .ReadWrite);
BinaryWriter binWrit = new BinaryWriter (myFStream);
string testString = "Writing into a File..This is a test Value." ;
binWrit.Write(testString);
binWrit.Close();
myFStream.Close();
}
{ //Reading from the file.
long imageWidth = 0;
long imageHeight = 0;
int imagePlanes = 0;
int imageBitCount = 0;
string [] cma = Environment .GetCommandLineArgs();
if (cma.GetUpperBound(0) >= 1)
{
FileStream myFStream = new FileStream (cma[1], FileMode .Open, FileAccess
.Read);
BinaryReader binRead = new BinaryReader (myFStream);
binRead.BaseStream.Position=0x12;
imageWidth = binRead.ReadInt32();
imageHeight= binRead.ReadInt32();
imagesPlanes= binRead.ReadInt16();
imagesBitCount = binRead.ReadInt16();
Console .WriteLine( "[{0}] {1}x{2} {3}- bit" ,cma[1], imageWidth, imageHeight,
imageBitCount);
binRead.Close();
myFStream.Close();
}
}
{ //Copying File.
string [] strcla = Environment .GetCommandLineArgs();
if (strcla.GetUpperBound(0) == 2)
{
FileInfo cpyfi = new FileInfo (strcla[1]);
cpyfi.CopyTo(strcla[2], true );
MessageBox .Show( "Copied " + cpyfi.Length + " bytes." );
}
else
MessageBox .Show( "Usage: cp <input file> <output file>" );
}
{ //Deleting File.
{
FileInfo delfi = new FileInfo (strcla[1]);
delfi.Delete();
MessageBox .Show( "File : " + strcla[1]);
MessageBox .Show( "Attributes: " + delfi.Attributes.ToString());
MessageBox .Show( "File Deleted..." );
}
else
MessageBox .Show( "Usage: rm <filename>" );
}
{ //Moving File.
{
FileInfo movfi = new FileInfo (strcla[1]);
movfi.MoveTo(strcla[2]);
MessageBox .Show( "File Created : " +movfi.CreationTime.ToString());
MessageBox .Show( "Moved to : " + strcla[2]);
}
else
MessageBox .Show( "Usage: mv <source file> <destination file>" );
}
}
}
Generating Help File in C sharp
An interesting feature of the C# compiler is to generate XML documentation from
the comments. C# compiler reads specially formatted comments and generates XML
documentation from the comments. You can then displays this XML on the Web to
provide an extra level of documentation to developers who need to understand the
structure of your applications.
Pre-requisites to generate XML documentation from the comments are:
• Use three slashes for comments(///). The C# compiler does not generate any XML
Documentation for any comments that do not begin with three slashes. Nor does the
C# compiler generates any XML documentation for regular, multi line, comments.
• Use the /doc option of the C# compiler to specify the name of the file that should
contain the generated XML documentation.
Example: Demonstrate XML documentation from Comments

Step1: In the first step we create the C# code file.
using System;
{
{
/// <summary>
/// Developed By : C# Team
/// Developed On : 21 Oct,07
/// </summary>
[ STAThread ]
static void Main ()
{
Application .EnableVisualStyles();
Application .SetCompatibleTextRenderingDefault( false );
System.Console.WriteLine( "StartUp for C# World!" );
}
}
}
Step2: The following command is used to generate the help file. The command will
create two files i.e. “Program.exe” and other is “ProgramHelpFile.xml” .
Command: csc /doc: HelpFile.xml ProgramFile.cs
Output:-
The following xml will be generated by the above command.
ProgramHelpFile.xml
<?xml version="1.0"?>
<doc>
<assembly>
<name>Program</name>
</assembly>
<members>
<member name="M:_CSharpApplication.Program.Main">
<summary>
The main entry point for the application.
Developed By : C# Team
Developed On : 21 Oct,07
</summary>
</member>
</members>
</doc>
Note: -Main portion of XML documentation is found in <member> element: This
element contains one <member> tag for each documented item in the source code.
The <member> tag contains one attribute, name, which names the member being
documented. The value of the name attribute starts with a one-letter prefix
describing the type of information being described. Options for the first letter of the
name attribute's value and its meaning. <member> “name” = Attribute Prefixes >
Other Important Tags:
The following is the list of more help file tags which can be used in the C#.
1. <c>:- T ag to indicate that a small part of your comment should be treated

as code. Style sheets may use this element to display the code portion of your
comment E.g. /// This is the <c> Main ()</c> function for the /// Program
class.
2. <code>:- Tag to indicate that multiple lines of text in your comments should
be treated as code: E.g.
/// <code>
/// Argument[0]: command line argument 1
/// </code>
3. <exception>:- You can use the <exception> tag to document any
exceptions that may be raised from the member's code. The <exception> tag
must contain an attribute called cref whose value specifies the type of
exception being documented. The cref attribute value must be enclosed in
quotes. The text of the element describes the conditions under which the
exception is thrown: E.g.
/// <exception cref="System.Exception">
/// Raised if the input is less than 0.
/// </exception>
4. <permission>:- Use the <permission> tag to document the permissions
available on a given function or variable. Access to a class's code and data
can mean access to all of the code or it can be restricted to a certain subset
of code. You can use the <permission> tag to document the availability of
your code and data. The <permission> tag makes use of one attribute: cref.
The value of the cref element must name the function or variable whose
permissions are being documented: E.g.
/// <permission name="Main()">
/// Everyone can access Main ().
/// </permission>
5. <remarks>:- Use the <remarks> tag to add information about an item. The
<remarks> element is great for providing an overview of a method or
variable and its usage. The <remarks> tag carries no attributes and its text
contains the remarks: E.g.
/// <remarks>
/// The Main () function is the entry point into the
/// application. The CLR will call Main () to start
/// the application after the application loads
/// </remarks>
Code Access Security

Code access security is a feature of .NET that manages code, dependent on our level
of trust. If the CLR trusts the code enough to allow it to run, it will begin executing
the code. Depending on the permissions provided to the assembly, however, it might
run within a restricted environment. If the code is not trusted enough to run, or if it
runs but then attempts to perform an action, for which it does not have the relevant
permissions, a SecurityException is thrown. The code access security system means
that we can stop malicious code running, but we can also allow code to run within a
protected environment where we are confident that it cannot do any damage.
CAS is part of .Net security model that determines whether or not a piece of code is
allowed to run and what resources it can use while running. CAS grants rights to
program depending on the security configuration of the machine. For e.g. the
program has rights to edit or create a new file but the security configuration of
machine does not allow the program to delete a file.
Code access security is based on two concepts Code Groups and Permissions. The
following sections will discuss both in detail.
Code Group
Code Group is the concept of bringing together the code with similar characteristics.
Two examples for code groups are Internet and Intranet. The group Internet defines
code that is sourced from the Internet, the group Intranet defines code sourced
from the LAN. Code groups have an entry requirement called membership
condition . Each code group has one, and only one, membership condition.
Following is the available list of code group memberships:
• Zone: The region from which the code originated. A zone is one of the commonly
used condition. A zone is the region of origin of a piece of code and refers to one of
the following: My Computer, Internet, Intranet, Trusted, or not trusted.
• Site: The Web site from which the code originated.
• Strong Name: A unique, verifiable name for the code.
• Publisher: The publisher of the code.
• URL: The specific location from which the code originated.
• Hash Value: The hash value for the assembly.
• Skip Verification: This condition requests that it bypasses code verification checks.
• Application Directory: The location of the assembly within the application.
• All Code: All code fulfills this condition.
• Custom: A user-specified condition.
Code groups are arranged hierarchically with the All Code membership condition at
the root.
Permissions
Permissions are the actions we allow each code group to perform? For example,
permissions include “able to access the user interface” and “able to access local
storage.” The system administrator usually manages the permissions at the
enterprise, machine, and user levels.
Multi-Threading
A thread is a sequence of execution in a program. All our C# programs up to this
point have one entry point—the Main () method. Execution starts with the first
statement in the Main () method and continues until that method returns. A thread
is the basic unit to which the operating system allocates processor time.
Processes are made up of one or more threads. A thread is defined as a single flow
of operation within a program. When a program executes on the CPU, it traverses
the program statements in a single thread until the thread is complete.
Amultithreaded application distributes functions among multiple program flows,
allowing two or more paths of execution to occur. Each path of execution is a
separate thread.
Multi-tasking: It's a feature of modern operating systems with which we can run
multiple programs at same time example word, excel etc
Multi-Threading: Multi-threading forms subset of multi-tasking instead of having
to switch between programs this feature switches between different parts of the
same program. Example we are writing a word document and at the same time
word is doing a spell check in background.
Multithreaded programs create their own threads that can be executed separately
from the main thread of the program. All threads created by the primary thread
share the same memory address space as the primary thread. Often the secondary
threads are used to perform computationally intensive functions, allowing the main
thread to continue responding to Windows events. Without the secondary threads,
the user could not select anything from the menu or click any buttons while an
application computed a mathematical function
System.Threading: This namespace has all the classes that are related to
implement threading. Any .Net application who wants to implements threading has
to import this namespace.
Note: In .Net program, there are always at least two threads running, i.e. one is the
main program and other is the garbage collector.
States:
Threads have several operational states, which are enumerated using the .NET
Thread State enumeration, found in the System.Threading namespace.
• Initialized: The thread has been initialized but not started.

• Ready: The thread is waiting for a processor.
• Running: The thread is currently using the processor.
• Standby: The thread is about to use the processor.
• Terminated: The thread is finished and is ready to exit.
• Transition: The thread is waiting for a resource other than the processor.
• Unknown: The system is unable to determine the thread state.
• Wait: The thread is not ready to use the processor
The Thread Class

Use the Thread class to create a new Thread object, which produces a new thread
within the current process. The format of the Thread constructor is as follows, where
start is a ThreadStart delegate:
Thread (ThreadStart start)
The ThreadStart delegate points to the method that will be performed within the
new thread.
E.g. Thread newthread= new Thread (new ThreadStart (anyMethod));
Void anyMethod () {}
After the Thread object is created, it can be controlled using various Thread class
methods, which are as under:
• Abort (): Terminate the thread.

• Equals (): Determines whether two thread objects are same.
• GetHashCode (): Get a unique representation for the thread.
• GetType (): Get the type of the current thread.
• Interrupt (): Interrupts a thread that is in a wait state.
• Join (): Blocks the calling thread until the thread terminates.
• Resume (): Resumes a thread that has been suspended.
• Start (): Change the state of the thread to running.
• Suspend (): Suspend the execution of the thread.
• ToString (): gets a string representation of the Thread object.
Thread priority: The thread priority determines the order in which thread has to
execute. The thread priority can be changed by using Threadname.Priority =
ThreadPriority.Highest.
Different levels of priority provided by .Net:
• ThreadPriority.Highest
• ThreadPriority.AboveNormal
• ThreadPriority.Normal
• ThreadPriority.BelowNormal
• ThreadPriority.Lowest
Thread.Sleep (): Thread execution can be paused by calling the Thread.Sleep

method. This method takes an integer value that determines how long the thread
should sleep.
Example: Demonstrate Threading
using System;
using System.Text;
using System.Runtime.Remoting;
using System.Threading;
namespace ConsoleApplication1
{
class Program1
{
static void Main ( string [] args)
{
Program1 ts = new Program1 ();
}
public Program1()
{
int i;
Thread firstThread = new Thread ( new ThreadStart (FirstMethod));
Thread secondThread = new Thread ( new ThreadStart (SecondMethod));
firstThread.Start();
secondThread.Start();
for (i = 0; i < 10; i++)
{
Console.WriteLine( "Main: {0}" , i);
Thread .Sleep(1000);
}
}
void FirstMethod()
{
int i;
for (i = 0; i < 10; i++)
{
Console.WriteLine( " First thread: {0}" , i);
}
}
void SecondMethod()
{
int i;
for (i = 0; i < 10; i++)
{
Console.WriteLine( " Second thread2: {0}" , i);
}
}
}
}
Output:
Main : 0 First thread: 0 Second thread2: 0 Main : 1 First thread: 1 Main : 2 Second
thread2: 1 Main : 3 First thread: 2 Main : 4 Main : 5 Second thread2: 2 First thread:
3 Main : 6 Main : 7 First thread: 4 Main : 8 Second thread2: 3 Main : 9 First thread:
5 Second thread2: 4 First thread: 6 First thread: 7 Second thread2: 5 First thread: 8
Second thread2: 6 First thread: 9 Second thread2: 7 Second thread2: 8 Second
thread2: 9
Globalization and Localization –1
When writing applications for international distribution, different cultures and
regions must be kept in mind. Different cultures have diverging calendars and use
different number and date formats, and also the sort order with the letters A-Z may
lead to various results. To make applications fit for global markets you have to
globalize and localize them.
• Globalization is about internationalizing applications: preparing applications for

international markets. With globalization, the application supports number and date
formats depending on the culture, different calendars, and so on.
• Localization is about translating applications for specific cultures. For translations of
strings, you can use resources.
.NET supports globalization and localization of Windows and Web applications. To

globalize an application you can use classes from the
namespace System.GlobalizationSystem.Resources. whereas to localize an
application you can use resources that are supported by the namespace
System.Globalization
The System.Globalization namespace holds all culture and region classes to support
different date formats, different number formats, and even different calendars that
are represented in classes such as Gregorian calendar, Hebrew Calendar, Japanese
Calendar, and so on. Using these classes you can display different representations
depending on the user's locale.
Cultures and Regions
The world is divided into multiple cultures and regions, and applications have to be
aware of these cultural and regional differences. RFC 1766 defines culture names
that are used worldwide depending on a language and a country or region. Some
examples are en-AU, en-CA, en-GB, and en-US for the English language in Australia
, Canada , United Kingdom , and the United States .
Note:- Most Important class in System.Globaliation namespace
isCultureInfo [Represents a Culture]
Example: Demonstrate CultureInfo
using System;
using System.Text;
using System.Globalization;
{
class Program1
{
{
int val = 1234567890;
string name = "visualbuilder" ;
//Culture of the Current Thread
Console .WriteLine(val.ToString( "N" ));
//use IFormatProvider
Console .WriteLine(val.ToString( "N" , new CultureInfo ( "fr- FR" )));
//Change the culture of the thread
Thread .CurrentThread.CurrentCulture = new CultureInfo ( "de- DE" );
Console .WriteLine(val.ToString( "N" ));
}
}
}
Output:
The following output will be displayed on console.
Display in Current Culture: 1,234,567,890.00
Display in French Culture: 1 234 567 890, 00
Display in DE Culture: 1.234.567.890, 00
Working with Registry in C sharp

Windows Registry is a central database for application configuration settings and
other information required by the applications. The Windows Registry is a data
repository that exists on each computer in Windows Operating systems. Both the
system and application programs use this repository to store information needed at
runtime. For example, the system stores file associations (the applications or
command lines associated with each known file extension) in the Registry.
Applications often use the Registry to store information such as users' option
settings and data file pathnames.
Note:- If you've never open Windows registry, you can see it by

running regedit from command line
.NET Framework Library provides two classes - Registry and RegistryKey to work
with the windows registry. These classes are defined in Microsoft.Win32 namespace.
So before using these classes, you need to add reference to this namespace.
Registry Class:
The Registry class contains members to provides access to registry keys. We can
define registry keys in the following order.
• CurrentUser - Stores information about user preferences.

• LocalMachine - Stores configuration information for the local machine.
• ClassesRoot - Stores information about types (and classes) and their properties.
• Users - Stores information about the default user configuration.
• PerformanceData - Stores performance information for software components.
• CurrentConfig - Stores non-user-specific hardware information.
• DynData - Stores dynamic data.
The Registry class members are described in the following table.
Returns a RegistryKey type which provides access to

ClassesRoot HKEY_CLASSES_ROOT key.
LocalMachine Returns a RegistryKey type which provides access to

HKEY_LOCAL_MACHINE key.
CurrentConfig Returns a RegistryKey type which provides access to

HKEY_CURRENT_CONFIG key.
DynData Returns a RegistryKey type which provides access to

HKEY_DYN_DATA key.
CurrentUser Returns a RegistryKey type which provides access to

HKEY_CURRENT_USER key
PerformanceData Returns a RegistryKey type which provides access to

HKEY_PERFORMANCE_DATA key.
Users Returns a RegistryKey type which provides access to

HKEY_USERS key.
RegistryKey Class :
The RegistryKey class contains members to add, remove, replace, and read registry
data. Some of its common methods and properties are defined in the following
table.
Properties:
Name - Represents the name of the key.
SubKeyCount - Represents the count of subkeys at the base level, for theCurrent
key.
ValueCount - Represents the count of values in the key.
Methods:
GetValueNames Retrieves an array of strings that contains all the value names
associated with this key.
GetValue Returns the specified value.
OpenSubKey Opens a subkey.
GetSubKeyNames Returns an array of strings that contains all the subkey names.
DeleteSubKeyTree Deletes a subkey and any children.
DeleteSubKey Deletes the specified subkey.
CreateSubKey Creates a new subkey if not exists, otherwise opens an existing

subkey.
SetValue Sets the specified value.
DeleteValue Deletes the specified value from a key.
Close Closes the key.
Example:- Working with Windows Registry.

Form1.cs
using System;
using System.Data;
using System.Text;
using Microsoft.Win32;
namespace WindowsApplication1
{
{
public Form1()
{
}
{ //Adding a Key and Value in Registry
RegistryKey key = Registry .LocalMachine.OpenSubKey( "Software" , true );
//Create Key inside the software folder
RegistryKey newkey = key.CreateSubKey( "NewTestKeyAdded" );
//User Can also set the value for this Key
newkey.SetValue( "NewTestKeyAdded" , "ValueForThisTestKey" );
MessageBox.Show( "Key/Value is added in the Registry..." );
}
{ //Retrieving Data From Registry
RegistryKey pRegKey = Registry .LocalMachine;
pRegKey = pRegKey.OpenSubKey( "HARDWARE\\
DESCRIPTION\\System\\FloatingPointProcessor\\0" );
Object valueOfKey = pRegKey.GetValue( "Identifier" );
MessageBox.Show( "Key Value is :: " + valueOfKey);
}
{ //Deleting Key/Value from Registry
RegistryKey delKeyValue = Registry .LocalMachine.OpenSubKey(
"Software\\" );
delKeyValue.DeleteValue( "ValueForThisTestKey" );
// Delete the key from the registry.
RegistryKey delSubKey = Registry .LocalMachine.OpenSubKey( "Software" ,
true );
delSubKey.DeleteSubKey( "NewTestKeyAdded" );
MessageBox.Show( "Deleting Key/Value in the Registry" );
}
}
}
Output:
Adding a Key/Value in the Registry
Retrieving Value from the Registry
Globalization and Localization –2

The coming section will discuss about some more classes used for Globalization in
C#.
Resources and ResourceWriter
Resources such as pictures or string tables can be put into resource files or satellite
assemblies. Such resources can be very helpful when localizing applications, and
.NET has built-in support to search for localized resources. A resource file can be a
text file or a .resx file or XML file. This file contains the key/value pairs. Where the
keys are used in the program and at run time they are replaced with the values that
is corresponding to each key. For example:-
Name = Jim Tire
Address = USA
Author = Puppet
Publisher = Jim Toe
Note:-ResGen.exe utility is used to create a resource file out of this “test.txt” file.
the command Resgen test.txt will create the text.txt resource file
and Resgen test.txt test.resx will createtthe XML file from the test.txt file.
ResourceWriter
This class under the System.Resources namespace is used to create the resource file
through the programming. The below example will create the object of
theResourceWriterAddResource() method. and then we can use the same object to
add upto 2GB of resources. We have to just supply the key/value pair to the object's
Example: Demonstrate ResourceWriter
using System;
using System.Text;
using System.Globalization;
using System.Resources;
{
class Program1
{
{
ResourceWriter rw = new ResourceWriter ( "RWDemo.resources" );
rw.AddResource( "Name " , "VisualBuilder" );
rw.AddResource( "Adress" , " UK " );
rw.AddResource( "Hobby" , "Cricket" );
rw.AddResource( "Favourite Country" , " Australia " );
rw.AddResource( "Player" , "Sunny" );
rw.Close();
}
}
}
Output:
This will create RWDemo.resources file, which contains the key/value pairs. The
Close() method of the ResourceWriter class automatically calls
ResourceWriter.Generate() to finally write the resources to the file
RWDemo.resources.
Using Resource File in an Application
We can add resource files to assemblies using the assembly generation tool al.exe,
using the /embed option or using the c# compiler with /resource option or directly
using the VS.Net. The following are the steps to use the resource files in C#
application.
1. Open the application

2. Use the context menu of the solution explorer (Add >> Add Existing Item)
3. Locate the path where the resource file is situated.
4. If you check the Resource after adding it to the projects, its BuildAction is
“Embedded Resource”, this means the resource is embedded to the output
assembly.
5. You can view the resource file using the ILDasm.exe utility by checking it in
the assembly manifest.
6. To access the embedded resources, use the Resource Manager class from the
System.Resources namespace.
7. You can pass the assembly that has the resources as an argument to the
constructor of the Resource Manager class
8. Once you include the resource file in the application use the Resource
Manager and load the resource file into this.
Example: Demonstrate Usage of Resource File

using System;
using System.Data;
using System.Text;
using System.Reflection;
using System.Resources;
{
{
public Form22()
{
}
{ //Using Resource File
System.Resources. ResourceManager rm;
Assembly assembly = Assembly .GetExecutingAssembly();
rm = new ResourceManager ( "cSHARPEXAMPLES.RWDemo" , assembly);
txtName.Text = rm.GetString( "Name " );
txtAddress.Text=rm.GetString( "Adress" );
txtHobby.Text = rm.GetString( "Hobby" );
txtFCountry.Text = rm.GetString( "Favourite Country" );
txtPlayer.Text = rm.GetString( "Player" );
}
}
}
Windows Service
The core function of a Windows Service is to run an application in the background.
One of the ways that it differs from an windows application in that a Windows
Service starts before any user logs in to the system (if it has been setup to start at
boot up), although it can also be setup in such a way that it requires user to start it
manually. A Windows Service also has its own process hence it runs very efficiently.
Normally a Windows Service will not have a user interface for a simple reason it can
be run even if no one is logged on to the system but this is not a rule, you can still
have a Windows Service with a user interface.
Creating a Windows Service:
Step 1:- Open VS 2005, Click on File > Projects.
Step 2:- This will open up a project and clicking on the hyperlink that is there on
the page, you will be able to open the code behind page where you can code for the
web service.
Step 3:- Add Functionality to the web service that you have created. There are two
overridden function i.e. “OnStart” and “OnStop”. The OnStart function executes
when you start your service and the OnStop function gets execute when you stop a
service.
//OnStart
protected override void OnStart( string [] args)
{}
//OnStop
protected override void OnStop()
{}
Step 4:- Install and Run the Service: For Installation of the service on the computer,
one need to have the administrator rights to install the service on the computer. The
installUtil tool is provided by with the .Net framework to install the application.
Note:- The use should have administrator rights to install the utility. If the utility is
not installed then it will display a popup when you run the program.
Example: Demonstrate Windows Services.
using System;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using System.IO;
namespace winServiceFirst
{
public partial class OTestService : ServiceBase
{
public OTestService()
{
}
protected override void OnStart( string [] args)
{
//This will be printed at the start of the service....
FileStream fs = new FileStream
( @"C:\windowServiceTest\trackerForWebService.txt" , FileMode
.OpenOrCreate, FileAccess .Write);
StreamWriter m_streamWriter = new StreamWriter (fs);
m_streamWriter.BaseStream.Seek(0, SeekOrigin .End);
m_streamWriter.WriteLine( " ************************** \n" );
m_streamWriter.WriteLine( " mcWindowsService: Service Started \n" );
m_streamWriter.WriteLine( " ************************** \n" );
m_streamWriter.Flush();
m_streamWriter.Close();
}
protected override void OnStop()
{ // TODO: Add code here to perform any tear-down necessary to stop your
service.
//This will be printed at the end of the service...
FileStream fs = new FileStream
( @"C:\windowServiceTest\trackerForWebService.txt" , FileMode .OpenOrCreate,
FileAccess .Write);
StreamWriter m_streamWriter = new StreamWriter (fs);
m_streamWriter.BaseStream.Seek(0, SeekOrigin .End);
m_streamWriter.WriteLine( " *************************** \n" );
m_streamWriter.WriteLine( " mcWindowsService: Service Stopped \n" );
m_streamWriter.WriteLine( " *************************** \n" );
m_streamWriter.Flush();
m_streamWriter.Close();
}
}
}
Output:
Note:- Thr program will write the content in the text file that we specified. The
following lines gets printed in the text file.
**************************
mcWindowsService: Service Started

**************************
***************************
mcWindowsService: Service Stopped
***************************
Web Service
The term "web service" refers to a form of a component that can be used remotely.
Web services are invoked remotely using SOAP or HTTP-GET and HTTP-POST
protocols. Web services are based on XML and return an "answer" to the client in
XML format. Web services have all the advantages of components plus many more.
The most significant benefits include:
1. Platform and Language Independence : Web services can be built and

consumed on any operating system just as long as that operating system
supports the SOAP protocol and XML.
2. Automatic Upgrade : Unlike components, if a web service requires an
update, that update is propagated to all applications consuming that web
service immediately. This is because the actual methods and properties for
the web service are invoked from the web server remotely, meaning that each
function contained within a web service appears as a "black box" to a client:
they aren't concerned with the way the function does its job, just as long as it
returns the expected result.
Some Important Terms in Web Services:
1. UDDI : UDDI (Universal Description, Discovery and Integration) is a registry

that provides a place for a company to register its business and the services
that it offers. People or businesses that need a service can use this registry to
find a business that provides the service. When you search for a web service
using UDDI's web service or web browser, UDDI returns a listing of web
services that matched your criteria. This list is returned in the form of a
DISCO or WSDL document.
2. WSDL: WSDL (Web Services Description Language) is a language that
describes a web service. It contains information such as where you can find
the web service, methods and properties that it supports, its data types, and
the protocol used to communicate with the web service. WSDL is based on
the XML format and it's used to create proxy objects. Basically, without a
WSDL document, developers wouldn't be able to use web services simply
because they wouldn't know which methods and properties they support and
also which communication method any particular web service supports.
3. DISCO : DISCO (Abbreviated from disco very) is a list of WSDL documents.
DISCO is used to group common web services together. DISCO documents
are also in XML format.
4. SOAP: SOAP (Simple Object Access Protocol) is a protocol to transport data
to and from the web server. It is in XML format and allows you to transport a
variety of data types used in .NET. As an alternative to SOAP, we can use
HTTP-GET and HTTP-POST, which will be covered later in the article. These
protocols return the output in a non-SOAP format; however this output is still
in XML format.
Example: Demonstrate Web Service

using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
[ WebService (Namespace = "http://tempuri.org/" , Description = "New WEB
Service Developed by V.D" )]
[ WebServiceBinding (ConformsTo = WsiProfiles .BasicProfile1_1)]
public class Service : System.Web.Services. WebService
{
public Service () {
//Uncomment the following line if using designed components
//InitializeComponent();
}
[ WebMethod (Description= "GetEmployeeName: This will return the Employee
Name." )]
public string getEmployeeName()
{
return "James Tube" ;
}
[ WebMethod (Description = "GetEmployeeAge: This will return the Employee
Age." )]
public string getEmployeeAge()
{
return "23" ;
}
}
Output: Run this Web Service or F5
Note:
1]. There are 2 methods that are associated with this web service.
2]. The web service us under the default namespace that is http://tempuri.org. .
3]. Each XML Web service needs a unique namespace in order for client applications
to distinguish it from other services on the Web.http://tempuri.org/ is available for
XML Web services that are under development, but published XML Web services
should use a more permanent namespace .
Output: If user clicks on the getEmployeeAge link
Click on the Invoke Button will display the value.
Consuming Web Services
A Web Service is an external interface provided by a Web site that can be called
from other Web sites. For example, a financial company may make up to the minute
stock quotes available via Web Service for those who do their trading with that
company. This information could be read from a Web page and displayed, or read
from a stand-alone application on a customer's desktop computer.
Client Communicate through web service:
SOAP over HTTP SOAP over HTTP
XML XML
Location
1 Location 2
Soap calls are remote function calls that invoke methods executions on Web Service
components at Location 2. The output is render as XML and pass back to the
Location 1 where the user wants to access the Web Service.
At Location 1, the user need to consume some of the functions of the web service
that is available on the internet, to make the remote function calls (RFC). All the
processing can't be done on the remote machine, therefore, we have to create the
proxy of the web service from where we can process our data. This whole process is
also called as marshalling of data.
Due to security threats, we create the proxy of the server object here it is web
service. That means we are creating a " proxy object " to act on behalf of the
original Web service. The proxy object will have all the public available data
interfaces as the original Web service.
Consuming a Web Service
The following are the steps to call/consume a webservice.
Step 1: Create a Web Service project and run it so that no compilation error exists.
Step 2: Create new Web Site that will consume this web site that is there in your
system using the VS.Net. Create New Web Site with the name: Web Site Name that
will consume web service:WebService_Consume.
Step 3: Once you are done with the creation of the new site that will consume the
web Service. Let example the web service run as this
URL:http://localhost:1508/WebService_New/MyWebService.asmx
Step 4: Right click on the solution, Click on “Add Web Reference”. This will open up
a new pop-up window where you can specify theURL name of your web service .
Here we specify the web service URL and if you look at the right panel there is Web
Reference Name: localhost [This the default name that is there].
Step5: We specify “localhost_myWebService” name for the web reference. This will
include 3 files under this folder.
• MyWebService.disco
• MyWebService.discomap
• MyWebService.wsdl
Step6: Look Inside the contents of the “disco” file

<?xml version="1.0" encoding="utf-8" ?>
<discovery xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"xmlns="http://schema
s.xmlsoap.org/disco/">
<contractRefref="http://localhost:1508/WebService_New/MyWebService.asmx?wsdl
"docRef="http://localhost:1508/WebService_New/MyWebService.asmx" xmlns="htt
p://schemas.xmlsoap.org/disco/scl/" />
<soapaddress="http://localhost:1508/WebService_New/MyWebService.asmx" xmlns
:q1="http://tempuri.org/" binding="q1:ServiceSoap"xmlns="http://schemas.xmlso
ap.org/disco/soap/" />
<soapaddress="http://localhost:1508/WebService_New/MyWebService.asmx" xmlns
:q2="http://tempuri.org/" binding="q2:ServiceSoap12"
xmlns="http://schemas.xmlsoap.org/disco/soap/" />
</discovery>
Step7: Look Inside the contents of the “discomap” file
<?xml version="1.0" encoding="utf-8" ?>
<DiscoveryClientResultsFilexmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance"xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Results>
<DiscoveryClientResultreferenceType="System.Web.Services.Discovery.DiscoveryDo
cumentReference"url="http://localhost:1508/WebService_New/MyWebService.asmx
?disco" filename="MyWebService.disco" />
<DiscoveryClientResultreferenceType="System.Web.Services.Discovery.ContractRefe
rence"url="http://localhost:1508/WebService_New/MyWebService.asmx?wsdl" filena
me="MyWebService.wsdl" />
</Results>
</DiscoveryClientResultsFile>
Example: Demonstrate the Consumption of the Web Service in the Web Site
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
public partial class _Default : System.Web.UI. Page
{
protected void Page_Load( object sender, EventArgs e)
{
}
protected void Button1_Click( object sender, EventArgs e)
{ //Consuming the WebServices through Add Web Reference
//Fetching the Value from the Web Services
localhost_myWebService. Service objServiceConsume
= newlocalhost_myWebService. Service ();
txtName.Text = objServiceConsume.getEmployeeName();
txtAge.Text = objServiceConsume.getEmployeeAge();
}
}
Output:
Click on the Fetcher button: This will fetch the value from the Web Service.
Creating Proxy Object of Web Service

There are many ways to consume Web Services.
1. The first way is to use a SOAP Proxy Client Object generated by the WSDL
utility, and it provides programmers with their familiar object model that they
can use to call methods provided by the generated Proxy Interface.
2. The second way is to use HTTP-POST and HTTP-GET protocols.
3. The third way is to use a SOAP standard Request message that parses SOAP
response messages with the help of the XMLHTTP COM object that is installed
by the Microsoft XML Parser.
WSDL: Web Services Description Language (WSDL) is an XML based protocol for
information exchange in decentralized and distributed environments. A WSDL
document defines services as collections of network endpoints, or ports. A WSDL
document uses the following elements in the definition of network services:
• Types – a container for data type definitions using some type system (such as XSD).
• Message – an abstract, typed definition of the data being communicated.
• Operation – an abstract description of an action supported by the service.
• Port Type –an abstract set of operations supported by one or more endpoints.
• Binding – a concrete protocol and data format specification for a particular port
type.
• Port – a single endpoint defined as a combination of a binding and a network
address.
• Service – a collection of related endpoints.
Proxy Class: This proxy class serves as an intermediate between the ASP.NET Web
page and the Web service
Consuming Web Service object:
1. The Asp.Net page instantiates an instance of the proxy class. For e.g.
ProxyClassName objproxy = new ProxyClassName();
2. Once the object is instantiated, then with the help of proxy object, this will
make a call to the web service method. For e.g.
objproxy.WebMethodName(any Parameter that has to send);
3. The proxy class marshals the parameter list and makes an HTTP request to
the Web service sitting on Web Server 2.
4. The Web service unmarshals the incoming parameters, runs the method, and
marshals the output parameters. These are sent back in an HTTP response.
5. The proxy class unmarshals the return parameters and passes back the result
to the ASP.NET Web page.
Creating a Proxy Class:

Creating a Proxy class involves three steps:
tep 1:- First create the proxy class of the web service using the WSDL tool.
wsdl.exe:-Utility to generate code for xml web service clients and xml web services
using ASP.NET from WSDL contract files, XSD schemas and discomap discovery
documents. This tool can be used in conjunction with disco.exe.
Run this from the Command Prompt:
C:\Program Files\Microsoft Visual Studio
8\VC> wsdlhttp://localhost:1508/WebService_New/MyWebService.asmx
Microsoft (R) Web Services Description Language Utility
[Microsoft (R) .NET Framework, Version 2.0.50727.42]
Copyright (C) Microsoft Corporation. All rights reserved.
Writing file 'C:\Program Files\Microsoft Visual Studio
8\VC\Service.cs'.
Step 2:- This will create the “Service.cs” file on the specified location. After this
compile this Proxy Class to generate the compiled proxy
Class i.e. “Service.dll” Run this from the command Prompt:
C:\Program Files\Microsoft Visual Studio 8\VC> csc /t:libraryService.cs
Microsoft (R) Visual C# 2005 Compiler version 8.00.50727.42
for Microsoft (R) Windows (R) 2005 Framework version 2.0.50727
Copyright (C) Microsoft Corporation 2001-2005. All rights Reserved.
Step 3:-Place this compiled proxy class in the dll of the Web Site from where you
want to access the Web Service.
WSDL.EXE:
• Wsdl.exe contains only one required parameter, a URL or path to the WSDL for
the Web service. The following optional parameters can be specified:
• /language: language – specifies what language the Proxy class should be created
in (vb/cs/js).
• /protocol: protocol – specifies the payload protocol to be used (SOAP, HttpGet,
HttpPost)
• /namespace: namespace – the namespace of the generated Proxy class.
• /out: filename – the filename of the Proxy class.
Proxy Class inclusion
1. Add the proxy class to the newly created Web Site

2. Go to Solution Explorer; right click on that solution à click on “Add Reference”.
Below pop-up window appears
1. Clicking “Ok” will include the proxy class to the solution under “Bin folder”.
2. Now we can use this proxy class and the methods that are there in the web
services.
Note: A proxy class is a class containing all of the methods and objects exposed by
the Web service. These methods handle the marshalling of the parameters into
SOAP, sending the SOAP request over HTTP, receiving the response from the Web
service, and unmarshalling the return value. The proxy class allows the client
program to call a Web service as if the Web service was a local component.
Once you create a proxy class using the .NET command-line toolwsdl.exe , a Web
service client may invoke proxy class methods, which communicate with a Web
service over the network by processing the SOAP messages sent to and from the
Web service.
Example: Demonstrate the Creation of Proxy Class and its Usage
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
public partial class _Default : System.Web.UI. Page
{
protected void Page_Load( object sender, EventArgs e)
{
}
protected void btnCustomer_Click( object sender, EventArgs e)
{ //Fetching the Customer Data from the Proxy Class.
try
{
Service objService = new Service ();
txtCustomerAge.Text = objService.getEmployeeAge();
txtCustomerName.Text = objService.getEmployeeName();
}
catch ( Exception ex) {
Response.Write(ex.Source);
}
}
}
Output:
Click On the “Customer Data” Button:
Creating an XML document

The .NET gives us flexibility to work with the XML files easily. .NET provides following
five namespaces for XML manipulation.
1. System.Xml:- Contains major XML classes.This namespace contains many

classes to read and write XML documents.Some classes under this namespace
are XmlReader, XmlTextReader, XmlValidatingReader, XmlNodeReader,
XmlWriter, and XmlTextWriter.
2. System.Xml.Schema:- Contains classes which work with XML schemas.
XmlSchema, XmlSchemaAll, XmlSchemaXPath, and XmlSchemaType are the
classes comes under this namespace..
3. System.Xml.Serialization:- Contains classes that are used to serialize
objects into XML format documents or streams.
4. System.Xml.XPath:- Contains XPath related classes to use XPath
specifications. XPathDocument, XPathExression, XPathNavigator, and
XPathNodeIterator classes comes under this namespace..
5. System.Xml.Xsl :- Contains classes to work with XSLT transformations.
Example: Demonstrate Creation of XML Document

using System;
using System.Data;
using System.Text;
using System.Xml;
{
{
public Form10()
{
}
{
XmlDocument xmldoc;
XmlNode xmlnode;
XmlElement xmlelem;
XmlElement xmlelem2;
XmlElement xmlelem3;
XmlText xmltext;
xmldoc= new XmlDocument ();
//XML DECLARATION SECTION
xmlnode=xmldoc.CreateNode( XmlNodeType .XmlDeclaration, "" , "" );
xmldoc.AppendChild(xmlnode);
//STARTING NODE
xmlelem=xmldoc.CreateElement( "" ,txtRoot.Text, "" );
xmltext=xmldoc.CreateTextNode(txtRootDesc.Text);
xmlelem.AppendChild(xmltext);
xmldoc.AppendChild(xmlelem);
//ADD CHILD ELEMENT TO THIS NODE
xmlelem2=xmldoc.CreateElement( "" ,txtFirstChild.Text, "" );
xmltext=xmldoc.CreateTextNode(txtFirstChildDesc.Text);
xmlelem2.AppendChild(xmltext);
xmldoc.ChildNodes.Item(1).AppendChild(xmlelem2);
//ADD CHILD ELEMENT TO THIS NODE
xmlelem3 = xmldoc.CreateElement( "" ,txtSecondChild.Text, "" );
xmltext = xmldoc.CreateTextNode(txtSecondChildDesc.Text);
xmlelem3.AppendChild(xmltext);
xmldoc.ChildNodes.Item(1).AppendChild(xmlelem3);
//SAVE THE XML DOCUMENT IN A FILE "C:\CREATEXML.XML"
try {
xmldoc.Save( "c:\\CREATEXMLDocument.xml" );
} catch ( Exception ex) {
Console.WriteLine(ex.Source);
}
MessageBox.Show( "***********XML DOCUMENT CREATED************" );
}
}
}
Output:
Clicking on the “Create XML Document” after filling all the fields.
Generated XML files looks like:

<?xml version="1.0" ?>
<RootName>
<FirstChildName> FirstChildDesc </FirstChildName>
<SecondChildName> SecondChildDesc </SecondChildName>
</RootName>
Reading XML document in C sharp
The XmlReader and XmlTextReader classes are defined in the System.XML
namespace.The XmlTextReader class is derived from XmlReader class. The
XmlTextReader class can be used to read the XML documents. The read function of
this document reads the document until end of its nodes.
Example: The following example will show how the C# program will read the xml
file.
using System;
using System.Data;
using System.Text;
using System.Xml;
{
{
public Form11()
{
}
{ //Read XML Document
try
{
// Open an XML file : Read Any XML that you have
XmlTextReader reader = new XmlTextReader
( "C:\\CREATEXMLDocument.xml" );
while (reader.Read())
{ // Move to first element
reader.MoveToElement();
lstReadXML.Items.Add( "XmlTextReader Properties Test" );
lstReadXML.Items.Add( "===================" );
// Read Element's Properties
lstReadXML.Items.Add( "Name:" + reader.Name);
lstReadXML.Items.Add( "Base URI:" + reader.BaseURI);
lstReadXML.Items.Add( "Local Name:" + reader.LocalName);
lstReadXML.Items.Add( "Attribute Count:" +
reader.AttributeCount.ToString());
lstReadXML.Items.Add( "Depth:" +reader.Depth.ToString());
lstReadXML.Items.Add( "Line Number:" + reader.LineNumber.ToString());
lstReadXML.Items.Add( "Node Type:" + reader.NodeType.ToString());
lstReadXML.Items.Add( "Attribute Count:" + reader.Value.ToString());
}
}
catch ( Exception ex)
{
MessageBox .Show ( "Exception: {0}" , ex.ToString());
}
}
}
}
Output: The following screen will be displayed when run the above
program.
Clicking On the ‘ Read XML “ button the following screen will be displayed.
Using XMLWriter class to Write XML document in C sharp

The XmlWriter class contains the functionality to write to XML documents. XmlWriter
is an abstract base class and is a super class of XmlTextWriter and XmlNodeWriter
classes which are used to write the XML documents. This class has many WriteXXX
methods to write paired, unpaired and empty XML elements. Some of these
methods are used in a start and end pair. For example, to write an element, you
need to call WriteStartElement then write a string followed by WriteEndElement.
Example: Demonstrate Writing to XML file
using System;
using System.Data;
using System.Text;
using System.Xml;
{
{
public Form12()
{
}
{ //Writing XML DOCUMENT
try
{
//CREATE NEW FILE
XmlTextWriter xmlWRITER = new XmlTextWriter
( "C:\\writeEmployeeRecordInXML1.xml" , null );
//OPEN DOCUMENT FOR WRITING

xmlWRITER.WriteStartDocument();
//WRITE COMMENTS
xmlWRITER.WriteComment( "Commentss: START DATE : 21-OCT-07" );
xmlWRITER.WriteComment( "Commentss: WRITE XML DOCUMENT" );
//WRITE FIRST ELEMENT
xmlWRITER.WriteStartElement( "EMPLOYEE" );
xmlWRITER.WriteStartElement( "r" , "RECORD" , "urn:record" );
//WRITE NEXT ELEMENT
xmlWRITER.WriteStartElement( "EMPLOYEE NAME" , "" );
xmlWRITER.WriteString(txtName.Text);
xmlWRITER.WriteEndElement();
//WRITE ANOTHER ELEMENT
xmlWRITER.WriteStartElement( "EMPLOYEE ADDRESS" , "" );
xmlWRITER.WriteString(txtAddress.Text);
xmlWRITER.WriteStartElement( "EMPLOYEE Date Of Birth" , "" );
xmlWRITER.WriteString(txtDOB.Text);
xmlWRITER.WriteStartElement( "EMPLOYEE Qualification" ,"" );
xmlWRITER.WriteString(txtQual.Text);
//WRITE CHARACTERS
char [] ch = new char [3];
ch[0] = 'X' ;
ch[1] = 'M' ;
ch[2] = 'L' ;
xmlWRITER.WriteStartElement( "WRITING CHARACTER IN XML
DOCUMENT" );
xmlWRITER.WriteChars(ch, 0, ch.Length);
// END OF DOCUMENT
xmlWRITER.WriteEndDocument();
// CLOSE WRITER
xmlWRITER.Close();
MessageBox.Show( "*********DONE***********" );
}
catch ( Exception ex) {
MessageBox .Show(ex.Source);
}
}
}}
Clicking on the “Writing XML Document”

This will generate a Xml file that contains the contents as given below:
“writeEmployeeRecordInXML.xml”
<?xml version="1.0"?>


<EMPLOYEE>
<r:RECORD xmlns:r="urn:record">
<EMPLOYEE NAME>Joseph</EMPLOYEE NAME>
<EMPLOYEE ADDRESS>Terry</EMPLOYEE ADDRESS>
<EMPLOYEE Date Of Birth>17-7-1981</EMPLOYEE Date Of Birth>
<EMPLOYEE Qualification>MBA</EMPLOYEE Qualification>
<WRITING CHARACTER IN XML DOCUMENT>XML</WRITING CHARACTER IN XML
DOCUMENT>
</r:RECORD>
</EMPLOYEE>
Assembly Information : Getting Permission set of the assembly

The basics of CAS is whenever any code is being executed in managed world the
.NET runtime verifies whether that code is allowed or not based on evidence and set
of permissions. Two important things that are very much importance to the
framework is:
• Evidence:- From where the code comes? Is the code managed or unmanaged.
• Permissions:- The permission set on which the code executes.
Permissions and Permission Sets

Permission is what a code can do with particular resource like File, Registry etc., and
Permission Set is collection of permission.
Policy Levels
NET System comes up with 4 Policies that are Enterprise , Machine User, and
AppDomain (which can be done through programmatically). Each policy has multiple
code groups and multiple permission sets.They have the hierarchy given below.
Enterprise : All managed code in an enterprise setting.

Machine: All managed code on the computer.
User: Code in all processes associated with the current user.
Application Domain: Managed code in the host's application domain.
Example:- To get the permission set of Current Assembly.
Form13.cs
using System;
using System.Data;
using System.Text;
using System.Diagnostics;
using System.Reflection;
using System.Security;
using System.Security.Policy;
using System.Security.Permissions;
using System.Collections;
{
{
//NAME OF THE BUILD_IN NAMED PERMISSION SET FOR FULLTRUST.
const string sFullTrust = "FullTrust" ;
static PermissionSet finalSet = new NamedPermissionSet ( "FinalAssemblySet" );
static PermissionSet permSet = null ;
//FIND OUT WHETHER THIS ASSEMBLY IS FULLTRUST PERMISSIONS.
static bool fullTrust = true ;
public Form13()
{
}
{
}
//FIGURE OUT THE CODEGROUP AND THE POLICY LEVEL OF THE ASSEMBLY.
static bool isResGroups( CodeGroup _codeGroupparent, PolicyLevel _policyLevel)
{
NamedPermissionSet _namedPermissionSet =
_policyLevel.GetNamedPermissionSet( _codeGroupparent.PermissionSetName);
if (isFullTrust(_namedPermissionSet)) return true ;
if (permSet == null ) permSet = ( PermissionSet )_namedPermissionSet;
else permSet = permSet.Union(_namedPermissionSet);
if (_codeGroupparent.Children.Count > 0)
{
foreach ( CodeGroup cp in _codeGroupparent.Children)
{
if (cp.Children.Count > 0)
isResGroups(cp, _policyLevel);
else
{
NamedPermissionSet nps2 =
_policyLevel.GetNamedPermissionSet( cp.PermissionSetName);
if (isFullTrust(nps2))
return true ;
permSet = permSet.Union(nps2);
}
}
}
//FULL TRUST CODE NOT FOUND
return false ;
}
//CHECK WHETHER THE PERMISSION SET IF FULLTRUST OR NOT FOR THE
CURRENT ASSEMBLY.
static bool isFullTrust( NamedPermissionSet _namedPermissionSet)
{
if (_namedPermissionSet.Name.Equals( "FullTrust" ))
return true ;
return false ;
}
//PASS THE PERMISSION SET AND LISTBOX AS ARGUMENT TO THE FUNCTION.
static void getOutput( PermissionSet _permissionSet, ListBox _listBox)
{
IEnumerator psEnumerator = _permissionSet.GetEnumerator();
while (psEnumerator.MoveNext())
_listBox.Items.Add(psEnumerator.Current);
}
{ //Fetching the Permission Set of the Assembly
lstPermission.Items.Add( "List of permissions assign to current assembly" );
IEnumerator policy = SecurityManager .PolicyHierarchy();
while (policy.MoveNext())
{
PolicyLevel currentLevel = ( PolicyLevel )policy.Current;
CodeGroup group =currentLevel.ResolveMatchingCodeGroups ( Assembly
.GetExecutingAssembly().Evidence);
fullTrust &= isResGroups(group, currentLevel);
if (!fullTrust)
{
if (finalSet == null ) finalSet = permSet;
else finalSet = finalSet.Intersect(permSet);
permSet = null ;
}
else
{
lstPermission.Items.Add( "Current Level-" +currentLevel.Label + " || " +
"Group--" + group.Name + " || " + "Group Policy--" +
group.PermissionSetName);
}
}
if (fullTrust)
lblMode.Text = "Assembly is running in full-trust mode." ;
else
getOutput(finalSet, lstPermission);
}
}
}
Output:
Clicking on the “Assembly Information” button.

Creating your own Permission Set
User can also create their own permission sets and code groups in the C#. The
following are the steps needs to follow to create your own permission sets and code
groups:-
Steps to create your own permission set and Code group
1. Go to Control Panel --> Administrative Tools --> Microsoft .NET Framework

2.0 Configuration à Double click on this a popup windows appear
2. Creating a new Permission Set à Expand “Runtime Security Policy”. There are 3
security policy levels i.e. Enterprise , Machine and User. We are creating the
permission set for the machine security level.
3. Assign the permission to the permission set: Each permission set is a collection of
much different permission to various resources on the computer. Select the
permission that you need in the permission set.
4. Here I am selecting the “File IO” permission from the pool of permission set. And
then change the settings for this permission. Here specify the “C:\” in the file path
and assign only reading permission to this.
5. Here we assign 3 permission to the newly create permission set i.e. File IO,
Security and User Interface.
Create New Code Group

Create new code group and assign the permission that you create to this code group
so that your assembly will work under the specified permission set. Right click on
the All_Code node and this will open a pop-up window i.e. Create Code Group
wizard. Specify the name for your code group.
1. Choose a condition type for the code group:

The membership condition determines whether or not an assembly meets specific
requirements to get the permission associated with a code group.
Condition type in the specified context: Strong Name. You have to just click on the
Import button à Select the assembly from the pop-up and this will extract the
information that we needed.
2. Assign a Permission Set to the code group:
Here through this window we can assign the permission set to this code group that
we are going to create. Select the permission set that we created earlier. Though
this window either we can create new permission set or reuse the existing one.
3. Go through the properties of the newly created Code Group

Right click on the code group that you just created and you can view the “Code
Group ” properties like the Code Group Name, its membership conditions and
permission set that is associated to it.
Create an Application: That will perform read and write operations on file.
using System;
using System.Data;
using System.Text;
using System.IO;
namespace winCreatingPSET
{
{
public Form1()
{
}
{ //Writing to the Document
StreamWriter _streamWriter = new StreamWriter
( "c:\\TestPermission.txt" );
_streamWriter.WriteLine( " Security is Important" );
_streamWriter.WriteLine( " Security can provide Authentication " );
_streamWriter.Close();
}
{ //Reading from the Document
StreamReader _streamWriter = new StreamReader
( "c:\\TestPermission.txt" );
lstPSET.Items.Add(_streamWriter.ReadLine());
lstPSET.Items.Add(_streamWriter.ReadLine());
_streamWriter.Close();
}
}
}
Output:
Now run the application and try to click on the “write” button the screen, this will
give you following exception.:-
Using C sharp Socket

The System.Net.Sockets namespace contains the classes that provide the actual
.NET interface to the low-level Winsock APIs. This section gives a brief overview of
the C# Socket class. The core of the System.Net.Sockets namespace is the Socket
class. It provides the C# managed code implementation of the Winsock API. The
Socket class constructor is as follows:
Socket(AddressFamily af , SocketType st , ProtocolType pt )
As you can see, the basic format of the Socket constructor mimics the original Unix
socket() function. It uses three parameters to define the type of socket to create:
• An AddressFamily to define the network type

• A SocketType to define the type of data connection
• A ProtocolType to define a specific network protocol
Each of these parameters is represented by a separate enumeration within the

System.Net_.Sockets namespace. Each enumeration contains the values that can be
used. For normal IP communications on networks, the AddressFamily.InterNetwork
value should always be used for the AddressFamily. With the InterNetwork
AddressFamily, the SocketType parameter must match a
particular ProtocolTypeparameter. You are not allowed to mix and
match SocketTypesand ProtocolTypes.
Socket Properties:
Several properties of the Socket class can be used to retrieve information from a
created Socket object
Description
Property
AddressFamily Gets the address family of the Socket

Blocking Gets or sets whether the Socket is in blocking mode
LocalEndPoint Gets the local EndPoint object for the Socket
Connected Gets a value that indicates if the Socket is connected to a

remote device
RemoteEndPoint Gets the remote EndPoint information for the Socket
SocketType Gets the type of the Socket
Handle Gets the operating system handle for the Socket
ProtocolType Gets the protocol type of the Socket
Available Gets the amount of data that is ready to be read
Introduction to Socket Exceptions:

One feature of socket programming included in .NET Framework is neither used by
Unix nor the Winsock API is socket exceptions. All of the Socket class methods use
the SocketException exception. Any socket programming you do should always
check for SocketException exceptions and then attempt to recover from the error, or
at least warn the user of the problem.
Example: Demonstrate Socket Properties and Socket Exception Handling
using System;
using System.Data;
using System.Text;
using System.Net;
using System.Net.Sockets;
{
{
public Form5()
{
}
{ // Demonstrate Socket Properties
IPAddress _ipAddress = IPAddress .Parse( "127.0.0.1" );
IPEndPoint _ipEndPoint = new IPEndPoint (_ipAddress, 8000);
Socket _socketTest = new Socket ( AddressFamily .InterNetwork,
SocketType .Stream, ProtocolType .Tcp);
lstSocketProperties.Items.Add( "AddressFamily :: " +
_socketTest.AddressFamily);
lstSocketProperties.Items.Add( "SocketType :: " + _socketTest.SocketType);
lstSocketProperties.Items.Add( "ProtocolType :: " +
_socketTest.ProtocolType);
lstSocketProperties.Items.Add( "Blocking :: " +_socketTest.Blocking);
_socketTest.Blocking = false ;
lstSocketProperties.Items.Add( "new Blocking :: " + _socketTest.Blocking);
lstSocketProperties.Items.Add( "Connected :: " + _socketTest.Connected);
_socketTest.Bind(_ipEndPoint);
IPEndPoint _newIpEndPoint = ( IPEndPoint )_socketTest.LocalEndPoint;
lstSocketProperties.Items.Add( "Local EndPoint :: " +
_newIpEndPoint.ToString());
_socketTest.Close();
}
{ //Socket Exceptions
IPAddress _hostIPAddress = IPAddress .Parse( "192.168.1.1" );
IPEndPoint _hostIPEndPoint = new IPEndPoint (_hostIPAddress, 8000);
Socket _socket = new Socket ( AddressFamily .InterNetwork, SocketType
.Stream, ProtocolType .Tcp);
try
{
_socket.Connect(_hostIPEndPoint);
}
catch ( SocketException e1)
{
lstSocketExceptions.Items.Add( "Problem Connecting To Host ........" );
lstSocketExceptions.Items.Add(e1.ToString());
_socket.Close();
return ;
}
try
{
_socket.Send( Encoding .ASCII.GetBytes( "testing" ));
}
catch ( SocketException ex)
{
lstSocketExceptions.Items.Add( "Problem Sending Data" );
lstSocketExceptions.Items.Add(ex.ToString());
_socket.Close();
return ;
}
_socket.Close();
}
}
}
Output:
Clicking On both the Buttons will display the respective outputs in the
listbox

C Sharp QR

Uploaded by

Copyright:

Available Formats

C Sharp QR

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C Sharp QR

Uploaded by

Copyright:

Available Formats

C#

• Interactive Development Environment.

static class Program

/// The main entry point for the application.

static void Main ()

Application .SetCompatibleTextRenderingDefault( false );

Application .Run( new Form1 ());

A C# program is divided into 4 parts:

Value Types Reference Types

Allocated on stack Allocated on heap

Integer, float, Boolean, double

Struct is value type.

Control Statement: Selection Statement in C sharp

Switch (Evaluated Value can be Boolean or Enums or integral type or strings) {

//switch with integer type

Case 1: // Block of statement

Case 2: // Block of statement

Case 3: // Block of statement

Case 4: // Block of statement

Default: // Block of statement

public partial class Form2 : Form

private void Form2_Load( object sender, EventArgs e)

Console.WriteLine( "FORM 2" );

private void button1_Click( object sender, EventArgs e)

{ // Here we can go through the example on IF

int _value = Int32 .Parse(txtEnter.Text);

MessageBox .Show( "Value is greater than 100" );

} else if (_value < 100 && _value > 200){

MessageBox .Show( "Value is less than 100" );

private void button2_Click( object sender, EventArgs e)

{ // Here we can go through the example on Switch

int _value = Int32 .Parse(txtEnter.Text);

switch (_value) // switch example with integer type

MessageBox .Show( "Value is 1 or 4 or 5" );

MessageBox .Show( "Value is 2" ); txtEnter.Text = "" ;

MessageBox .Show( "Value is 3" ); txtEnter.Text = "" ;

MessageBox .Show( "Value is greater than 3" );

Click on: IF Example Button

This print value is less than 100

Click on: switch Example Button

This print value is greater than 3

static class Program

/// The main entry point for the application.

static void Main ()

Application.Run( new Form1 ());

public partial class Form4 : Form

private void Form4_Load( object sender, EventArgs e)

lblEnter.Text = lblEnter.Text + "Enter 1 to Add" + "\n" ;

lblEnter.Text = lblEnter.Text + "Enter 2 to Sub" + "\n" ;

lblEnter.Text = lblEnter.Text + "Enter 3 to Multiply" + "\n" ;

private void btnExecute_Click( object sender, EventArgs e)

int _valDec = Int32 .Parse(txtdecision.Text);

int _firstVal = Int32 .Parse(textBox1.Text);

int _secondVal = Int32 .Parse(textBox2.Text);

case 1: fxadd(_firstVal, _secondVal); break ;

case 2: fxsubtract(_firstVal, _secondVal); break ;

case 3: fxmultiply(_firstVal, _secondVal); break ;

case 4: fxdivide(_firstVal, _secondVal); break ;

MessageBox .Show( "Please Enter Specified Value.." );

int _add = firstarg + secondarg;