.Net2Me

2012-02-01T11:00:00.002+08:00

Blog has moved to http://devmines.wordpress.com

Installing FitNesse as a service.

2010-05-24T13:09:00.001+08:00

Found this blog about installing FitNesse as a windows service.

RESTing in WCF

2010-03-16T07:42:00.007+08:00

Rob Bagby created a wonderful blog and screencast series on REST in WCF. Earlier, in 2008, Rob Skonnard, of Pluralsight, also provided a guide to designing and building RESTful web services with WCF 3.5 featured on MSDN. Another series on REST is on The .NET Endpoint by the .NET and AppTabric team which showcased the technology in .Net 4.0. REST's (REpresentational State Transfer) point of view is that a real web service is one designed to embrace the web from the ground up. I find REST's architectural style very interesting.

Silverlight 4 development on VS2010 RC

2010-03-07T19:35:00.006+08:00

I was enjoying going through the Silverlight 4 and MEF videos of Mike Taulty at Channel 9 and immediately fell in love with MEF. I like the declarative way of exporting and importing parts and the ease of composing them into a working application. But before the love affair blossomed into something I found out that Silverlight 4 along with MEF do not work and is not supported in VS2010 RC. It really broke my heart. I mean, how could these MS people excites you so much with something great and leave you #$@!@! Anyway, read the story here. I was about to remove VS2010 RC from my laptop when a speck of hope came. I was desperately googling Silverlight 4 and MEF development in VS2010 RC and after about a week, there in the list of google's search list is Dr. Z's blog sharing an interesting blog how to enable Silverlight 4 in VS2010 RC. He actually just found the hack from Andrew Veresov who translated the work of Alex Sorokoletov. So, thanks to these guys. And happy silverlighting!

ATDD, FIT and FItNesse Training

2010-02-20T07:09:00.005+08:00

Just finished conducting training and coaching atdd, fit and fitnesse in Amsterdam. It was a great experience. Fit provides a medium of communication between business people and developers to speak a common language and express business rules that both understand. Ward Cunningham in his book Fit for Development said that two major interconnected tasks essential to the value and quality of software application is helping to think about and communicate through concrete examples of what is needed in a software application; and automatically testing, from a business perspective, that the application is doing what is expected and continues to do so as it grows in functionality. ATDD with FIT and FitNesse are a perfect combination to execute these tasks.

Great MSDN Articles

2010-01-07T13:52:00.003+08:00

Articles that are must-read for silverlight devs:
1. Drill into .Net Framework internals to see how the CLR creates runtime objects.
2. Build LOB Enterprise Apps with Silverlight Part I
3. Build LOB Enterprise Apps with Silverlight Part II

I'll be adding more...

Globe, Smart or Sun

2010-01-07T10:37:00.004+08:00

Ever wonder which cellphone number belongs to which network? The fourth digit is the key. Look at the following table:

So for example a number 0917-344-3433 belongs to a Globe network and 0918-443-3224 belongs to a Smart network. So if you have one of those unlimited call on the same network subscription make sure you know the correct information.

Starting ATDD

2010-01-06T11:00:00.002+08:00

I found a great site that provides useful tutorials in understanding Acceptance Test Driven Development (ATDD). Enjoy learning ATDD here.

Installing Windows 7 from USB

2009-12-27T09:33:00.002+08:00

I have a company issued Thinkpad X61 laptop. X61 is lighweight and small but i find it powerful and suits my job. Since it doesn't have a internal DVD drive, i have to plug in an external one to install Windows 7. I found a link though that allows me to install Windows 7 from a USB thumb drive. Very helpful!

First Christmas

2009-12-07T11:37:00.002+08:00

I am looking forward to celebrate Christmas in my home town. This will be my first Christmas in nineteen years. I left as single man but am coming back with a family of my own- a beautiful wife and wonderful children. And lots of gray hair on my head.

Develop With Passion

2009-12-07T11:32:00.002+08:00

I enjoyed reading Jean-Paul Boodhoo's Develop With Passion blog. I am inspired of his unselfish motivation for his dedication to share his knowledge.

Enabling TFS 2008 Support for Expression Blend 3

2009-11-26T09:40:00.003+08:00

TFS 2008 support for expression blend 3 is enabled by the following:
A. Service-side component.
1. Download and install Team Foundation Server 2008 service pack 1 from here.

B. Client-side componnent.
1. Download and install Visual Studio 2008 Service Pack 1 here.
2. Download and install Team Explorer 2008 here.
3. Download and install Team Explorer hotfix here.

Fit for Agile

2009-09-11T11:26:00.003+08:00

I been doing Agile development for the last two years and it's encouraging to see the visible improvement in the development teams. Since then Agile interests me a lot that i started reading some more. And the more i read the more i realized that there is still tons in Agile development that i really wasn't aware of. ATDD, STDD, Fitnesse, Slim - all agile practices and tools . I like the way the Describe-Demonstrate-Develop cycle's simplicity and the greater focus on creating and using tests to produce quality software. I foresee a drastic improvement in the dev teams in the coming days.

Mocking .Net 3.5

2009-06-18T09:14:00.006+08:00

VS2008 lacks mocking feature. With TDD, being able to create mock objects is an essential. Why mock? One rule of unit testing is to isolate the test as much as possible to focus on one specific object and test solely around the behavior we expect from it and not of any of its dependencies. The dependency objects' implementation in fact doesn't have to exist yet and may well just be represented by interfaces utilize by the mocking framework to create mock objects. Since VS2008 is yet to have this feature, searching for mock frameworks in the web leads me to Moq, pronounced "Mock-you". I'll be spending a lot of time mocking with this tool. So, Happy Mocking!

Practicing Scrum

2009-06-03T17:41:00.003+08:00

I found this article about Implementing Scrum a good read. The article mentioned the following steps:
Step #1: Get your backlog in order!
Step #2: How to estimate your product backlog
Step #3: Sprint Planning/clarify requirements
Step #4: Sprint Planning/estimate tasks
Step #5: Create a collaborative workspace
Step #6: Sprint!
Step #7: Stand up and be counted!
Step #8: Track progress with a daily burndown chart
Step #9: Finish when you said you would
Step #10: Review, reflect, repeat...

I've been following the scrum practices for almost two years already and there are still a lot for me to learn and improve.

Fit for Life

2009-06-01T08:43:00.004+08:00

This isn't about .net or technology but i cannot help but be proud of my beautiful wife. On May 31st, she joined the four-mile (6.4 km) fun run held at the Global City, Taguig and crossed the finish line under 42 minutes, which is three minutes faster than her personal goal. She's just awesome: a very hardworking mother of two energetic kids, a working mom, a health conscious lady, and to top it - a wife of a stubborn husband. May 31, 2009, I can never forget it. It's our sixth year anniversary.

ISO 9001 Certified!

2009-05-28T10:35:00.002+08:00

BlastAsia, Inc. is now ISO 9001 certified! Congratulations to all especially to the very hard working QA team headed by the hunk Jun Sionson!

Space full, store them in the cloud

2009-05-16T09:41:00.008+08:00

There seems to be a lot of noise with storage in the cloud. Microsoft's Live Skydrive allows you to store up to 25 GB (free) of data with 50MB maximum upload per file. Not bad! Google is coming up with Google Drive too. With available third party utilities such as Gladinet, these online storage can be made available to your desktop as though they are locally stored making your favorite drag and drop feature works like a snap.

.Net Syndication

2009-05-15T17:20:00.010+08:00

I been looking at the .Net assemblies through the .Net Reflector and i found the System.ServiceModel.Syndication namespace inside the System.ServiceModel.Web assembly with several useful classes for web syndication. I am making some sort of feed aggregator site which basically contains a collection of links to syndication feeds and making it the central viewing site.

The final output would be something like on the above.

There are three different commonly used formats for syndication feeds namely: RSS 1.0, RSS 2.0, and ATOM 1.0. If you look at the format of each you will see that they have different element specification.

The SyndicationFeed class represents a top-level feed object in Atom 1.0 and RSS 2.0. Although RSS 1.0 is not natively supported, you can easily create a formatter class that can handle it by deriving the abstract SyndicationFeedFormatter class. The Atom10FeedFormatter and RSS20FeedFormatter,which handles Atom 1.0 and RSS 2.0 respectively are derived from this base class.

Loading the feed from Martin Fowler's site at http://martinfowler.com/bliki/bliki.atom, you use the following code:




string uri = "http://martinfowler.com/bliki/bliki.atom";

// Read in the feed.
XmlReader reader = XmlReader.Create(uri);

// Check whether RSS 2.0 or ATOM 1.0
SyndicationFeedFormatter formatter;

SyndicationFeedFormatter rss20Formatter = new Rss20FeedFormatter();
SyndicationFeedFormatter atom20Formatter = new Atom10FeedFormatter();

// Try first if RSS 2.0
if (rss20Formatter.CanRead(reader))
{
    formatter = rss20Formatter.ReadFrom(reader);
}
else if(atom10Formatter.CanRead(reader))
{
    formatter = atom10Formatter.ReadFrom(reader);
}
else
    throw new ApplicationException("Feed Format currently not supported!");

// other codes...

You can use the SyndicatonFeedFormatter class to load from a source feed (SyndicationFeed), check the version of the feed, gain access to the feed items(SyndicationItem) and write the feed contents to an XMLWriter.

Other useful classes are SyndicationItem, SyndicationPerson, TextSyndicationContent,SyndicationLink and SyndicationCategory.

Model-View-ViewModel Pattern for WPF

2009-01-28T09:09:00.002+08:00

Great articles using design patterns for WPF.
Pete Weissbrod's M-V-VM
Dan Crevier's DM-V-VM series

Managing Connection Strings using ConfigurationManager Class

2008-05-22T18:32:00.002+08:00

The .Net Framework 2.0 introduces the ConfigurationManager class in the System.Configuration namespace. I use this class to manage the ConnectionStrings section in the application configuration file(app.config or web.config). The ConnectionStrings section allows you to store connection information for accessing databases. And by using the static ConnectionStrings property of the ConnectionManager class you will be able to get the different records in the ConnectionStrings section of the config file.

To configure a connection string for a database named BAIDB in a SQL Server named BAISERVER using Windows Authentication, we add a record in the ConnectionStrings section:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
<add name="SQLConnection"
connectionString="Data Source=BAISERVER;Initial
Catalog=BAIDB;Integrated Security=true"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>

Now, to use the connection string in code, we add a reference to the System.Configuration assembly. This is very important. If you don't explicitly reference the assembly you will not see the ConfigurationManager class.

using System;
using System.Configuration.
using System.Data;
using System.Data.SqlClient;

namespace BAI
{
static class Program
{
static void Main(string[] args)
{
//retrieve the connection record in the
//ConnectionStrings section named SQLConnection

string connectionString =
ConfigurationManager.ConnectionStrings
["SQLConnection"].ConnectionString;

SqlConnection connection = new SQLConnection
(connectionString);

connection.Open();

//Do something with the connection.

//Close the connection

connection.Close();
}
}
}

If your application uses more than one database, you can add the appropriate connection string record in the ConnectionStrings section.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
<add name="SQLConnection"
connectionString="Data Source=BAISERVER;Initial
Catalog=BAIDB;Integrated Security=true"
providerName="System.Data.SqlClient" />
<add name="SQLConnection2"
connectionString="Data Source=BAISERVER2;Initial
Catalog=BAIDB2;Integrated Security=true"
providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>

And you can use the second connection like this:

using System;

using System.Configuration.

using System.Data;

using System.Data.SqlClient;

namespace BAI

{
static class Program
{

static void Main(string[] args)

{

//retrieve the connection record in the

//ConnectionStrings section named SQLConnection

string connectionString =
ConfigurationManager.ConnectionStrings
["SQLConnection"].ConnectionString;

SqlConnection connection = new SQLConnection
(connectionString);

connection.Open();

//Do something with the connection.

//Close the connection

connection.Close();

string connectionString2 =
ConfigurationManager.ConnectionStrings
["SQLConnection2"].ConnectionString;

SqlConnection connection2 = new SQLConnection
(connectionString2);

connection2.Open();

//Do something with the connection.

//Close the connection

connection2.Close();
}

}

As you can see the .Net Framework has already done much of the work for us to manage connection string information. You can also encrypt the connection strings for security reasons.

The ConfigurationManager class can also be use to manage the different sections of the configuration file.

2008-05-10T00:00:00.002+08:00

Design Pattern: Singleton Implementation in .Net

Some of our development tasks require us to control the number of instances created for a particular class or type. There could be possible reasons for this. One, you have limited resources in terms of memory and disk such as programming for pocket PCs and mobile apps. Two, a resource pool is maintained for an application to use such as connection to database servers for licensing concerns. These are just two cases among others wherein the creation of objects is controlled.

The singleton design pattern allows us to limit the instance of an object to one. It is the easiest design pattern to understand and implement among the 23 defined by the Gang Of Four(GOF). In this article, we try to implement the pattern using C#.Net.

The following are significant in using singleton:

1. The user of the class must not be able to create an instance by using a public constructor.

2. The class must not be inheritable thus preventing any subclass to define a public constructor and create the instance from there.

3. A global point of access to the single instance must be provided.

Let us create a POSRegister class. This class is responsible for all functions related to cashiering and tendering in a POS application. We only need one instance of this class for the whole application so we use the Singleton pattern to implement this.

So first we define the skeleton of the class:

public class POSRegister
{
#region Business Properties

// All properties related to the operation of the

// class goes here.

#endregion

}

To prevent the user of this class from creating instances of this class we have to make its contructor private:

public class POSRegister
{
#region Constructors

// Make the constructor private

private POSRegister()

{

}

#endregion

#region Business Properties

// All properties related to the operation of the

// class goes here.

#endregion

}

Then, we make sure that this class cannot be subclassed or inherited by using the "sealed" specifier:

// Sealed makes the class not inheritable

public sealed class POSRegister
{

#region Constructors

// Make the constructor private

private POSRegister()

{

}

#endregion

#region Business Properties

// All properties related to the operation of the

// class goes here.

#endregion

}

At this point, we have a class that cannot be instantiated and cannot be subclassed. A pretty useless class. The last thing we need to do is to provide a global point of access to the single instance. We do this by keeping a static field available to the class and then implementing either a static public property or method for the client to use.

// Sealed makes the class not inheritable

public sealed class POSRegister
{

#region Constructors

// Make the constructor private

private POSRegister()

{

}

#endregion

#region Business Properties

// All properties related to the operation of the

// class goes here.

#endregion

// define a static field of POSRegister class.

private static POSRegister _singleInstance;

// define a public static method for the user of this class

// to use.

public static POSRegister Instance()

{

// check if the single instance is already instantiated or

// not

if (_singleInstance == null)

_singleInstance = new POSRegister();

return _singleInstance;

}

That's it, we have implemented the singleton pattern for the POSRegister class. Now, client can use this class by:

class Program
{
public static void Main(string[] args)
{

POSRegister register = POSRegister.Instance();

//call any methods or properties exposed by the class

}

The only access to the single instance of the class is through the static Instance method. Users of this class will end up sharing the same instance throughout the application's life.

So we have seen the Singleton pattern implementation in .Net and learned that using this pattern allows us to limit the number of instances created from a class to just one.

Happy coding!

2007-11-03T15:40:00.001+08:00

Needed Upgrade

I am planning to upgrade my MCSD certification to MCPD. Microsoft provides two upgrade exams for this. The exams are 70-553 and 70-554, which are called Upgrade: MCSD Microsoft.Net Skills to MCPD Enterprise Application Developer by using Microsoft .NET Framework Part 1 and Part 2, respectively. These are the two Professional Developer (PRO) Upgrade Exams for those who have obtained the MCSD on Microsoft .NET certification.

The 70-553 exam measures your ability to develop and implement rich client applications, targeting the Windows Forms platform using .NET Framework 2.0, as well as build interactive, data-driven Web-based applications with Web Forms, ASP.NET, and the .NET Framework for both intranet and internet uses.

The 70-554 exam, on the other hand, measures your ability to develop and implement n-tier solutions targeting both web and rich-client user experiences.

I will be digging deeper into the topics listed on the Microsoft learning website
http://www.microsoft.com/learning/exams/70-553.mspx and
http://www.microsoft.com/learning/exams/70-554.mspx for each exam on the next few weeks with the following purposes: first, obviously is to upgrade my .NET knowledge taking advantage of the new features the .NET 2.0 brings; second, is to obtain the MCPD Enterprise Application Developer certification.

2007-06-05T03:34:00.000+08:00

Have you seen the Surface?

Take a look at the endless possibilities here at Microsoft Surface.

Amazing!!!

2007-05-28T10:01:00.000+08:00

Technology Core Group

Meeting with the core group on technology is filled with learning and fun. On Friday, May 25, the group welcomed three more members who are as hot as our Q.A. Director, Jun. We welcome Redgie, Shem, and Vic!

2007-05-18T10:05:00.001+08:00

Decorator Design Pattern gives Power

It is an amazing fact that once you get to understand the concept of designing your software using patterns you will start to get the habit of thinking in patterns in your programming development style. Design patterns just simply work!

Messing around with the Decorator, I find that I can provide additional behaviors to my objects without resorting to deep heirarchical subclassing. It's like bestowing an object with added powers under your control. If super heroes will put into commercial their unique abilities, I'll be shopping around for Spiderman's skill of travelling with his web; without using a car, I can have more savings. Superman may have something in market too, and i'll definitely be going after his bullet repelling power for a safe vacation to beautiful destinations. Having the power of congress to make laws is desirable; I want to make sure that no one in this planet sells Kryptonite. Now, back to decorators. They are also known as wrappers. You can have a simple guy and wrap him with some web and impenetrateable powers, and you have the new amazing SuperSpider. Really going back to decorators now...

The Gang of Four says that decorators allow you to attach additional responsibilities(think powers) to an object dynamically. Decorators provide a flexible alternative to subclasing for extending functionality.

Here is the diagram:

Let us dig into the participants of this pattern.

The Component defines the interface for objects that can have responsibilites added to them dynamicaly.*

The ConcreteComponent defines an object to which additional responsibilities can be attached.*

The Decorator maintains a reference to a Component object and defines an interface that conforms to Component's interface.*

The ConcreteDecorator adds responsibilities to the component.*

*Design Patterns, Elements of Reusable Object Oriented Sotftware,
by Gamma, Helm, Johnson and Vlissides

Note that the Decorator is a Component , and holds or wraps and instance of another Component. Decorator forwards requests to its Component object, and may optionally perform additional operations before and after forwarding the request.

Implementation.

Let us walk through a sample implementation of this pattern.

We are developing a control for our windows application project. This control draws itself on the form container as a simple rectangular box. However, additional requirement comes in and the team lead says that the control should be able to fill a background with some color of choice. Barely started the new design, we received another requirement on our desk. The control should also be able to draw text assigned to it. Additionally, it needs to accomodate displaying an icon inside its border when needed.

The control requirements:
1. Simple rectangular box control.
2. Background color power.
3. Text displaying power.
4. Icon showing power.

We can actually make a simple control and provide properties for the second, third and fourth requirements, but we don't want to have those powers attached when we don't need to. We want to be able to select a few or all of those powers according to our need or mood. There are times that the new amazing SuperSpider just want to live like a simple guy; he wants to travel with his feet and get a feel of those smuggled Kryptonites. Remember, with much power , comes great responsibility.

So we design our solution using the Decorator pattern like this:

Matching the decorator pattern participants, we have:

CellBase - Component, an abstract class
TableCell - ConcreteComponent
CellDecoratorBase - Decorator, an abstract class
FillableCellDecorator - ConcreteDecorator, additional behavior
BorderedCelDecorator - ConcreteDecorator, additional behavior
TextCellDecorator - ConcreteDecorator, additional behavior
IconCellDecorator - ConcreteDecorator, additional behavior

To implement our control in C#.Net, we first define our abstract class Component, CellBase.

public abstract class CellBase
{
   #region Properties
   #endregion

   // Provide basic painting of control.
   public virtual void Draw(System.Drawing.Graphics graphics,
      int cellWidth, int cellHeight)
   {
      //Get the rectangle bounds.
      Rectangle r = GetRectangle(cellWidth, cellHeight);

      //Fill the rectangle with default silver color.
      graphics.FillRectangle(Brushes.Silver, r);

      //Draw a simple border.
      graphics.DrawRectangle(Pens.Black, r);
   }

   // Helper method. Use to get the bounds of this control
   protected virtual Rectangle GetRectangle(int cellWidth,
      int cellHeight)
   {
      Rectangle r = new Rectangle(columnNo * cellWidth,
         rowNo * cellHeight, cellWidth, cellHeight);

      return r;
   }

   // Helper method. Use to check whether this control
   // has been clicked.
   public bool Intersects(int x, int y)
   {
      Rectangle r = GetRectangle(100, 50);
      Rectangle r1 = new Rectangle(x, y, 1, 1);

      return (r1.IntersectsWith(r));    
   }
 }

TableCell, the ConcreteComponent class, implements the CellBase.

public class TableCell : CellBase
{
   public override string ToString()
   {
      return "I am a simple TableCell";
   }
}

Then we define CellDecoratorBase, which is the abstract Decorator class.

public abstract class CellDecoratorBase : CellBase
{
   protected CellBase cell;
   public CellDecoratorBase(CellBase cell)
   {
      this.cell = cell;  
      this.TableNo = cell.TableNo;
      this.RowNo = cell.RowNo;
      this.ColumnNo = cell.ColumnNo;           
   }

   // Forward requests to containted component.
   public override void Draw(System.Drawing.Graphics graphics,
      int cellWidth, int cellHeight)
   {
      cell.Draw(graphics, cellWidth, cellHeight);
   }  
   // Forward requests to containted component.
   public override int TableNo
   {
      get{return cell.TableNo;}
      set{cell.TableNo = value;}
   }

   // Forward requests to containted component.
   public override int ColumnNo
   {
      get{return cell.ColumnNo;}
      set{cell.ColumnNo = value;}
   }

   // Forward requests to containted component.
   public override int RowNo
   {
      get{return cell.RowNo;}
      set{cell.RowNo = value;}
   }
}

Here now is the FillableCellDecorator, the power to fill a background color.

public class FillableCellDecorator : CellDecoratorBase
{
   private Color backColor;
   public FillableCellDecorator(Color backColor, CellBase cell)
      : base(cell)
   {
      this.backColor = backColor;
   }

   public override void Draw(System.Drawing.Graphics graphics, int cellWidth, int cellHeight)
   {
      //Call base method
      base.Draw(graphics, cellWidth, cellHeight);

      //Fill rectangle.
      Rectangle r = base.GetRectangle(cellWidth, cellHeight);

      //Make sure we don't fill the borders.
      r.Inflate(-1, -1);
      r.Width += 1;
      r.Height += 1;

      SolidBrush brush = new SolidBrush(backColor);

      graphics.FillRectangle(brush, r);

      brush.Dispose();
   }

   public override string ToString()
   {
       string str = cell.ToString();
       str += "\nBestowed with FillableCellDecorator power,";
       str += "\n      i can now hide myself in a background color.";
       return str;
   }
}

Then our TextCellDecorator, the power to draw text, will be like this.

public class TextCellDecorator : CellDecoratorBase
{
   private Color foreColor;
   private string text;
   public TextCellDecorator(string text, Color foreColor, CellBase cellBase)
      : base(cellBase)
   {
      this.text = text;
      this.foreColor = foreColor;

   }

   public override void Draw(Graphics graphics, int cellWidth, int cellHeight)
   {
      //Call contained cell's Draw method.
      base.Draw(graphics, cellWidth, cellHeight);

      RectangleF r = (RectangleF)GetRectangle(cellWidth, cellHeight);
         r.Inflate(-3, -3);

      SolidBrush brush = new SolidBrush(foreColor);
      graphics.DrawString(text, new Font("Arial", 14f), brush, r);
      brush.Dispose();
   }

   public override string ToString()
   {
      string str = cell.ToString();
      str += "\nIt's nice to have a TextCellDecorator power,";
      str += "\n      can you read my text?";
      return str;
   }
}

And in order to have the power to show off some iconic power, we have the IconCellDecorator.

public class IconCellDecorator : CellDecoratorBase
{
   private Image image;
   public IconCellDecorator(Image image, CellBase cell)
      : base(cell)
   {
      this.image = image;
 
   }

   public override void Draw(Graphics graphics, int cellWidth, int cellHeight)
   {
      //Call contained component's draw method
      base.Draw(graphics, cellWidth, cellHeight);

      //draw icon.    
      Rectangle r = this.GetRectangle(cellWidth, cellHeight);
      r.Inflate(-3, -3);
      r.Width -= 50;
      r.X = r.X + 50;
   
      graphics.DrawImage(image, r);
   }

   public override string ToString()
   {
      string str = cell.ToString();
      str += "\nWow! This is great, with IconCellDecorator power,";
      str += "\n      i can now show off my icon.";
      return str;
   }
}

I added a new Decorator just to drive the point that it is easy to add more behavior as needed. The BorderedCellDecorator allows you to draw a highlighted border around the the control when it is clicked.

public class BorderedCellDecorator : CellDecoratorBase
{
   private Color borderColor;
   private int borderWidth = 4;
   public BorderedCellDecorator(Color borderColor, CellBase cell)
      : base(cell)
   {
      this.borderColor = borderColor;
   }

   public override void Draw(System.Drawing.Graphics graphics, int cellWidth, int cellHeight)
   {
      base.Draw(graphics, cellWidth, cellHeight);
    
      Rectangle r = GetRectangle(cellWidth, cellHeight);
      r.Inflate(-3, -3);
      Brush b = new SolidBrush(Color.Orange);
      Pen p = new Pen(b, borderWidth);

      graphics.DrawRectangle(p, r);
   }

   public override string ToString()
   {
      string str = cell.ToString();
      str += "\nAdded BorderedCellDecorator power,";
      str += "\n      i can now enclosed myself with a shield border.";
      return str;
   }
}

Finally, in order to test our control and its amazing powers, we code something like this.


public partial class MainForm : Form
{
   public MainForm()
   {
      InitializeComponent();
    
   }

   private int rows;
   private int columns;

   private void btnDraw_Click(object sender, EventArgs e)
   {
      rows = int.Parse(this.txtRows.Text);
      columns = int.Parse(this.txtColumns.Text);

      CreateCells(rows, columns);

      this.Refresh();

   }

   protected override void OnPaint(PaintEventArgs e)
   {
      if (list == null) return;
      if (list.Count == 0) return;

      DrawLayout(e.Graphics);
   }

   private System.Collections.ArrayList list;
   private void CreateCells(int rows, int columns)
   {
      list = new System.Collections.ArrayList();

      CellBase cellBase = null;
      Image img = Image.FromFile(@"bell.gif");

      int counter = 0;
      for (int i = 0; i < rows; i++)
      {
         for (int j = 0; j < columns; j++)
         {
            //cellBase = new TableCell();
            cellBase = new TableCell();

            cellBase.RowNo = i;
            cellBase.ColumnNo = j;
            cellBase.TableNo = counter;

            if (chkBackColor.Checked)
               cellBase = new FillableCellDecorator(Color.Purple, cellBase);

            if (chkText.Checked)
               cellBase = new TextCellDecorator(counter.ToString(), 
                   Color.Yellow, cellBase);

            if (chkImage.Checked)
               cellBase = new IconCellDecorator(img, cellBase);

            list.Add(cellBase);
            counter++;
         }
      }  
   }
 
   // DrawLayout method using offscreen rendering to avoid flicker.
   private void DrawLayout(Graphics g)
   {
      int cellWidth = 100;
      int cellHeight = 50;

      Bitmap bmpOff;
      Graphics gxOff;

      //Create a bitmap the size of the form.
      bmpOff = new Bitmap(ClientRectangle.Width, ClientRectangle.Height);
      SolidBrush blueBrush = new SolidBrush(Color.Blue);
      Pen whitePen = new Pen(Color.White, 3);

      //Create a Grahics object that is not of the screen.
      gxOff = Graphics.FromImage(bmpOff);
      // gxOff.FillRectangle(new SolidBrush(Color.Red), 0, 0, bmpOff.Width, bmpOff.Height);

      foreach (CellBase cell in list)
      {
         cell.Draw(gxOff, cellWidth, cellHeight);
      }
   
      // Render the off-screen bitmap onto the screen.
      g.DrawImage(bmpOff, 0, 0, ClientRectangle, GraphicsUnit.Pixel);

      // Dispose created Graphic object.
      gxOff.Dispose();

   }

   protected override void OnMouseUp(MouseEventArgs e)
   {
      if (list == null) return;
      if (list.Count == 0) return;

      foreach (CellBase cell in list)
      {
         if (cell.Intersects(e.X, e.Y))
         {
            Graphics g = this.CreateGraphics();
            
            DrawLayout(g);

            this.lblCellTypeUnClicked.Text = cell.ToString();
            
            // Wrapped object to have a highlight power.
            CellBase clickedCell = new BorderedCellDecorator(Color.Orange, cell);
            clickedCell.Draw(g, 100, 50);

            this.lblCellTypeClicked.Text = clickedCell.ToString();
            g.Dispose();

            break;
         }
      }
   }
}

Here are some images of our application.

Ordinary Simple control, living as ordinary citizen.

Ordinary Simple control, living as ordinary citizen, but with ability to hide in a shade of purple.

Ordinary Simple control, living as ordinary citizen, but with ability to hide in a shade of purple and to show its number logo.

The new amazing super ordinary control with all its powers.

In conclusion, using decorators we can provide additional behaviors to an object. This we can do without resorting to subclassing. Behaviours can be attached or detached without the knowledge of the object being wrapped or decorated.

Email me if you want the source codes.

Happy coding!

2007-05-08T23:30:00.000+08:00

100" T.V., Anyone???
I asked a Japanese colleague about some interesting facts.

I said,"Sumimasen, is it true that Japanese people use their T.V. sets, components, refs and other equipment for a year and replace them after that."

He replied, "No, no, no! T.V. sets and refs gets five to ten years before replacing them. Too expensive if changed yearly!"

He also added, "But watches and cellphones, yes, Japanese replace every year."

So, there goes straight facts from a Japanese himself.

Next time you're considering of buying that second-hand T.V. at the port area, remember it's not just a year old.

2007-05-08T09:50:00.000+08:00

Strategy Design Pattern Implementation

Here is the definition of the Strategy design pattern by GOF(Gang of Four):
“Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.”*

And here are the uses or applications by GOF:
1. many related classes differ only in their behavior. Strategies provide a way to configure a class with one of many behaviors.*
2. you need different variants of an algorithm. For example, you might define algorithms reflecting different space/time trade-offs. Strategies can be used when these variants are implemented as a class hierarchy of algorithms [HO87].*
3. an algorithm uses data that clients shouldn't know about. Use the Strategy pattern to avoid exposing complex, algorithm-specific data structures.*
4. a class defines many behaviors, and these appear as multiple conditional statements in its operations. Instead of many conditionals, move related conditional branches into their own Strategy class.*

Here is the diagram by GOF:

I had a chance to notice this design pattern when working on the restaurant management system project. And this proves to be very useful when we have different algorithms that we can use interchangeably. Instead of having switch or if statements, we can encapsulate the different strategies or policies in each own class and then instantiate the one that is relevant.

We try to walk through a sample implementation of this pattern with a tax calculation project. Different countries have different tax calculation policy. If our system is targeted to an international environment it needs to have some way to load the correct tax calculator. We do not want angry Japanese waving their samurais when they have been charged with special tax on their Sake just because we use the tax calculator intended for Singapore. At the same time, it should be simple enough to change tax calculators with a few code change or no code change at all.

In the example that follows we will encapsulate the tax calculation policy for each country on its own strategy class. Each strategy will derived from a base abstract class. This way, we can use each of these strategies interchangeably without the knowledge of the client class.

Here is the uml diagram for our solution.

Now, for the implementation we define first the strategy abstract class.
Here is the code in C#.Net.


public abstract class TaxCalculationStrategyBase
{
   // Maintain an instance of the context class
   protected OrderInfo orderInfo;

   // Set the instance of the context class.
   public void SetTaxableInfo(OrderInfo orderInfoBase)
   {
      this.orderInfo = orderInfoBase;
   }

   // Concrete strategies will provide implementation
   // for this abstract method.
   public abstract void CalculateTax();
}

Then we create a tax calculator concrete strategy implementation for Japan:


public class JapanTaxCalculationStrategy : TaxCalculationStrategyBase
{
   // Default constructor
   public JapanTaxCalculationStrategy()
   {
   }

   // Implement specific algorithm.
   public override void CalculateTax()
   {
      // Japan uses this formula for computing
      // inclusive taxes.
      base.orderInfo.TaxAmount =
            (base.orderInfo.OrderAmount + 10) / (100 + 10);
   }
}

And, here is another tax calculator concrete strategy implementation for Singapore:


public class SingaporeTaxCalculationStrategy : TaxCalculationStrategyBase
{
   // Default constructor
   public SingaporeTaxCalculationStrategy()
   {
   }

   // Singapore may use tax calculation
   // formula different from Japan
   public override void CalculateTax()
   {
      base.orderInfo.TaxAmount =
           base.orderInfo.OrderAmount * 10 / 100;
   }
}

We also make use of a factory to give us a specific tax calculator.

Below is one version of the factory.
This class is the point of change when we try to add more calculators.
This version, though, requires code compilation.


public class TaxCalculatorFactory
{
   // Context objects uses this static method
   // to create a specific tax calculator.
   public static TaxCalculationStrategyBase
       CreateTaxCalculator()
   {
      TaxCalculationStrategyBase calculator = null;

      // We can retrieve a tax calculator name by using
      // an application configuration file.
      string calculatorName =
        System.Configuration.ConfigurationSettings.AppSettings
           ["TaxCalculator"];

      // We can add appropriate case statements
      // to new calculators.
      switch (calculatorName)
      {
         case "Japan":
            calculator = new JapanTaxCalculationStrategy();
            break;
         case "Singapore":
            calculator =
               new SingaporeTaxCalculationStrategy();
            break;
         // Add more case statements here.
         // case "Philippine":
         //     calculator =
         //         new PhilippineTaxCalculationStrategy();
         //     break;
      }

      return calculator;
   }
}

Below is another version of a factory.

We can use reflection to instantiate the type of the calculator based on a configuration file.
This way, we only change the configuration file with no code compilation steps needed. The configuration file entry includes the full name of the class that will be instantiated.


public class TaxCalculatorFactory
{
   public static TaxCalculationStrategyBase
     CreateTaxCalculator()
   {
      // We assume the calculator class is located in
      // the same assembly as the client.
      // But we can easily load it from any assembly.
      Assembly assembly = Assembly.GetExecutingAssembly();


      // App.config: ["TaxCalculatorName"] values - 
      //   "TaxCalculators.SingaporeTaxCalculatorStrategy"
      string className =
          System.Configuration.ConfigurationSettings.AppSettings
               ["TaxCalculatorName"];

      // Use reflection to create an instance.
      // Make sure that we cast the result of the
      // CreateInstance method.
      TaxCalculationStrategyBase calculator;
      calculator =
        (TaxCalculationStrategyBase)
             assembly.CreateInstance(className);

      return calculator;
   }
}

Here is the context class that uses the tax calculators:


public class OrderInfo
{
   // Default Constructor
   public OrderInfo()
   {
   }

   // Context class contains or knows only
   // the abstract class but has no knowledge
   // of any concrete strategy classes.
   protected TaxCalculationStrategyBase calculator;


   // Provides a method to set a strategy
   public void SetTaxCalculationStrategy
       (TaxCalculationStrategyBase calculator)
   {
      this.calculator = calculator;
   }

   // Client can call this method for tax computation.
   public void CalculateTax()
   {
      // Use the factory to create calculator instance.
      this.calculator =
          TaxCalculatorFactory.CreateTaxCalculator();

      // Set the context of the strategy.
      // This type of assignment is often called
      // dependency injection.
      calculator.SetTaxableInfo(this);

      // This effectively sets the TaxAmount property.
      calculator.CalculateTax();
   }

   // Other properties of the context class.
   private int orderNo;
   public int OrderNo
   {
      get
      {
         return orderNo;
      }
      set
      {
         orderNo = value;
      }
   }

   private double orderAmount;
   public double OrderAmount
   {
      get
      {
         return orderAmount;
      }
      set
      {
         orderAmount = value;
      }
   }

   private double taxAmount;
  
   // This method will be called by the concrete strategy
   // using dependency injection
   // or otherwise also termed "inversion of control"
   public double TaxAmount
   {
      get
      {
         return taxAmount;
      }
      set
      {
         taxAmount = value;
      }
   }

   public double TotalAmount
   {
      get
      {
         return orderAmount + taxAmount;
      }
   }
}

We can use a client with the following code:


public partial class OrderForm : Form
{
   public OrderForm()
   {
      InitializeComponent();
   }

   private void calculateButton_Click
      (object sender, EventArgs e)
   {

      // Instantiate the context object.
      OrderInfo orderInfo = new OrderInfo();

      // Assign properties
      orderInfo.OrderNo = 9999; 
      orderInfo.OrderAmount =
          double.Parse(this.orderAmountTextBox.Text);


      // Call tax calculation
      orderInfo.CalculateTax();


      // Show results.
      this.lblOrderAmount.Text =
          orderInfo.OrderAmount.ToString();
      this.lblTaxAmount.Text =
          orderInfo.TaxAmount.ToString();

   }
}

Several things to note here:
1. The context class (OrdeInfo) doesn’t have to know which specific tax calculator it is using. It only knows the base abstract class(TaxCalculationStrategyBase). The factory takes care of the creation of the specific calculator based on the configuration file.
2. The client class(OrderForm) doesn’t have to know any tax calculators at all. The tax calculation procedure is encapsulated inside the context class(OrderInfo).
3. If we want to use a specific calculator, we simply change the configuration file
4. If we want to create another tax calculator for another country, for example, Philippine taxation, we simple derived from the base abstract class (TaxCalculationStrategyBase) and code inside the specific tax calculation implementation.

In conclusion, the strategy design pattern allows us to encapsulate algorithms that varies into its own classes. This way we avoid code complexity inside the context class.

Please email me if you want the source code used in this article.

Happy coding!

References:
*Design Patterns Elements of Reusable Object Oriented Software
by Gamma, Helm, Johnson, Vlissides

2007-05-03T17:53:00.000+08:00

Design Patterns for Blasters

We had a meeting with some of the senior developers last April 27th. The goal was to address project delays. We started by identifying the causes of the problem. Identified areas that needed strengthening are project management and skill set augmentation. As developers, we agreed to take action on the latter task. Our first response is to have better programming development style by incorporating design patterns in our analysis and coding. This is really a pretty exciting endeavour to pursue in the next few weeks...or years.

2006-11-06T16:55:00.000+08:00

trying to test what's blogging blah blah blah is all about.