.

NET Story
May2014
.NET Tutorial 2
ASP.NET
Asp.NET is successor of Microsoft's Active server pages (ASP) technology.
ASP.NET is a server-side Web application framework designed for Web
development to produce dynamic Web pages. It was developed by Microsoft to
allow programmers to build dynamic web sites, web applications and web
services.
ASP.NET is built on the Common Language Runtime (CLR), allowing
programmers to write ASP.NET code using any supported .NET language
Date Version Comments
Jan, 2002 1.0
April, 2003 1.1
Nov, 2005 2.0
Nov, 2006 3.0
Nov, 2007 3.5
Aug, 2008 3.5 sp1
April, 2010 4.0 Parallel extensions and
other .NET 4 features
introduced
Aug, 2012 4.5 Released with VS 2012
.NET Tutorial 3
Common Language Runtime - CLR
The Common Language Runtime (CLR) is the virtual machine
component of Microsoft's .NET framework and is responsible for
managing the execution of .NET programs.
In a process known as just-in-time compilation, the compiled code is
converted into machine instructions that, in turn, are executed by the
computer's CPU
The CLR provides additional services including memory management,
type safety, exception handling,garbage collection and thread
management
CLR is common to all versions of the .NET framework
CLR Version .NET Version
1.0 1.0
1.1 1.1
2.0 2.0, 3.0, 3.5
4 4, 4.5
.NET Tutorial 4
Common Language Infrastructure (CLI) & Common Intermediate Language (CIL)
The Common Language Infrastructure (CLI) is an open specification
developed by Microsoft
In August 2000, Microsoft, Hewlett-Packard, Intel, and others worked to
standardize CLI.
To implement the CLI standard requires conformance to one of the
supported and defined profiles of the standard
The .NET Framework is Microsoft's original commercial implementation
of the CLI
.NET Compact Framework is Microsoft's commercial implementation of
the CLI for portable devices and Xbox 360.
CLI Languages are computer programming languages that are used to
produce libraries and programs that conform to the Common Language
Infrastructure (CLI) specifications
Most CLI languages compile entirely to the Common Intermediate
Language (CIL), an intermediate language that can be executed using an
implementation of CLI such as the Common Language Runtime (CLR, a
part of the Microsoft .NET Framework), Mono, or Portable.NET
Common CLI compliant languages are -
C#
A# (CLI implementation of Ada)
Cobra
F#
IronRuby
IronPython


.NET Tutorial 5
Getting Started
// Namespace Declaration
using System;

// Program start class
class WelcomeCSS
{
// Main begins program execution.
static void Main()
{
// Write to console
Console.WriteLine("Welcome to the C# Tutorial!");
}
}
Namespaces are C# equivalent of Java packages.
Collection of namespace/s are distributed generally as dll. In Java world, it is similar to jar files.
.NET Tutorial 6
Value Types, Reference Types, aliases and difference from Java
In particular, C# provides two typesclass and struct, which are almost the same except that one is a reference type while
the other is a value type
Put simply, structs are cut-down classes. Imagine classes that dont support inheritance or finalizers, and you have the
cut-down version: the struct
Structs are value types, while classes are reference types, and the runtime deals with the two in different ways
When a value-type instance is created, a single space in memory is allocated to store the value. Primitive types such
as int, float, bool and char are also value types, and work in the same way (Not String/string). When the runtime deals
with a value type, it's dealing directly with its underlying data and this can be very efficient, particularly with primitive
types.
With reference types, however, an object is created in memory, and then handled through a separate referencerather like
a pointer

How to check which type it is
Console.WriteLine(typeof(int).IsValueType); // displays "True
We will discuss shortly why string isnt a value type like integer

.NET Tutorial 7
Value Types, Reference Types, aliases and difference from Java(contd..)
With reference types, however, an object is created in memory, and then handled through a separate referencerather
like a pointer. Suppose Point is a struct, and Form is a class. We can instantiate each as follows:
Point p1 = new Point(); // Point is a *struct*
Form f1 = new Form(); // Form is a *class*
In the first case, one space in memory is allocated for p1, wheras in the second case, two spaces are allocated: one for
a Form object and another for its reference (f1). It's clearer when we go about it the long way:
Form f1; // Allocate the reference
f1 = new Form(); // Allocate the object
If we copy the objects to new variables:
Point p2 = p1;
Form f2 = f1;
p2, being a struct, becomes an independent copy of p1, with its own separate fields. But in the case of f2, all weve copied
is a reference, with the result that both f1 and f2 point to the same object.

.NET Tutorial 8
Value Types, Reference Types, aliases and difference from Java(contd..)
The Common Language Runtime allocates memory for objects in two places: the stack and the heap. The stack is a
simple first-in last-out memory structure, and is highly efficient. When a method is invoked, the CLR bookmarks the top
of the stack. The method then pushes data onto the stack as it executes. When the method completes, the CLR just
resets the stack to its previous bookmarkpopping all the methods memory allocations is one simple operation!
In contrast, the heap can be pictured as a random jumble of objects. Its advantage is that it allows objects to be allocated
or deallocated in a random order. The heap requires the overhead of a memory manager and garbage collector to keep
things in order.
Why string /String isnt a value type?
Mainly reason is Performance: Strings can be at times large and stack memory allocation being less (many times at 1MB
only) it can create space and performance issue. So its handled via heap memory like reference types.
Even after being a reference type, C# allows string to be used like a value type. But in Java, string comparison like the
below one will compare the references and will return false.
string s = "hello";
string t = "hello";
bool b = (s == t); will return true
.NET Tutorial 11
Unary Operators
using System;

class Unary
{
public static void Main()
{
int unary = 0;
int preIncrement;
int preDecrement;
int postIncrement;
int postDecrement;
int positive;
int negative;
sbyte bitNot;
bool logNot;

preIncrement = ++unary;
Console.WriteLine("pre-Increment: {0}", preIncrement);

preDecrement = --unary;
Console.WriteLine("pre-Decrement: {0}", preDecrement);

postDecrement = unary--;
Console.WriteLine("Post-Decrement: {0}", postDecrement);


postIncrement = unary++;
Console.WriteLine("Post-Increment: {0}", postIncrement);

Console.WriteLine("Final Value of Unary: {0}", unary);}}


Output:

pre-Increment: 1
pre-Decrement 0
Post-Decrement: 0
Post-Increment: -1
Final Value of Unary: 0

.NET Tutorial 12
Control Statements
using System;
class SwitchSelect
{
public static void Main()
{
string myInput;
int myInt;

begin:

Console.Write("Please enter a number between 1 and 3: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);

// switch with integer type
switch (myInt)
{
case 1:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 2:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
}

decide:
Console.Write("Type \"continue\" to go on or \"quit\" to stop: ");
myInput = Console.ReadLine();

// switch with string type
switch (myInput)
{
case "continue":
goto begin;
case "quit":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("Your input {0} is incorrect.", myInput);
goto decide;
}
}
}

.NET Tutorial 13
Nested Namespace
// Namespace Declaration
using System;

namespace csharp_tutorial
{
// Program start class
class NamespaceCSS
{
// Main begins program execution.
public static void Main()
{
// Write to console
Console.WriteLine("This is the new C#
Namespace.");
}
}
}
// Namespace Declaration
using System;

namespace csharp_tutorial
{
namespace tutorial
{
// Program start class
class NamespaceCSS
{
// Main begins program execution.
public static void Main()
{
// Write to console
Console.WriteLine("This is the new C#
Tutorial Namespace.");
}
}
}
}
.NET Tutorial 14
Three pillars of Object Oriented Programming
Encapsulation: Encapsulation involves a single object that
contains both its data and behaviors and can hide what it
wants from other objects. In real programming world it is
achieved by classes, access modifiers etc.
Inheritance : Inheritance allows the concept of creating a
basic functionality which can be inherited in many places
as well as enhanced as required.
Polymorphism: Is probably the hardest of the three
concepts and will be discussed in detail in later sections.
.NET Tutorial
15
Classes
using System;

// helper class
class OutputClass
{
public string myString;

// Constructor
public OutputClass(string inputString)
{
myString = inputString;
}

// Instance Method
public void printString()
{
Console.WriteLine("{0}", myString);
}
public static String testStatic()
{
Console.WriteLine(This is a static calls);
//The following line will not complie this refers to an instance at runtime which might not
be available
this.myString=Static Update;
New OutputClass.myString=Another static update; // This will work
}



// Destructor
~OutputClass()
{
// Some resource cleanup routines
}
}

class ExampleClass
{
// Main begins program execution.
public static void Main()
{
// Instance of OutputClass
OutputClass outCl = new OutputClass("This is printed by the output class.");

// Call Output class' method
outCl.printString();
//Static Call
OutputClass.testStatic();
}
}
.NET Tutorial 16
Classes (Contd..)

Desigining classes reflects the requirements
In a bottom-up design approach many DB layer objects can be
mapped to single classes or clubbed together as a class as per the
requirements.
e.g. Department Table and Employee Table is linked as each
employee is part of a department. One way to effectively map this
relationship to class level is design a Department Class an Employee
Class and have a property in the Department class which can hold a
collection of employee class objects.

public Class Department
{
String deptId;
Sring deptName;
String deptHeadEmpId;
Dictionary <String,Employee> empList;
}

public Class Employee
{
Public String empId;
Public String empName;
Public String deptId;
Public String reportsToId;
}
.NET Tutorial 17
Access Modifiers
Access mofiders support a major pillar of object oriented
programming- encapsulation.

Modifier Description
public There are no restrictions on accessing public
members.
private Access is limited to within the class
definition. This is the default access modifier
type if none is formally specified
protected Access is limited to within the class
definition and any class that inherits from
the class
internal Access is limited exclusively to classes
defined within the current project assembly
protected internal Access is limited to the current assembly
and types derived from the containing class.
All members in current project and all
members in derived class can access the
variables
The default access for everything in C# is "the most restricted access you could declare for
that member".
So for example:
namespace MyCompany{
class Outer
{
void Foo() {}
class Inner {}
}}
is equivalent to
namespace MyCompany{
internal class Outer
{
private void Foo() {}
private class Inner {}
}}
.NET Tutorial 18
Access Modifiers private Class
Default access level of a class in C# is internal
You can not declare a root level class as private in a na mespace
A root level class in a namespace can only be public or internal
(default)







The following is allowed



.NET Tutorial 19
Classes Properties (another example of encapsulation)
Traditional Getter/Setters:
using System;
public class Customer
{ private int m_id = -1;
public int GetID() { return m_id; }
public void SetID(int id) { m_id = id; }
private string m_name = string.Empty;
public string GetName() { return m_name; }
public void SetName(string name) { m_name = name; } }

public class CustomerManagerWithAccessorMethods{
public static void Main()
{
Customer cust = new Customer();
cust.SetID(1);
cust.SetName("New Cust");
Console.WriteLine(
"ID: {0}, Name: {1}",
cust.GetID(), cust.GetName()); }}
New Way:
using System;
public class Customer {
private int m_id = -1;
public int ID { get { return m_id; } set { m_id = value; } }
private string m_name = string.Empty;
public string Name { get { return m_name; } set { m_name = value; } } }

public class CustomerManagerWithProperties{
public static void Main() {
Customer cust = new Customer();
cust.ID = 1;
cust.Name = "New Cust";
Console.WriteLine(
"ID: {0}, Name: {1}",
cust.ID,
cust.Name); }}
Properties can be made read-only. This is accomplished by having only a get accessor in the
property implementation
.NET Tutorial 20
Classes - Inheritance
using System;
public class Parent
{
string parentString;
public Parent()
{
Console.WriteLine("Parent Constructor.");
}
public Parent(string myString)
{
parentString = myString;
Console.WriteLine(parentString);
}
public void print()
{
Console.WriteLine("I'm a Parent Class.");
}
}
public class Child : Parent
{
public Child() : base("From Derived")
{
Console.WriteLine("Child Constructor.");
}
public new void print()
{
base.print();
Console.WriteLine("I'm a Child Class.");
}
public static void Main()
{
Child child = new Child();
child.print();
((Parent)child).print();
}
}
.NET Tutorial 21
Classes Inheritance (Contd..)
Output:
From Derived
Child Constructor.
I'm a Parent Class.
I'm a Child Class.
I'm a Parent Class.

Derived classes can communicate with base classes during instantiation. The
colon, ":", and keyword base call the base class constructor with the
matching parameter list. If the code had not appended base("From
Derived") to the Derived constructor, the code would have automatically
called Parent(). The first line of output shows the base class constructor
being called with the string "From Derived".
Sometimes you may want to create your own implementation of a method that
exists in a base class. The Child class does this by declaring its own
print() method. The Child print() method hides the Parent print()
method. The effect is the Parent print() method will not be called, unless
we do something special to make sure it is called.


Inside the Child print() method, we explicitly call the Parent print() method.
This is done by prefixing the method name with "base.". Using the base
keyword, you can access any of a base class public or protected class
members. The output from the Child print() method is on output lines 3
and 4.

Another way to access base class members is through an explicit cast. This is done in the last
statement of the Child class Main() method. Remember that a derived class is a
specialization of its base class. This fact allows us to perform a cast on the derived class,
making it an instance of its base class. The last line of output shows the Parent print()
method was indeed executed.
.NET Tutorial 22
Classes Inheritance (Contd..) - Multiple Vs Multi-Level
In traditional concepts of OOP two forms of inheritance are talked
about-
Multiple inheritence: Where one class can inherit from
multiple base classes.
Multi- Level inheritence: Where once class can inherit
from only one base class.
A clear need of implementing multiple inheritence remains
debatable subject over the years.
C# only allows a weak form of multiple inheritence. All classes
without an explicit base class is still the base class of the Object
class. Otherwise, multiple inheritence can be implemented using
interfaces.
Microsoft's blog quotes on why multiple inheritence is generally not
allowed -
http://blogs.msdn.com/b/csharpfaq/archive/2004/03/07/85562.aspx
There are new ways of implementing multiple- inheritence in C# 4.0
onwards - http://www.canerten.com/multiple-inheritance-in-c-using-
dynamic-features/

.NET Tutorial 23
Classes - Polymorphism
Polymorphism is often referred to as the third pillar of object-oriented
programming, after encapsulation and inheritance.Polymorphism is a
Greek word that means "many-shaped".
using System;

public class DrawingObject
{
public virtual void Draw()
{
Console.WriteLine("I'm just a generic drawing object.");}}
using System;
public class Line : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I'm a Line.");}}

public class Circle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I'm a Circle.");}}




public class Square : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I'm a Square.");}}
using System;
public class DrawDemo
{
public static int Main( )
{
DrawingObject[] dObj = new DrawingObject[4];

dObj[0] = new Line();
dObj[1] = new Circle();
dObj[2] = new Square();
dObj[3] = new DrawingObject();

foreach (DrawingObject drawObj in dObj)
{
drawObj.Draw();
}
return 0;
}}
.NET Tutorial 24
New Vs Override
Case 1 : Base Class
public void DoIt();

Case 1 : Inherited class
public new void DoIt();

Case 2 : Base Class
public virtual void DoIt();

Case 2 : Inherited class
public override void DoIt();
virtual: indicates that a function may be overriden by an inheritor
override: overrides the functionality of a virtual function in a base class,
providing different functionality.
new: hides the original function (which doesn't have to be virtual), providing
different functionality. This should only be used where it is absolutely
necessary

If you're using real polymorphism you should always use override. The only
time we can use new on methods is when the inherited implementation
has nothing to do with the base implementation.
.NET Tutorial 25
Indexers
Indexers allow your 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. Regardless of the internal
implementation of the class, its data can be obtained consistently through the use of
indexers.
using System;

/// <summary>
/// A simple indexer example.
/// </summary>
class IntIndexer
{
private string[] myData;

public IntIndexer(int size)
{
myData = new string[size];

for (int i=0; i < size; i++)
{
myData[i] = "empty";
}
}


public string this[int pos]
{
get
{
return myData[pos];
}
set
{
myData[pos] = value;
}
}


static void Main(string[] args)
{
int size = 10;

IntIndexer myInd = new IntIndexer(size);

myInd[9] = "Some Value";
myInd[3] = "Another Value";
myInd[5] = "Any Value";

Console.WriteLine("\nIndexer Output\n");

for (int i=0; i < size; i++)
{
Console.WriteLine("myInd[{0}]: {1}", i, myInd[i]);
}
}
}
.NET Tutorial 26
Arrays
Initializing Arrays:
int[] numbers = new int[5] {1, 2, 3, 4, 5};
string[] names = new string[3] {"Matt", "Joanne", "Robert"};

You can omit the size of the array, like this:
int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};

You can also omit the new operator if an initializer is provided, like this:
int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};
Arrays Are Objects:
In C#, arrays are actually objects. System.Array is the abstract base type of all
array types. You can use the properties, and other class members, that
System.Array has. An example of this would be using the Length
property to get the length of an array.




int[] numbers = {1, 2, 3, 4, 5};
int LengthOfNumbers = numbers.Length;
The System.Array class provides many other useful methods/properties, such
as methods for sorting, searching, and copying arrays.


Using foreach on Arrays:
int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};
foreach (int i in numbers)
{
System.Console.WriteLine(i);
}

.NET Tutorial 27
Collections
For many applications, you want to create and manage groups of related
objects. There are two ways to group objects: by creating arrays of objects,
and by creating collections of objects
Arrays are most useful for creating and working with a fixed number of
strongly-typed objects
Collections provide a more flexible way to work with groups of objects.
Unlike arrays, the group of objects you work with can grow and shrink
dynamically as the needs of the application change.
For some collections, you can assign a key to any object that you put into
the collection so that you can quickly retrieve the object by using the key
If your collection contains elements of only one data type, you can use
one of the classes in the System.Collections.Generic namespace.



System.Collection Classes
The classes in the System.Collections namespace do not store elements as specifically
typed objects, but as objects of type Object.
Whenever possible, you should use the generic collections in the
System.Collections.Generic namespace or the System.Collections.Concurrent
namespace instead of the legacy types in the System.Collections namespace.
The following table lists some of the frequently used classes in the System.Collections
namespace:


Class Description
ArrayList
Represents an array of objects whose size
is dynamically increased as required
Hashtable
Represents a collection of key/value pairs
that are organized based on the hash code
of the key
Queue
Represents a first in, first out (FIFO)
collection of objects
Stack
Represents a last in, first out (LIFO)
collection of objects
.NET Tutorial 28
Boxing and Unboxing
Boxing is the process of converting a value type to the type object or to any
interface type implemented by this value type. When the CLR boxes a
value type, it wraps the value inside a System.Object and stores it on the
managed heap. Unboxing extracts the value type from the object. Boxing
is implicit; unboxing is explicit. The concept of boxing and unboxing
underlies the C# unified view of the type system in which a value of any
type can be treated as an object.

In the following example, the integer variable i is boxed and assigned to object
o.
int i = 123;
// The following line boxes i.
object o = i;
The object o can then be unboxed and assigned to integer variable i:

o = 123;
i = (int)o; // unboxing

In relation to simple assignments, boxing and unboxing are computationally
expensive processes. When a value type is boxed, a new object must be
allocated and constructed. To a lesser degree, the cast required for
unboxing is also expensive computationally

Boxing & Unboxing in Collections:

int i = 10;
ArrayList arrlst = new ArrayList();
arrlst.Add(i); // Boxing occurs automatically
int j = (int)arrlst[0]; // Unboxing occurs


.NET Tutorial 29
Generics
The following block of Java code illustrates a problem that exists when not
using generics. First, it declares an ArrayList of type Object. Then, it adds
a String to the ArrayList. Finally, it attempts to retrieve the added String
and cast it to an Integer.
List v = new List();
v.add("test"); //boxing happens here
Integer i = (Integer)v.get(0); // Run time error
Although the code compiles without error, it throws a runtime exception
(InvalidCastException in C# and java.lang.ClassCastException in Java)
when executing the third line of code. This type of problem can be
avoided by using generics and is the primary motivation for using
generics.
Using generics, the above code fragment can be rewritten as follows:
List<String> v = new List<String>();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error
System.Collections.Generic Classes
You can create a generic collection by using one of the classes in the
System.Collections.Generic namespace. A generic collection is useful when every item
in the collection has the same data type.
The following table lists some of the frequently used classes of the System.Collections.Generic
namespace:





Class Description
Dictionary<TKey, TValue> Represents a collection of key/value pairs
that are organized based on the key.
List<T>

Represents a list of objects that can be
accessed by index. Provides methods to
search, sort, and modify lists.
Queue<T>

Represents a first in, first out (FIFO)
collection of objects
SortedList<TKey, TValue>

Represents a collection of key/value pairs
that are sorted by key based on the
associated implementation
Stack<T>

Represents a last in, first out (LIFO)
collection of objects.
.NET Tutorial 30
Generics (Contd..)
No boxing /Unboxing Required in Generics:
List<int> list1 = new List<int>();
list1.Add(3); // No boxing
Interger i=list1.get(0); // No unboxing

Boxing doesn't happen here because the array that backs the List is T[], not
object[]. Therefore, the runtime knows your items are integers and
doesn't need to box them.
.NET Tutorial 31
Interface
An interface looks like a Class but has no implementation
The only thing it contains are declarations
No fields can be defined in an interface
Inherited by Class/Structs which must provide an implementation for each
interface method
Interface defines a contract
If we add a new method to an Interface then we have to track down all the
implementations of the interface and define implementation for the new
method.
Interface naming convention is to start with 'I'

public interface IEmployee {
String ID { get; set; }
String FirstName { get; set; }
String LastName { get; set; }
String Add();
String Delete(); }



public class Emp_fulltime2 : IEmployee {
protected String id;
protected String lname;
protected String fname;
public Emp_fulltime2() { // // TODO: Add constructor logic here // }
public String ID { get { return id; } set { id = value; } }
public String FirstName { get { return fname; } set { fname = value; } }
public String LastName { get { return lname; } set { lname = value; } }
public String Add() { return "Fulltime Employee " + fname + " added."; }
public String Delete() { return "Fulltime Employee " + fname + " deleted."; } }

private void InterfaceExample_Click(object sender, System.EventArgs e) {
try { IEmployee emp;
Emp_fulltime2 emp1 = new Emp_fulltime2();
emp = emp1; emp.ID = "2234";
emp.FirstName= "Rahman" ; emp.LastName = "Mahmoodi" ; //call add method od the object
MessageBox.Show(emp.Add().ToString()); //call the CalculateWage method
MessageBox.Show(emp.CalculateWage().ToString()); }
catch(Exception ex) { MessageBox.Show(ex.Message); } }
.NET Tutorial 32
Abstract Class
An Abstract class without any implementation just looks like an Interface
An abstract class is a special kind of class that cannot be instantiated
It only allows other classes to inherit from it but cannot be instantiated
When we create an abstract class, we are creating a base class that might have
one or more completed methods but at least one or more methods are left
uncompleted and declared abstract


public abstract class Employee { //we can have fields and properties //in the Abstract class
protected String id;
protected String lname;
protected String fname;
public abstract String ID { get; set; }
public abstract String FirstName { get; set; }
public abstract String LastName { get; set; }
public String Add() { return "Employee " + id + " " + lname + " " + fname + " added"; }
public String Update() { return "Employee " + id + " " + lname + " " + fname + " updated"; }
public abstract String CalculateWage();}


public class Emp_Fulltime : Employee
{ //uses all the properties of the //Abstract class therefore no //properties or fields here!
public Emp_Fulltime() { }
public override String ID { get { return id; } set { id = value; } }
public override String FirstName { get { return fname; } set { fname = value; } }
public override String LastName { get { return lname; } set { lname = value; } }
//common methods that are //implemented in the abstract class
public new String Update() { return base.Update(); }
public override String CalculateWage() { return "Full time employee " + base.fname + " is
calculated " + "using the Abstract class..."; }

private void cmdAbstractExample_Click(object sender, System.EventArgs e)
{ Employee emp;
emp = new Emp_Fulltime();
emp.ID = "2244"; emp.FirstName= "Maria" ; emp.LastName = "Robinlius" ;
MessageBox.Show(emp.Add().ToString()); //call the CalculateWage method
MessageBox.Show(emp.CalculateWage().ToString()); }
.NET Tutorial 33
Interface Vs Abstract Class
As always there is a trade-off, an interface gives you freedom with regard
to the base class, an abstract class gives you the freedom to add new
methods later. Erich Gamma
You cant go and change an Interface without having to change a lot of
other things in your code, so the only way to avoid this would be to
create a whole new Interface, which might not always be a good thing.
Abstract classes should primarily be used for objects that are closely
related, whereas interfaces are better at providing common functionality
for unrelated classes.
An abstract class, in contrast to interface, provides more structure. It
usually defines some default implementations and provides some tools
useful for a full implementation. The catch is, code using it must use your
class as the base.In Jav/C#a, a class can inherit from only one base class.
Feature Interface Abstract Class
Multiple inheritance A class may inherit several
interfaces.
A class may inherit only
one abstract class
Default implementation An interface cannot
provide any code, just the
signature
An abstract class can
provide complete, default
code and/or just the details
that have to be overridden
Access Modfiers An interface cannot have
access modifiers for the
subs, functions, properties
etc everything is assumed
as public
An abstract class can
contain access modifiers
for the subs, functions,
properties
Core VS Peripheral Interfaces are used to
define the peripheral
abilities of a class. In other
words both Human and
Vehicle can inherit from a
IMovable interface.
An abstract class defines
the core identity of a class
and there it is used for
objects of the same type.
Speed Requires more time to find
the actual method in the
corresponding classes
Fast
.NET Tutorial 34
Delegates
In Common Language Infrastructure (CLI), a delegate is a form of type-
safe function pointer usually used in an observer pattern as a means
telling which method to call when an event is triggered
Delegate is a type which holds the method(s) reference in an object
Used to call a method asynchronously

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

public delegate double Delegate_Prod(int a,int b);
class Class1 {
static double fn_Prodvalues(int val1,int val2) { return val1*val2; }
static void Main(string[] args) {
//Creating the Delegate Instance
Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues);
Console.Write("Please Enter Values");
int v1 = Int32.Parse(Console.ReadLine());
int v2 = Int32.Parse(Console.ReadLine()); //use a delegate for processing
double res = delObj(v1,v2);
Console.WriteLine ("Result :"+res);
Console.ReadLine(); } }

.NET Tutorial 35
Events
Today's graphical user interface (GUI) programming model uses event-
driven programming. A modern program presents the user interface and
waits for the user to take an action. The user might take many different
actions, such as choosing among menu selections, pushing buttons,
updating text fields, clicking icons, and so forth. Each action causes an
event to be raised. Other events can be raised without direct user action,
such as events that correspond to timer ticks of the internal clock, email
being received, file-copy operations completing, and so forth.
An event is the encapsulation of the idea that "something happened" to
which the program must respond. Events and delegates are tightly
coupled concepts because flexible event handling requires that the
response to the event be dispatched to the appropriate event handler. An
event handler is typically implemented in C# via a delegate

Publishing and Subscribing (Observer Design Pattern)
In C#, any object can publish a set of events to which other classes can
subscribe. For example, a button might notify any number of interested
observers when it is clicked. The button is called the publisher because
the button publishes the Click event and the other classes are the
subscribers because they subscribe to the Click event.

Note that the publishing class does not know or care who (if anyone)
subscribes; it just raises the event. Who responds to that event, and how
they respond, is not the concern of the publishing class.
The publisher and the subscribers are decoupled by the delegate. The
publisher can change the reason of raising the event and the subscribers
can change the way they respond.
Events and Delegates (Working together)
Events in C# are implemented with delegates
The publishing class defines a delegate. The subscribing class does two
things: first, it creates a method that matches the signature of the
delegate, and then it creates an instance of that delegate type
When the event is raised, the subscribing class's methods are invoked
through the delegate.
A method that handles an event is called an event handler. You can
declare your event handlers
By convention, event handlers in the .NET Framework always return
void and take two parameters. The first parameter is the "source" of the
event (that is, the publishing object). The second parameter is an object
derived from EventArgs. Your event handlers will need to follow this
design pattern






.NET Tutorial 36
Events (Contd..)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace Example_17_3_ _ _ _Delegates_and_Events{
public class TimeInfoEventArgs : EventArgs
{
public int hour;
public int minute;
public int second;

public TimeInfoEventArgs(int hour, int minute, int second)
{
this.hour = hour;
this.minute = minute;
this.second = second;
}
}


// The publisher: the class that other classes
// will observe. This class publishes one delegate:
// SecondChanged.
public class Clock
{
private int hour;
private int minute;
private int second;
// the delegate the subscribers must implement
public delegate void SecondChangeHandler(object clock,
TimeInfoEventArgs timeInformation);
// an instance of the delegate with event keyword added
public event SecondChangeHandler SecondChanged;
Events (Contd..)
// set the clock running
// it will raise an event for each new second
public void Run( )
{
for (; ; )
{ // sleep 10 milliseconds
Thread.Sleep(100);
// get the current time
System.DateTime dt = System.DateTime.Now;
// if the second has changed
// notify the subscribers
if (dt.Second != second)
{
// create the TimeInfoEventArgs object
// to pass to the subscriber
TimeInfoEventArgs timeInformation =
new TimeInfoEventArgs(dt.Hour, dt.Minute, dt.Second);


// if anyone has subscribed, notify them
if (SecondChanged != null)
{
SecondChanged(this, timeInformation);
}
}

// update the state
this.second = dt.Second;
this.minute = dt.Minute;
this.hour = dt.Hour;
}
}
}

.NET Tutorial
Events (Contd..)
// A subscriber: DisplayClock subscribes to the
// clock's events. The job of DisplayClock is
// to display the current time
public class DisplayClock
{ // given a clock, subscribe to
// its SecondChangeHandler event
public void Subscribe(Clock theClock)
{ theClock.SecondChanged +=
new Clock.SecondChangeHandler(TimeHasChanged);
}
// the method that implements the
// delegated functionality
public void TimeHasChanged(object Clock, TimeInfotheEventArgs ti)
{
Console.WriteLine("Current Time: {0}:{1}:{2}",
ti.hour.ToString( ), ti.minute.ToString( ), ti.second.ToString( ));
}
}
// a second subscriber whose job is to write to a file
public class LogCurrentTime
{
public void Subscribe(Clock theClock)
{ theClock.SecondChanged +=
new Clock.SecondChangeHandler(WriteLogEntry);
}
// this method should write to a file
// we write to the console to see the effect
// this object keeps no state
public void WriteLogEntry(object theClock, TimeInfoEventArgs ti)
{
Console.WriteLine("Logging to file: {0}:{1}:{2}",
ti.hour.ToString( ), ti.minute.ToString( ), ti.second.ToString( ));
}
}
.NET Tutorial
public class Tester
{
public void Run( )
{
// create a new clock
Clock theClock = new Clock( );

// create the display and tell it to
// subscribe to the clock just created
DisplayClock dc = new DisplayClock( );
dc.Subscribe(theClock);
// create a Log object and tell it
// to subscribe to the clock
LogCurrentTime lct = new LogCurrentTime( );
lct.Subscribe(theClock);
// Get the clock started
theClock.Run( );
}
}
What is the event keyword is not used?
The event keyword indicates to the compiler that the delegate can be
invoked only by the defining class, and that other classes can subscribe
to and unsubscribe from the delegate using only the appropriate += and -
= operators, respectively
The following code will be possible if the event keyword is not used
public void Subscribe(Clock theClock)
{
theClock.SecondChanged =
new Clock.SecondChangeHandler(WriteLogEntry);
}
This assignment will replace the multicast delegate. Also, other classes can
directly invoke the event which is not intended.

.NET Tutorial
Exception Handling
using System;
using System.IO;

class FinallyDemo
{
static void Main(string[] args)
{
FileStream outStream = null;
FileStream inStream = null;

try
{
outStream = File.OpenWrite("DestinationFile.txt");
inStream = File.OpenRead("BogusInputFile.txt");
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
if (outStream != null)
{
outStream.Close();
Console.WriteLine("outStream closed.");
}
if (inStream != null)
{
inStream.Close();
Console.WriteLine("inStream closed.");}}}}
Exception Handling Best Practices
Try to write code to avoid exception as much possible. e.g.
Instead of writing -
int testInt=Int32.ParseInt(testString);
int testInt=Int32.TryParse(testString,out testInt);
Use try/catch blocks around code that can potentially generate an exception, and use a
finally block to clean up resources, if necessary
In catch blocks, always order exceptions from the most specific to the least specific
Throw exceptions instead of returning an error code
In most cases, use the predefined .NET Framework exception types. Introduce a new
exception class only when a predefined one doesn't apply
Throw an InvalidOperationException exception if a property set or method call is not
appropriate given the object's current state
Throw an ArgumentException exception or a class derived from ArgumentException
if invalid parameters are passed
For most apps, derive custom exceptions from the Exception class. Deriving from the
ApplicationException class doesn't add significant value
End exception class names with the word "Exception". For example:
public class MyFileNotFoundException : Exception
{
}
.NET Tutorial
Design Patterns
In software engineering, a design pattern is a general reusable solution to a commonly
occurring problem within a given context
A design pattern is not a finished design that can be transformed directly into source
or machine code. It is a description or template for how to solve a problem that can
be used in many different situations
Design patterns gained popularity in computer science after the book Design Patterns:
Elements of Reusable Object-Oriented Software was published in 1994 by the so-
called "Gang of Four" (Gamma et al.), which is frequently abbreviated as "GOF
Design patterns were mainly grouped into the following categories -
Creation Patterns: Design patters that deal with object creation
mechanisms.Creational design patterns are further categorized into Object-
creational patterns and Class-creational patterns.In greater details, Object-
creational patterns defer part of its object creation to another object, while
Class-creational patterns defer its object creation to subclasses. Five well
known creation patterns are -
Abstract Factory pattern
Builder pattern
Factory Method Pattern
Prototype Pattern
Singleton Pattern
Structural Patterns: Structrual patterns are meant to ease the design by identifying a simple
way to realize relationships between entities. Examples -
Adapter Pattern
Aggregate Pattern
Bridge Pattern
Behavioural Design Patterns: These patterns identify common communication patterns
between objects. By doing so, these patterns increase flexibility in carrying out this
communication. Examples -
Chain of Responsibility
Command Pattern
Observer Pattern
Schedules Task Pattern
Iterator Pattern
Protocol Stack


.NET Tutorial
Factory Pattern
The factory pattern method is a popularly used design pattern and it is very useful to restrict
clients from knowing the actual business logic methods, it is useful to create a decoupled
system, and it is useful to eliminate object creation in a client environment.

For example we have a scenario where based on user input we need to call particular class
methods. I have a customer input screen. He enters his choice whether they want to buy a
bike or a car. Normally we get input from the user and based on that will create an object in
the client class and call those methods like below.


If (choice == Car)
{
// call car class and its methods
Car c = new car();
c.buy();
}
If (choice == bike)
{
// call bike class and its methods
Bike b = new Bike();
b.buy()
}

In case in future if there is any other vehicle added then we need to change the client
functionality. Worse, if there are many client classes using these classes all of them might
neeed to be updated.
public interface IChoice { string Buy(); }

A new class will be added and this class we will be called factory class. This class sits between
the client class and the business class and based on user choice it will return the respective
class object through the interface.

// // Factory Class //
public class FactoryChoice {
static public IChoice getChoiceObj(string cChoice) {
IChoice objChoice=null;
if (cChoice.ToLower() == "car") { objChoice = new clsCar(); }
else if (cChoice.ToLower() == "bike") { objChoice = new clsBike(); }
else { objChoice = new InvalidChoice(); } return objChoice; } }

//Business classes Bike//
public class clsBike:IChoice
{ #region IChoice Members public string Buy() { return ("You choose Bike"); } #endregion }
//Business Class Car
public class clsCar:IChoice { IChoice Members public string Buy() { return ("You choose
Car"); } }

From the client class call the factory class object and it will return the interface object.
Through the interface object we will call the respective method
//Client class
IChoice objInvoice;
objInvoice = FactoryClass.FactoryChoice.getChoiceObj(txtChoice.Text.Trim());
MessageBox.Show(objInvoice.Buy());

In future if we need to add a new vehicle then there is no need to change the client class,
simply return that object using the factory class. .NET Tutorial
Singleton Pattern
Singleton Patterns are implemented when there is a need for only instance of a class
throughout the application.

Commonly used in Logging, shareable services etc. Multiple logger instances can slow down
the system performance using singleton pattern in these case is a perfect example.

public sealed class BusinessRulesManager
{
private BusinessRulesManager(){}

public static BusinessRulesManager GetInstance
{
get
{
return BusinessRulesManagerImpl.instance;
}
}

public void DisplayRules()
{
Console.WriteLine("Single instance object");
}

private class BusinessRulesManagerImpl
{
static BusinessRulesManagerImpl()
{}

internal static readonly BusinessRulesManager instance = new BusinessRulesManager();}}
private static void Singleton()
{
BusinessRulesManager businessRulesManager = BusinessRulesManager.GetInstance;
businessRulesManager.DisplayRules();

Console.ReadKey();
}

The class is marked as sealed which means that inheritance is not allowed for it

a private nested class is used to provide access to the instance that must only exist once in the
application.

This nested class has a static default constructor and an internal static read-only instance of
the object. Only the container class has access to the instance


.NET Tutorial
Adapter Pattern
The Adapter Design Pattern allows you to make an existing class work with other existing
class libraries without changing the code of the existing class.

Say, there is an Employee Class which implements the Iemployee interface. The organization
tree is constructed using this Employee class. You are then given the Consultant class and you
need to plug this Consultant class into the organization tree. The Consultant class is the
Adaptee.
The way to do this is by creating the adapter class named the EmployeeAdapter.

using System.Collections.Generic;
class Program {

static void Main(string[] args) {
List<iemployee> list = new List<iemployee>();
list.Add(new Employee("Tom"));
list.Add(new Employee("Jerry"));
list.Add(new EmployeeAdapter(new Consultant("Bruno")));
//*** Code below from the existing library does not need to be changed ***
ShowHappiness(list); }

//*** Code below from the existing library does not need to be changed ***
static void ShowHappiness(List<iemployee> list) { foreach (IEmployee i in list)
i.ShowHappiness(); } }
//from the existing library, does not need to be changed
public interface IEmployee { void ShowHappiness(); }


public class Employee : IEmployee {
private string name;
public Employee(string name) { this.name = name; }
void IEmployee.ShowHappiness() { Console.WriteLine("Employee " + this.name + " showed
happiness"); } }

//existing class does not need to be changed
public class Consultant
{ private string name;
public Consultant(string name) { this.name = name; }
protected void ShowSmile() { Console.WriteLine("Consultant " + this.name + " showed
smile"); } }

public class EmployeeAdapter : IEmployee {
Consultant _consultant;
public EmployeeAdapter(Consultant consultant) { _consultant = consultant; } v
oid IEmployee.ShowHappiness()
{ consultant.ShowSmile(); //call the adaptee Consultant class } }
.NET Tutorial
Observer Pattern
Many a times, we need one part of our application updated with the status of
some other part of the application. One way to do this is to have the receiver
part repeatedly check the sender for updates, but this approach has two main
problems. First, it takes up a lot of CPU time to check the new status and
second, depending on the interval we are checking for change we might not get
the updates "immediately".

This problem has one easy solution i.e. Observer Pattern.

Events and delegates uses the oberserver pattern in C#


According to MSDN MVC is a fundamental design pattern for the separation
of user interface logic from business logic.
.NET Tutorial
Iterator Pattern
Provides a way to access the elements of an aggregate object sequentially
without exposing its underlying representation

"Enumerated" means to count off the members of a set/collection/category one
by one (usually in order, usually by name).
An enumerable then is an object that can step through a series of other objects
one by one.

You use the iterator pattern most likely in your every day work maybe without
being aware of:

List<string> all = new List<string>() { "you", "me", "everyone" };
...
foreach(string who in all)
{
Console.WriteLine("who: {0}!", who);
}

Behind the scenes, the foreach loop translates into -
using (var it = all.GetEnumerator())
while (it.MoveNext())
{
string who = it.Current; ...}


A class that can be used in a foreach loop must provide a IEnumerator<T>
GetEnumerator() { ... } method. The method name is reserved for that purpose.

Some classes may also provide the non-generic IEnumerator GetEnumerator() {
... } method. This is from the older days where there were no generics yet.

So, the core of the C# implementation of the Iterator Pattern is the
GetEnumerator() method

What is an Iterator?
An iterator provides a means to iterate (i.e. loop) over some items. The
sequence of elements is given by the implementations of the
IEnumerator/IEnumerator<T> interfaces:

namespace System.Collections
{
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
}

.NET Tutorial
Iterator Pattern (Contd..)
namespace System.Collections.Generic
{
public interface IEnumerator<out T> : IDisposable, IEnumerator
{
T Current { get; }
}
}


The pattern is basically given by MoveNext() and Current. The semantics is
that one has to first call MoveNext() to get to the first element. If MoveNext()
returns false, then there is no more element. Current returns the current
element. You are not supposed to call Current if the preceeding MoveNext()
returned false.

The MoveNext() gives the next element in the sequence of elements - what ever
that sequence is, e.g. from first to last, or sorted by some criteria, or random,
etc.
We know now how to apply the iterator pattern (e.g. in a foreach loop) and
that this is possible for all classes that provide the above mentioned
GetEnumerator() method (the iterator).
.NET Tutorial