On Demand training on latest web technologies

 

Programming with HTML5 and related technologies

http://www.microsoft.com/showcase/en/in/details/4f39070b-c435-4de5-9f50-0d2852c1dfbe

Visual Studio 2010 SP1 for Web Developers

http://www.microsoft.com/showcase/en/in/details/90b79e80-eae9-47c8-a4f4-a2431e62178d

ASP.NET MVC3 Development with Visual Studio 2010

http://www.microsoft.com/showcase/en/in/details/fd907f28-bcbd-4a00-871f-4be5965d3764

Code-First Development with Entity Framework

http://www.microsoft.com/showcase/en/in/details/966167f3-9da3-422b-ab7c-0ecedd3ae5f2

Web Sockets & Indexed DB

http://www.microsoft.com/showcase/en/in/details/83478b2d-e2c2-427d-8a05-7e795efa03f0

Building cross browser compatible websites

http://www.microsoft.com/showcase/en/in/details/0ed592c6-cf3b-495b-8e22-48f530f89f3b

* Patterns : Iterator Behavioral Pattern

Iterator Behavioral Pattern provides an access interface to an aggregate or collection object for clients. The iterator abstracts the clients from how the collection has been structured and also provides sequential navigation capabilities over collection.

Consider the following class diagram :

NodeCollection type holds objects of type Node and there are two Iterators provided for NodeCollection objects.

The client code looks like following :

public class Client
{
    NodeCollection nc = new NodeCollection();
    BaseIterator forwardIterator;
    public void Run()
    {
        nc.AddNode(new Node("Name 0"));
        nc.AddNode(new Node("Name 1"));
        nc.AddNode(new Node("Name 2"));
        nc.AddNode(new Node("Name 3"));
        nc.AddNode(new Node("Name 4"));
        nc.AddNode(new Node("Name 5"));
        nc.AddNode(new Node("Name 6"));
        nc.AddNode(new Node("Name 7"));

        forwardIterator = nc.GetForwardIterator();
        Node n = forwardIterator.FirstNode();
        Console.WriteLine(n.Name);
        n = forwardIterator.NextNode();
        Console.WriteLine(n.Name);
        n = forwardIterator.NextNode();
        Console.WriteLine(n.Name);
        n = forwardIterator.NextNode();
        Console.WriteLine(n.Name);
        n = forwardIterator.NextNode();
        Console.WriteLine(n.Name);
    }
}

 

If iterators are not provided, client needs to know how to access each element using [index]. But with iterators the accessing code becomes much simpler & can be same for any type of collection structures.

Download Iterator Behavioral Pattern Source Code

Other Design Patterns

* Patterns : Interpreter Behavioral Pattern

Interpreter Behavioral Pattern as name suggests is used to interpret sentences in langauge provided represented in a particular form.

The langauge should be representable in form of abstract syntax tree. Two types of nodes are used for expressions : Terminal Expressions & Non-Terminal Expressions.

Let's take an example of a command line calculator which can take expressoins in form of a+b-c+d and return the output.

The class diagram representing such calculator can be following :

Calculator class is an example of an Interpreter which parses the input statement and creates tree using NumberExpression (Terminal) & OperatorExpression (Non-Terminal). Both Expression classes have an abstract base which is used by Calculator to evaluate the tree.

public class Calculator
{
    BaseExpression bTree; //not used.
    Context ctx;
    public void Calculate(string expr)
    {
        //expr = "5+1-3";
        ctx = new Context();
        List<BaseExpression> tree = new List<BaseExpression>();
        char[] elements = expr.ToCharArray();
        foreach (char c in elements)
        {
            if (c.ToString().Equals("+") || c.ToString().Equals("-"))
            {
                tree.Add(new OperatorExpression(c));
            }
            else
            {
                tree.Add(new NumberExpression((int)c-48));
            }
        }
        foreach (BaseExpression exp in tree)
        {
            exp.Evaluate(ctx);
        }
        Console.WriteLine(ctx.Total);
    }
}

Download Interpreter Behavioral Pattern Source code

Other Design Patterns

* Patterns : Command Behavioral Pattern

Command Patterns helps encapculating/mapping a request to object called command. All commands are derived from base command which has mainly two methods Execute & UnExecute. The commands forwards the request data to Receiver for further processing.

Either client can decide which Command and  Receiver to be invoked or it can be configuration based for loose coupling.

One of the popular places where Command Pattern is used : Model View Controller (MVC) pattern.

Consider the diagram below :

Invoker is the class responsible for executing commands. Since all commands expose common interface, Inovker can be quite generic and appropiate place for logging details.

In the above implementation, client needs to be aware of all three objects Invoker, Command and Receiver. This can be alternately be config based and client just needs to pass request to Invoker.

public class Client
    {
        Receiver receiver;
        BaseCommand command;
        Invoker invoker;

        public void Run()
        {
            receiver = new Receiver();
            command = new ConcreteCommand();
            command.SetReceiver(receiver);
            invoker = new Invoker();
            invoker.SetCommand(command);
            invoker.ExecuteCommand();
            Console.Read();
        }
    }

Download Source code : Command Behavioral Pattern

Other Design Patterns

* Patterns : ChainOfResponsibility Behavioral Pattern

ChainOfResponsibility Behavioral Pattern helps achieving loose coupling between request sender and receiver object.

It helps in introducing a set of chained interceptor objects which can handle the request or pass it to next member in chain. The chaining can be pre-configured or can be done by client before invoking the chain.

Consider the below class diagram:

Based on the base exception handler, a set of concrete exception handlers are created. Now client can chain them based on how specific handling of exception is required.

BaseExceptionHandler sqlHandler, securityHandler, allHandler;
public void Run()
{
    sqlHandler = new SqlExceptionHandler();
    securityHandler = new SecurityExceptionHandler();
    allHandler = new AllExceptionHandler();

    sqlHandler.SetSuccessor(securityHandler);
    securityHandler.SetSuccessor(allHandler);

    Exception ex = new Exception();
    sqlHandler.HandleException(ex);
}

Additional handlers can be configured in between or at the end.

It chains the receiving objects and pass the request along the chain until an object handles it.

Download code of ChainOfResponsibility Behavioral Pattern

Other Design Patterns

* Patterns : Flyweight Structural Pattern

Flyweight Structural Pattern is used to manage large number of shared objects. They are maintained in a collection and same instances used whenever required. These objects have their own attributes/features but they can have a common feature also which can be externalized.

Consider a scenario where a picture has to be drawn which consists of large numbers of polygons of different colors. All polygons have number of sides property which is very specific to them but all of them have a common property called color which can be externalized. Also for same polygon type like 'Square',  number of sides remain same but color may change. Flyweight pattern helps in managing such kind of scenarios.

Polygon factory manages the collection of polygons. Each concrete polygon stores number of sides but the color property is taken at runtime. Same instance of polygon can be used to draw any number of times with different color.

The client code is following :

namespace FlyWeight
{
    public class Client
    {
        PolygonFactory factory;
        public void Run()
        {
            factory = new PolygonFactory();
            Polygon square = factory.GetPolygon("SQUARE");
            square.Draw("RED");
            Polygon triangle = factory.GetPolygon("TRIANGLE");
            triangle.Draw("GREEN");
        }
    }
}

Download source code : Flyweight Structural Pattern Source Code

* Patterns : Facade Structural Pattern

'Facade Structural Pattern' is primarily used to unify and simply a set of interfaces of subsystems. This helps the client in using the interface with less effort.

Consider the class diagram below :

Above shows a typical scenario of a Bank where a new Customer approaches the Bank to open new account and also deposit some initial amount.

The Core Banking subsystems provide two different interfaces for Customer and Account and two different calls are required for Account opening and deposit of amount.

The Bank Facade shown above simplifies the new Customer creation, new Account Creation and deposit amount by providing a single interface/call to perform the required actions.

The Bank facade has following code :

// Acts as Facade
public class Bank
{
    Customer cust;
    Account acct;
    public void CreateCustomer(string name, string address, double initalDeposit)
    {
        cust = new Customer(name, address);
        acct = new Account(name, 1234);
        acct.Deposit(initalDeposit);
    }
}

Download Full source code : Facade Structural Pattern Source Code

* Patterns : Decorator Structural Pattern

The primary use of 'Decorator Structural Pattern' is to add behaviors to object at runtime. It generally involves wrapping the original object with the decorator object which adds the new behaviors but keep the structure of original object intact. Multiple behaviors can be added out of given options based on decision criteria.

Consider the class diagram below :

There is a BookBase class which is extended based on subjects of books and types of books. FictionBook subclasses BookBase based on subject/category while VideoBookBase subclasses BookBase based on type of book.

Now BookBase has a method called DisplayInfo() which is used to display about book. If DisplayInfo is called on FictionBook object it will display only the properties which are common to all display books, but suppose the fiction book is a video book and the DispayInfo should also display the duration, we use the above pattern as below :

The client code looks like following :

public class Client
{
    FictionBook bookFiction;
    VideoBookBase videoBookFiction;
    public void Run()
    {
        bookFiction = new FictionBook();
        //NonFictionBook bookNonFiction = new NonFictionBook();
        videoBookFiction = new VideoBook(bookFiction);
        //VideoBookBase videoBookNonFiction = new VideoBook(bookNonFiction);

        bookFiction.DisplayInfo();
        videoBookFiction.DisplayInfo();
        //videoBookNonFiction.DisplayInfo();
    }
}

FictionBook object is wrapped by VideoBook at runtime.

Download full source code : Decorator Structural Pattern

 

* Patterns : Composite Structural Pattern

Composite Structural Pattern is applicable when you need to deal with whole-part kind of relationships or tree kind of structures. It helps client to deal with individual or composite objects in a uniform manner and thus abstracts the client from complexities of internal structure.

Consider the following class diagram :

In the above diagram Book is a simple type but LibrarySection is a complex type and is composed of Book type instances. But both have same base which is BookBase and so both the simple type and composite type have same methods exposed to client.

The client code will look like following :

public class Client
{
    Book cSharpBook,vbBook,historyBook,religion;
    LibrarySection techBooks, nonTechBooks, library;
    public void Run()
    {
        cSharpBook = new Book("CSharp Book");
        vbBook = new Book("Visual Basic Book");
        techBooks = new LibrarySection("Technical Books");
        techBooks.Add(cSharpBook);
        techBooks.Add(vbBook);
        techBooks.List();

        Console.WriteLine("----------------------------------------------------------");

        historyBook = new Book("History Book");
        religion = new Book("Religion Book");
        nonTechBooks = new LibrarySection("Non Technical Books");
        nonTechBooks.Add(historyBook);
        nonTechBooks.Add(religion);
        nonTechBooks.List();

        Console.WriteLine("----------------------------------------------------------");

        library = new LibrarySection("Library");
        library.Add(techBooks);
        library.Add(nonTechBooks);
        library.List();
    }
}

By using this pattern a more complex type could also be created by adding the instances of LibrarySection to the same type.

You can download the complete source code from here : Composite Structural Pattern Source Code

* Patterns : Bridge Structural Pattern

Bridge Structural Pattern decouples an abstraction from its implementation so that the two can vary independently. Multiple variants of abstraction can be created provided they implement the common interface. Similarly, multiple variants of implementations can be created provided they implement the common interface. Given the option of multiple abstraction variants and multiple implementation variants, clients have the flexibility of using any abstraction class with any implementation.

Consider the class diagram below :

 

There is one variant of abstraction called AbstractionX and two variants of implementation ImplementationA and ImplementationB.

The client code looks like following :

public class Client
{
    AbstractionBase absBase;
    public void Run()
    {
        ImplementationA implA = new ImplementationA();
        ImplementationB implB = new ImplementationB();

        absBase = new AbstractionBase(implA);
        absBase.PrintString("Hello\n\r");
        absBase = new AbstractionBase(implB);
        absBase.PrintString("Hello\n\r");

        AbstractionX absX = new AbstractionX(implB);
        absX.PrintString("Hello\n\r");
    }
}

Client code shows that same abstraction can be used with multiple implementations and similarly same implementation can be used with multiple abstractions.

Download complete source code : Bridge Structural Pattern source code

* Patterns : Adapter Structural Pattern

Adapter pattern also called as Wrapper pattern lets client adapt a framework/service with different call definitions than what client has been designed for. Clients continue using the original definitions and adapter takes care of transformation.

Consider the class diagram below :

Client calls the ClientBase class which is client's default framework. Now Client is supposed to use FrameworkBase which has Print method instead of PrintString method. Now instead of changing the client, an Adapter class is created which take care of transforming the method calls.

Provided the methods in ClientBase are virtual, Adapter class can use ClientBase class as base class to provide the transformation functionality.

public class Adapter : ClientBase
{
    private FrameworkBase frmkBase;

    public Adapter()
    {
        frmkBase = new FrameworkBase();
    }

    public override void PrintString(string str)
    {
        frmkBase.Print(str);
    }
}

The client can make calls in same way just by making sure that instance of Adapter class is used.

public class Client
{
    ClientBase cb1, cb2;
    public void Run()
    {
        cb1 = new ClientBase();
        cb2 = new Adapter();
        cb1.PrintString("Hello");
        cb2.PrintString("Hello");
    }
}

Download full source code from here : Adapter Structural Pattern

* Singleton Creational Pattern

One of the most popular creational pattern. It is used to restrict the number of instances of a type to one and so all clients use the same instance.

Consider the following class diagram :

Client creates two variables of type Singleton, s1 and s2. 

The client code looks like following :

    public class Client
    {
        Singleton s1,s2;
        public void Run()
        {
            // s1 = new Singleton(); // new cannot be called.
            s1 = Singleton.GetInstance();
            s1.ID = 999;
            s2 = Singleton.GetInstance();
            Console.WriteLine("ID = " + s2.ID);
        }
    }

The output of s2.ID is '999' which shows that both s1 and s2 are referring to same instance of Singleton. Also note that default constructor has been protected.

The code for actual 'Singleton' class looks like following :

    public class Singleton
    {
        public int ID;
        private static Singleton Instance;
        
        // Constructor is protected so that new cannot be called.
        protected Singleton()
        {            
        }

        /// <returns>Singleton</returns>
        public static Singleton GetInstance()
        {
            if (Instance == null)
            {
                Instance = new Singleton();
            }
            return Instance;
        }
    }

Download full source code from here : Singleton Creational Pattern Source Code

* Patterns : Prototype Creational Pattern

Prototype Creational Pattern provides an interface which can be used by client to get access to already existing instance of a type which can be used as prototype by client to create new instance. Client can clone the existing object using deep or shallow copy and use it. It is used mainly when inherent cost of creating a new object is high.

Consider the following class diagram :

Above scenario goes like this :

Client needs the updated list of managers. ListAdmin can provide the list but its not latest. Now, client instead of creating the list from scratch which can be very resource consuming, picks the list from ListAdmin, creates a shallow copy of it and updates it for further use.

    public class Client
    {
        public static void Run()
        {
            ManagersList managersList = ListAdmin.getManagersList();
            Console.WriteLine("Printing managersList ....");
            DisplayList(managersList);
            ManagersList list = (ManagersList)managersList.Clone(); // Creates a shallow copy
            list.managers.Add("D_Manager1");
            list.id = 2;
            Console.WriteLine("Printing list ....");
            DisplayList(list);
            Console.WriteLine("Printing managersList again....");
            DisplayList(managersList);
        }

        private static void DisplayList(ManagersList list)
        {
            Console.WriteLine("ID = " + list.id);
            for(int i=0;i<list.managers.Count;i++)
            {
                Console.WriteLine(list.managers[i]);
            }
            
        }
    }

The above client code output will be following :

Printing managersList ....
ID = 1
B_Manager1
A_Manager1
C_Manager1
Printing list ....
ID = 2
B_Manager1
A_Manager1
C_Manager1
D_Manager1
Printing managersList again....
ID = 1
B_Manager1
A_Manager1
C_Manager1
D_Manager1

Download full source code from here : Prototype Creational Pattern

* Patterns : Factory Method Creational Pattern

It provides an interface for creating an object but lets subclass decide which class to instantiates. So, it can also be called as virtual constructor.

Consider the following class diagram :

ShapeCreator class provides an factory method to create objects of BaseShape. Client always uses ShapeCreator and BaseShape type variables to work on instances of derives classes.

The client looks like following :

    public class Client
    {
        ShapeCreator createsShape;
        public void Run()
        {
            BaseShape shape;
            createsShape = new CircleCreator();
            shape = createsShape.CreateShape();
            shape.WhoAmI();
        }
    }

The code of CircleCreator looks like following :

    public class CircleCreator : ShapeCreator
    {
        public override BaseShape CreateShape()
        {
            return new CircleShape();
        }
    }

The CircleCreator decides which class to instantiate in response to CreateShape() method.

Download full source code from here : Factory Method Creational Pattern

* Patterns : Builder Creational Pattern

Builder Creational Pattern separates the process of construction of a complex object from its actual representation. This means that the same process can create different representations of same object.

Consider the following diagram :

The main class here is ShapeCreator which is called Director and controls the process of construction of object. 

    // Director
    public class ShapeCreator
    {
        public void CreateSquare(SquareBuilder sb)
        {
            sb.Create();
            sb.SetColor();
        }
    }

While Square is the actual object. RedSquareBuilder controls the actual representation of the object.

Consider the following client code :

    public class Client
    {
        ShapeCreator d;
        public void Run()
        {
            d = new ShapeCreator(); //Director
            SquareBuilder sb = new RedSquareBuilder();
            d.CreateSquare(sb);
            Square sq;
            sq = sb.GetSquare();
            Console.WriteLine(sq.Color + " Color Square created");
        }
    }

Just by changing the instance value of SquareBuilder, another representation of Square can be created by ShapeCreator.

Download full source code from here : Builder Creational Pattern source code

* Pattern : Abstract Factory Creational Pattern

Provides a single interface for creating families of related or dependent objects without using the concrete type name.

Consider the following class diagram :

In above diagram, CreateShapes acts as an single interface for creating various families of products. The diagram shows only Red shapes but it can be extended to create more color shapes.

The client code will look like this :

    public class Client
    {
        CreateShapes redShapes;

        public void Run()
        {
            redShapes = new CreateRedShapes();
            redShapes.CreateCircle();
            redShapes.CreateSquare();
        }
    }

Once the current instance has been assigned to variable of type CreateShapes, the remaining code remains same for every family.

A practical use can be creating shapes for a particular theme.

The complete source code can be downloaded from following location : Abstract Factory Creational Pattern Source Code

* Design Patterns : Gang of Four

Over next few days, I will be discussing the implementation of GOF design patterns in CSharp.

I wont be discussing the benefits of Design Patterns here ... you can read about them here : Design Patterns.

In one line : "They bring best practice for solving common design problems to software development which helps in ensuring success of design and increase in productivity."

Here is a quick reference card of GOF patterns.