Patterns

De- Caching items on all the servers in the Windows Azure

2012-01-05T10:24:00.006Z

You can use the following code even if you would like to pass any message to all the instances in the cloud.

The following post shows you how to get the ip address of each instance in the windows azure.

In order to de-cache keys or to communicate or to pass the messages to all load balanced servers, please create a new internal endpoint in azure web role. Add a internal endpoint with name "DeCacheEndPointInternal".

In order to send a message through query string. use the following code

  foreach (RoleInstance roleInstance in RoleEnvironment.CurrentRoleInstance.Role.Instances)                     {                         var ipEndpoint =                              roleInstance.InstanceEndpoints["DeCacheEndPointInternal"].IPEndpoint;                         var url = string.Format("http://{0},{1},{2}" ,ipEndpoint.ToString() ,                             "/Cache.aspx?ClearCache=", CacheKey) ;                         var req = (HttpWebRequest)WebRequest.Create(url);                         var res = (HttpWebResponse)req.GetResponse();                     }

This will send a HTTPRequest to the "Cache.aspx" with the querystring containing cache-key to remove on each servers.

Thanks

JQuery AutoComplete using XML with Key Value pair

2009-08-24T21:09:00.001+01:00

Recently i have been to different websites and blogs for autocomplete plug-in but i could not find much help regarding to auto complete with key value pair specially using xml. because personally i think using xml file for autocomplete is better option than using JavaScript strings because of ease of use of xml file. It can be generated and changed easily.

AutoComplete

Autocomplete an input field to enable users quickly finding and selecting some value, leveraging searching and filtering. For more help you can read all documentation and examples about this plug-in at http://docs.jquery.com/Plugins/Autocomplete#API_Documentation.

To download JavaScript files please visits http://www.pengoworks.com/workshop/jquery/autocomplete.htm.

To download JQuery
http://code.google.com/p/jqueryjs/downloads/detail?name=jquery-1.3.2.min.js

Output

How to use XML with AutoComplete

You may find couple of example on internet but none of them has actually worked for me.

First of all you can create any xml. I have an xml file having links inside in it.

<?xml version="1.0"?>
<items>
  <item>
    <text> <![CDATA[yahoo]]> </text>
    <value><![CDATA[www.yhaoo.com]]></value>
  </item>
  <item>
    <text><![CDATA[google]]></text>
    <value><![CDATA[www.google.com]]></value>
  </item>
  <item>
    <text><![CDATA[msn]]></text>
    <value><![CDATA[www.msn.com]]></value>
  </item>
</items>

JavaScript to use JQuery and plug-in

    <script type="text/javascript" src="JavaScripts/jquery-1.3.2.min.js"></script>
    <script src="JavaScripts/jquery.autocomplete.pack.js" type="text/javascript"></script>

To use JQuery with XML file

 <script type="text/javascript">
        //this function will clear only the default text of input field
        function clearText(thefield) {
            if (thefield.defaultValue == thefield.value)
                thefield.value = ""
        }
        $(document).ready(function() {
            // get the input field
            var input = $('input#txtResourceFinder');
            // This function opens the full list before even typing
            // if you dont want this  omit this part.
            input.one('click', function() {
                $(this).focus().click().select();
                $(this).one('click', arguments.callee);
            });
            // Jquery autocomplete with xml file
            input.autocomplete('links.xml', {
                delay: 10,
                minChars: 2,
                matchSubset: 1,
                matchContains: 1,
                minChars: 0,
                parse: parseXML,
                formatItem: formatItem,
                formatResult: formatResult
            }).result(function(event, item) {
                window.location.href = item.value
            });
            
            // this function will parse xml and return as a array of string
            function parseXML(xml) {
                var results = [];
                $(xml).find('item').each(function() {
                    var text = $.trim($(this).find('text').text());
                    var value = $.trim($(this).find('value').text());
                    results[results.length] = { 'data': { text: text, value: value },
                        'result': text, 'value': value
                    };
                });
                return results;
            };
            
            function formatItem(data) {
                return data.text;
            };
            
            function formatResult(data) {
                return data.text;
            };
        });
    </script>

parseXML: This function will parse xml and return as a array of text value pairs.

As you can see above that result returns item as a text value pair. Once you select the option it will redirect to that location.

Download Code

Decorator Design Pattern using C#

2009-08-14T08:34:00.001+01:00

Introduction

The role of the Decorator pattern is to be able to add functionality dynamically to an object, making it appear as if the object used inheritance.Decorator pattern provides a way of attaching new state and behaviour to an object dynamically. The object does not know it is being decorated,which makes this a useful pattern for evolving systems. Decorator pattern is the instantiation and organization of the individual
elements

Explanation

To discuss it more take a little look at UML diagram below.

UML Diagram

In our example

Component: To keep this example simple i am using System.Draw.Image class as a component.
Decorator: In our example we have IDecorator interface
ConcreteDecorator: Then we have two classes DrawText and DrawRectangle as concrete decorator classes.

Attributes of Decorator Design Pattern

The component implementations is dynamic and can be altered at runtime.
The original object is unaware of any decorations.
The decorations are independent of each other.
The decorations can be composed together in a mix-and-match fashion.

using System;
using System.Drawing.Imaging;
using System.Drawing;
using System.IO;
class DecoratorPattern
{
    // Interface 
    interface IDecorator
    {
        void Operation();
    }
    //ConcreteDecorator   Classes
    class DrawText : IDecorator
    {
        Image image;
        public DrawText(Image image)
        {
            this.image = image;
        }
        /// <summary>
        /// Drawing text on image
        /// </summary>
        public void  Operation(  )
        {
          
            Graphics g = Graphics.FromImage(image);
            StringFormat strFormat = new StringFormat();
            strFormat.Alignment = StringAlignment.Center;
            strFormat.LineAlignment = StringAlignment.Center;
            g.DrawString("pebbles", new Font("Tahoma", 20), Brushes.Black,50,50);
            image.Save("new.jpg");
            
        }
    }
    //ConcreteDecorator   Classes
    class DrawRectangle : IDecorator
    {
       Image image;
       public DrawRectangle(Image image)
        {
            this.image = image;
        }
        /// <summary>
        /// drawing rectangle on Image
        /// </summary>
       public void Operation()
        {
            Graphics g = Graphics.FromImage(image);
            Pen blackPen = new Pen(Color.Black, 3);
            Rectangle rect = new Rectangle(0, 0, 200, 200);
            g.DrawRectangle(blackPen, rect);
            image.Save("new.jpg");
        }
    }
    class Client
    {
        static void Main()
        {
            //Component can have responsibilities added to them dynamically. 
            Image image = Image.FromFile("pebbles.jpg");
            IDecorator decorator = new DrawRectangle(image);
            decorator.Operation();
            decorator = new DrawText(image);
            decorator.Operation();
        }
    } 
}

Before

After

Summary

In general decorator pattern is used to extend the functionality of individual objects, not classes. So because of it all modification are done at runtime rather than on design time. A you can see above pebbles example that we have changed the image by drawing rectangle and text. A Decorator, also known as a Wrapper. Because of its dynamic behavior they are also useful for adapting objects to new situations without re-writing the original object's code. Though its called decorator pattern in my example but i have spoiled the image than decorating it :).

Strategy Design Pattern

2009-07-31T14:09:00.001+01:00

codeproject

Introduction

By definition Strategy design pattern allow an object to change its behaviour when its internal state changes. The object will appear to change its class. The Strategy design pattern enables a client to choose which algorithm to use from a family of algorithms and gives it a simple way to access it. The algorithms can also be expressed independently of the data they are using.

A little about past

In my childhood i used to play a very interesting number game with my Phopho (Aunt :)). She used to play that game with me and i could never figure it out how was that possible. In this game you ask for any number from a person for example if the person thinks a number like 498 then you tell him ok after some calculation answer will be 2496. How cool was that to guess the number even before any calculation. Now then you ask number again from the person and that could be 764 then you give your number which is 235 then 3rd time you ask from person for number which could be 671 and you give him number which is 328 now if you add these number up 498 +764 +235 +671 + 328 = 2496 and that's the number my Aunt always guessed it before.

In this number game only rule is you can think of any number greater than 2 but if you give any number then user have to stick with that length of number so if its 7864 then all numbers will be equal to length 4.

Explanation

Now lets study more about strategy design pattern to implement this example.The Strategy pattern involves removing an algorithm from its host class and putting it in a separate class. There may be different algorithms (strategies) that are applicable for a given problem. If the algorithms are all kept in the host, messy code with lots of conditional statements will result. The Strategy pattern enables a client to choose which algorithm to use from a family of algorithms and gives it a simple way to access it. The algorithms can also be expressed independently of the data they are using.

in our example we have following classes as form UML Diagram

Strategy = IStrategy

Concrete = FinalAnswerGet,YourNumberGet

Context = Context

Client will be our Main class

The client does need to know about the general workings of the various IStrategy implementations and the workings of the algorithms inside the Context. The Context class doesn’t know about the different IStrategy implementations, and only knows the IStrategy interface. So in other words Context class won’t directly reference the IStrategy implementations and IStrategy implementations won’t directly reference the context class instance.

// The Context class
        class Context
        {
            //this could be any userNumber from User . But it Must be greater than 9
            public int userNumber = 5;
            // that would be the asnswer you can show it to user or friend
            public int FinalAnswer = 0;
            // that would be your calculated  userNumber against user userNumber  
            public int yourNumber = 0;
            // Strategy aggregation
            IStrategy strategy = new FinalAnswerGet();
            // Algorithm invokes a strategy method
            public int Algorithm()
            {
                return strategy.Play(this);
            }
            //// Changing strategies
            public void SwitchStrategy()
            {
                if (strategy is FinalAnswerGet)
                    strategy = new YourNumberGet();
                else
                    strategy = new FinalAnswerGet();
            }
        }
        // Strategy interface
        interface IStrategy
        {
            int Play(Context c);
        }
        // Strategy 1
        class FinalAnswerGet : IStrategy
        {
            public int Play(Context c)
            {
                return c.FinalAnswer = Convert.ToInt32(("2" + Convert.ToString(c.userNumber - 2)));
            }
        }
        // Strategy 2
        class YourNumberGet : IStrategy
        {
            public int Play(Context c)
            {
                //gets the length of userNumber
                int length = Convert.ToString(c.userNumber).Length;
                string numbeToMinus = string.Empty;
                for (int i = 0; i < length; i++)
                {
                    numbeToMinus = numbeToMinus + "9";
                }
                return c.yourNumber = Math.Abs(c.userNumber - Convert.ToInt32(numbeToMinus));
            }
        }
       
        static class Program
        {
            static void Main()
            {
                Context context = new Context();
                context.userNumber = 899;
                context.Algorithm();
                Console.WriteLine("User  enter number = {0} \t  my already guessed  final answer =  {1}", context.userNumber, context.FinalAnswer);
                context.userNumber = 245;
                Console.WriteLine("User  enter number  2nd time = {0} ", context.userNumber);
                context.SwitchStrategy();
                context.Algorithm();
                Console.WriteLine("Your   number   = {0} ", context.yourNumber);
                context.userNumber = 382;
                Console.WriteLine("User  enter number  3rd time = {0} ", context.userNumber);
                context.Algorithm();
                Console.WriteLine("Your   number   = {0} ", context.yourNumber);
                Console.WriteLine("{0} 899 + 245 + 754 + 382+ 617= 2897 AND OFCOURSE I  GUESSED THIS NUMBER BEFORE", Environment.NewLine);
            }
        }

And output is

Difference between Strategy Design Pattern and State Design Pattern.

Strategy pattern is similar to the State Design Pattern from an architectural point of view but the intent is entirely different.Unlike the State pattern, the Algorithm class doesn’t manage state, but represents an algorithm that uses one or more IStrategy implementations.The IStrategy implementation isn’t managed by the Algorithm class, but assigned by the client where as a state usually selects the next state of its context. A state tends to have lots of unrelated methods, so there is little cohesion between the methods of a state. For more detail please read my posting on State Design Pattern.

Your feedback is welcome

State Design Pattern

2009-07-22T12:05:00.003+01:00

codeproject

Introduction

In state design pattern, it can change its behaviour by switching to a set of different operations and we achieved this pattern from an object variable changing its subclass, within a hierarchy. Allow an object to alter its behaviour when its internal state changes. The object will appear to change its class.

Explanation

The State pattern has some Mediator design pattern aspects to it. To understand more about state design patterns lets look in more detail of an example has been mentioned by in many books and many blogs but i myself could not find its actual and true implementation of it which is Assume you have a sales order that can be in several different states, such as "NewOrder," "Registered," "Granted," "Shipped," "Invoiced," and "Cancelled." There are strict rules concerning to which states the order can "go," and from which states it can "come." In my example, for instance, the state's not allowed to go directly from Registered to Shipped. This example is from Applying Domain-Driven Design and Patterns: With Examples in C# and .NET [Addison-Wesley Professional, ISBN: 0321268202] by Jimmy Nilsson. However there was not any code implementation of it.

There are also differences in behaviour depending upon the states. For example, when order is dispatched, you can't call registered or approved or cancel order for adding more items to the order. Always remember that certain behaviour leads to state transformation. UML diagram of state design pattern is

UML Diagram

In our example

Context = OrderState, State = IOrderState , Concrete State = (NewOrder, Registered, Dispatched, Approved)

SO we have an interface called IOrderState which manages all the states of an order i have kept it to only 4 different state in my example as below

public interface IOrderState
        {
            void NewOrderPlaced();
            void Register();
            void Dispatch();
            void Approve();
        }

Then we have four concrete state classes which implements IOrderState interface which are NewOrder, Registered, Dispatched, Approved as given below

public class NewOrder : IOrderState
        {
            private readonly OrderState _Parent;
            public NewOrder(OrderState OrderState)
            {
                _Parent = OrderState;
                this.NewOrderPlaced();
           
            }
            public bool IsDispatched
            {
                get { return false; }
            }
            public void NewOrderPlaced()
            {
                Console.WriteLine("NewOrderPlaced");
            }
            public void Dispatch()
            {
                _Parent._CurrentState = new Dispatched(_Parent);
            }
            public void Register()
            {
                _Parent._CurrentState = new Registered(_Parent);
            }
            public void Approve()
            {
                _Parent._CurrentState = new Approved(_Parent);
            }
        }
        public class Registered : IOrderState
        {
            private readonly OrderState _Parent;
            public void NewOrderPlaced()
            {
                throw new Exception("OrderState has already been placed");
            }
            public Registered(OrderState OrderState)
            {
                _Parent = OrderState;
                this.Register();
            }
            public void Dispatch()
            {
                throw new Exception("OrderState has not been registered yet");
            }
            public void Register()
            {
                Console.WriteLine("Regisrered");
            }
            public void Approve()
            {
                _Parent._CurrentState = new Approved(_Parent);
            }
        }
        public class Approved : IOrderState
        {
            private readonly OrderState _Parent;
            public Approved(OrderState OrderState)
            {
                _Parent = OrderState;
                this.Approve();
            }
            public void NewOrderPlaced()
            {
                throw new Exception("OrderState has already bene placed");
            }
            public void Dispatch()
            {
                _Parent._CurrentState = new Dispatched(_Parent);
            }
            public void Register()
            {
                throw new Exception("OrderState has already been registered");
            }
            public void Approve()
            {
                Console.WriteLine("Approved");
            }
        }
        public class Dispatched : IOrderState
        {
            private readonly OrderState _Parent;
            public void NewOrderPlaced()
            {
                throw new Exception("OrderState has already bene placed");
            }
            public Dispatched(OrderState OrderState)
            {
                _Parent = OrderState;
                this.Dispatch();
            }
            public void Dispatch()
            {
                Console.WriteLine("dispatched");
            }
            public void Register()
            {
                throw new Exception("OrderState has already been registered");
            }
            public void Approve()
            {
                _Parent._CurrentState = new Approved(_Parent);
            }
        }

Then we have a, OrderState class which is a context class that manages all the states of a class as below

public class OrderState
        {
            public IOrderState _CurrentState;
            public OrderState()
            {
                _CurrentState = new NewOrder(this);
            }
            public void Dispatch()
            {
                _CurrentState.Dispatch();
            }
            public void Register()
            {
                _CurrentState.Register();
            }
            public void Approve()
            {
                _CurrentState.Approve();
            }
        }

to use it

static void Main(string[] args)
        {
            OrderState OrderState = new OrderState();
            OrderState.Register();
            OrderState.Approve();
            OrderState.Dispatch();
        }

and output is

Note:

Now the beauty of this pattern is once you have OrderState.Dispatch(); you cannot user OrderState.Register(); it will throw and exception that OrderState has already been registered. So it also removes so many if/else statement. because it switches to different class depending on its state.

Things to remember

Using state design pattern the program can potentially be flooded with small classes.
Each derived or small class has knowledge of (coupling to) its siblings, which introduces dependencies between subclasses.
The state pattern requires tight coupling between its classes.
State Design Pattern somehow solves your problem with the least amount of duplicated code and also the responsibility portioned out into encapsulated and cohesive unites, the concrete state classes
State has no state usually it selects the next state of its context. A state tends to have lots of unrelated methods, so there is little cohesion between the methods of a state.

Difference between Strategy Design Pattern and State Design Pattern.

Mediator design pattern

2009-07-14T16:24:00.001+01:00

Introduction

The Mediator pattern is there to enable objects to communicate without knowing each other’s identities.it promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

Explanation

Mediator design pattern deal with communication. Today there could be many ways of communication. Consider a Facebook group where so many people becomes fan and get the messages so people interested in that group can get messages by subscribing to it. Any messages that come in will go to all of the list’s subscribers. Members can remove themselves from the list at any time by going to their notification options or from their group preferences. So clearly the moderation process here is performing part of the role of the Mediator pattern is establishing a communication protocol and content filter. The other part keeping fan unaware of each other is inherently part of the mailing list.

FacebookGroupMediator is playing a role of mediator which has all the preferences or filters option of sign on, block or unblock etc.

Fan is a class who send and receives messages on that group or in any mailing list. And that class is associates his self to FacebookGroupMediator.

FanB is a class in a which does not get copies of own messages.

class FacebookGroupMediator
    {
        public delegate void Callback
            (string message, string from);
        Callback respond;
        public void SignOn(Callback method)
        {
            respond += method;
        }
        public void Block(Callback method)
        {
            respond -= method;
        }
        public void Unblock(Callback method)
        {
            respond += method;
        }
        // Send is implemented as a broadcast
        public void Send(string message, string from)
        {
            respond(message, from);
            Console.WriteLine();
        }
    }
    class Fan
    {
        FacebookGroupMediator mediator;
        protected string name;
        public Fan(FacebookGroupMediator mediator, 
            string name)
        {
            this.mediator = mediator;
            mediator.SignOn(Receive);
            this.name = name;
        }
        public virtual void Receive(string message, string from)
        {
            Console.WriteLine(name + " received from " 
                + from + ": " + message);
        }
        public void Send(string message)
        {
            Console.WriteLine("Send (From "
                + name + "): " + message);
            mediator.Send(message, name);
        }
    }
    class FanB : Fan
    {
        public FanB(FacebookGroupMediator mediator, string name)
            : base(mediator, name)
        {
        }
        // Does not get copies of own messages
        public override void Receive(string message, string from)
        {
            if (!String.Equals(from, name))
                Console.WriteLine(name + 
                    " received from " + from + ": " + message);
        }
    }
    static void Main()
    {
        FacebookGroupMediator m = 
            new FacebookGroupMediator();
        
        Fan fan1 = new Fan(m, "Fan 1");
        FanB fan2 = new FanB(m, "Fan 2");
        Fan fan3 = new Fan(m, "Fan 3");
        fan1.Send("i like this group");
        // this is the fan who does not want to get copy own messages
        fan2.Send("yes i also like this group");
        // fan 3 temp uncheck to get the messages
        m.Block(fan3.Receive); 
        fan1.Send("Do you agree that this is the best group");
        fan2.Send("Yes i Agree");
        m.Unblock(fan3.Receive); 
        // open again
        fan1.Send("Thanks all");
    }

and the output is

So when fan1 posts a message other fans receive the message.If a fan3 uncheck its receiving option then fan3 does get any updates regarding to messages.

Difference between Observer Design Pattern in C# and Mediator design pattern

In my previous article Observer Design Pattern in C# i have explained an example of blog and their subscribers. Mediator and Observer are very similar patterns. Mailing lists, chat rooms, groups and blogs etc all involve communication between individuals who actively sign up to the activity. The difference Mediator centralizes the communication between fans, class workers, colleagues, whereas the Observer distributes control of information by differentiating between subjects (publishers) and observers (subscribers). Mediator hides all activities that it implements, the user is better able to understand the system and the interactions that that the fan make.

The communication in the Mediator pattern is easier to understand. Fans send messages to a mediator and the transmission of the information further to whomever is currently in the group is handled there, where as In the Observer pattern do not send any information; they wait to receive it from subjects, who distributed it to all who have subscribed. An example is the blog. for further details visit at Observer Design Pattern in C# .

Reference:

http://www.dofactory.com/Patterns/PatternMediator.aspx
C# 3.0 Design Patterns Judith Bishop

Observer Design Pattern in C#

2009-07-10T14:02:00.001+01:00

Introduction

The Observer design pattern is a relationship between objects so that when one
changes its state, all the others are notified accordingly. In other words it defines that an object must be able to notify other objects without making assumptions about what these objects are.

Observer design pattern is quite useful when a change to one object requires changing others but, you don't know how many objects need to be changed.

Using Observer Design Pattern in Blog Subscriber Example.

In this example i have used two other behavioral patterns which are Iterator Design Pattern in C# and Facade Design Pattern in C#. The simplest way to understand observer pattern is to look at blogs, which are website where people write about different topics. Take a example of a one blog where so many users have subscribed themselves for any new post. As we all know bloggers don't always post regularly so it would be great for bloggers to alert his all subscribers whenever blogger post a new topic.

Blog is a class which deals with the new blog post and also with the blog subscribers.
BlogPost is a class which deals with the posting of new article.
Subscribers are the user who have subscribed themselves for alerts of new articles.
Facade deals them in simpler way and give you operations like PublishSinglePost() or PublishMultiPost() etc.
Subject class whose instances independently change their state and it notify to all the subscribers. Run method loops through all of the Subscribers calling their Update methods to notify them about post. Its also contains methods for attaching and detaching functions with event

Imagine using Iterator Design Pattern in C# we have a list of subscriber as follows.

     class Subscriber

      {

          public string Name { get; set; }

          public string Email { get; set; }

          public Subscriber(string name, string email)

          {

              this.Name = name;

              this.Email = email;

          }

      }

      class BlogSubscribers : IEnumerable

      {

          Subscriber[] Arrays = { new Subscriber("user1", "firstEmail@gmail.com"), new Subscriber("user2", "2ndEmail@gmail.com") };

          public IEnumerator GetEnumerator()

          {

              foreach (Subscriber element in Arrays)

                  yield return element;

          }

      }

For more detail related to above code and Iterator design pattern read my article on Iterator Design Pattern in C#.

Subject class whose instances independently change their state and it notify to all the subscribers. It defines a Dictionary object to store the subscribers name and their callback functions.

    public delegate void Callback(String subscriber);

       class Subject

       {

           //Declaring delegate 

           Dictionary<string, Callback> Notify = new Dictionary<string, Callback>();

           //Declaring Event 

           // List of Users as IEnumerable

           BlogSubscribers blogSubscribers = new BlogSubscribers();

           /// <summary>

           /// Attaching the events

           /// </summary>

           /// <param name="subscriber">its the name of user or email address</param>

           /// <param name="Update">A method to attach </param>

           public void Attach(string subscriber, Callback Update)

           {

               if (!Notify.ContainsKey(subscriber))

               {

                   Notify[subscriber] = delegate { };

               }

               Notify[subscriber] += Update;

           }

           /// <summary>

           /// To Detach method for specific user

           /// </summary>

           /// <param name="subscriber">its the name of user or email address</param>

           /// <param name="Update">A method to attach</param>

           public void Detach(string subscriber, Callback Update)

           {

               Notify[subscriber] -= Update;

           }

           /// <summary>

           /// Loop through all users to notify for anychange

           /// </summary>

           public void Run()

           {

               foreach (Subscriber subscriber in blogSubscribers)

               {

                   string message = string.Format(" To {0}<{1}> ", subscriber.Name, subscriber.Email);

                   Notify[subscriber.Name](message);

               }

           }

       }

An interface for IObserver specifying how they should be updated. A BlogSpot for posting new articles and an observers as a BlogObserver

    interface IObserver

        {

            void Update(string message);

        }

        class BlogPost

        {

            public string PostName { get; set; }

        }

        class BlogObserver : IObserver

        {

            //name of the posting

            // Implmenting through IOC Inversion of control 

            Subject subject;

            List<BlogPost> ListOfBlogNewPosts = new List<BlogPost>();

            public BlogObserver(Subject subject)

            {

                this.subject = subject;

                subject.Attach("user1", Update);

                subject.Attach("user2", Update);

            }

            public void AddPost(BlogPost blogPost)

            {

                ListOfBlogNewPosts.Add(blogPost);

            }

            public void Update(string message)

            {

                foreach (BlogPost blogPost in ListOfBlogNewPosts)

                {

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

                    Console.WriteLine(" {0} for Post {1}", message, blogPost.PostName);

                    Console.WriteLine();

                }

            }

            public void DetachFromPost(string subscriber)

            {

                subject.Detach(subscriber, Update);

            }

        }

I have used Facade Design Pattern in C# to make an easy interface for these different sub systems.

    public class BlogFacade

        {

            public static void PublishMultiPost()

            {

                Subject subject = new Subject();

                BlogPost Ps3 = new BlogPost();

                Ps3.PostName = "PS3";

                BlogPost Xbox = new BlogPost();

                Xbox.PostName = "Xbox";

                BlogObserver salmanBlog = new BlogObserver(subject);

                salmanBlog.AddPost(Ps3);

                salmanBlog.AddPost(Xbox);

                //lets try to detach users2 from the subscriber list  for posting xbox

                //salmanBlog.DetachFromPost("user2");

                subject.Run();

            }

            public static void PublishSinglePost()

            {

                Subject subject = new Subject();

                BlogPost Xbox = new BlogPost();

                Xbox.PostName = "Xbox";

                BlogObserver salmanBlog = new BlogObserver(subject);

                salmanBlog.AddPost(Xbox);

                subject.Run();

            }

        }

For more detail regarding facade pattern visit Facade Design Pattern in C#.

    static void Main()

      {

          //BlogFacade.PublishSinglePost();

          BlogFacade.PublishMultiPost();

      }

OUTPUT

So if you run facade operation BlogFacade.PublishMultiPost(); by commenting //salmanBlog.DetachFromPost("user2"); then output will be

and if you uncomment this salmanBlog.DetachFromPost("user2"); and run BlogFacade.PublishMultiPost(); the out put will be

because we have unsubscribed user2 from the list. So that is our blog on Observer pattern if for any new post or change in post all the others are notified accordingly.

Your feedback is welcome.
download code here.

Facade Design Pattern in C#

2009-07-10T11:58:00.000+01:00

What is Facade Design Pattern?

Facade defines a higher-level interface that makes the subsystem easier to use. Facade is one of the common and easiest patterns. It wrap a complicated subsystem with a simpler interface. As a developer we often use this facade pattern. Even some of them don't recognise while using it that its a facade patterns. I have tried to explain facade pattern by building a blog system.

When to use it?

Facade design patterns gives easier interface for common task. It provides simplified and uniform interface to a large subsystem of classes. For example in a shopping cart system there could be many API’s related to register user, purchase,user detail, transactions etc so facade deals with all these interfaces and provide one simple modified interface to deals with them.

A more simple non-software example can be if you want to play a game suppose Metal gear Solid on PS3 (Did i tell you that i love that game?). You Require PS3, HD TV, Controller etc. So there are so many sub system could be involve if you want to play a game on ps3. But actually all you are doing in simpler term is playing a game. So facade can give you a simple interface with a operation call PlayGame() in this example.The Facade object should be a fairly simple advocate or facilitator. If the Facade is the only access point for the subsystem, it will limit the features and flexibility that “power users” may need.

Using Facade in Blog Example

Consider another example of a Library. Where people borrow and returns books.

UML Diagram

In our example we have
Facade :Facade
Subsystem classes : Book ,Shelf , Person

class program
    {
        internal class Book
        {
            internal string FindBook()
            {
                return "Subsystem for Book, Method FindBook\n";
            }
            internal string Returned()
            {
                return "Subsystem for Book, Method Returned\n";
            }
        }
        internal class Shelf
        {
            internal string AssignBook()
            {
                return "Subsystem for Shelf, Method AssignBook\n";
            }
            internal string PlaceBook()
            {
                return "Subsystem for Shelf, Method PlaceBook\n";
            }
        }
        internal class Person
        {
            internal string Return()
            {
                return "Subsystem For  Person, Method Return\n";
            }
            internal string Borrow()
            {
                return "Subsystem For  Person, Method Borrow\n";
            }
        }
        public static class Facade
        {
            static Book book = new Book();
            static Shelf shelf = new Shelf();
            static Person person = new Person();
            public static void ReturnBook()
            {
                Console.WriteLine("ReturnBook 1\n" +
                person.Return() +
                shelf.PlaceBook()+
                book.Returned());
            }
            public static void BorrowBook()
            {
                Console.WriteLine("BorrowBook 1\n" +
               book.FindBook() +
                person.Borrow()                 
                );
            }
        }
        static void Main()
        {
            Facade.BorrowBook();
            Facade.ReturnBook();
        }
    }

Output

Above was very simple demonstration of using a facade design pattern. The role of above example was to provide an easier interface for different high-level views of subsystems whose details are hidden from users.Everything in the façade has to be public so that the Client, which is compiled into a different assembly, can access it. In library example we have different subsystems and using facade we give very simple interface to client.

Your feedback is welcome.

Iterator Design Pattern in C#

2009-07-09T15:52:00.001+01:00

Introduction

The Iterator pattern provides a way of accessing elements of a collection sequentially,
without exposing its underlying representation. An Iterator object encapsulates the internal structure of how the iteration occurs.

Explanation

The Iterator design pattern is useful because it provides a defined way to move thought a set of elements without exposing what is taking place inside a class. Enumerators are responsible for producing the next element in a sequence defined by certain criteria. Such a sequence is said to be enumerable.

Example of Blog Subscribers

Consider an example of a blog where users subscribes themselves to get alerts for newer post. We can use iterator pattern in this example because all we want to returns the list of emails of subscribers without really know its its underlying representation.

Suppose we have a class called Subscriber which takes name and email address to subscribe for new posts for blog.

    class Subscriber
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public Subscriber(string name, string email)
        {
            this.Name = name;
            this.Email = email;
        }
    }

Then we have a class Blog Subscribers which fetch the list of email addresses from database however i have used an array of blog subscribers in this example

   class BlogSubscribers : IEnumerable
    {
        Subscriber[] Arrays = { new Subscriber("user1", "firstEmail@gmail.com"), new Subscriber("user2", "2ndEmail@gmail.com") };
        public IEnumerator GetEnumerator()
        {
            foreach (Subscriber element in Arrays)
                yield return element;
        }
    }

You may have noticed that BlogSubscribers is an IEnumerable. IEnumerable is an interface that has one method, GetEnumerator. Classes that implement IEnumerable supply a GetEnumerator method that successively returns a value from a collection using yield return. Each time GetEnumerator is invoked, control picks up after the yield return statement.

  static void Main()
    {
        BlogSubscribers collectionOfBlogSubscribers = new BlogSubscribers();
        // Consumes values generated from collectionOfBlogSubscribers's GetEnumerator method
        foreach (Subscriber subscriber in collectionOfBlogSubscribers)
        {
            Console.Write("To {0}<{1}>", subscriber.Name, subscriber.Email);
            Console.WriteLine("\n");
        }
    }

How does it Work?

The BlogSubscribers.GetEnumerator method encounters a yield statement and returns the value of first subscriber. But before returning from the method, a bookmark is made to where execution returned control.In the foreach loop, the .NET runtime assigns the value to subscriber object. The loop executes and calls the method Console.WriteLine. Then a new loop is started, and the bookmark in the GetEnumerator method is the starting
point of the next execution.Then another yield statement is encountered, and the value of 2nd subscriber is returned. Another foreach loop occurs, and this bookmarking and looping occurs until there are no more yields.

Now you may argue and wonder why we simply did not loop through the Arrays of subscribers The reason is that subscribers is declared not in the Client, but in its own collection class. Even without the benefits gained from separating iteration and enumeration, it would be bad style for the Client to subscribers directly.

Singleton Design Pattern in Asp.net using C#

2009-07-06T15:43:00.002+01:00

Introduction

When we want to make a only one instance of a class and also making sure that there is a global access point to that object then the design pattern we user is called Singleton. The pattern ensures that the class is instantiated only once and that all requests are directed to that one and only object.

Usage

In asp.net you can use singleton through sessions or application variables easily however i will show you how to implement singleton object to User class.

Problem

In Asp.net to get user information like first name, surname or username through Memebership object does not look neat because to get UserID first you need to know user User.Identity.Name then use Membership.GetUser in order to get more detail for user.

Solution

I have created a interface called IUser which you can use anywhere on the page.

public interface IUser

          string Email { get; set; }

          string Firstname { get; set; }

          string Surname { get; set; }

          string UserID { get; set; }

          string Username { get; set; }

Here is our Singleton class implementing IUser.

public sealed class Singleton
      {
          private const string IUserSessionName = "User";
          private static readonly object padlock = new object();
          private static IUser objUser ;
          Singleton()
          {

          }
          /// 
          /// Loading user information
          /// 
          public static IUser IUserInstance
          {
              get
              {
                  lock (padlock)
                  {
                                            
                         if (null == Session[IUserSessionName])
                         {
                         
                          string userID = Membership.GetUser().ProviderUserKey.ToString();
                          // getting userinformation from database
                          objUser = new UserClass().GetUserInformation(userID);
                          Session[IUserSessionName] = objUser;
                         }
                         else
                         {
                         objUser = (IUser)Current.Session[IUserSessionName];
                         }
                    
         
                     return objUser;
                 }
              }
              set
              {
                  Session[IUserSessionName] = value;
              }
          }
        
          public static void UserInstanceFlush()
          {
              Session[IUserSessionName] = null;
          }

      }

Because of IuserSessionName you are also making sure that you will keep this session name unique and at only one place.

IUser is a static property which can be used on any page from Singleton.IUserInstance.UserID.

UserInstanceFlush flushes the session if you want to remove the session value.

Note: People may argue its not a pure Singleton object example because its one instance of object per user and i agree with all of them its a one instance of object per user when they get authenticated throughout for all pages in application and give you extra user properties through the interface IUser.

your feed is welcome.

Adapter Design Pattern How to use in Asp.net using C#

2009-07-01T16:52:00.002+01:00

What is Adapter Pattern?

The Adapter pattern is a structural design pattern which enables a system to use classes whose interfaces don’t quite match its requirements or in other words is used to make a interface which client understands.

When to use it?

Its quite useful when dealing with the legacy code specially that was written a while ago and to which one might not have access.
It is especially useful for off-the-shelf code, for toolkits, for libraries or any third party software's

Lots of us uses the enterprise library data access application block. Suppose later if we find that some other third party data access application block is better than micorsoft data access application block then in the project would not change just adapter internally would call the new data access application block.

Object adapter pattern

In Object adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object.

       // Existing class.. this may be your legacy code or third party code

          class Adaptee

          {

              // validates the email

              public bool IsEmail(string email)

              {

                  return System.Text.RegularExpressions.Regex.IsMatch(email, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");

              }

          }

          // Required standard  implementing through interface

          interface ITarget

          {

              // Rough estimate required

              bool ValidateEmail(string email);

          }

          // Implementing the required standard via Adaptee

          class Adapter : Adaptee, ITarget

          {

              public bool ValidateEmail(string email)

              {

                  return IsEmail(email);

              }

          }

          class Client

          {

              static void Main()

              {

                  // Showing the Adapteee in standalone mode

                  Adaptee first = new Adaptee();

                  Console.Write("Before the new standard: ");

                  Console.WriteLine(first.IsEmail("anyemail@gmail.com"));

                  // What the client really wants

                  ITarget second = new Adapter();

                  Console.WriteLine("\nMoving to the new standard");

                  Console.WriteLine(second.ValidateEmail("anyemail@gmail.com"));

              }

          }

ITarget
The interface that the Client wants to use
Adaptee
An implementation that needs adapting
Adapter The class that implements the ITarget interface in terms of the Adaptee
ValidateEmail
An operation that the Client wants
IsEmail
The implementation of Request’s functionality in the Adaptee

Note :

The adapter pattern is also useful in where an already existing class provides some or all of the services you need but does not use the interface you need. Also using this way you can change third-party library easily without effecting your project . In above example if you want to change the validation method of email all you need to do is to use ValidateEmail function for any new method or third party library functions.

Your feedback is welcome.

Asp.net date picker control part 2

2009-06-29T16:59:00.004+01:00

codeproject

download code here

Introduction

In my previous post How to: Create a Date Picker Composite Control in ASP.NET (C#). I explained how to work with asp.net composite control to create a date picker control for asp.net.

Problem

However to use that control you still require JavaScript, style and images to include on.

Solution

In this post i will explain you how i have embedded javascript , images and style sheet to my previous article . How to: Create a Date Picker Composite Control in ASP.NET (C#). Also i have added another property to control which is how to change date format for the control. You can download the code , drag and drop it and start using it inside data navigation controls or anywhere in your asp.net web application.

Property

DateFormat By defaults its been set to "%d/%m/%Y" which is DMY.

How to embed ?

I added to the project images, java scripts, and styles that I need for my date picker control.Click on each file properties and change Build Action from Content to Embedded Resource, then modify the AssemblyInfo.cs as below

[assembly: System.Web.UI.WebResource("DatePicker.Resources.calendarview.css", "text/css")]
[assembly: System.Web.UI.WebResource("DatePicker.Resources.calendarview.js", "text/js")]
[assembly: System.Web.UI.WebResource("DatePicker.Resources.CalendarIcon.gif", "img/gif")]
[assembly: System.Web.UI.WebResource("DatePicker.Resources.prototype.js", "text/js")]

Note: the format of embedded resources is very important which is

[Assembly Name].[Folder].[File Name]

To embed JavaScript

To embed JavaScript i have created a function called AddJavaScript(string javaScriptFile) which is

private void AddJavaScript(string javaScriptFile)
    {
        string scriptLocation = Page.ClientScript.GetWebResourceUrl(this.GetType(),javaScriptFile );
        Page.ClientScript.RegisterClientScriptInclude(javaScriptFile, scriptLocation);

    }

To embed Style Sheet

private void AddStyleSheet()
     {
         string includeTemplate = "<link rel='stylesheet' text='text/css' href='{0}' />";
         string includeLocation =
               Page.ClientScript.GetWebResourceUrl(this.GetType(), "DatePicker.Resources.calendarview.css");
         LiteralControl include = new LiteralControl(String.Format(includeTemplate, includeLocation));
         Page.Header.Controls.Add(include);
     }

To embed Image

just add following line inside OnInit function

_ImgDate.ImageUrl = Page.ClientScript.GetWebResourceUrl(this.GetType(), "DatePicker.Resources.CalendarIcon.gif");

add these functions indise OnInit function

AddStyleSheet();
AddJavaScript("DatePicker.Resources.prototype.js");
AddJavaScript("DatePicker.Resources.calendarview.js");

and that is our date picker control is ready to use you can drag and drop on any page and start using it.

Your feedback is welcome.

download code here

The Scrum Management ( A practical example )

2009-06-28T13:46:00.006+01:00

codeproject

Introduction

As a brief introduction, Scrum is an agile process for software development. With Scrum, projects progress via a series of iterations called sprints. Each sprint is typically 2-4 weeks long. Scrum is ideally suited for projects with rapidly changing or highly emergent requirements. As i have found it ideal for in-house development. Though its equally recommended for third party clients because of rapid change of requirments.

Introduction to Terms

Scrum team	Scrum team consists of product owner, scrum master, developers or anyone who is related to project.
Product Owner	In ideal situation a product owner is your stakeholder or any representative from client. However as in our sprint planning most often we don't find them present for meetings so thats part goes to Project Manager for us. Again product owner could be anyone who is concerning to your project the most :)
Scrum master	Scrum master could be your team lead or again project manager if you luckily find product stake holder resent in the meeting. Scrum master deals with the burn down charts, daily scrum meeting and sprint planning etc.
Product backlog	The product backlog is a prioritized features list containing every desired feature or change to the product.
Sprint Planning	Sprint planning is a meeting ideally not more than 4 hours. But i have seen some people take it to long and waste their whole day. In sprint plan developers, designers , scurm master , products owner or anyone who is concerning to project or to those task are present.

A practical example : How we do sprint planning ?

Lets suppose we have one Project Manager as a product owner ( In most cases we don't find stakeholders, customers present all time ) then a scrum master (can be your team lead) then We have a team of 2 developer, 1 designer and 1 database admin.

Note i am using developer1 as a scrum master. as show in the figure below

Story Points

Lets suppose we have discussed in our sprint plan total six tasks. A story point can also be represent as a day but a story point is actually amount of time you can put to work on any specific story or task.

in other words we have total

5 + 3 + 7+ 1+ 3 + 6 = 25 points

Man days

You can always do from 2-4 week sprints , however i prefer 2 weeks of sprint planning. imagine in 2 weeks of sprint plan each member has 14 man days. But we always ask in sprint plan i any of our team member has booked their annual leaves .Lets suppose devlioper1 has booked 3 annual leaves,developer2 booked 4 annual leaves, designer booked 2 annual leaves where database admin no annual leaves booked. in this case we have

Team member for 2 weeks sprint (14 days)	Man days
Developer1	11
Developer2	10
Designer	12
Database Admin	14
Total Days	47

In this we have total man days = 51

Focus factor

Now lets suppose we have focus factor is 50%

Focus factor is basically the amount time of we can give to our stories (tasks) in our next 2 weeks of sprint. We use a "focus factor" to help account for all the interruptions we will invariably have. When we plan a sprint, we multiply the ideal man hours available in the sprint (40 hours * 2 weeks * x developers) by a percentage such as 0.8. That calculation tells us how many hours worth of product backlog items we can commit to for the sprint.

Estimated velocity

( Available man days * Focus factor = Estimated velocity )

in our case we have

47 * 0.50 (50%) = 23 story points

So our estimated velocity for the upcoming sprint is 23 story points. that's means the team should add stories to the sprint until it adds up to approximately 23. in this case we will remove our task 5 which can be less important and may not fit in this scrum and we will move it to our product backlog.

Scrum board

and that is how our scrum board will look like.

Not Checked Out	Checked Out	Done

i will update my post regarding to burn down chart and daily scrum meeting in my next post

References

• http://agilemanifesto.org/ • http://www.mountaingoatsoftware.com/scrum • http://www.xprogramming.com/xpmag/whatisxp.htm

How to: Create a Date Picker Composite Control in ASP.NET (C#)

2009-06-26T13:04:00.002+01:00

codeproject

download code here

Introduction

Composite controls are controls that combine multiple controls together to form a new reusable control. For example, a simple composite control could consist of both a Label control and a TextBox control. This example, however, puts one TextBox with an Image control together to allow a user to pick a date. The Calendar widget is a JavaScript-based calendar using prototype that can either be embedded within a page or popup when a trigger element is clicked. It is based very loosely on the Dynarch Calendar, only in the sense that it was used as a base, but has been almost entirely re-implemented. You can read more about this JavaScript-based calendar to here http://calendarview.org/ . What I have done here is used this JavaScript-based calendar inside a web composite control combined with a image in order to make it work like a true date picker control for asp.net.

Problem

it’s not very simple to use JavaScript control inside a repeater, datalist or gridview because repeater uses .net prefix with them. Because they don't expose commandName and commandArgument properties for calendar control.

Solution

I will extend this control with properties of CommandName and CommandArgument to use it easily inside data navigation controls.

Here we go guys I have combined image control with the textbox control with JavaScript based control http://calendarview.org/ to make it work perfect for an asp.net date picker control.

How to Do it?.

it’s very simple and I will guide you step by step how to make a perfect asp.net date picker control.

Things you need?

Prototype Library

http://calendarview.org/ (JavaScript and CSS files only.)

Here We Go

Using visual Studio 2008 click on file then New then choose Project. Under web menu choose ASP.NET Server Control and name the project DatePicker.

Now we will change this control inheritance form WebControl to a CompositeControl. We will rename the toolboxdata and also will give the name to control with a default prefix showing as below

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.Web Controls;

[assembly: TagPrefix("DatePicker", "SQ")]
namespace DatePicker
{
 [DefaultProperty("Text")]
 [ToolboxData("<{0}:DatePicker runat=server></{0}:DatePicker>")]
 public class DatePicker : CompositeControl
 {

Note: Instead of asp tag prefix i have used SQ (Salman Qayyum :)Now we will add asp TextBox,Image and properties.

Properties

ImageUrl : URL for image. AutoPostBack: To set AutoPostBack true or false. Value: To access the value of date picker e.g datepicker. ImageCssClass: To style the image. TextBoxCssClass: To Style the textbox .

//To retrieve value i am using textbox
     private TextBox _TxtDate = new TextBox();
     // Image to select the calendar date
     private Image _ImgDate = new Image();
     // Image URL to expose the image URL Property
     private string _ImageUrl;
     // Exposing autopostback property 
     private bool _AutoPostBack;
     // property get the value from datepicker.
     private string _Value;
     //CSS class to design the Image
     private string _ImageCssClass;
     //CSS class to design the TextBox
     private string _TextBoxCssClass;

     /**** properties***/

     [Bindable(true), Category("Appearance"), DefaultValue("")]
     public string ImageUrl
     {
         set
         {
             this._ImageUrl = value;
         }
     }

     [Bindable(true), Category("Appearance"), DefaultValue(""), Localizable(true)]
     public string Text
     {
         get
         {
             String s = (String)ViewState["Text"];
             return ((s == null) ? string.Empty : s);
         }

         set
         {
             ViewState["Text"] = value;
         }
     }

     [Bindable(true), Category("Appearance"), DefaultValue(""), Localizable(true)]
     public string Value
     {
         get
         {

             return _Value = _TxtDate.Text;
         }

         set
         {
             _Value = _TxtDate.Text = value;
         }
     }
     [Bindable(true), Category("Appearance"), DefaultValue(""), Localizable(true)]
     public bool AutoPostBack
     {
         get
         {
             return _AutoPostBack;
         }

         set
         {
             _AutoPostBack = value;
         }
     }
     [Bindable(true), Category("Appearance"), DefaultValue(""), Localizable(true)]
     public string ImageCssClass
     {
         get
         {
             return _ImageCssClass;
         }

         set
         {
             _ImageCssClass = value;
         }
     }

     [Bindable(true), Category("Appearance"), DefaultValue(""), Localizable(true)]
     public string TextBoxCssClass
     {
         get
         {
             return _TextBoxCssClass;
         }

         set
         {
             _TextBoxCssClass = value;
         }
     }

     [Bindable(true), Category("Custom"), DefaultValue(""), Localizable(true)]
     public string CommandName
     {
         get
         {
             string s = ViewState["CommandName"] as string;
             return s == null ? String.Empty : s;
         }
         set
         {
             ViewState["CommandName"] = value;
         }
     }

     [Bindable(true), Category("Custom"), DefaultValue(""), Localizable(true)]
     public string CommandArgument
     {
         get
         {
             string s = ViewState["CommandArgument"] as string;
             return s == null ? String.Empty : s;
         }
         set
         {
             ViewState["CommandArgument"] = value;
         }
     }

Above I have also added CommandName and CommandArgument property to make this date picker work inside data navigation controls.

Generating Bubble Event

Event bubbling enables events to be raised from a more convenient location in the controls hierarchy and allows event handlers to be attached to the original control as well as to the control that exposes the bubbled event. Event bubbling is used by the data-bound controls to expose command events raised by child controls (within item templates) as top-level events. While ASP.NET server controls in the .NET Framework use event bubbling for command events (events whose event data class derives from CommandEventArgs), any event defined on a server control can be bubbled.

protected static readonly object EventCommandObj = new object();

     public event CommandEventHandler Command
     {
         add
         {
             Events.AddHandler(EventCommandObj, value);
         }
         remove
         {
             Events.RemoveHandler(EventCommandObj, value);
         }
     }
     //this will raise the bubble event
     protected virtual void OnCommand(CommandEventArgs commandEventArgs)
     {
         CommandEventHandler eventHandler = (CommandEventHandler)Events[EventCommandObj];
         if (eventHandler != null)
         {
             eventHandler(this, commandEventArgs);
         }
         base.RaiseBubbleEvent(this, commandEventArgs);
     }
     //this will be initialized to  OnTextChanged event on the normal textbox
     private void OnTextChanged(object sender, EventArgs e)
     {
         if (this.AutoPostBack)
         {
             //pass the event arguments to the OnCommand event to bubble up
             CommandEventArgs args = new CommandEventArgs(this.CommandName, this.CommandArgument);
             OnCommand(args);
         }
     }

We will raise this bubble event with texbox.OnTextChanged using OnInit function as below.

Note: Always create dynamic controls inside OnInit function because viewstate reloads after OnInit and before the Load event. So if you want to keep the viewstate on postback then the best place to keep the code is inside OnInit

protected override void OnInit(EventArgs e)
     {
         //AddStyleSheet();
         //AddJavaScript();
         base.OnInit(e);

         // For TextBox
         // setting name for textbox. using t just to concat with this.ID for unqiueName
         _TxtDate.ID = this.ID + "t";
         // setting postback
         _TxtDate.AutoPostBack = this.AutoPostBack;
         // giving the textbox default value for date
         _TxtDate.Text = this.Value;
         //Initializing the TextChanged with our custom event to raise bubble event
         _TxtDate.TextChanged += new System.EventHandler(this.OnTextChanged);
         //Setting textbox to readonly to make sure user dont play with the textbox
         _TxtDate.Attributes.Add("readonly", "readonly");
         // adding stylesheet 
         _TxtDate.Attributes.Add("class", this.TextBoxCssClass);

         // For Image
         // setting alternative name for image
         _ImgDate.AlternateText = "imageURL";
         if (!string.IsNullOrEmpty(_ImageUrl))
             _ImgDate.ImageUrl = _ImageUrl;
      
         //setting name for image
         _ImgDate.ID = this.ID + "i";
         //setting image class for textbox
         _ImgDate.Attributes.Add("class", this.ImageCssClass);
     }

Now we will add and render controls

/// <summary>
    /// adding child controls to composite control
    /// </summary>
    protected override void CreateChildControls()
    {
        this.Controls.Add(_TxtDate);
        this.Controls.Add(_ImgDate);
        base.CreateChildControls();
    }

    public override void RenderControl(HtmlTextWriter writer)
    {
        // render textbox and image
        _TxtDate.RenderControl(writer);
        _ImgDate.RenderControl(writer);
        RenderContents(writer);
    }

Replace or add your RenderContents function with

/// <summary>
    /// Adding the javascript to render the content 
    /// </summary>
    /// <param name="output"></param>
    protected override void RenderContents(HtmlTextWriter output)
    {
        StringBuilder calnder = new StringBuilder();
        //adding javascript first
        calnder.AppendFormat(@"<script type='text/javascript'>
                                 document.observe('dom:loaded', function() {{
                                    Calendar.setup({{
                                    dateField: '{0}',
                                    triggerElement: '{1}',
                                    dateFormat: '%d/%m/%Y'
                                 }})
                                }});
                          ", _TxtDate.ClientID, _ImgDate.ClientID);
        calnder.Append("</script>");
        output.Write(calnder.ToString());
    }

Above code is JavaScript code to make the calendar control to work using prototype. For more help kindly visit http://calendarview.org/.

We are almost there now

Now to test this file chose solution file add new website and name it DatePickerTest. Click on view from top menu and chose Toolbox if it’s not already opened. on toolbox click right button of mouse and chose items then click browse and navigate to datepicker project under bin directory add DatePicker.dll and click OK. DatePicker has seen added to your design view.

Drag and drop and on your page and start using it :)

<SQ:DatePicker ID="DatePicker1" runat="server"  ImageUrl="Javascript/CalendarIcon.gif" />

Adding JavaScript

<head id="Head1" runat="server">

 <script src="Javascript/prototype.js" type="text/javascript"></script>
 <script src="Javascript/calendarview.js" type="text/javascript"></script>
 <link href="Javascript/calendarview.css" rel="stylesheet" type="text/css" />
 <title></title>
</head>

To retrieve value useResponse.Write(DatePicker1.Value);

Inside repeater

<asp:Repeater ID="Repeater1" runat="server"  DataSourceID="SqlDataSource1"
    onitemcommand="Repeater1_ItemCommand">
    <ItemTemplate>
    <SQ:DatePicker ID="DatePicker2" runat="server" CommandName="Clicked" AutoPostBack="true" ImageUrl="Javascript/CalendarIcon.gif"  />
     <%# Eval("ProductName")%><br />
    </ItemTemplate>
</asp:Repeater>

Using ItemCommand event

protected void Repeater1_ItemCommand(object source, RepeaterCommandEventArgs e)
 {
     DatePicker.DatePicker dtp = (DatePicker.DatePicker)e.Item.FindControl("DatePicker2");
     if (e.CommandName == "Clicked")
     {
         Response.Write(dtp.Value);
     }
 }

Don’t forget to see my next posting in weeks time how to work with Scrum Management and DSDM (Dynamic Systems Development Method) and how to implement them in real time scenarios with development.

Your feedback is welcome.

Don't forget to see its updated version on my blog Asp.net date picker control part 2.