Build Better Code Easily - CodeEdifice.com

Get last modified stored procedures on SQL 2005 and above

2010-11-04T13:09:00.000-07:00

If you need to quickly get the list of all last modified stored procedures and the body of the stored procedure to aid in a quick update deployment from pre staging to production environment, try this stored procedure.


Create proc DevGetLastModifiedItems
(
  @AfterTimeStamp as datetime
)
as
  declare varCur cursor for 
    Select sys.objects.name, modify_date,
           sys.all_sql_modules.definition
      from sys.objects
           inner join sys.all_sql_modules on sys.objects.object_id = sys.all_sql_modules.object_id
      where sys.objects.type='P'
        and sys.objects.modify_date >= @AfterTimeStamp
        and sys.objects.name <> 'DevGetLastModifiedItems' -- Cannot see why this SP should ever turn up on a production server :)
      order by modify_date desc
  open varCur
  declare @name as varchar(200),
          @definition as varchar(max),
          @modify_date as datetime
  Fetch next from varCur into @name, @modify_date, @definition
  while @@Fetch_status = 0
  begin
    Print '-- ' + @name + ' last modified on ' + convert(varchar(40), @modify_date, 9)
    Print ''
    Print @definition
    Print 'go'
    Print ''
    Print ''
    Fetch next from varCur into @name, @modify_date, @definition
  end
  close varCur
  deallocate varCur
go

To get the complete list and body of the stored procedures that have been modified since a date say '2010-11-04', simply fire this on the Management Studio window and check out the contents of the messages window


exec DevGetLastModifiedItems '2010-11-04'

Expose Child Control In A Custom User Control For Javascript

2010-10-13T11:08:00.000-07:00

Hit upon a javascript requirement. I have two controls on my page - a textbox control and a custom user control. The custom user control itself hosts two textboxes. The requirement wanted me to set the value of the standalone textbox control on one of the two inside textbox controls. Came up with two solutions

The unelegant one first - Add an attribute in the hosting page load to handle the blur event of the standalone textbox triggering a __doPostBack. In the load event of the custom user control, adding code to use the FindControl function on the parent page to retrieve the standalone textbox's value and store this in the inside textbox.
While this did the task, the actual postback of the page was a real spoiler (especially since my page had more than just these two items).

Relooked at the same issue a while back and thought of another solution.
An elegant one - Expose the inside textbox as a property of the usercontrol. In the hosting page, add an attribute to handle the blur event, this time however use a simple javascript to set the value of the textbox exposed as a property to the value of the standalone textbox.
Consider the standalone textbox is called txt1 and the usercontrol uc1 has two textboxes - txt2 and txt3. We want to set the value of txt3 to be the same as txt1. We have now exposed txt3 as a property of uc1 say txt3TextBox

In code,
Dim blurJS As String = String.Format(document.getElementByID('{0}').value = document.getElementByID('{1}').value, uc1.txt3TextBox.ClientID, txt1.ClientID)
txt1.Attributes.Add("OnBlur", blurJS)

Well, I had more fun than I added here especially with the txt3 control being part of a view of the multiview and hence I needed to add more checks to ensure that the left hand side of the expression was not null and such. But that is another story.

Is that default namespace in XML bothering you?

2008-01-15T12:10:00.000-08:00

I had one of my dev team members walk up to me some days back with this really interesting requirement. He had these XML files that contained similar information except that the elements were in different namespaces on those files. If you find yourself caught up in a situation like this, probably this blog entry might be useful. Once again, I will show a few ways of getting this done, pick the right one based on your requirements.

For starters, I will create an XML file that contains a Person node at the root and three nodes - Name that lies in the n1 namespace, Age that lies in the n2 namespace and Gender that is part of the default namespace.

A listing of the Sample.xml file

<?xml version="1.0" encoding="utf-8" ?>
<Person xmlns:n1="http://codeedifice.com/N1" xmlns:n2="http://codeedifice.com/N2" xmlns="http://codeedifice.com/N">
  <n1:Name>Alvin</n1:Name>
  <n2:Age>10</n2:Age>
  <Gender>Male</Gender>
</Person>

The example that I am listing here lists the top three approaches taken by developers who are still getting their hands dirty with XML that contains namespaces. The next three approaches are alternatives that you must work out for yourself and pick the one that suits your actual requirement

  Sub Main()
    Dim xdoc As XmlDocument = New XmlDocument
    xdoc.Load("Sample.xml")
 
    'Fails due to lack of namespace
    Console.WriteLine("Looking for Person Node(s) without a namespace manager...")
    Dim xNodLst1 As Xml.XmlNodeList = xdoc.SelectNodes("/Person")
    Console.WriteLine(Space(4) & "Found " & xNodLst1.Count & " matche(s)")
 
    Dim nsMgr As XmlNamespaceManager = New XmlNamespaceManager(xdoc.NameTable)
    nsMgr.AddNamespace("n1", "http://codeedifice.com/N1")
    nsMgr.AddNamespace("n2", "http://codeedifice.com/N2")
 
    'Fails since the namespaces do not include the default one
    Console.WriteLine("Looking for Person Node(s) with the namespace manager not including the default namespace...")
    Dim xNodLst2 As Xml.XmlNodeList = xdoc.SelectNodes("/Person", nsMgr)
    Console.WriteLine(Space(4) & "Found " & xNodLst1.Count & " matche(s)")
 
    nsMgr.AddNamespace("", "http://codeedifice.com/N")
    'Fails since the empty string namespace is not useful (quite contrary to popular vote)
    Console.WriteLine("Looking for Person Node(s) with the namespace manager including the default namespace as an empty string...")
    Dim xNodLst3 As Xml.XmlNodeList = xdoc.SelectNodes("/Person", nsMgr)
    Console.WriteLine(Space(4) & "Found " & xNodLst3.Count & " matche(s)")
 
    nsMgr.RemoveNamespace("", "http://codeedifice.com/N")  'take the useless one out
    nsMgr.AddNamespace("ALVIN", "http://codeedifice.com/N")
    'Finally a working solution
    Console.WriteLine("Looking for Person Node(s) with the namespace manager including the default namespace as a unique value - ALVIN...")
    Dim xNodLst4 As Xml.XmlNodeList = xdoc.SelectNodes("/ALVIN:Person", nsMgr)  'Note how the dummy namespace is used
    Console.WriteLine(Space(4) & "Found " & xNodLst4.Count & " matche(s)")
 
    'A slightly more elegant solution that does not rely on the unique value ALVIN to be created by the developer 
    Console.WriteLine("Looking for Person Node(s) without the namespace manager using the localName XPath function...")
    Dim xNodLst5 As Xml.XmlNodeList = xdoc.SelectNodes("/*[local-name()='Person']")
    Console.WriteLine(Space(4) & "Found " & xNodLst5.Count & " matche(s)")
 
    'Accessing the Name and Age nodes correctly will require the use of the namespace
    Console.WriteLine("Looking for Name Node(s) with the namespace manager using the localName XPath function...")
    Dim xNodLst6 As Xml.XmlNodeList = xdoc.SelectNodes("/*[local-name()='Person']/n1:Name", nsMgr)
    Console.WriteLine(Space(4) & "Found " & xNodLst6.Count & " matche(s)")
 
    'Accessing the Name and Age nodes in a namespace agnostic fashion
    'This implies that you are assuming that you do not care about the namespace and can be dangerous
    Console.WriteLine("Looking for Name Node(s) without the namespace manager using the localName XPath function...")
    Dim xNodLst7 As Xml.XmlNodeList = xdoc.SelectNodes("/*[local-name()='Person']/*[local-name()='Name']")
    Console.WriteLine(Space(4) & "Found " & xNodLst7.Count & " matche(s)")
 
    Console.ReadLine()
  End Sub

And a look at the results

Get XML Nodes that do not have a specific attribute

2008-01-10T09:05:00.000-08:00

Alright after those design patterns, this one might strike as a real lightweight entry. Recently, I needed a method to identify all XML nodes that did not have a specific atrribute. Well, the first approach was a simple IF clause to verify if the attribute object is nothing. This did a fine job till I realized that I could a better approach, call it a result of refactoring or just an afterthought.

Sample code

  Sub Main()
    'Sample XML island
    Dim sb As System.Text.StringBuilder = New System.Text.StringBuilder
    sb.AppendLine("<items>")
    sb.AppendLine("  <item type='Pencil' qty='5' IsCanceled='1' />")
    sb.AppendLine("  <item type='Pen' qty='2' />")
    sb.AppendLine("  <item type='Book' qty='1' />")
    sb.AppendLine("  <item type='Pencil' qty='3' />")
    sb.AppendLine("</items>")
 
    Dim xDoc As Xml.XmlDocument = New Xml.XmlDocument
    xDoc.LoadXml(sb.ToString)
 
    Console.WriteLine("Original XML Content")
    Console.WriteLine(sb.ToString)
 
    'Original Strategy
    Console.WriteLine("Active list of items")
    Dim xNodLst As Xml.XmlNodeList = xDoc.SelectNodes("/items/item")
    For Each xNod As Xml.XmlNode In xNodLst
      If xNod.Attributes("IsCanceled") Is Nothing Then
        Console.WriteLine("{0} [{1}]", xNod.Attributes("type").Value, xNod.Attributes("qty").Value)
      End If
    Next
    Console.WriteLine()
 
    'Alternate Strategy
    Console.WriteLine("Active list of items (Alternate)")
    Dim xNodAltLst As Xml.XmlNodeList = xDoc.SelectNodes("/items/item[not (@IsCanceled)]")
    For Each xNod As Xml.XmlNode In xNodAltLst
      Console.WriteLine("{0} [{1}]", xNod.Attributes("type").Value, xNod.Attributes("qty").Value)
    Next
 
    Console.ReadLine()
  End Sub

In this example, I have eliminated nodes that do not have the IsCanceled attribute. The exact value of the attribute was not relevant to me, its existence was reason enough to have it eliminated from my result list.

A look at the execution result

Of course, if you wanted to include only nodes that had a specific attribute, you guessed right, just take the 'not' keyword out of the query -

Dim xNodAltLst As Xml.XmlNodeList = xDoc.SelectNodes("/items/item[@IsCanceled]")

Template Method Design Pattern

2008-01-03T11:49:00.000-08:00

Consider a business application where your application receives data in different representations – XML, Text file, SQL data table etc. You need to print this data in a tabular format with a common header, footer, page size settings among other things. We can quickly cook up a couple of designs to accomplish this. At the simplest level, we can create a single module that prints the header, then based on the appropriate type of data, extracts the information from the data representations and prints individual rows of data, then prints the footer.

PrintFormatter Class Listing

Public Class PrintFormatter
 
  Public Enum DataRepresentation
    TextFormat
    XMLFormat
    SQLDataTableFormat
  End Enum
 
  Private _TextData As String
  Private _XMLData As Xml.XmlDocument
  Private _SQLData As DataTable
  Private _DataRepresentation As DataRepresentation
 
  Public Sub New(ByVal PrintDataRepresentation As DataRepresentation)
    _DataRepresentation = PrintDataRepresentation
  End Sub
 
  Public WriteOnly Property TextData() As String
    Set(ByVal value As String)
      _TextData = value
    End Set
  End Property
 
  Public WriteOnly Property XMLData() As Xml.XmlDocument
    Set(ByVal value As Xml.XmlDocument)
      _XMLData = value
    End Set
  End Property
 
  Public WriteOnly Property SQLData() As DataTable
    Set(ByVal value As DataTable)
      _SQLData = value
    End Set
  End Property
 
  Public Sub PrintFormattedData()
    _PrintHeader()
    Select Case _DataRepresentation
      Case DataRepresentation.TextFormat
        _PrintTextData()
      Case DataRepresentation.XMLFormat
        _PrintXMLData()
      Case DataRepresentation.SQLDataTableFormat
        _PrintSQLData()
    End Select
    _PrintFooter()
  End Sub
 
  Private Sub _PrintHeader()
    Console.WriteLine("This represents the page header")
  End Sub
 
  Private Sub _PrintFooter()
    Console.WriteLine("This represents the page footer")
  End Sub
 
  Private Sub _PrintTextData()
    Console.WriteLine("This represents the formatted text data - " & _TextData)
  End Sub
 
  Private Sub _PrintXMLData()
    Console.WriteLine("This represents the formatted XML data - " & _XMLData.OuterXml)
  End Sub
 
  Private Sub _PrintSQLData()
    Console.WriteLine("This represents the formatted SQL data - " & _SQLData.TableName)
  End Sub
 
End Class

Not much of a class diagram hierarchy to show

modMain Module Listing

Module modMain
 
  Sub Main()
 
    'Sample Data - one of each kind
    Dim TextData As String = "<<TextData>>"
    Dim XMLData As Xml.XmlDocument = New Xml.XmlDocument
    XMLData.LoadXml("<xMLData />")
    Dim SQLData As DataTable = New DataTable("SQLDataTable")
 
    Dim oPrintFormatter As PrintFormatter
    oPrintFormatter = New PrintFormatter(PrintFormatter.DataRepresentation.TextFormat)
    oPrintFormatter.TextData = TextData
    oPrintFormatter.PrintFormattedData()
 
    oPrintFormatter = New PrintFormatter(PrintFormatter.DataRepresentation.XMLFormat)
    oPrintFormatter.XMLData = XMLData
    oPrintFormatter.PrintFormattedData()
 
    oPrintFormatter = New PrintFormatter(PrintFormatter.DataRepresentation.SQLDataTableFormat)
    oPrintFormatter.SQLData = SQLData
    oPrintFormatter.PrintFormattedData()
 
    Console.ReadLine()
  End Sub
 
End Module

Let’s put our application to the test

Alright, things look good for a one off application requirement. However, extending this design to support additional data formats would require modifying the PrintFormatter class by adding additional data representations and modifying the PrintFormattedData method. A template method pattern can be effectively used in this example to eliminate the need to modify the base class and extending the base class to support additional data formats.
The primary idea behind the template method is to use a method to perform the actions that are common across representations – printing the header and footer while leaving the task of printing specific data representations to abstract methods. The PrintFormatter class can then be extended by the TextPrintFormatter to provide the implementation for printing text data. Similarly the XMLPrintFormatter can implement the abstract PrintSpecificData method to print XML Data while the SQLPrintFormatter can provide the SQL data printing logic.

PrintFormatter Class Listing

Public MustInherit Class PrintFormatter
 
  'Our Template method
  Public Sub PrintFormattedData()
    PrintHeader()
    PrintSpecificData()
    PrintFooter()
  End Sub
 
  'Some methods that provide a default implementation
  Public Sub PrintHeader()
    Console.WriteLine("This represents the page header")
  End Sub
 
  Public Sub PrintFooter()
    Console.WriteLine("This represents the page footer")
  End Sub
 
  'Abstract methods
  Public MustOverride Sub PrintSpecificData()
 
End Class

TextPrintFormatter Class Listing

Public Class TextPrintFormatter
  Inherits PrintFormatter
 
  Private _TextData As String
 
  Public Sub New(ByVal TextData As String)
    _TextData = TextData
  End Sub
 
  Public Overrides Sub PrintSpecificData()
    Console.WriteLine("This represents the formatted text data - " & _TextData)
  End Sub
End Class

XMLPrintFormatter Class Listing

Public Class XMLPrintFormatter
  Inherits PrintFormatter
 
  Private _XMLData As Xml.XmlDocument
 
  Public Sub New(ByVal XMLData As Xml.XmlDocument)
    _XMLData = XMLData
  End Sub
 
  Public Overrides Sub PrintSpecificData()
    Console.WriteLine("This represents the formatted XML data - " & _XMLData.OuterXml)
  End Sub
End Class

SQLDataPrintFormatter Class Listing

Public Class SQLDataPrintFormatter
  Inherits PrintFormatter
 
  Private _SQLData As DataTable
 
  Public Sub New(ByVal SQLData As DataTable)
    _SQLData = SQLData
  End Sub
 
  Public Overrides Sub PrintSpecificData()
    Console.WriteLine("This represents the formatted SQL data - " & _SQLData.TableName)
  End Sub
End Class

The Template method pattern class hierarchy

modMain Module Listing

Module modMain
 
  Sub Main()
    'Sample Data - one of each kind
    Dim TextData As String = "<<TextData>>"
    Dim XMLData As Xml.XmlDocument = New Xml.XmlDocument
    XMLData.LoadXml("<xMLData />")
    Dim SQLData As DataTable = New DataTable("SQLDataTable")
 
    Dim oPrintFormatter As PrintFormatter
 
    oPrintFormatter = New TextPrintFormatter(TextData)
    oPrintFormatter.PrintFormattedData()
 
    oPrintFormatter = New XMLPrintFormatter(XMLData)
    oPrintFormatter.PrintFormattedData()
 
    oPrintFormatter = New SQLDataPrintFormatter(SQLData)
    oPrintFormatter.PrintFormattedData()
 
    Console.ReadLine()
  End Sub
 
End Module

And a look at the results

Singleton Design Pattern

2008-01-02T11:43:00.000-08:00

For this example, we will design an application to remotely monitor the temperature and memory usage of the PC. Each monitoring function runs in a separate thread and monitors corresponding elements to produce a value every 1 second. This information needs to be relayed across to the remote device connected via the Serial communication interface of the PC.
Well with requirements as simple as this, let’s dig in

TemperatureMonitor Class Listing

Public Class TemperatureMonitor
  Private _IsExitSignalled As Boolean
 
  Public Sub New()
    _IsExitSignalled = False
  End Sub
 
  Public Sub StartMonitoring()
    Dim oSerialCommunicator As SerialCommunicator = New SerialCommunicator
    Dim th As System.Threading.Thread = New System.Threading.Thread(AddressOf _MonitoringThread)
    th.Start(oSerialCommunicator)
  End Sub
 
  Private Sub _MonitoringThread(ByVal oSerialCommunicator As Object)
    Dim oSC As SerialCommunicator = CType(oSerialCommunicator, SerialCommunicator)
    Do
      'Add steps here to perform actual temperatur monitoring,
      oSC.SendMonitoredInfo("Memory Temperature Message")
      Threading.Thread.Sleep(2000) 'Sleep for 2 seconds
    Loop Until _IsExitSignalled
  End Sub
 
  Public Sub SignalExit()
    _IsExitSignalled = True
  End Sub
End Class

MemoryMonitor Class Listing

Public Class MemoryMonitor
  Private _IsExitSignalled As Boolean
 
  Public Sub New()
    _IsExitSignalled = False
  End Sub
 
  Public Sub StartMonitoring()
    Dim oSerialCommunicator As SerialCommunicator = New SerialCommunicator
    Dim th As System.Threading.Thread = New System.Threading.Thread(AddressOf _MonitoringThread)
    th.Start(oSerialCommunicator)
  End Sub
 
  Private Sub _MonitoringThread(ByVal oSerialCommunicator As Object)
    Dim oSC As SerialCommunicator = CType(oSerialCommunicator, SerialCommunicator)
    Do
      'Add steps here to perform actual memory monitoring,
      oSC.SendMonitoredInfo("Memory Monitor Message")
      Threading.Thread.Sleep(2000) 'Sleep for 2 seconds
    Loop Until _IsExitSignalled
  End Sub
 
  Public Sub SignalExit()
    _IsExitSignalled = True
  End Sub
End Class

SerialCommunicator Class Listing

Public Class SerialCommunicator
 
  Public Sub New()
    'Open the communication port
    Console.WriteLine("Opening Serial Port")
  End Sub
 
  Public Sub SendMonitoredInfo(ByVal Message As String)
    Console.WriteLine("Sending message " & Message)
  End Sub
 
End Class

And here is what our classes look like

So what else, well the test harness to test our little application

modMain Module Listing

Module modMain
  Sub Main()
    Dim oTemperatureMonitor As TemperatureMonitor = New TemperatureMonitor
    Dim oMemoryMonitor As MemoryMonitor = New MemoryMonitor
 
    oTemperatureMonitor.StartMonitoring()
    oMemoryMonitor.StartMonitoring()
 
    Console.WriteLine("Press Enter to stop monitoring")
    Console.ReadLine()
 
    oTemperatureMonitor.SignalExit()
    oMemoryMonitor.SignalExit()
 
    Console.WriteLine("Monitoring stopped")
    Console.ReadLine()
  End Sub
End Module

And a first look at the results

All this looks pretty simple on the face of it; however, as any experienced programmer who has used the COM port of a PC will tell you, you cannot concurrently open the same port more than once. This implies that the information that the Temperature Monitoring thread will produce will need to be sent over the serial interface in a timeshared fashion along with the information produced by the Memory Monitoring thread. This also implies that the highlighted portion in the output which indicates that the port has been opened concurrently is an issue and this application cannot be used for sending messages out.
So, how do we fix this port sharing issue? Put the Singleton pattern to use. We transform our SerialCommunicator class into a singleton so that it returns a single instance of itself to all requesting methods. With only a single instance of the SerialCommunicator, we eliminate the issue of opening the serial port concurrently. To transform this class into a Singleton, the first thing we need to do is to prevent its external instantiation using the New keyword. We can achieve this by changing the scope of the constructor to Private.
Hold on, won’t that prevent object instantiation? In the conventional sense, Yes! However a private constructor implies that the object can be instantiated within the class. What good is that? How will our TemperatureMonitor and MemoryMonitor acquire this instance? Ok, Enough beating around the bush. Just add a shared method that creates and returns an instance of the class. Ensure that it creates an instance only if an instance of the class does not exist. If an instance exists, it simply returns that instance.
Well, here is the new and improved Singleton SerialCommunicator class –

SerialCommunicator Class Listing

Public Class SerialCommunicator
 
  Private Shared _oSerialCommunicator As SerialCommunicator
 
  Private Sub New()
    'Open the communication port
    Console.WriteLine("Opening Serial Port")
  End Sub
 
  Public Shared Function GetSerialCommunicator() As SerialCommunicator
    If _oSerialCommunicator Is Nothing Then
      _oSerialCommunicator = New SerialCommunicator
    End If
    Return _oSerialCommunicator
  End Function
 
  Public Sub SendMonitoredInfo(ByVal Message As String)
    SyncLock Me
      Console.WriteLine("Sending message " & Message)
    End SyncLock
  End Sub
 
End Class

We need to change our TemperatureMonitor and MemoryMonitor classes as well since the public constructor of the SerialCommunicator is no longer available.

TemperatureMonitor StartMonitoring Method Listing

Public Class TemperatureMonitor
  'No change in code here
 
  Public Sub StartMonitoring()
    Dim oSerialCommunicator As SerialCommunicator = SerialCommunicator.GetSerialCommunicator
    Dim th As System.Threading.Thread = New System.Threading.Thread(AddressOf _MonitoringThread)
    th.Start(oSerialCommunicator)
  End Sub
 
  'No change in code or here
End Class

MemoryMonitor StartMonitoring Method Listing

Public Class MemoryMonitor
  'No change in code here
 
  Public Sub StartMonitoring()
    Dim oSerialCommunicator As SerialCommunicator = SerialCommunicator.GetSerialCommunicator
    Dim th As System.Threading.Thread = New System.Threading.Thread(AddressOf _MonitoringThread)
    th.Start(oSerialCommunicator)
  End Sub
 
  'No change in code here
End Class

Our class diagram is identical to our original. The only difference being the scope of the SerialCommunicator constructor and an additional method in the same class to create and return an instance of the SerialCommunicator class.

With no change in our test harness, let’s put our application to the test

Notice that we only have one “Opening Serial Port” message indicating our Singleton pattern is in effect.

Adapter Design Pattern

2008-01-02T11:22:00.000-08:00

Let us extend our simulation game example and introduce some animals in addition to the Human characters. For example, Trained elephants or Elephants for short. These trained elephants share a common behavior with other animals, say, Sleep, Drink, Eat and Graze. These elephants, being trained for warfare can also Move and Fight similar to Human characters. For this example, I will consider the Soldier who implements the Eat, Talk, Fight and Move behavior from the GameCharacter interface.

GameCharacter Interface Listing

Public Interface GameCharacter
  Sub Eat()
  Sub Talk()
  Sub Fight()
  Sub Move()
End Interface

Soldier Class Listing

Public Class Soldier
  Implements GameCharacter
 
  Public Sub Eat() Implements GameCharacter.Eat
    Console.WriteLine("Soldier is eating")
  End Sub
 
  Public Sub Fight() Implements GameCharacter.Fight
    Console.WriteLine("Soldier is fighting")
  End Sub
 
  Public Sub Move() Implements GameCharacter.Move
    Console.WriteLine("Soldier is moving slowly")
  End Sub
 
  Public Sub Talk() Implements GameCharacter.Talk
    Console.WriteLine("Soldier is talking")
  End Sub
End Class

Let us assume that the Animal class and the inheriting sub-classes for specific animals were created by another developer on the team.

Animal Class Listing

Public MustInherit Class Animal
  Public Sub Sleep()
    Console.WriteLine("Animal is sleeping")
  End Sub
 
  Public Sub Drink()
    Console.WriteLine("Animal is drinking")
  End Sub
 
  Public Sub Eat()
    Console.WriteLine("Animal is eating")
  End Sub
 
  Public Sub Graze()
    Console.WriteLine("Animal is grazing")
  End Sub
 
  Public Sub MakeSound()
    Console.WriteLine("Animal is making some noise")
  End Sub
End Class

The TrainedElephant class extends the Animal class by adding the Move and Attack methods

TrainedElephant Class Listing

Public Class TrainedElephant
  Inherits Animal
 
  Public Sub Move()
    Console.WriteLine("TrainedElephant is moving")
  End Sub
 
  Public Sub Attack()
    Console.WriteLine("TrainedElephant is attack")
  End Sub
End Class

Let us have a quick look at our class and interface hierarchy

And finally, lets list our requirement. With an existing design that resembles this, we would like to maintain a list of all character instances in the game including humans as well as animals that can fight and move. A quick solution is to use a generic list that holds GameCharacter objects. Since Soldiers natively implement the GameCharacter interface, it is quite easy to add a Soldier to this list. However, there is no relation between the Animal class and the GameCharacter interface and neither does the TrainedElephant class implement the Animal interface. It, therefore makes it impossible to add the TrainedElephant as a GameCharacter to the list.

One solution is to modify the code for the TrainedElephant class so that it implements the GameCharacter Interface. Although this seems easy from the looks of it, this may not be practical in a real life application where this portion of the code is built by another developer or when the source code for this class is not available for modification. In such scenarios, we can employ the services of the Adapter pattern to adapt the functionality of the TrainedElephant class to map to the GameCharacter class.
The TrainedElephantAdapter class simply wraps around a TrainedElephant object while implementing the GameCharacter interface. Thus, we do not need to modify the source code for the TrainedElephant or the Animal class and can use this TrainedElephantAdapter object interchangeably as a GameCharacter.

TrainedElephantAdapter Class Listing

Public Class TrainedElephantAdapter
  Implements GameCharacter
 
  Private _oElephant As TrainedElephant
 
  Public Sub New(ByVal oElephant As TrainedElephant)
    _oElephant = oElephant
  End Sub
 
  Public Sub Eat() Implements GameCharacter.Eat
    _oElephant.Eat()
  End Sub
 
  Public Sub Fight() Implements GameCharacter.Fight
    _oElephant.Attack()
  End Sub
 
  Public Sub Move() Implements GameCharacter.Move
    _oElephant.Move()
  End Sub
 
  Public Sub Talk() Implements GameCharacter.Talk
    _oElephant.MakeSound()
  End Sub
End Class

Our class diagram now contains our new TrainedElephantAdapter which encapsulates the TrainedElephant object while implementing the GameCharacter interface

Finally, a little test harness using the TrainedElephantAdapter to do the magic for us

modMain Module Listing

Module modMain
  Sub Main()
    Dim GameCharacters As List(Of GameCharacter) = New List(Of GameCharacter)
    GameCharacters.Add(New Soldier)
    'And here is the Wrapped up TrainedElephant
    GameCharacters.Add(New TrainedElephantAdapter(New TrainedElephant))
 
    For Each oGC As GameCharacter In GameCharacters
      oGC.Eat() : oGC.Fight() : oGC.Move() : oGC.Talk()
    Next
    Console.ReadLine()
  End Sub
End Module

And the results of using the Adapter pattern

Facade Design Pattern

2008-01-02T11:09:00.000-08:00

The Facade pattern is probably one of the most frequently used design patterns. When a class requires the functionality derived from different classes, it is often useful to use a façade class that encapsulates the calls to the various classes. This class can then be effectively used instead of making calls to the individual classes and improves code reuse. Additionally, if we decide to make changes to the encapsulated classes, all we need to alter are the method invocations in the façade class.
Consider a business application for a mortgage company. The Mortgage Company uses multiple services that are both internal to the company as well as require interaction with other parties to determine if a loan can be sanctioned. Using the Facade pattern here is easy, create a class say LoanHelper. We can then create shared method unless you prefer to create an instance of the LoanHelper. Add the method calls to the different internal and external services. This LoanHelper method can then be used anywhere within your code to validate a prospect before allotting a loan and determining the rate of interest.

LoanHelper Class Listing

Public Class LoanHelper
 
  Public Const DEFAULT_LOAN_PERCENT As Double = 10.0
 
  Public Shared Function GetEligbleLoanCriteria(ByVal SSN As String, ByVal RequiredLoanAmount As Double, _
   ByRef EligibleLoanAmount As Double, ByRef EligibleLoanPercent As Double) As Boolean
    'Add the method calls to various systems - internal and external to determine 
    'the values of EligibleLoanAmount and the EligibleLoanAmount
    EligibleLoanAmount = 100000
    EligibleLoanPercent = 8.25
    Console.WriteLine("Façade class LoanHelper was invoked to determine Eligible Loan Criteria")
    Return True  'Return false if SSN failed to match
  End Function
End Class

modMain Module Listing

Module modMain
  Sub Main()
    Dim SSN As String = "SampleSSN"
    Dim RequiredLoanAmount As Double = 100000
    Dim EligibleLoanAmount As Double = 0
    Dim EligibleLoanPercent As Double = LoanHelper.DEFAULT_LOAN_PERCENT
    Dim IsSSNMatch As Boolean = LoanHelper.GetEligbleLoanCriteria(SSN, RequiredLoanAmount, _
     EligibleLoanAmount, EligibleLoanPercent)
    Console.ReadLine()
  End Sub
End Module

A look at the classes

And the results

State Design Pattern

2008-01-02T00:51:00.001-08:00

For this example, let us assume that we would like to design an application that simulates the interaction in a single character game. The character, in this game, can be moving on the ground, swimming under water, flying an airplane or driving a car. Each gaming episode may involve the character in any one of these conditions. The character is expected to navigate in these different environments using the same navigation keys on the keyboard. Additionally, the character may use the Action Key (say Control key on the keyboard) to perform actions that are relevant to each environment. While on ground, the Action Key is used to talk; while in water, it is used to float up for a breath of air, while in an airplane, to get directions and while in the car, to use the GPS.
A map of the keys versus environments is listed here

Key	Ground	Underwater	Airplane	Car
Front Direction	Move Forward	Swim Forward	Increase Throttle	Accelerate
Back Direction	Move Backward	Swim Backward	Decrease Throttle	Decelerate
Right Direction	Move Angular Right	Swim Angular Right	Change Direction to the Right	Turn Car to the Right
Left Direction	Move Angular Left	Swim Angular Left	Change Direction to the Left	Turn Car to the Left
Action	Talk	Surface for Air	Get directions	Use GPS

A first take at this design would be by starting off creating a GameCharacter class. The interactions that are possible would be based on the key strokes that the GameCharacter supports. Let me map them to the normal gaming keys on the keyboard – UpArrowPressed, DownArrowPressed, RightPressed and LeftPressed to cover the navigation areas and the ActionPressed method for supporting the character’s action feature. The State of the environment can be stored in an instance value that holds an enumeration.

GameCharacter Class Listing

Public Class GameCharacter
  Private Enum EnvironmentStates
    Land
    Underwater
    Airplane
    Car
  End Enum
 
  Private _EnvironmentState As EnvironmentStates
 
  Public Sub New()
    'All episodes start with the character on Land
    _EnvironmentState = EnvironmentStates.Land
  End Sub
 
  Public Sub UpArrowPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is moving forward")
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is swimming forward")
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is increasing throttle")
      Case EnvironmentStates.Car
        Console.WriteLine("Character is accelerating")
    End Select
  End Sub
 
  Public Sub DownArrowPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is moving backwards")
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is swimming backwards")
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is decreasing throttle")
      Case EnvironmentStates.Car
        Console.WriteLine("Character is decelerating")
    End Select
  End Sub
 
  Public Sub RightArrowPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is moving at an angular right")
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is swimming at an angular right")
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is changing directionto the right")
      Case EnvironmentStates.Car
        Console.WriteLine("Character is turning car to the right")
    End Select
  End Sub
 
  Public Sub LeftArrowPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is moving at an angular left")
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is swimming at an angular left")
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is changing directionto the left")
      Case EnvironmentStates.Car
        Console.WriteLine("Character is turning car to the left")
    End Select
  End Sub
 
  Public Sub ActionPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is talking")
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is surfacing for air")
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is getting directions")
      Case EnvironmentStates.Car
        Console.WriteLine("Character is using the GPS")
    End Select
  End Sub
End Class

Additionally, while in water, if the character reaches the edge of the water body, user will jump out of water and be on solid ground. Similarly, reaching the landing area, whilst in an airplane, will move the character on the ground. In a similar fashion, the character will change environments when he reaches the periphery of that environment. Ground is compatible with all the three environments and changes are triggered in both directions on reaching appropriate boundaries. Environment changes between other boundaries are not possible.

Environment	Water boundary	Airport boundary	Parking Lot boundary
Land	Jump underwater	Jump inside Airplane	Jump inside Car
Underwater	Jump on Land*	Not Applicable	Not Applicable
Airplane	Not Applicable	Jump on Land*	Not Applicable
Car	Not Applicable	Not Applicable	Jump on Land*

* Next corresponding boundary

We can extend our design to add instance variables that can help define the boundary parameters. Note that while on land – a two dimensional co-ordinate system can be used to map the boundary, however while in water or in air, we need a three dimensional co-ordinate system to store the depth and height respectively in addition to the x and y co-ordinates.

Additional Instance variables

  Private _XCoord As Integer
  Private _YCoord As Integer
  Private _DepthCoord As Integer
  Private _HeightCoord As Integer
  Private _OpenLandXDimension As Integer
  Private _OpenLandYDimension As Integer
  Private _WaterXDimension As Integer
  Private _WaterYDimension As Integer
  Private _WaterDepthDimension As Integer
  Private _AirplaneXDimension As Integer
  Private _AirplaneYDimension As Integer
  Private _AirplaneHeightDimension As Integer
  Private _RoadXDimension As Integer
  Private _RoadYDimension As Integer

Modified constructor

  Public Sub New()
    'All episodes start with the character on Land
    _EnvironmentState = EnvironmentStates.Land
    ' ... at location 0,0; isn't that nice.
    _XCoord = 0 : _YCoord = 0 : _DepthCoord = 0 : _HeightCoord = 0
 
    'Define the dimensions of each environment
    _OpenLandXDimension = 100 : _OpenLandYDimension = 100
    _WaterXDimension = 100 : _WaterYDimension = 100 : _WaterDepthDimension = 50
    _AirplaneXDimension = 100 : _AirplaneYDimension = 100 : _AirplaneHeightDimension = 200
    _RoadXDimension = 50 : _RoadYDimension = 200
  End Sub

Boundary determining functions

  Private Function _IsWaterBoundaryEncountered() As Boolean
    'Use the layout map and the current X and Y coordinates and the Depth coordinate to determine if the water boundary is encountered
    'the depth coordinate is useful when the current state is in water
  End Function
 
  Private Function _IsAirportBoundaryEncountered() As Boolean
    'Use the layout map and the current X and Y coordinates as well as the Height coordinate to determine if the airport boundary is encountered
    'the height coordindate is useful when the current state is in the airplane
  End Function
 
  Private Function _IsParkingLotBoundaryEncountered() As Boolean
    'Use the layout map and the current X and Y coordinates as well as the coordinate to determine if the parking lot boundary is encountered
  End Function

Partially modified listing of the UpArrowPressed method

  Public Sub UpArrowPressed()
    Select Case _EnvironmentState
      Case EnvironmentStates.Land
        Console.WriteLine("Character is moving forward")
        _XCoord += 1
 
        Select Case True
          Case _IsWaterBoundaryEncountered()
            _EnvironmentState = EnvironmentStates.Underwater
            _XCoord = 0 : _YCoord = 0 : _DepthCoord = 1
 
          Case _IsAirportBoundaryEncountered()
            _EnvironmentState = EnvironmentStates.Airplane
            _XCoord = 0 : _YCoord = 0 : _HeightCoord = 1
 
          Case _IsParkingLotBoundaryEncountered()
            _EnvironmentState = EnvironmentStates.Car
            _XCoord = 0 : _YCoord = 0
        End Select
 
      Case EnvironmentStates.Underwater
        Console.WriteLine("Character is swimming forward")
        'Repeat similar code here
 
      Case EnvironmentStates.Airplane
        Console.WriteLine("Character is increasing throttle")
        'Repeat similar code here
 
      Case EnvironmentStates.Car
        Console.WriteLine("Character is accelerating")
        'Repeat similar code here
    End Select
  End Sub

Of course, besides navigating in these environments, the character performs a number of actions that are not relevant in the context of this example and I have deliberately avoided them (at least for now)
Well, we have a working design and things look good. A closer look at the code brings out the following issues –

The instance variable definition shows that a lot of variables only have contextual meaning based on the state of the character. For example, the _DepthCoord and the _HeightCoord have no meaning when the GameCharacter is on ground or while he is driving a car.

Each supported keystroke handler has the same “Select Case” code blocks to determine their action based on the state of the GameCharacter.

State transitions are interspersed in code making it almost impossible to understand when a transition takes place.

Adding a new state – say Sailing in a boat will require rework of each keystroke handler and additional rework on maintaining the correct state when the boundary is encountered. This implies that the entire GameCharacter class will need to be checked for changes and at least five methods will need to be altered in addition to adding instance variables to represent state specific behavior.

So how do we fix this? Quite easily, as a matter of fact, all we need to do is build a state interface that provides methods to address the keystrokes and implement each required state to handle the keystrokes as it sees fit in its environment. The GameCharacter simply holds the instance of the current state and delegates all keystrokes to the current state instance.

IEnvironmentState Interface Listing

Public Interface IEnvironmentState
  Sub UpArrowPressed()
  Sub DownArrowPressed()
  Sub RightArrowPressed()
  Sub LeftArrowPressed()
  Sub ActionPressed()
End Interface

Move the responsibility of holding and determining the environment boundaries to the GameEnvironmentManager class

GameEnvironmentManager Class Listing

Public Class GameEnvironmentManager
 
  Private _OpenLandXDimension As Integer
  Private _OpenLandYDimension As Integer
  Private _WaterXDimension As Integer
  Private _WaterYDimension As Integer
  Private _WaterDepthDimension As Integer
  Private _AirplaneXDimension As Integer
  Private _AirplaneYDimension As Integer
  Private _AirplaneHeightDimension As Integer
  Private _RoadXDimension As Integer
  Private _RoadYDimension As Integer
 
  Public Sub New()
    'Define the dimensions of each environment
    _OpenLandXDimension = 100 : _OpenLandYDimension = 100
    _WaterXDimension = 100 : _WaterYDimension = 100 : _WaterDepthDimension = 50
    _AirplaneXDimension = 100 : _AirplaneYDimension = 100 : _AirplaneHeightDimension = 200
    _RoadXDimension = 50 : _RoadYDimension = 200
  End Sub
 
  Public Function IsWaterBoundaryEncountered(ByVal XCoord As Integer, ByVal YCoord As Integer) As Boolean
    'Use the X and Y coord to determine if the Water boundary is encountered
  End Function
 
  Public Function IsWaterBoundaryEncountered(ByVal XCoord As Integer, ByVal YCoord As Integer, ByVal DepthCoord As Integer) As Boolean
    'Use the X and Y coord alongwith the depth to determine if the Water boundary is encountered
  End Function
 
  'Other functions to determine the other boundaries
End Class

Implement each state and control the state of the GameCharacter appropriately by creating classes for WalkingLand, SwimmingUnderWater, FlyingAirplane and DrivingCar

WalkingLand Class Listing

Public Class WalkingLand
  Implements IEnvironmentState
 
  Private _oGameCharacter As GameCharacter
  Private _oGEM As GameEnvironmentManager
  Private _XCoord As Integer
  Private _YCoord As Integer
 
  Public Sub New(ByVal oGameCharacter As GameCharacter, ByVal oGEM As GameEnvironmentManager)
    _oGameCharacter = oGameCharacter
    _oGEM = oGEM
    _XCoord = 0
    _YCoord = 0
  End Sub
 
  Public Sub UpArrowPressed() Implements IEnvironmentState.UpArrowPressed
    Console.WriteLine("Character is moving forward")
    _XCoord += 1
    _HandleIfBoundaryEncountered()
  End Sub
 
  Public Sub DownArrowPressed() Implements IEnvironmentState.DownArrowPressed
    Console.WriteLine("Character is moving backwards")
    _XCoord -= 1
    _HandleIfBoundaryEncountered()
  End Sub
 
  Public Sub RightArrowPressed() Implements IEnvironmentState.RightArrowPressed
    Console.WriteLine("Character is moving at an angular right")
    _XCoord += 1 : _YCoord -= 1
    _HandleIfBoundaryEncountered()
  End Sub
 
  Public Sub LeftArrowPressed() Implements IEnvironmentState.LeftArrowPressed
    Console.WriteLine("Character is moving at an angular left")
    _XCoord += 1 : _YCoord += 1
    _HandleIfBoundaryEncountered()
  End Sub
 
  Public Sub ActionPressed() Implements IEnvironmentState.ActionPressed
    Console.WriteLine("Character is talking")
  End Sub
 
  Private Sub _HandleIfBoundaryEncountered()
    Select Case True
      Case _oGEM.IsWaterBoundaryEncountered(_XCoord, _YCoord)
        _oGameCharacter.EnvironmentState = New SwimmingUnderwater(_oGameCharacter, _oGEM)
 
        'Other boundary encountered statements go here
    End Select
  End Sub
End Class

GameCharacter Class Listing

Public Class GameCharacter
  Private _oEnvironmentState As IEnvironmentState
  Private _oGEM As GameEnvironmentManager
 
  Public Sub New()
    _oGEM = New GameEnvironmentManager
    'All episodes start with the character on Land
    _oEnvironmentState = New WalkingLand(Me, _oGEM)
  End Sub
 
  Public Sub UpArrowPressed()
    _oEnvironmentState.UpArrowPressed()
  End Sub
 
  Public Sub DownArrowPressed()
    _oEnvironmentState.DownArrowPressed()
  End Sub
 
  Public Sub RightArrowPressed()
    _oEnvironmentState.RightArrowPressed()
  End Sub
 
  Public Sub LeftArrowPressed()
    _oEnvironmentState.DownArrowPressed()
  End Sub
 
  Public Sub ActionPressed()
    _oEnvironmentState.ActionPressed()
  End Sub
 
  Public WriteOnly Property EnvironmentState() As IEnvironmentState
    Set(ByVal value As IEnvironmentState)
      _oEnvironmentState = value
    End Set
  End Property
End Class

I have ignored the details of the other classes to reduce the code bulk in this example. This design completely separates the GameCharacter from its constituent states and the behavior of the GameCharacter is delegated to the individual states. Interestingly, each state may need to be aware of other related transitioning states in the system so that a state transition can be effectively addressed. An alternative to our design is to have these states predefined in the GameCharacter class and simply trigger the GameCharacter class via public methods to set its next state appropriately. This alternate design will eliminate any need for the implementing EnvironmentStates to know about each other and the entire controlling mechanism is built in the GameCharacter class.
Selecting an appropriate design choice depends on how best you feel about handling additional states or packaging components.

I have built a test harness to test our GameCharacter and its reaction based on Keystrokes. For the sake of keeping the example short, I have forced a return value of true for the boundary condition tests when the GameCharacter moves forward and when it surfaces for air after swimming backward.

modMain Module Listing

Module modMain
  Sub Main()
    Dim oGameCharacter As GameCharacter = New GameCharacter
    oGameCharacter.UpArrowPressed()  'This will trigger Swimming in water
    oGameCharacter.DownArrowPressed()
    oGameCharacter.ActionPressed() 'This will trigger Jumping on Land
    oGameCharacter.UpArrowPressed()  'This will trigger Swimming in water again, but we wont test it
    Console.ReadLine()
  End Sub
End Module

And the results

Strategy Design Pattern

2008-01-01T10:45:00.000-08:00

Consider the following example – We need to develop the framework for a game design (Age of Empires is a good example) that requires simulation of individual characters. Let us start this design by considering a couple of character types – peasants and soldiers with the following characteristics for these characters

Both peasants and soldiers can eat and talk

Peasants can move slowly (well walk) while soldiers can move fast

Peasants cannot fight whereas soldiers can fight

A person well conversant with OOPS would start out by building this design based on a GameCharacter abstract class that will provide the default implementations for the common methods say eat and talk while leaving the implementation of methods such as move and fight to the sub classes.

GameCharacter Class Listing

Public MustInherit Class GameCharacter
  Public Sub Eat()
    Console.WriteLine("Character is eating")
  End Sub
 
  Public Sub Talk()
    Console.WriteLine("Character is talking")
  End Sub
 
  Public MustOverride Sub Move()
  Public MustOverride Sub Fight()
End Class

The Peasant class and the Soldier class can then inherit from the GameCharacter class providing concrete implementations of the Move and the Fight methods

Peasant Class Listing

Public Class Peasant
  Inherits GameCharacter
 
  Public Overrides Sub Fight()
    Console.WriteLine("Character cannot fight")
  End Sub
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving slowly")
  End Sub
End Class

Soldier Class Listing

Public Class Soldier
  Inherits GameCharacter
 
  Public Overrides Sub Fight()
    Console.WriteLine("Character is Fighting")
  End Sub
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

Let us now consider the introduction of a new character – the Cavalry man with the following characteristics

Cavalry man can fight

Cavalry man moves by riding a horse

Using our existing design, this is fairly easy to accomplish by creating another class – CavalryMan which implements the GameCharacter class and providing appropriate implementations for the Move and Fight methods. For sake of simplicity, I am ignoring the Horse at this point of time since it does not provide any independent behavior of its own.

CavalryMan Class Listing

Public Class CavalryMan
  Inherits GameCharacter
 
  Public Overrides Sub Fight()
    Console.WriteLine("Character is fighting")
  End Sub
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is riding a horse")
  End Sub
End Class

A quick view of the class diagram shows a fairly decent class hierarchy and the design seems to fit the requirements quite aptly.

If you review the code, you will find that both the Soldier and the CavalryMan provide the same implementation for the Fight method. Although, my example uses a single line of code to provide the appropriate implementation, real world classes will have complex logic that would be repeated in both these classes to provide this implementation. An alternative to this design might inspire a few programmers to suggest that we move the Fight method implementation to the GameCharacter abstract class and override this behavior in the Peasant sub-class. We can then consolidate the implementation at one location without need to rewrite the same implementation in the Soldier and CavalryMan sub-classes.

GameCharacter Class Listing

Public MustInherit Class GameCharacter
  Public Sub Eat()
    Console.WriteLine("Character is eating")
  End Sub
 
  Public Sub Talk()
    Console.WriteLine("Character is talking")
  End Sub
 
  Public Overridable Sub Fight()
    Console.WriteLine("Character is Fighting")
  End Sub
 
  Public MustOverride Sub Move()
End Class

Soldier Class Listing

Public Class Soldier
  Inherits GameCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

CavalryMan Class Listing

Public Class CavalryMan
  Inherits GameCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is riding a horse")
  End Sub
End Class

Clearly, the Peasant class requires no change and the original overriding of the Fight method provides its default behavior. The Class diagram is identical to our original class diagram barring the default method implementation of the Fight method and the missing implementations in the Soldier and the CavalryMan class.

Now, if we have to introduce another character – the Mason who exhibits the following characteristics

Mason cannot fight, a behavior that he shares with the peasant

Mason moves fast, a behavior that he shares with the soldier

Ah, we have a challenge at hand now. If we were to use our last idea, we could simply provide a default implementation of the Move method as well in the GameCharacter class, allowing the Mason and Soldier to move fast and therefore, requiring no special implementation of these methods in the Soldier and Mason classes. The Peasant and CavalryMan classes already provide their implementation of the Move method. The Fight method, would however pose a challenge of sorts. We would need to implement the behavior in the Mason class to override the default implementation in the GameCharacter class.

GameCharacter Class Listing

Public MustInherit Class GameCharacter
  Public Sub Eat()
    Console.WriteLine("Character is eating")
  End Sub
 
  Public Sub Talk()
    Console.WriteLine("Character is talking")
  End Sub
 
  Public Overridable Sub Fight()
    Console.WriteLine("Character is Fighting")
  End Sub
 
  Public Overridable Sub Move()
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

Soldier Class Listing

Public Class Soldier
  Inherits GameCharacter
 
  'Wow no implementation, 
  'does this mean the GameCharacter is a soldier by default. Hmm!
End Class

Mason Class Listing

Public Class Mason
  Inherits GameCharacter
 
  Public Overrides Sub Fight()
    Console.WriteLine("Character cannot fight")
  End Sub
End Class

Well, looks like we have a working solution to our requirement.

However, this design suffers from certain flaws that are readily visible. One of most obvious flaws is the GameCharacter representing the Soldier class by default. In a truly object oriented design, this could be read as GameCharacter and Soldier class being the same. Extending this statement to the implementing classes implies that

Peasant is a type of Soldier who walks slowly and does not fight

Mason is a type of Soldier who walks fast and does not fight

CavalryMan is a type of Soldier who rides instead of walking

Barring the last one pertaining to the CavalryMan, the other two definitions do not fit our logical definition of these characters.
The OOPS solution to this would be to increase the depth of inheritance by introducing an additional sub-class that can act as a super-type for characters that fight. The Soldier and CavalryMan could then extend from this FightingCharacter class while the Peasant and the Mason could extend from the GameCharacter Class.

GameCharacter Class Listing

Public MustInherit Class GameCharacter
  Public Sub Eat()
    Console.WriteLine("Character is eating")
  End Sub
 
  Public Sub Talk()
    Console.WriteLine("Character is talking")
  End Sub
 
  Public Overridable Sub Fight()
    Console.WriteLine("Character cannot fight")
  End Sub
 
  Public MustOverride Sub Move()
End Class

FightingCharacter Class Listing

Public MustInherit Class FightingCharacter
  Inherits GameCharacter
 
  Public Overrides Sub Fight()
    Console.WriteLine("Character is fighting")
  End Sub
End Class

Soldier Class Listing

Public Class Soldier
  Inherits FightingCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

CavalryMan Class Listing

Public Class CavalryMan
  Inherits FightingCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is riding a horse")
  End Sub
End Class

Peasant Class Listing

Public Class Peasant
  Inherits GameCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving slowly")
  End Sub
End Class

Mason Class Listing

Public Class Mason
  Inherits GameCharacter
 
  Public Overrides Sub Move()
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

The default Fight implementation of the GameCharacter class would prevent the character from fighting and therefore, the Peasant and Mason class would not need to provide any implementation for the Fight method. The default Fight implementation of the FightingCharacter class would provide the necessary Fighting ability to the class overriding the implementation of the GameCharacter class. The Soldier and CavalryMan class would not be required to provide any implementation of the Fight method simply inheriting the implementation of the FightingCharacter.

However, we would still need to resolve the Move implementation where classes in different hierarchies – Soldier from the FightingCharacter->GameCharacter hierarchy and Mason from the GameCharacter hierarchy need to provide the same implementation.
This approach would therefore not work out for us. Even complicating the design by creating a FastMovingCharacter class which extends the Gaming character and provides a “is moving fast” implementation of the Move method, then extending the Mason class and trying to extend the Soldier from the same class is not possible. This is primarily because multiple inheritance is not available to us and even using a language permitting this would complicate the application since it won’t be clear about the exact nature of implementation.
This brings us to revealing the second flaw in the design. The use of overriding is a cautious exercise and overriding without understanding its impact might complicate the understanding of the classes and their exact implementation nature.
Well, so what is the best design for this little requirement? Please welcome the Strategy pattern. It helps address requirements of our characters – Peasant, Mason, Soldier and Cavalryman by translating their Move and Fight methods into strategies. Each Strategy is declared within an interface and an unlimited number of implementations are then possible for this strategy. In our example, we can declare …

A couple of strategies for Fighting – Is Fighting and Cannot Fight.

Three strategies for Moving – Moving Fast, Moving Slowly, Riding a horse

Each strategy interface provides the methods required for the strategy. Let us consider these interfaces - FightStrategy interface for providing the Fight functionality and the MoveStrategy interface for providing the Move functionality.

FightStrategy Interface Listing

Public Interface FightStrategy
  Sub Fight()
End Interface

MoveStrategy Interface Listing

Public Interface MoveStrategy
  Sub Move()
End Interface

We can then implement the actual Fight strategies using the RealFighter and the WimpyFella classes where each class implements the FightStrategy providing a unique implementation for the Fight method.

RealFighter Class Listing

Public Class RealFighter
  Implements FightStrategy
 
  Public Sub Fight() Implements FightStrategy.Fight
    Console.WriteLine("Character is fighting")
  End Sub
End Class

WimpyFella Class Listing

Public Class WimpyFella
  Implements FightStrategy
 
  Public Sub Fight() Implements FightStrategy.Fight
    Console.WriteLine("Character cannot fight")
  End Sub
End Class

In the same fashion, let us create the three Move strategies based on our requirement – FastMover, SlowMover and the RidingMover classes that implement the Move method of the MoveStrategy

FastMover Class Listing

Public Class FastMover
  Implements MoveStrategy
 
  Public Sub Move() Implements MoveStrategy.Move
    Console.WriteLine("Character is moving fast")
  End Sub
End Class

SlowMover Class Listing

Public Class SlowMover
  Implements MoveStrategy
 
  Public Sub Move() Implements MoveStrategy.Move
    Console.WriteLine("Character is moving slowly")
  End Sub
End Class

RidingMover Class Listing

Public Class RidingMover
  Implements MoveStrategy
 
  Public Sub Move() Implements MoveStrategy.Move
    Console.WriteLine("Character is riding a horse")
  End Sub
End Class

We can then declare instance variables in the original GameCharacter class to represent the Fight and Move strategies. I generally use the naming convention that prefixes class names with the lower case letter o to represent objects. I will declare two variables – oMoveStrategy and oFightStrategy in my GameCharacter class. The default implementation of the Eat and Talk method can remain unchanged while the Move and Fight methods will delegate the responsibility of using the appropriate strategy to the instance variables. Although, I have left the instance variables at a Protected access scope, you might decide to use a Private scope and restrict the access via get/set methods. For sake of simplicity, I have defined a constructor that requires the two strategies. This will prevent invocation of the object’s Fight and Move methods without setting the two strategies.

GameCharacter Class Listing

Public Class GameCharacter
  Protected oFightStrategy As FightStrategy
  Protected oMoveStrategy As MoveStrategy
 
  Public Sub New(ByVal oFightStrategy As FightStrategy, ByVal oMoveStrategy As MoveStrategy)
    With Me
      .oFightStrategy = oFightStrategy
      .oMoveStrategy = oMoveStrategy
    End With
  End Sub
 
  Public Sub Eat()
    Console.WriteLine("Character is eating")
  End Sub
 
  Public Sub Talk()
    Console.WriteLine("Character is talking")
  End Sub
 
  Public Sub Fight()
    oFightStrategy.Fight()
  End Sub
 
  Public Sub Move()
    oMoveStrategy.Move()
  End Sub
End Class

We can now redefine our characters to extend the Gamecharacter class and all we need to provide is the correct instantiation parameters for the instance of the child class.

Peasant Class Listing

Public Class Peasant
  Inherits GameCharacter
 
  Public Sub New()
    MyBase.New(New WimpyFella, New SlowMover)
  End Sub
End Class

Soldier Class Listing

Public Class Soldier
  Inherits GameCharacter
 
  Public Sub New()
    MyBase.New(New RealFighter, New FastMover)
  End Sub
End Class

CavalryMan Class Listing

Public Class CavalryMan
  Inherits GameCharacter
 
  Public Sub New()
    MyBase.New(New RealFighter, New RidingMover)
  End Sub
End Class

Mason Class Listing

Public Class Mason
  Inherits GameCharacter
 
  Public Sub New()
    MyBase.New(New WimpyFella, New FastMover)
  End Sub
End Class

Well, that’s all there is to it.

To demonstrate the functionality, I built a console application around these classes.

modMain Module Listing

Module modMain
  Sub Main()
    Dim oGC As GameCharacter
    Console.WriteLine("Peasant") : oGC = New Peasant : oGC.Fight() : oGC.Move()
    Console.WriteLine("Soldier") : oGC = New Soldier : oGC.Fight() : oGC.Move()
    Console.WriteLine("CavalryMan") : oGC = New CavalryMan : oGC.Fight() : oGC.Move()
    Console.WriteLine("Mason") : oGC = New Mason : oGC.Fight() : oGC.Move()
  End Sub
End Module

And the results of our sample test application

Application Launch Directory

2007-12-17T21:45:00.000-08:00

A lot of Windows based applications generally require one or more files that are consumed by the application to be placed in the same folder hierarchy as the application. For example, if I need a couple of XML files, I generally create a folder called XMLData and place the files inside it.

Although accessing these file paths in code is pretty straightforward, there is a small caveat to it. A lot of users use the System.Environment.CurrentDirectory

This works well in most situations. Note how the tooltip states - "the directory from which this process starts".

However, if your application contains any piece of code that can alter the current working directory - say, you use a OpenFileDialog control to pick a file on the file system but do not restore the working directory by setting the RestoreDirectory property, this results in changing the current working directory and the quoted portion of the tooltip no longer holds good.

I would recommend using the Application.StartupPath instead of the System.Environment.CurrentDirectory. The folder path returned by this function is not altered during the course of execution of the application.

Console applications do not have access to the Application object and hence you might need to use the System.Reflection.Assembly.GetExecutingAssembly.Location method to get the full path of the console application. You can then use the IO.Path.GetDirectoryName method to extract the application launch directory.

Dynamic ComboBox in a DataGridView

2007-12-16T11:50:00.001-08:00

And here is the second installment. It is generally convenient to bind the grid column to a single datasource such that all dropdowns have identical items. However, certain applications require that the items in the dropdown depend upon other attributes of the row.

For this example, I will create a three column grid with the first column containing the Employee Name, the second one containing the Department and third one being the dynamic combobox column that lists the positions for the particular department.

Once again, I have created the datasources at runtime to provide a complete example. To add that dynamic feel, I have decided to handle a DataGridView event - CellValueChanged. You can of course set this value after binding the original gridview source as well.

The Setup code that declares two dummy datasources and binds the Employee datasource with the gridview.

    'Create the sample list of names
    Dim dtNames As DataTable = New DataTable
    dtNames.Columns.Add("Name", GetType(String))
    dtNames.Columns.Add("Department", GetType(String))
 
    Dim dr As DataRow
    dr = dtNames.NewRow : dr.Item("Name") = "Alvin Menezes" : dr.Item("Department") = "" : dtNames.Rows.Add(dr)
    dr = dtNames.NewRow : dr.Item("Name") = "Saikumar Chettiar" : dr.Item("Department") = "" : dtNames.Rows.Add(dr)
    dr = dtNames.NewRow : dr.Item("Name") = "Sample Name 1" : dr.Item("Department") = "" : dtNames.Rows.Add(dr)
    dr = dtNames.NewRow : dr.Item("Name") = "Sample Name 2" : dr.Item("Department") = "" : dtNames.Rows.Add(dr)
 
    'create the sample department - position choices
    dtChoices = New DataTable
    dtChoices.Columns.Add("Department", GetType(String))
    dtChoices.Columns.Add("Position", GetType(String))
 
    dr = dtChoices.NewRow : dr.Item("Department") = "IT" : dr.Item("Position") = "Tech Architect" : dtChoices.Rows.Add(dr)
    dr = dtChoices.NewRow : dr.Item("Department") = "IT" : dr.Item("Position") = "Project Manager" : dtChoices.Rows.Add(dr)
    dr = dtChoices.NewRow : dr.Item("Department") = "IT" : dr.Item("Position") = "Project Leader" : dtChoices.Rows.Add(dr)
    dr = dtChoices.NewRow : dr.Item("Department") = "IT" : dr.Item("Position") = "Developer" : dtChoices.Rows.Add(dr)
    dr = dtChoices.NewRow : dr.Item("Department") = "HR" : dr.Item("Position") = "Manager" : dtChoices.Rows.Add(dr)
    dr = dtChoices.NewRow : dr.Item("Department") = "HR" : dr.Item("Position") = "Executive" : dtChoices.Rows.Add(dr)
 
 
    'Bind the datagridview
    dgvSampleEx.AutoGenerateColumns = False
    dgvSampleEx.DataSource = dtNames

The code listing for the dynamic ComboBox rendering

  Private Sub dgvSampleEx_CellValueChanged(ByVal sender As Object, ByVal e As System.Windows.Forms.DataGridViewCellEventArgs) Handles dgvSampleEx.CellValueChanged
    If e.RowIndex < 0 Then
      Exit Sub
    End If
 
    If e.ColumnIndex = 1 Then
      Dim Department As String = CStr(dgvSampleEx.Rows(e.RowIndex).Cells(1).Value)
      Dim dv As DataView = New DataView(dtChoices, "Department = '" & Department & "'", "", DataViewRowState.CurrentRows)
 
      Dim dgvComboCell As DataGridViewComboBoxCell = CType(dgvSampleEx.Rows(e.RowIndex).Cells(2), DataGridViewComboBoxCell)
      With dgvComboCell
        .DisplayMember = "Position"
        .ValueMember = "Position"
        .DataSource = dv
      End With
    End If
  End Sub

Guess the trick is to know that binding a DataGridView column sets all dropdown elements to be identical whereas binding the DataGridViewCell gives you more control over the exact elements that need to be displayed in the dropdown choices.

And the results for all to see

Note how the dropdown values differ - depending on the Department that has been entered. Ideally, the Department could also be rendered as a combobox. I decided to go with plain text to keep this example simple.

ComboBox in a DataGridView

2007-12-16T11:29:00.000-08:00

It is often useful to add a dropdown box in a DataGridView column. I will list a couple of methods that can be used to achieve this. Of course, your real world applications will differ in certain areas related to the source of data. For the sake of this example, I have created these datasources at runtime.
The first example deals with displaying a two column grid with the first column containing the Employee Name and the second column that can be used to collect the Employee Gender

Drag a DataGridView on the form

Expand the DataGridView tasks and add a couple of columns
Set the DataPropertyName for the first column appropriately, Since my data source deals with Employee Names, I have selected 'Name' which corresponds to the column name in my datasource.

Finally, bind the data source with the grid and another datasource with the second column so that the dropdown choices are rendered correctly.
'Create the sample list of names
Dim dtNames As DataTable = New DataTable
dtNames.Columns.Add("Name", GetType(String))

Dim dr As DataRow
dr = dtNames.NewRow : dr.Item("Name") = "Alvin Menezes" : dtNames.Rows.Add(dr)
dr = dtNames.NewRow : dr.Item("Name") = "Saikumar Chettiar" : dtNames.Rows.Add(dr)
dr = dtNames.NewRow : dr.Item("Name") = "Sample Name 1" : dtNames.Rows.Add(dr)
dr = dtNames.NewRow : dr.Item("Name") = "Sample Name 2" : dtNames.Rows.Add(dr)

'Create the sample list of dropdown choices
Dim dtGenders As DataTable = New DataTable
dtGenders.Columns.Add("Gender", GetType(String))
dtGenders.Columns.Add("GenderId", GetType(Integer))

dr = dtGenders.NewRow : dr.Item("GenderId") = 1 : dr.Item("Gender") = "Male" : dtGenders.Rows.Add(dr)
dr = dtGenders.NewRow : dr.Item("GenderId") = 2 : dr.Item("Gender") = "Female" : dtGenders.Rows.Add(dr)

'Bind the datagridview
dgvSample.AutoGenerateColumns = False
dgvSample.DataSource = dtNames

'Setup the Combobox column
Dim dgvComboCol As DataGridViewComboBoxColumn = CType(dgvSample.Columns(1), DataGridViewComboBoxColumn)
With dgvComboCol
.DisplayMember = "Gender"
.ValueMember = "GenderId"
.DataSource = dtGenders
End With

And that's it, we are good to go

Scrollbar on a PictureBox, Nah!

2007-12-15T10:25:00.000-08:00

The quickest way to add a scrollbar to a PictureBox is not to add one to it. Instead drag a Panel on the Form. Set its AutoScroll property to True.

Now, drag a PictureBox on this panel, such that the panel becomes the parent container of this PictureBox control. Set the SizeMode property of the PictureBox to AutoSize.

Ensure that you set the location of the PictureBox to 0,0. This will align the PictureBox to the top left of the Panel.

And... well nothing. That's it. You can load any image in the PictureBox at Design / Run time and the panel will do the rest for you.

Basic XPath Query

2007-12-15T00:44:00.000-08:00

Consider the following the XML segment

<tests>
  <test title="Sample Test 1">
    <result type="Passed" status="0"/>
    <result type="Failed" status="0"/>
  </test>
  <test title="Sample Test 2">
    <result type="Passed" status="0"/>
    <result type="Failed" status="0"/>
  </test>
  <test title="Sample Test 3">
    <result type="Passed" status="1"/>
    <result type="Failed" status="0"/>
  </test>
  <test title="Sample Test 4">
    <result type="Passed" status="0"/>
    <result type="Failed" status="1"/>
  </test>
</tests>

Note: xdoc in the following example refers to an instance of Xml.XmlDocument that contains this XML document

To retrieve all test nodes from this XML Block, we can use the basic XPath query -

xDoc.SelectNodes("/tests/test")

To retrieve all result nodes that have the type attribute set to "Passed",

xDoc.SelectNodes("/tests/test/result[@type='Passed'")

To retrieve all result nodes that have the type attribute set to "Failed" and having a status of "0",

xDoc.SelectNodes("/tests/test/result[@type='Failed' and @status='0'")

To retrieve the second test node, we can use the following query

xDoc.SelectNodes("/tests/test[position()=2]")

The last one is especially useful if you do not have unique node identifier attributes and need to access the nth item from the node list. Of course, the other alternative is to use a for each loop and skip n-1 items from the top. But this is a far more elegant solution.

Multi Colored ComboboxListItems

2007-12-14T20:09:00.000-08:00

Requirement

Consider this, a list of Students and their overall performance. For the sake of this example, I will simply rate the performance at two levels

80% and above
below 80%

To easily discern between students at these performance levels, we can display the student listitems in different colors using the Combobox control.

A little about the Combobox Item rendering

Listitems in a combobox are rendered in one of two ways - an unselected listitem and a selected listitem.

Since we would like to render the Student Listitems based on the performance factor at two levels, we will require a total of four color combinations -

Students whose overall performance meets or exceeds 80%

Normal unselected

Selected

Students whose overall performance is below 80%

Normal unselected

Selected

Lets dig in

Having defined the colors that we can use for rendering the listitems, here are the steps that are required

Change the DrawMode property of the Combobox to OwnerDrawVariable. The default value is Normal.

Handle the MeasureItem event of the Combobox. This allows for manipulating the size of each Listitem. In this current example, I have simply set a fixed height and width, however based on the value of e.Index and its corresponding Listitem element, you can change these values if you wish to render the Listitems differently.

Private Sub cmbStudents_MeasureItem(ByVal sender As Object, ByVal e As System.Windows.Forms.MeasureItemEventArgs) _
Handles cmbStudents.MeasureItem

e.ItemHeight = 18 'Pick this based on desired height of the listitem
e.ItemWidth = cmbStudents.Width
End Sub

Handle the DrawItem event of the Combobox. Like the event name suggests, this event allows you to perform a custom draw of the Listitem every time the Listitem is displayed. For our example, it is sufficient to know that this event is fired each time a user expands the Combobox to view a list of items as well runs his mouse over the expanded list resulting in a hover selection of that listitem.

Private Sub cmbStudents_DrawItem(ByVal sender As Object, ByVal e As System.Windows.Forms.DrawItemEventArgs) _
Handles cmbStudents.DrawItem
  If e.Index < 0 Then
    Exit Sub
  End If

  'Get the Student object that needs to be rendered using the e.Index
  Dim oStudent As Student = CType(cmbStudents.Items(e.Index), Student)
  Dim DisplayStr As String = oStudent.Name

  Dim r As RectangleF = New RectangleF(e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height)

  If (e.State And DrawItemState.Selected) = DrawItemState.Selected Then
    If oStudent.OverallPerformanceScore > 80 Then
      e.Graphics.FillRectangle(Brushes.Lavender, r)
      e.Graphics.DrawString(DisplayStr, e.Font, System.Drawing.Brushes.Blue, r)
    Else
      e.Graphics.FillRectangle(Brushes.AntiqueWhite, r)
      e.Graphics.DrawString(DisplayStr, e.Font, System.Drawing.Brushes.Red, r)
    End If
  Else
    If oStudent.OverallPerformanceScore > 80 Then
      e.Graphics.FillRectangle(Brushes.GhostWhite, r)
      e.Graphics.DrawString(DisplayStr, e.Font, System.Drawing.Brushes.Blue, r)
    Else
      e.Graphics.FillRectangle(Brushes.SeaShell, r)
      e.Graphics.DrawString(DisplayStr, e.Font, System.Drawing.Brushes.Red, r)
    End If
  End If

  ' Draw the focus rectangle if mouse hovers over the item.
  e.DrawFocusRectangle()
End Sub

The Result

Student Class Listing

   Private Class Student
     Private _Name As String
     Private _OverallPerformanceScore As Double
   
     Public Sub New(ByVal Name As String, ByVal OverallPerformanceScore As Double)
       _Name = Name
       _OverallPerformanceScore = OverallPerformanceScore
     End Sub
   
     Public ReadOnly Property Name() As String
       Get
         Return _Name
       End Get
     End Property
   
     Public ReadOnly Property OverallPerformanceScore() As Double
       Get
         Return _OverallPerformanceScore
       End Get
     End Property
   
     Public Overrides Function ToString() As String
       Return Name
     End Function
   End Class
  

Remove Duplicate Whitespaces using Regular Expressions

2007-12-13T23:46:00.000-08:00

A quick way to eliminate duplicate white spaces from a string using regular expressions using VB.Net

   Dim DirtySample As String = "The quick   brown fox " & ControlChars.CrLf & " jumped" & ControlChars.Tab & ControlChars.Tab & " over lazy dog"
   Dim CleanSample As String = System.Text.RegularExpressions.Regex.Replace(DirtySample, "\s+", " ")
   
   Debug.WriteLine("DirtySample : ")
   Debug.WriteLine(DirtySample)
   
   Debug.WriteLine("CleanSample : ")
   Debug.WriteLine(CleanSample)
    

Output

   DirtySample :
   The quick   brown fox 
    jumped   over lazy dog
   CleanSample : 
   The quick brown fox jumped over lazy dog
    

Normal unselected
Selected

Normal unselected
Selected