Monday, July 28, 2008

Command Pattern


This pattern is a behavioural pattern. Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
If you look at the Class diagram you see that client set the receiver for ConcreteCommand. Invoker has a list of commands and translates which command should be executed based on condition. (Do not worry about the class diagram we get back to that in a sample). There are different variation for this pattern for example sometimes there are no receiver.
The Command Pattern encapsulates a single function free of any variables. "It elevates the role of a function to the level of a class" Robert C Martin.

When to use this pattern?
When you need to change a method to a class then you can have a group of function in shape of unique class. You can use this pattern to create Undo and Redo functions. You can use this pattern to decouple two behaviours that are highly coupled like validating and doing behaviour. You can use this pattern to route requests, execute actions or forward actions in a uniform way.
In this post I am going to give you a sample of this pattern in real world also in next post I will show you an example of Undo, Redo using Command Pattern.

A real world Sample
I was assigned a task to implement a part of application. In that application users after selecting product and filling different information at final step had to select the payment method which was Credit Card and Ezi pay. The issue was that this application had many users so this part had to be implemented highly scalable and maintainable. I decided to use Command so users request from UI was changed to objects of requests. Because I was dealing with objects I could use message queuing also I could move this part to another server that do this so in that server the invoker did not have any idea about what sort of request are coming. A command was loaded and the execute method was called. I simplified the code and put it in one application to show you how amazing this pattern is. I made the UI very simple (just providing account number) however in real world it is more complex and each of these payments has its own attributes. Also you can check how many commands are in the queue. You can click on submit multiple times then by checking command numbers you see that there are some command in the queue that should be run. I used a queue list however in real world there are better way to implement. Let’s check the code:

UICode:

protected void butSubmitEzipay_Click(object sender, EventArgs e)

{

EziPayCommand cmd = new EziPayCommand(txtAccountNum.Text);

Invoker.Instance.AddCommand(cmd);

}

protected void butSubmitCredit_Click(object sender, EventArgs e)

{

CreditCardCommand cmd = new CreditCardCommand(txtCreditCardNum.Text);

Invoker.Instance.AddCommand(cmd);

}

protected void butCheck_Click(object sender, EventArgs e)

{

lblComandCount.Text = Invoker.Instance.GetNumberofCommandRunning().ToString();

}


As you see for each submit button I am adding the correct command into Invoker object (a singleton object. Just in my case I decide to use Invoker as singleton the pattern do not suggest this however here I needed just one object to control all the request for command by adding commands in a queue and running them one by one)


Invoker Class:

public class Invoker

{

private static Invoker m_Instance;

private bool InProgress=false;

public static Invoker Instance

{

get

{

if (m_Instance == null)

m_Instance = new Invoker();

return Invoker.m_Instance;

}

}

Queue<ICommand> commandList = new Queue<ICommand>();

public void AddCommand(ICommand cmd)

{

lock (this)

{

commandList.Enqueue(cmd);

}

CheckForExecution();

}

//for testing

public int GetNumberofCommandRunning()

{

return commandList.Count;

}

private void CheckForExecution()

{

if (!InProgress && commandList.Count > 0)

{

ThreadStart ts = new ThreadStart(ExecuteCommand);

Thread t = new Thread(ts);

t.Start();

}

}

private void ExecuteCommand()

{

InProgress = true;

while (commandList.Count > 0)

{

lock (this)

{

ICommand cmd = commandList.Dequeue();

}

cmd.Execute();

}

InProgress = false;

}

}


As you see I used singleton pattern here to have just one Invoker object controlling all the command execution. Invoker puts all the requests in a queue and run them one by one. When a command is added to the queue we check wether execution has been started if it is not started by creating new thread we start the process in a separate thread. In the execution process, a command is loaded and it will be run. As you see In Invoker we do not care about type of Command and Invoker itself has no idea which type of command it is running.

Sunday, July 20, 2008

Design Patterns

A Design pattern is a general reusable solution to a commonly occurring problem in software design. Each pattern has an intention that try to solve a common problem. You need to know the intention of each pattern also the problem they solve then if you come up with that issue you need to apply that pattern to solve the problem. I have seen so many programmers have no idea about design pattern if you are part of those people I should say you are not classified as senior programmer. I believe a senior programmer need to know these patterns. I could find a big gap in terms of design patterns knowledge between Java programmers and C# programmers. Java programmers know design patterns very well however; C# programmers hardly know them and use them. I had a lot of co-workers writing horrible codes just because they do not know how to solve a common problem. I wish I had a chance to convince them apart from technologies like ASP.NET, WCF, WF, and etc you need much more deep understanding about coding and design patterns otherwise you may know amazing technology but you do not have enough capacity to use them correctly!

This is why I decided to start writing about design patterns and give you some idea about them and also share my experiences over some of these patterns.

I hope you can find this useful. Please follow my post about design patterns and help me to correct myself also share your experiences with me.

A sample of Multi Thread programming in Asp.net

Download The Source Code

Please See the clip

Understanding the issue

I was assigned to implement a part of web application that was responsible for calling a java based application. There were some concerns about this part of application as follows:

1. The java based application was supposed to create a file that I had to process that file and show to user

2. A user could run the process from a page but after running he was not able to run it again (since the process took 3 min)

3. When application was running no one else could run application but they were supposed to see that application was run by someone else.

4. Page should be updated every 10 seconds to check whether the process is finished or not

5. When process is finished a file was generated I saved the file output in a temporary table (for simplicity I will save this data in a static variable)

To simulate this let's say we have an application called ExternalApp (a console application) to create a file but creating that file may take 3 min.

class Program

{

static void Main(string[] args)

{

if (args.Length == 1)

{

System.Threading.Thread.Sleep(180000);

StreamWriter w = new StreamWriter(args[0],false);

for(int i=0;i<10;i++)

w.WriteLine(" A Sample Data :"+ i);

w.Close();

}

}

}

Now we should create a web application to call this application by using Multi thread programming.

First I create a library to run the external application in a separate method. We need to check whether the process of running is finished or not. I created two classes one was Director another one was Builder.

Take a look at Director Class:

public class Director

{

Builder builder;

string userName;

public static List<string> Result = new List<string>();

public AlgorithemStatus Constract(Builder builder,string user)

{

this.userName = user;

if (HttpContext.Current.Application["athread"] == null)

{

this.builder = builder;

ThreadStart ts = new ThreadStart(RunThread);

Thread t = new Thread(ts);

t.Start();

HttpContext.Current.Application["athread"] = t;

return AlgorithemStatus.AlgorithemRunSuccessful;

}

else

return AlgorithemStatus.AlgorithemWasRunning;

}

public static bool IsAlgorithemRunning

{

get

{

if (HttpContext.Current.Application["athread"] == null)

return false;

else

{

Thread t = HttpContext.Current.Application["athread"] as Thread;

if (!t.IsAlive)

{

HttpContext.Current.Application.Remove("athread");

return false;

}

else

return true;

}

}

}

private void RunThread()

{

try

{

builder.PrepareHistoryFolder(userName);

builder.RunExternalAll();

Result = builder.LoadResult();

}

catch (Exception ex)

{

System.IO.StreamWriter w = new System.IO.StreamWriter(System.Configuration.ConfigurationManager.AppSettings["HistoryPath"] + "\\err.log", true);

w.WriteLine("Date Time : " + DateTime.Now);

w.WriteLine(ex.ToString());

w.Close();

}

}

}

In This class construct create a new thread and run RunThread method in it. IsAlgorithemRunning Property Check whether the running process has been started. Finally RunThread method calls different method in builder class and retrieve the result.

Check the Builder Class:

using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

namespace AlgorithemManagment

{

public class Builder

{

private string pathResultExteranlApp;

private string pathExternalApp;

private StreamWriter statswriter;

internal void PrepareHistoryFolder(string userName)

{

//Check for History folder first

string path = System.Configuration.ConfigurationManager.AppSettings["HistoryPath"];

if (!Directory.Exists(path))

Directory.CreateDirectory(path);

string foldername = string.Format("{0:d4}_{1:d2}_{2:d2}_{3:d2}_{4:d2}_{5:d2}", DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);

string HistoryPaht = path + "\\" + foldername;

Directory.CreateDirectory(HistoryPaht);

pathResultExteranlApp = HistoryPaht + "\\Result.CSV";

pathExternalApp = System.Configuration.ConfigurationManager.AppSettings["ExteranlAppPath"];

string pathstats = HistoryPaht + "\\stats.log";

statswriter = new StreamWriter(pathstats, true);

statswriter.WriteLine("User who runned the Algorithem: " + userName);

statswriter.WriteLine("Starting DateTime: " + DateTime.Now.ToString());

}

internal void RunExternalAll()

{

System.Diagnostics.Process prc = new System.Diagnostics.Process();

prc.StartInfo.FileName = pathExternalApp;

prc.StartInfo.Arguments = pathResultExteranlApp;

if (prc.Start())

statswriter.WriteLine("Allocatoin application has just started at " + DateTime.Now.ToString());

prc.WaitForExit();

}

internal List<string> LoadResult()

{

List<string> strs = new List<string>();

StreamReader r = File.OpenText(pathResultExteranlApp);

string data = r.ReadLine();

while (data != null)

{

strs.Add(data);

data = r.ReadLine();

}

statswriter.WriteLine("Temptable was filled successfully DateTime:" + DateTime.Now.ToString());

statswriter.Close();

return strs;

}

}

}

PrepareHistoryFolder creates a history folder to log and also save the result. RunExternalApp runs the External application and wait until it result is generated. LoadResult read the file generated by external app and process it.

Check the Page code:

protected void Page_Load(object sender, EventArgs e)

{

if (Director.IsAlgorithemRunning)

{

PrepareDisableMode();

}

else

{

PrepareEnableMode();

}

}

private void PrepareEnableMode()

{

ButtonRunAlgorithm.Enabled = true;

imgwait.Visible = false;

DataListResult.Visible = true;

if (Director.Result.Count > 0)

{

DataListResult.DataSource = Director.Result;

DataListResult.DataBind();

}

}

private void PrepareDisableMode()

{

ButtonRunAlgorithm.Enabled = false;

imgwait.Visible = true;

ClientScript.RegisterStartupScript(typeof(string), "mykey", "<script>RefreshPageinSecond();</script>");

DataListResult.Visible = false;

}

protected void ButtonRunAlgorithm_Click(object sender, EventArgs e)

{

PrepareDisableMode();

AlgorithemManagment.Director d = new AlgorithemManagment.Director();

AlgorithemManagment.Builder b = new AlgorithemManagment.Builder();

d.Constract(b,"The User Name");

}

When page is load if algorithm is running we are disabling the button and showing an image indicating we are middle of the process. If algorithm is not running we enable the button and also show the result. When button is clicked we disable button and show the image and also run the algorithm.

Please see the clip to understand the code better.
Please download the source code and also go to web.config file and update the ExteranlAppPath which is the address of ExternalApp exe file and update the HistoryPath which is the address of history folder to log information.

Thursday, July 3, 2008

Multi Thread Programming in .NET

What is multi thread programming?

Multi thread programming allows you to do two or more tasks at the same time. As a windows user you have experienced doing two or more tasks together for example while you are listening to music you are using word at the same time you may printing a picture as well. It means that your computer has the ability of doing some tasks simultaneously. Multi thread programming gives you a chance to do this with different parts of the code.

What is process?

Process is a space assigned by CPU allows the code to be run in that space.

What is Thread?

Each process has at least one Thread which is a reference for CPU to run next line in that process

A better definition for Multi threads programming:

Create different thread in current process to run two different parts of the code simultaneously.

Why do we need Multi thread programming?

Each process has at least one thread that run the code called main thread. Sometimes we cannot hang main thread because it is reflecting the hang issue to user. Let me give you an example. Let's say we have a windows application and in part of our code we need to run an external application which may take 1 minute to run. But we cannot spend 1 minute to run this application because the main thread is responsible to render user interface as well so we may create a new thread to do this task for us and leave the main thread to take care of user interface. You see sometimes without multi thread programming our code is not efficient.

How multi thread programming works in .net?

Thanks to .net framework where you can find so many ways to implement multi thread programming. Even you can find this awesome technology in ado.net and UI and... I am going to start from very basic one which is the simple Thread class.

First rule in multi thread programming is that you can run part of your code in another thread as long as your code is defined in a method. It means that if you need to run part of your code in new thread you need to define that code in a method. So a new thread can be run over a method. In .Net there are two classes that help you to do this first is Thread class and second ThreadStart delegate. By ThreadStart you define the address of the method you need to run in a new Thread. By Thread class you start the Thread. Take a look at this code:

ThreadStart ts = new ThreadStart(myfunction);

Thread t = new Thread(ts);

t.Start();


In above code first myfunction address is assigned to ts delegate then a new object of Thread is created and in constructor the ts is passed to thread object so when Start is called it will start the new thread for ts which is actually myfunction.

I was always asked by students where do we use this how we can use this in a web based application it may not be useful for a web based application. But the reality is that you can use this even in a web based application in next post I show you how! I was assigned a small project that I had to use multi thread programming

Thursday, June 19, 2008

Passing viewstates of a page to another page

Download the source code

Sometimes we need to pass information of one page to the next page to do this there are different approaches one of them is that you can pass just a querystring then lookup data in your data source. However sometimes there are no data sources so you need to have all states of one page in another page. So you may use Session object to pass this information. However, this may not be the best way because you are using Session object which is shared between different pages for a user. There is another way which is PostBackUrl.(In next posts I will compare State Management in asp.net)

How to pass viewstate by PostBackURL

After Visualstudio 2005 all our buttons has a nice properties called PostBackUrl which can be assigned to a page then state of this page (the page that has button with PostBackUrl) will be passed to Next page.

Take a look at this:

In this example we have a textbox and a dropdownlist and we need to see state of these two controls in next page. Also we have a button that its PostBackUrl is set to a page. When user click on this button the state is passed to next page to access these states you need to use PreviousPage object. Remember if someone tries to access this page by giving this page address into browser or user is redirected from other redirection method Then PreviousPage object is null. So to be in safe side always check this object. Take a look to this code:

if (PreviousPage != null)

{

DropDownList lst = PreviousPage.FindControl("DropDownList1") as DropDownList;

if (lst != null)

LabelDropdown.Text = lst.Text;

TextBox txt = PreviousPage.FindControl("TextBox1") as TextBox;

if (txt != null)

LabelTextbox.Text = txt.Text;

}

As you see in the code we are checking PreviousPage object so we are sure that previous page state is passed to this page it means that redirection method was PostBackUrl.

Also we have another method to make controls type safe which is defining PreviousPageType Directive (in html code) but the issue with this approach is that you can define one page as your previous page. Also if user access to this page with any other of redirection method then an error will be generated. So I highly recommend you use the previous approach and never user PreviousPageType directive.

Let's see the steps:

1- Define a page with a button which its PostBackUrl is filled with a page ( we call it target page)

2- In Target page Use PreviousPage.FindControl to access controls in previous page.

3- Always check PreviousPage object to be sure it is not null

Download the source code