Ruskin Dantra

Using Microsoft Enterprise Library VAB with WCF services – Part 2

2009-12-21T15:40:00.000+13:00

In Part 1 we looked at a simple solution on how to do service side validation for a simple WCF service and pass the resulting validation result back to the client. In this article we’ll look at some other types of validators provided by the Enterprise Library and also touch the topic of rulesets and how they help.

So far we have looked at RangeValidator; let us look at some of its properties.

Bounds
The LowerBound and UpperBound of the validator are self-explanatory and denote the minimum and maximum value the validator can accept.

BoundType
The BoundType is synonymous to the bounds you have, it tells you whether the bounds are included, excluded or simply ignored.

Negated
If negated is set then we basically negate the rule, therefore in our example where we had the rangevalidator to accept only positive integers, setting negated=true would mean we only allow negative integers. Kind of a redundant property in my opinion and simply complicates things.

Tag
Allows the developer to replace the name of the property which caused the validation fault to a custom string. Useful when your property name is something like “accessDate” and you want to return “Access Date”. Keep in mind that the custom Tag is only read when you have a custom message template.

MessageTemplate
Each validator provided by the Enterprise Library comes with its own message which gets returned on a validation fault, this can be customised by the developer. For e.g. for the Range Validator we know (looking at the MSDN documentation) token {2} is the Tag, therefore our message template could be “{2} is invalid.” and we would get “Access Date is invalid.”

MessageTemplateResourceName/MessageTemplateResouceType
The following items come in handy when you have declared your messages in a resource file.

Ruleset
Allows the developer to target different validation rules depending on different criteria. E.g. different clients may have different validation rules depending on different business logic. This can be done by simply changing the config file to tell the validation block which ruleset to use as shown below:

To be continued…

De/Se-rializing C# objects to XML

2009-12-10T16:21:00.000+13:00

I have come across many projects over the years which need some sort of serializing and deserializing of C# objects to XML. I usually remember the general syntax but more than often end up searching for the exact syntax. There are tonnes of articles on this by the way and this blog is merely to give me a consistent way of doing this rather than anything else.

Say you have a couple of C# classes such that one class contains a collection of the other class and you want to serialize this into XML.

The way I usually do it is simply by adding some attributes to my C# classes which represent the structure of the resulting XML and run an XML serializer against it. So my C# classes would potentially look like:

[XmlRoot(ElementName = "Customer", IsNullable = false)]
public class Customer
{
	[XmlElement(ElementName = "Name")]
	public string Name { get; set; }

	[XmlElement(ElementName = "IsExpired")]
	public bool IsExpired { get; set; }

	[XmlElement(ElementName = "DOB")]
	public DateTime DOB { get; set; }

	[XmlArray("Orders")]
	[XmlArrayItem("Order", Type = typeof(Order))]
	public List<order> Orders { get; set; }
}

public class Order
{
	[XmlAttribute(AttributeName = "OrderID")]
	public int OrderID { get; set; }
}

With the above class we get an XML output as shown in the figure below:

And the code which actually does the serialization:

class Program
{
	static void Main(string[] args)
	{
		Customer c = new Customer()
		{
		    Name = "Ruskin Dantra",
		    DOB = DateTime.Today,
		    IsExpired = false,
		    Orders = new List<order>() 
		    {
		        new Order() { OrderID = 1},
		        new Order() { OrderID = 2},
		        new Order() { OrderID = 3}
		    }
		};

		System.Xml.Serialization.XmlSerializer s = new System.Xml.Serialization.XmlSerializer(typeof(Customer));

		XmlWriterSettings settings = new XmlWriterSettings();
		settings.Indent = true;

		XmlWriter writer = XmlWriter.Create(@"Customer.xml", settings); 
		s.Serialize(writer, c);
		writer.Close();
	}
}

If you want to deserialize the above created XML back into the object all you have to do is:

System.Xml.Serialization.XmlSerializer s = new System.Xml.Serialization.XmlSerializer(typeof(Customer));
XmlReader reader = XmlReader.Create(@"Customer.xml");
Customer deserializedCustomer = s.Deserialize(reader) as Customer;
reader.Close();

Its as easy as that :)

Using Microsoft Enterprise Library VAB with WCF services – Part 1

2009-12-09T13:22:00.000+13:00

I am starting to write a series of blog articles, each varying in complexity, highlighting how we use can the Validation Application Blocks within the Microsoft Enterprise Library to do really neat validation. Extremely flexible and configurable at runtime. Although we will slowly build towards that.

In this first part let me just give a brief introduction to what the VAB actually is some simple ways of using it within a WCF service.

While writing WCF services we often cannot guarantee the data we get passed in, let it be simple data like integers or complex business objects such as Customers or even worse, process definitions. Although, as developers we have to design some sort of clever program which can intelligently sorting out good data from bad data. Good data is often derived from pages of use cases and business rules. These rules tend to change often so it’s only advisable that we allow for this by allowing our program (in this case a WCF service) to read this rules at runtime. This is our end goal.

In the early days I used to do simple checks on data to determine its validity. Although strenuous and naive, it worked. For e.g. if you have a service which finds the square root of a number then we know for a fact that it cannot accept a negative number. So a developer has the following options:

Don’t care about the erroneous input
Cater for error scenarios (number being less than 0) and return a exception
Cater for error scenarios (number being less than 0) and return a message
Return an exception which has the message

Yes, the last option does look the most tempting but a bit harder to implement. Let us try and work through the other options first, for all our scenarios we will have the same interface and client definition:

Interface:

namespace VABService
{
	[ServiceContract]
	public interface IMyService
	{
		[OperationContract]
		double SquareRoot(double number);
	}
}

Client:

namespace VABServiceClient
{
	class Program
	{
		static void Main(string[] args)
		{
			service.MyServiceClient client = null;
			try
			{
				client = new VABServiceClient.service.MyServiceClient();
				double result = client.SquareRoot(4);
			}
			catch (Exception e)
			{
			}
			finally
			{
				if (client != null && client.State != System.ServiceModel.CommunicationState.Faulted)
				{
					try
					{
						client.Close();
					}
					catch (Exception e)
					{
						// don't care
					}
				}
			}
		}
	}
}

Don’t care about the erroneous input With this approach our implementation looks simple and we end up with:

namespace VABService
{
	public class MyService : IMyService
	{
		#region IMyService Members
		public double SquareRoot(double number)
		{
			return Math.Sqrt(number);
		}
		#endregion
	}
}

This service implementation will allow for the correct square root to be returned but say instead of passing in a positive integer we pass in a negative integer: –4; can the service guarantee a deterministic result? I don’t think so, the most the developer can say is that it will do whatever the .Net environment is set up to do. Left as is the result coming back will be NaN.

If the client was a high risk financial application and the service returned this value, the result would be quite catastrophic unless both the client and the service came to some sort of prior agreement about this returned value. Although wouldn’t it be nice if we raised an exception or an error of some kind sighting the problem?

Cater for error scenarios (with an Exception) To allow for an exception to be raised we have to slightly change the service implementation as shown below:

namespace VABService
{
	public class MyService : IMyService
	{
		#region IMyService Members
		public double SquareRoot(double number)
		{
			if (number < 0)
				throw new ArgumentOutOfRangeException(string.Format("Square root of negative numbers cannot be determined:{0}.", number));
			return Math.Sqrt(number);
		}
		#endregion
	}
}

Now with the same client as before if we pass in a negative number we get a exception although the client is nonetheless wiser than it was before:

You see the above exception because of an attempt to hide the implementation details of the service from the clients calling it. Just as the exception states, if we set the flag IncludeExceptionDetailsInFaults to be true, we will actually see why the exception occurred:

Although this is opening up our service unnecessarily and clients can get a clear view of our implementation when things go wrong and lets face it, things always can go wrong! So we want to avoid setting IncludeExceptionDetailsInFaults to true in a production environment.

Cater for error scenarios (with a message) To allow for this we have to add even more code to the implementation and also add another parameter to our interface which we can use to pass back the error message, which in this case is the exception text. We all know how this is going to look, yes UGLY! We don’t want to do that!!! This brings us to our last option and the most elegant solution.

Return an exception which has the message This is where Geers Blog comes in handy. WCF exposes really neat things which can be used to do all sorts of validation but why do this when we can go one step further and use an already well thought and designed framework wrapper. Yes, the VAB is exactly that.

The Meat

Yes so far all you have seen is bones and why, what…and blah blah, boring stuff. The meat of the post is now here…let us use the VAB to do simple validation while finding the square root of a number.

First step would be to install the enterprise library and add a reference to (within your service project):

Microsoft.Practices.EnterpriseLibrary.Validation.integration.WCF

Microsoft.Practices.EnterpriseLibrary.Validation.dll

Microsoft.Practices.EnterpriseLibrary.Common.dll

After doing so we’ll need to make 3 changes…

Service interface change

Our service interface will now contain the following code.

using System;
using System.ServiceModel;
using Microsoft.Practices.EnterpriseLibrary.Validation.Integration.WCF;
using Microsoft.Practices.EnterpriseLibrary.Validation.Validators;

namespace VABService
{
	[ServiceContract]
	public interface IMyService
	{
		[OperationContract]
		[FaultContract(typeof(ValidationFault))]
		double SquareRoot(
			[RangeValidator(0, RangeBoundaryType.Inclusive, Double.MaxValue, RangeBoundaryType.Inclusive)]
			double number);
	}
}

Note that we now have a rangevalidator for the parameter “number” and also declare that this particular interface method has a fault contract of type ValidationFault associated to it

Config file

Note that we have only added new a endpoint behaviour, a behaviour extension and mapped our already existing endpoint to the newly added endpoint behaviour.

Client change

static void Main(string[] args)
		{
			service.MyServiceClient client = null;
			try
			{
				client = new VABServiceClient.service.MyServiceClient();
				double result = client.SquareRoot(-4);
			}
			catch (FaultException fe)
			{
			}
			catch (Exception e)
			{
			}
			finally
			{
				if (client != null && client.State != System.ServiceModel.CommunicationState.Faulted)
				{
					try
					{
						client.Close();
					}
					catch (Exception e)
					{
						// don't care
					}
				}
			}
		}

With this change in the client, now instead of getting simply exceptions without any message we get a particular type of exception which we can catch and investigate as shown in the image below:

We’ll look at other validators in Part 2.

Debugging VB6 COM DLLs via .Net

2009-12-09T11:57:00.000+13:00

I am sure there are other ways of doing this but this post is just a simple step by step guide on one of them.

More often than not we have to use legacy COM components while writing new applications, let it be for database access, business logic or to simply avoid duplicating code. Every time I end up using a COM object in my .Net application I lose the ability to debug inside that COM object and mostly have to assume that whatever happens within that call is logically correct. Sometimes I am not convinced so I need to see proof of it first hand, so what do I do, I debug the COM call.

Adding a COM object to .Net cannot be easier, simply add a reference to the COM object which is registered on your computer and .Net automatically creates what we call a CCW (COM Callable Wrapper). This is widely documented here.

In order to demonstrate how to debug a COM call let us first create a very simple VB6 DLL called Project1.dll. In this COM DLL I have a single class called Class1.cls which contains a very simple Add method as shown below:

Option Explicit

Public Sub Add(ByVal a As Integer, ByVal b As Integer, ByRef result As Integer)
    result = a + b
    Exit Sub
End Sub

After creating this method, I built the DLL to a location using the default build options within the VB6 IDE by going to File>Make Project1.dll.

After this was done I created a new ConsoleApplication solution in C# to reference this COM DLL. Added a reference to Project1 which allowed me to do this:

Project1.Class1Class class1 = new Project1.Class1Class();
short res = 0;
class1.Add(1, 2, ref res);

Great, I can now use the add method which I wrote in the COM object, say if the COM method returns the wrong value and I want to step into that code, I simply go Debug>Step Into (F11). But what happens is that the debugger simply steps over that code and gets the result. What has happened is that none of the symbols for that Project1.dll were loaded into my IDE:

This can be achieved simply by building the VB6 DLL using symbolic information. You can do this by right clicking on the VB6 project in your IDE and going to Properties>Compile and check the boxes which say “Create Symbolic Debug Info” and also select “No Optimization”.

After the above is done, rebuild the Project1.dll. You’ Simply doing the above step will not allow you to step into the “Add” function because the .Net IDE still hasn’t loaded the symbols. To allow for this we have to enabled “Unmanaged Debugging” for our project, this can be done by going into the Project Properties>Debug and checking the box “Enable unmanaged code debugging” as shown below.

Doing the above process will now load the symbols:

Doing the above steps will still not allow us to step into the VB6 code, for this we have to do a manual step. Open up the code file which has the “Add” function defined and put a breakpoint at the desired line of code. Now when you step into the “Add” method call you will hit the breakpoint on the VB6 side as shown below:

Voila! :)

Using VB to show IIS sites within Installshield 2010

2009-10-24T14:44:00.000+13:00

Quite often I have worked on projects where an installer is needed. So far I am quite familiar with Installshield and its inner workings so this blog describes a simple piece of code which solves a generic issue I had.

More often than not we program in a web based world, a web based installer is needed and the obvious incline is to use IIS, well at least for me considering I am mainly of a .Net developer. In Installshield everything is easy when it comes to installing something on the local IIS but it gets complicated when you want to customise this process and allow users to choose the website within which the application will be installed or even the name of the application.

Customising the name of the application is easy and can be done simply by using what Installshield refers to as “properties”. Expose a simple edit box and then in your “Internet Information Services” node simply change the “Name” to point to the property mapped to the edit box (e.g. “[MY_VIRTUAL_DIRECTORY]”).

Things get complicated when you want to show the user a list of websites to which your application can be added to, by default it goes to the “Default Web Site” or at least that’s what I assume but not always as stated by this table here.

Saying that, there is no easy way of showing the user a list of already existing websites on the local computer so after a bit of hunting around I found several solutions on the Installshield forums which advised me of a particular VB script which does what we need.

Dim objViewDim objDB
Dim objInstaller
Dim objRecord
Dim objW3SVC, objIisWebSite
Dim lngOrder
Set objDB = Session.DatabaseSet 
objInstaller = Session.Installer

'Delete any records that may exist
Set viewList = Database.OpenView("SELECT * FROM ComboBox")
viewList.ExecuteSet recList = viewList.Fetch

'delete any existing records
While Not (recList Is Nothing)
	viewList.Modify 6, recList ' 6 = deleteSet
	recList = viewList.Fetch
Wend
viewList.CloseSet 

objView = objDB.OpenView("select * from ComboBox")

' enumerate webservers on localhost and populate ComboBox tableSet
objW3SVC = GetObject("IIS://localhost/W3SVC")
lngOrder = 1


For Each objIisWebSite In objW3SVC
	If objIisWebSite.Class = "IIsWebServer" Then
		If LCase(objIisWebSite.ServerComment) <> "administration web site" Then
			' add site name to ComboBox table (which is used by our dialog ComboBox)
			Set objRecord = objInstaller.CreateRecord(4)
			objRecord.StringData(1) = "WEBSITE_DROPDOWN" ' property name
			objRecord.IntegerData(2) = lngOrder ' order
			objRecord.StringData(3) = objIisWebSite.Name ' value
			objRecord.StringData(4) = objIisWebSite.ServerComment ' text    
			Call objView.Execute(objRecord) ' now add the record to the table 
			Call objView.Modify(7, objRecord) ' (7 = msiViewModifyInsertTemporary)
			
			lngOrder = lngOrder + 1
		End If
	End If
Next
Call objView.Close

Note that the value of the combobox is “objIisWebSite.Name” and you might think this is the human readable string which appears as the website name, but its not. The name of the website is a unique number (ID) assigned to it as shown in the figure below:

Therefore when you want to specify where your application will be added to, you have to modify the “Default Web Site” node (which you will add as the default behaviour and put all your applications under it). A bit counter intuitive as earlier I simply thought that instead of naming it “Default Web Site” I have to map it to my property which corresponds to the drop down list, i.e. "WEBSITE_DROPDOWN”. But the trick is to associate the “WEBSITE_DROPDOWN” property to the “Site Number” setting in the Default Web Site node.

Bhai Log Game 5 (28/04/09)

2009-04-29T09:16:00.000+12:00

The game yesterday had some bittersweet moments. Although we won it was not a victory we ought to cherish nor take into our heads…there is a long long road ahead of us.

We fielded first and luckily I did not have to eat my words when I said “yes we have 8”, when actually we only had 4 players. It was a mediocre start in the first over which I bowled conceding 11 runs, 9 of those extras although it set up Jacinth with two strikes from the last two deliveries which he executed with class getting a wicket. Our bowling wasn’t great…it just did enough as the batsman weren’t up to par so I think there is a still a lot of work to be done in that department. Also our fielding was a bit shaky, we have to communicate! The pick of the bowlers I have to say was Shashank. Great pace and always on target.

Our batting was good…well good with respect to the deliveries and fielding of the other team. We have to start hitting the side nets and not attempt hitting the back nets every time. Lucky for us it paid of this time around. We were also helped by poor bowling from the other side as they conceded 25 extras (~ 75 runs). We also saw some good clean hitting by Kasun and Jessie.

Overall a good performance by the majority of the team although the senior players had a sub-par day, maybe that’s why one of them decided to stay back and make up for it ;).

Let us carry this winning way over to next week when we play the top of the table, an unbeaten team, we’ll change that next week :).

Bhai Log Game 4 (21/04/09)

2009-04-23T09:21:00.000+12:00

Bhai Log continues to dive further into slum. Read more about it here. After a disappointing two weeks of cricket, Bhai Log could not record a win in what could be defined as the easiest game so far. After restricting the opposition for a meagre 106, Bhai Log failed to deliver with the bat.

A mediocre bowling and fielding attempt from Bhai Log was enough to restrict the opposition to 106 so imagine if Bhai Log fired every time at the right times, they would be the oppositions biggest nightmare. This week we took a turn in the below par performances where our batting was, no other word for it, absolutely shocking. We scored a mere 40 runs off the first two partnership with an atrocious third partnership with –4. I seriously don’t understand what part of “hit the side nets” is so complicated to understand. The last partnership was a consolidation attempt as in no way were we expecting them to get more than 50 runs.

Jessie was the star of the match which was his first game after he returned from a long vacation in India. Jessie, were you training there? Can you tell us how you do it?

Hoping we pick up our act and start getting into the winning habit which has been the essence of Bhai Log since we remember.

Here are the stats.

Bhai Log Game 3 (14/04/09)

2009-04-15T08:34:00.000+12:00

Following on from our below par performance from last week Bhai Log surely lived up to it. This is a team which came from winning the last season it played to being demolished by two mediocre opponents in two consecutive weeks. Mind you the team is not the same as last season but yet, it is not the losing that matters, it is the way the loss occurs.

This week we had a 9.35 game and only five team members showed up on time. You would’ve thought that a late game would mean that everyone would turn up on time. Worst part is that one team member didn’t show up at all. Quite a disappointment but that was expected given the history. So the game began and the only thing we have won so far is the toss. Elected to bowl considering we have a better chance of chasing and winning as we know how our game should be depending on the score, although that didn’t help at all.

First over was a shocker and unfortunately I was to blame for that giving away 13 runs although the shambles did not stop there. We bowled atrociously, short balls galore and the batsmen did well to utilise our underpowered field. There was no urgency in our fielding and I think that’s what lost us the game. The opponent posted a huge total of 178. In indoor cricketing terms that is close to impossible to attain.

Our batting started off well with 46 and 40 coming in the first two partnerships although the third partnership didn’t go as well as hoped leaving us to get 58 in the last partnership. This was a huge ask on its own.

To sum things up, it was yet another below average performance from Bhai Log and shabby umpiring work was partly to blame.

I hope we bounce back in the next game to record our first graded round game win. Neil and I bowled three overs each. Matthew Scott batted twice as we were short one player.

Reading XML Schemas

2009-04-12T11:04:00.000+12:00

XML information is everywhere in these times. We heavily rely on XML to send and analyse information. After dealing with XML in every aspect of development I realised that the internet is loaded with information on how to read, write and manipulate XML in every possible language (script) there is. And to make things worse, I myself have a post up on how to read XML documents using DOM.

This motivated me to write this document and to give XML Schemas the respect they require. What are XML schemas? They can be simply explained as a skeleton for a given XML file. An XML file can have any desired structure, XML schemas are what restrict them and keep them well-formed. So an XML schema is something like a parent which looks after it’s child (the XML document).

Let us look at an example:

<?xml version="1.0" encoding="utf-8" ?>
<blog>
	<topic date="2003-08-22">My first XML document</topic>
	<topic date="2006-10-18">My second XML document</topic>
</blog>

The schema for the above XML is:

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
	<xs:element name="Blog">
		<xs:complexType>
			<xs:sequence>
				<xs:element maxOccurs="unbounded" name="Topic">
					<xs:complexType>
						<xs:simpleContent>
							<xs:extension base="xs:string">
								<xs:attribute name="Date" type="xs:date" use="required" />
							</xs:extension>
						</xs:simpleContent>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
</xs:schema>

Now that we are familiar with XML schemas let us look at the actual reason of this post. Given an XML schema, how do we read it? How do we store the values within the schema, its relationships and other mandatory information required by XML data files.

The way I addressed this problem is using two passes:

Reading all the information given in XML schema
This was necessary as there can be attribute and element references throughout the file. Therefore we first need to store all the information about the XML schema and then determine the relationships between each of the data elements.

Forming relationships between elements
After we store all the information about the XML schema, we need to traverse through it to form the relationships. Relationships in this aspect represent the nested nature of the XML schema.

Let us look at how we start reading an XML schema. For that we have to understand a little about the different aspects of an XML schema. A good introduction is given by the W3C schools here. Let me briefly go over the main types here as well just to have a reference to them:

Simple types
1. Elements
2. Attributes
3. Restrictions

Complex types
1. Elements
2. Empty
3. Elements only
4. Text only
5. Mixed
6. Indicators
7. <any>
8. <anyAttribute>
9. Substitution

Data types
1. …

I decided that each of the above types can be represented by data structures which I can understand to make things simpler. You don’t have to do this, you can simply rely on the .NET representation of these schema types. Let us look at how I chose to represent each of these structures. Let me introduce a class diagram which we will analyse a bit later.

The above diagram shows three interfaces which help us make things much simpler and it also abstracts us away from the .NET representation the schema:

IAttribute
Any attribute like schema object will inherit from this interface. Note that I said “attribute type”, as I also want simple types (both implicitly and explicitly declared) to be used as attributes.

IElementComplex
Represents any complex type object within the schema. This includes both, implicitly and explicitly declared types.

IRelationship
Merely a wrapper around the complex element type which makes us easier to form relationships between them which we will use in our second pass.

Note that the above classes were developed a while ago while working on my Part IV engineering project (in 2005), only now have I realised that there is little to no help on how to read an XML schema, therefore I decided to publish this post. By no means is this “the only” or “the best” way. And also I am sure there are better ways of doing this.

Let me briefly give you an example of what implicitly and explicitly declared schema elements are with the XML schema below:

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="ImplicityExplicit" xmlns="http://tempuri.org/ImplicityExplicit.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:mstns="http://tempuri.org/ImplicityExplicit.xsd" elementformdefault="qualified" targetnamespace="http://tempuri.org/ImplicityExplicit.xsd">
	<!--Explicit complex type-->
	<xs:complextype name="CTEntity" />

	<!--Implicit complex type-->
	<xs:element name="CTElemEntity">
		<xs:complextype></xs:complextype>
	</xs:element>

	<!--Explicit simple type-->
	<xs:simpletype name="STEntity">
		<xs:restriction base="xs:string" />
	</xs:simpletype>

	<!--Implicit simple type-->
	<xs:element name="STElemEntity">
		<xs:simpletype>
			<xs:restriction base="xs:string" />
		</xs:simpletype>
	</xs:element>

	<!--Implicit shy simple type-->
	<xs:element name="STElem" />

	<!--An attribute-->
	<xs:attribute name="attribute" />
</xs:schema>

Now that we know the basic different types of XML schema elements let us look at how we can read/extract them. For this we rely heavily on the .NET XML classes. Reading the XML schema is quite simple, it is done using the following code:

using System;
using System.Xml;
using System.Xml.Schema;

namespace XmlLibrary
{
	public class SchemaReader
	{
		public String FileName { get; set; }
		public XmlSchema Schema { get; set; }

		private bool SchemaLoaded { get; set; }

		public SchemaReader(string fileName)
		{
			FileName = fileName;
			ReadSchema();
		}

		public void ExtractElements()
		{
			if (SchemaLoaded && Schema != null)
			{
				XmlSchemaObjectCollection itemsColl = Schema.Items;
				foreach (XmlSchemaObject item in itemsColl)
				{
					// TODO: Implementation
				}
			}
		}

		private void ReadSchema()
		{
			if (String.IsNullOrEmpty(FileName))
			{
				SchemaLoaded = false;
				Schema = null;
			}
			else
			{
				try
				{
					Schema = XmlSchema.Read(new XmlTextReader(FileName), null);
					SchemaLoaded = true;
				}
				catch (XmlException)
				{
					SchemaLoaded = false;
					Schema = null;
				}
				catch (XmlSchemaException)
				{
					SchemaLoaded = false;
					Schema = null;
				}
			}
		}

	}
}

The important method in the above code is the “ReadSchema” call. Note that it takes in a string as a parameter which points to the schema file on disk and then reads this in the populates the System.Xml.Schema.XmlSchema object. From this point forward we will only be concentrating on the ExtractElements method.

Let us examine the ExtractElements method closely. Currently it is stubbed out, although if you remember I mentioned that XML has a nested/recursive nature to it, therefore we expect to call a distinctive method recursively. Let us examine how we do it. After fleshing out the method a bit further we have the following:

public void ExtractElements()
{
	if (SchemaLoaded && Schema != null)
	{
		XmlSchemaObjectCollection itemsColl = Schema.Items;
		foreach (XmlSchemaObject item in itemsColl)
		{
			ManipulateSchemaObject(item);
		}
	}
}

private void ManipulateSchemaObject(XmlSchemaObject schemaObject)
{
	IndentLevel++;
	if (schemaObject is XmlSchemaElement || schemaObject is  XmlSchemaComplexType || schemaObject is  XmlSchemaSimpleType)
	{
		#region XmlSchemaElement
		if (schemaObject is XmlSchemaElement)
		{
			XmlSchemaElement schemaElement = schemaObject as XmlSchemaElement;
			Console.WriteLine(String.Format("{0}XmlSchemElement: {1} ({2})", GetIndentationString(), schemaElement, schemaElement.Name));

			ManipulateSchemaElement(schemaElement);
		}
		#endregion XmlSchemaElement
		#region XmlSchemaComplexType
		else if (schemaObject is  XmlSchemaComplexType)
		{
			XmlSchemaComplexType explicitComplexType = schemaObject as XmlSchemaComplexType;
			Console.WriteLine(String.Format("{0}XmlSchemaComplexType: {1} ({2})", GetIndentationString(), explicitComplexType, explicitComplexType.Name));
		}
		#endregion XmlSchemaComplexType
		#region XmlSchemaSimpleType
		else if (schemaObject is XmlSchemaSimpleType)
		{
			XmlSchemaSimpleType explicitSimpleType = schemaObject as XmlSchemaSimpleType;
			Console.WriteLine(String.Format("{0}XmlSchemaSimpleType: {1} ({2})", GetIndentationString(), explicitSimpleType, explicitSimpleType.Name));
		}
		#endregion XmlSchemaSimpleType
	}
	else
	{
		#region AttributeGroup
		if (schemaObject is XmlSchemaAttributeGroup)
		{
			XmlSchemaAttributeGroup schemaAttGroup = schemaObject as XmlSchemaAttributeGroup;
			Console.WriteLine(String.Format("{0}XmlSchemaAttributeGroup: {1} ({2})", GetIndentationString(), schemaAttGroup, schemaAttGroup.Name));
		}
		#endregion AttributeGroup
		#region Attribute
		else if (schemaObject is XmlSchemaAttribute)
		{
			XmlSchemaAttribute schemaAtt = schemaObject as XmlSchemaAttribute;
			Console.WriteLine(String.Format("{0}XmlSchemaAttribute: {1} ({2})", GetIndentationString(), schemaAtt, schemaAtt.Name));
		}
		#endregion Attribute
		#region Group
		else if (schemaObject is XmlSchemaGroup)
		{
			XmlSchemaGroup schemaGroup = schemaObject as XmlSchemaGroup;
			Console.WriteLine(String.Format("{0}XmlSchemaGroup: {1} ({2})", GetIndentationString(), schemaGroup, schemaGroup.Name));
		}
		#endregion Group
		else
		{
			Console.WriteLine(GetIndentationString() + schemaObject + " is not handled yet");
		}
	}
}

#region schema element
private void ManipulateSchemaElement(XmlSchemaElement schemaElement)
{
	XmlSchemaType schemaElementSchemaType = schemaElement.SchemaType;

	#region schema type defined
	if (schemaElementSchemaType != null)
	{
		Type xmlSchemaTypeType = schemaElementSchemaType.GetType();
		#region Complex type
		if (schemaElementSchemaType is XmlSchemaComplexType)
		{
			ManipulateSchemaElementComplexType(schemaElement);
		}
		#endregion Complex type
		#region Simple type
		else if (schemaElementSchemaType is XmlSchemaSimpleType)
		{
			ManipulateSchemaElementSimpleType(schemaElement);
		}
		#endregion Simple type
	}
	#endregion schema type defined
	#region Element with no schematype, thus simple
	else
	{
		if (schemaElement.RefName.IsEmpty) // not a reference
		{
			Console.WriteLine(String.Format("{0}Implicitly implicit simple type: {1}", GetIndentationString(), schemaElement.Name));
		}
	}
	#endregion
}
#endregion schema element

#region simple type
private void ManipulateSchemaElementSimpleType(XmlSchemaElement schemaElement)
{
	XmlSchemaSimpleType simpleElement = schemaElement.SchemaType as XmlSchemaSimpleType;
	Console.WriteLine(GetIndentationString() + String.Format("Simple type encountered: {0}", schemaElement.Name));
}
#endregion simple type

#region complex type
private void ManipulateSchemaElementComplexType(XmlSchemaElement schemaElement)
{			
	XmlSchemaComplexType complexElement = schemaElement.SchemaType as XmlSchemaComplexType;

	XmlSchemaObjectCollection attColl = complexElement.Attributes;
	foreach (XmlSchemaObject attCollObj in attColl)
		ManipulateSchemaObject(attCollObj);

	if (complexElement.Particle != null)
	{				
		XmlSchemaParticle complexElementParicle = complexElement.Particle;
		ParticleHandlingForElement(complexElementParicle);
	}
	else if (complexElement.ContentModel != null)
	{
		XmlSchemaContentModel complexElementContentModel = complexElement.ContentModel;
		if (complexElementContentModel is XmlSchemaSimpleContent)
		{
			XmlSchemaSimpleContent contentModelSimpleType = complexElementContentModel as XmlSchemaSimpleContent;
			XmlSchemaContent schemaContent = contentModelSimpleType.Content;
			if (schemaContent is XmlSchemaSimpleContentExtension)
			{
				XmlSchemaSimpleContentExtension xmlSchemaExtension = schemaContent as XmlSchemaSimpleContentExtension;
				XmlSchemaObjectCollection objColl = xmlSchemaExtension.Attributes;
				foreach (XmlSchemaObject item in objColl)
				{
					ManipulateSchemaObject(item);
				}
			}
		}
		else
		{
			Console.WriteLine(GetIndentationString() + complexElementContentModel.ToString());
			// Handle restrictions and extensions here (Complex or simple type)
		}
	}
}
#endregion complex type

#region particle handling for element
private void ParticleHandlingForElement(XmlSchemaParticle complexElementParicle)
{
	Type particleType = complexElementParicle.GetType();
	if (complexElementParicle is XmlSchemaSequence)
	{
		XmlSchemaSequence particleAsSeq = complexElementParicle as XmlSchemaSequence;
		ManipulateSchemaSequence(particleAsSeq);
	}
	else if (particleType.Equals(typeof(XmlSchemaChoice)))
	{
		XmlSchemaChoice complexChoice = complexElementParicle as XmlSchemaChoice;
		ManipulateSchemaChoice(complexChoice);
	}
}

#region choice
private void ManipulateSchemaChoice(XmlSchemaChoice groupChoice)
{
	XmlSchemaObjectCollection objColl = groupChoice.Items;
	foreach (XmlSchemaObject objCollObj in objColl)
	{
		XmlSchemaObject schemaObj = objCollObj;
		if (schemaObj.GetType().Equals(typeof(XmlSchemaSequence)))
		{
			XmlSchemaSequence choiceSeq = schemaObj as XmlSchemaSequence;
			ManipulateSchemaSequence(choiceSeq);
		}
		else if (schemaObj.GetType().Equals(typeof(XmlSchemaChoice)))
		{
			XmlSchemaChoice choiceChoice = schemaObj as XmlSchemaChoice;
			ManipulateSchemaChoice(choiceChoice);
		}
		else
			ManipulateSchemaObject(schemaObj);
	}
}
#endregion choice

#region Sequence
private void ManipulateSchemaSequence(XmlSchemaSequence choiceSeq)
{
	XmlSchemaObjectCollection objColl = choiceSeq.Items;
	foreach (XmlSchemaObject objCollObj in objColl)
		ManipulateSchemaObject(objCollObj);
}
#endregion Sequence

There are quite a lot of methods in the above snippet, although they are quite straight forward and most of them recursively call our ExtractElements method. Let us look at each of the methods which handle each different aspect of XML schema.

ManipulateSchemaObject(XmlSchemaObject schemaObject)
Handles various schema objects, this is the recursive method call which is centre of our XML schema reader. This method acts like a proxy which spreads out the flow depending on the type of the XML schema element.
ManipulateSchemaElement(XmlSchemaElement schemaElement)
Handles various schema elements, Complex and Simple.
ManipulateSchemaElementSimpleType(XmlSchemaElement schemaElement)
Handles the simple type.
ManipulateSchemaElementComplexType(XmlSchemaElement schemaElement)
Handles the complex type.
ParticleHandlingForElement(XmlSchemaParticle complexElementParicle)
Handles particles, which includes sequences and choice elements.

We have looked at how to cleanly handle the XML schema and recursively traverse through its structure. I’ll get back to this topic in a later post and show you how to I formed relationships between my custom schema based data structures using custom business objects.

Bhai Log Game 2 (07/04/09)

2009-04-08T21:47:00.000+12:00

After a convincing win in Game 1 we could not have done any worse. After a bismal fielding performance on field we continued along the downward spiral with our batting. Some brilliant moments did occur but not enough to reward us the win. The lost was brought upon by our own undoing. Below are the graphs for the bowling, batting and all round performances of each team member. Hoping to avenge our downfall in the next game. You can also read more about the game here.

StackOverflowException aka “The Uncatchable”

2009-04-03T22:39:00.000+13:00

Ever wrote a great little application just to find that at some odd moment calling into a third party DLL throws a nice little StackOverflowException. Then you go start digging into your code only to find that your call to this third party DLL is surrounded by not only one but two to three try/catch/finally blocks at different levels. Hmm…weird.

The below code can quickly get this error for you and no matter if you surround it one or even 10 try/catch blocks, it will still throw the exception.

class Program
{
	static void Main(string[] args)
	{
		try
		{
			Recurse();

			Console.WriteLine("No exception thrown");
		}
		catch (StackOverflowException e)
		{
			Console.WriteLine("No exception caught");
		}
	}

	private static void Recurse()
	{
		Recurse();
	}
}

Does the catch block not catch StackOverflowException?

The answer is simple…only after you think about it for a little while. No! The StackOverflowException cannot be caught by the .NET runtime because simply…according to Microsoft .NET it is bad coding practice.

Below is extracted from http://msdn.microsoft.com/en-us/library/system.stackoverflowexception.aspx.

Version Considerations

In prior versions of the .NET Framework, your application could catch a StackOverflowException object (for example, to recover from unbounded recursion). However, that practice is currently discouraged because significant additional code is required to reliably catch a stack overflow exception and continue program execution.

Starting with the .NET Framework version 2.0, a StackOverflowException object cannot be caught by a try-catch block and the corresponding process is terminated by default. Consequently, users are advised to write their code to detect and prevent a stack overflow. For example, if your application depends on recursion, use a counter or a state condition to terminate the recursive loop. Note that an application that hosts the common language runtime (CLR) can specify that the CLR unload the application domain where the stack overflow exception occurs and let the corresponding process continue. For more information, seeICLRPolicyManager Interface and Hosting the Common Language Runtime.

I found two great articles on how to handle the StackOverflow exception:

http://stackoverflow.com/questions/206820/how-do-i-prevent-and-or-handle-a-stackoverflowexception-c

AppDomains.pdf

Bhai Log Game 1 (31/03/09)

2009-04-01T20:32:00.000+13:00

Our first graded game was played last night. For a change everyone turned up with Shadow aka Rainbow aka Neil making his indoor debut. Read more about it here. Here are the stats graphs for the game.

INotifyPropertyChanged made easier using PostSharp

2009-03-31T08:56:00.000+13:00

How many times have you written a C# business class like the one below only to realise that if you want the UI to react to changes you need to implement this cumbersome INotifyPropertyChanged interface.

So the above class will provide no change notification, you’ll have to implement the interface after which your code will look something like this (Note that this is .NET 2.0 syntax):

public class Customer : System.ComponentModel.INotifyPropertyChanged 
{
	private String _Name; 
	private DateTime _DOB;

	public String Name 
	{ 
		get 
		{
			return _Name;
		}
		set 
		{ 
			_Name = value; 
			OnPropertyChanged("Name");
		} 
	} 

	public DateTime DOB 
	{ 
		get 
		{ 
			return _DOB; 
		} 
		set 
		{ 
			_DOB = value; 
			OnPropertyChanged("DOB"); 
		} 
	} 
	
	#region INotifyPropertyChanged Members 

	public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged; 

	protected void OnPropertyChanged(String propertyName) 
	{ 
		if (PropertyChanged != null) 
		{ 
			PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName)); 
		} 
	} 

	#endregion 
}

That class already looks extremely overloaded and ugly…now imagine if you are able to use .NET 3 or 3.5 and you want to utilise it’s extremely cool feature of auto-implemented properties (e.g. public int Age { get; set; }). Guess what…you can’t!!!! Because where would you put your calls to OnPropertyChanged(…)?

This is where PostSharp saves you.

The above class, with auto-implemented properties and the INotifyPropertyChanged interface.

public class Customer : System.ComponentModel.INotifyPropertyChanged 
{ 
	[Notify] 
	public String Name { get; set; } 

	[Notify] 
	public DateTime DOB { get; set; } 

	#region INotifyPropertyChanged Members 
	
	public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged; 

	protected void OnPropertyChanged(String propertyName) 
	{ 
		if (PropertyChanged != null) 
		{ 
			PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName)); 
		} 
	} 

	#endregion 
}

That’s cool…from ~50 lines of code to ~25 lines of code. You’ll be wondering, how will the PropertyChanged event fire now? The answer is within the [Notify] attribute. This attribute is a special attribute which inherits from the PostSharp class OnMethodBoundaryAspect. For this you’ll have to add references to the PostSharp DLLs.

The implementation is shown below:

[Serializable]
[global::System.AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public sealed class NotifyAttribute : OnMethodBoundaryAspect
{
	public override void OnExit(MethodExecutionEventArgs eventArgs)
	{
		if (eventArgs == null)
			return;

		//Why are property sets not properties? they are methods?
		if ((eventArgs.Method.MemberType & System.Reflection.MemberTypes.Method) == System.Reflection.MemberTypes.Method && eventArgs.Method.Name.StartsWith("set_"))
		{
			Type theType = eventArgs.Method.ReflectedType;
			string propertyName = eventArgs.Method.Name.Substring(4);

			// get the field storing the delegate list that are stored by the event.
			FieldInfo[] fields = theType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field = null;
			foreach (FieldInfo f in fields)
			{
				if (f.FieldType == typeof(PropertyChangedEventHandler))
				{
					field = f;
					break;
				}
			}

			if (field != null)
			{
				// get the value of the field
				PropertyChangedEventHandler evHandler = field.GetValue(eventArgs.Instance)as PropertyChangedEventHandler;

				// invoke the delegate if it's not null (aka empty)
				if (evHandler != null)
				{
					evHandler.Invoke(eventArgs.Instance, new PropertyChangedEventArgs(propertyName));
				}
			}
		}
	}
}

This works perfectly, on every method “exit” the above OnExit(…) method will fire and invoke the PropertyChangedEventHandler for that particular property with it’s property name.

Neat isn’t it? Let us run some tests against it to make sure that it is actually happening. For this we revert to NUnit.

[TestFixture]
public class CustomerTest
{
	private Customer _customer;
	private String _propertyChanged;

	[SetUp]
	protected void Setup()
	{
		_customer = new Customer();
		_customer.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Customer_PropertyChanged);
	}

	[TearDown]
	protected void TearDown()
	{
		_propertyChanged = String.Empty;
	}

	void Customer_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
	{
		_propertyChanged = e.PropertyName;
	}

	[Test]
	public void TestNotifyName()
	{
		_customer.Name = "Ruskin";
		Assert.AreEqual("Name", _propertyChanged);
	}

	[Test]
	public void TestNotifyDOB()
	{
		_customer.DOB = DateTime.Now;
		Assert.AreEqual("DOB", _propertyChanged);
	}
}

You can go one step further…ever had calculated properties in your business classes, for e.g. if you have a property for “Age” which gets calculated depending on the DOB, therefore, if DOB changes, Age changes. In our current implementation we can only mark properties to fire PropertyChanged events for themselves, but we can’t make them trigger events for other properties. This can be easily solved by adding another standard .NET attribute shown below:

[Serializable] 
[global::System.AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)] 
public sealed class NotifyChildrenAttribute : Attribute 
{ 
	public NotifyChildrenAttribute(params string[] dependents) 
	{
		Dependents = dependents; 
	} 

	public NotifyChildrenAttribute() { } 

	public string[] Dependents { get; set; } 
}

Now we add an “Age” property to our Customer class and let us look at the changed version:

public class Customer : System.ComponentModel.INotifyPropertyChanged
{
	[Notify] 
	public String Name { get; set; } 

	[Notify] 
	[NotifyChildren("Age")] 
	public DateTime DOB { get; set; } 
	
	public int Age { get { return DateTime.Now.Year - DOB.Year; } } 

	#region INotifyPropertyChanged Members 

	public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged; 

	protected void OnPropertyChanged(String propertyName) 
	{ 
		if (PropertyChanged != null) 
		{ 
			PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName)); 
		} 
	}

	#endregion 
}

As we can see, we have marked our DOB property to fire a PropertyChanged event not only for itself but also for the Age property. We still need to modify our implementation of the OnExit(…) method slightly to cater for this new attribute. Our implementation will look as follows:

[Serializable]
[global::System.AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public sealed class NotifyAttribute : OnMethodBoundaryAspect
{
	public override void OnExit(MethodExecutionEventArgs eventArgs)
	{
		if (eventArgs == null)
			return;

		//Why are property sets not properties? they are methods?
		if ((eventArgs.Method.MemberType & System.Reflection.MemberTypes.Method) == System.Reflection.MemberTypes.Method && eventArgs.Method.Name.StartsWith("set_"))
		{
			Type theType = eventArgs.Method.ReflectedType;
			string propertyName = eventArgs.Method.Name.Substring(4);

			List<string> allPropertiesThatNeedNotification = new List<string>();
			if (!String.IsNullOrEmpty(propertyName))
			{
				PropertyInfo pInfo = theType.GetProperty(propertyName);
				if (pInfo != null)
				{
					// get all the properties which may be affected
					object[] notifyChildren = pInfo.GetCustomAttributes(typeof(NotifyChildrenAttribute), false);
					foreach (var item in notifyChildren)
					{
						if (item is NotifyChildrenAttribute)
						{
							NotifyChildrenAttribute att = item as NotifyChildrenAttribute;
							allPropertiesThatNeedNotification.AddRange(att.Dependents);
						}
					}
				}
				allPropertiesThatNeedNotification.Add(propertyName);
			}

			// get the field storing the delegate list that are stored by the event.
			FieldInfo[] fields = theType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field = null;
			foreach (FieldInfo f in fields)
			{
				if (f.FieldType == typeof(PropertyChangedEventHandler))
				{
					field = f;
					break;
				}
			}

			if (field != null)
			{
				// get the value of the field
				PropertyChangedEventHandler evHandler = field.GetValue(eventArgs.Instance) as PropertyChangedEventHandler;
			
				// invoke the delegate if it's not null (aka empty)
				if (evHandler != null)
				{
					foreach (var item in allPropertiesThatNeedNotification)
					{
						evHandler.Invoke(eventArgs.Instance, new PropertyChangedEventArgs(item));
					}
				}
			}
		}
	}
}

Updating the tests…note that our previously defined tests won’t work now because for every singular property changed there may be a series of PropertyChanged events, we need some kind of collection which we need to test against. This testing is a little bit primitive but this is only for demonstration purposes.

[TestFixture]
public class CustomerTest
{
	private Customer _customer; 
	private List<String> _propertiesChanged; 

	[SetUp] 
	protected void Setup() 
	{
		_customer = new Customer(); 
		_customer.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Customer_PropertyChanged); 
	}

	[TearDown] 
	protected void TearDown() 
	{ 
		_propertiesChanged = new List<string>(); 
	} 

	void Customer_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) 
	{
		Assert.IsTrue(_propertiesChanged.Contains(e.PropertyName), String.Format("Property {0} is not contained within the list", e.PropertyName)); 
	}

	[Test] 
	public void TestNotifyName() 
	{ 
		_propertiesChanged.Add("Name"); 
		_customer.Name = "Ruskin"; 
	} 

	[Test]
	public void TestNotifyDOB() 
	{ 
		_propertiesChanged.Add("DOB"); 
		_propertiesChanged.Add("Age"); 
		_customer.DOB = DateTime.Now; 
	} 
}

Downloads: PostSharp

Common InstallShield functions and their Usage

2009-03-30T14:30:00.001+13:00

Getting a property string

   1: NUMBER nvBufferLen;

   2: STRING svInstallDir;

   3: MsiGetProperty(hMSI, "INSTALLDIR", svInstallDir, nvBufferLen);

Where:
hMSI = handle of the MSI (gets automatically passed into functions)
INSTALLDIR = The name of the property to get
svInstallDir = The variable in which to store the returned property value
nvBufferLen = The length of the buffer, often set to 255.

Setting a property string

   1: MsiSetProperty(hMSI, "INSTALLDIR", "C:\Program Files\InstallationDirectory");

Where:
hMSI = handle of the MSI (gets automatically passed into functions)
INSTALLDIR = The name of the property to set
Value = The value of the property to set to

Converting a number to string and vice versa

   1: number nTemp;

   2: string svTemp;

   3: nTemp = 25;

4:

   5: NumToStr(svTemp, nTemp); // 25 -> "25"

   6: StrToNum(nTemp, svTemp); // "25" -> 25

String comparison

   1: if (StrCompare("String A", "String B") == 0) then

   2:     // do something here

   3: endif;

String concatenation

   1: STRING svTemp;

   2: Sprintf(svTemp,

   3:     "A string taking two parameters %s %s",

   4:     "Parameter 1", "Parameter 2");

String Trim(…) (Extracted from http://community.installshield.com/showthread.php?t=24423)

   1: function Trim(aString)

   2:     BOOL done;

   3:     NUMBER startIndex;

   4:     NUMBER endIndex;

   5:     NUMBER aByte;

   6: begin

   7:     startIndex = 0;

   8:     endIndex = StrLength( aString ) - 1;

   9:     done = ( startIndex > endIndex );

  10:     while ( !done )

  11:         GetByte( aByte, aString, startIndex );

  12:         if ( aByte = ASCII_SPACE ) then

  13:             startIndex = startIndex + 1;

  14:             done = ( startIndex > endIndex );

  15:         else

  16:             done = TRUE;

  17:         endif;

  18:     endwhile;

  19:     done = ( startIndex > endIndex );

20:

  21:     while ( !done )

  22:         GetByte( aByte, aString, endIndex );

  23:         if ( aByte = ASCII_SPACE ) then

  24:             endIndex = endIndex - 1;

  25:             done = ( startIndex > endIndex );

  26:         else

  27:             done = TRUE;

  28:         endif;

  29:     endwhile;

30:

  31:     if ( startIndex > endIndex ) then

  32:         aString = "";

  33:     else

  34:         StrSub( aString, aString, startIndex, endIndex - startIndex + 1 );

  35:     endif;

  36:     return 0;

  37: end;

Reading XML using MS XML DOM 6 (Inspired by http://community.installshield.com/showthread.php?t=101600&page=2)

   1: OBJECT oDoc, oNode, oNodeList;

   2: NUMBER nvBufferLen, nTemp;

   3: STRING svXPathQuery, svValue, svTemp, svMessage, svError, svLine, svLinePos;

4:

   5: set oDoc = CreateObject("Msxml2.DOMDocument.6.0");

   6: if (IsObject(oDoc) = FALSE) then

   7:     MessageBox("MSXML DOM-Document Connection Failed", 0);

   8:     return -1;

   9: endif;

10:

  11: oDoc.async = FALSE;

  12: oDoc.setProperty("SelectionLanguage", "XPath");

  13: oDoc.load( svInstallDir ^ UI_APP_CONFIG );

14:

  15: if ( oDoc.parseError.errorCode != 0 ) then

  16:     NumToStr ( svError , oDoc.parseError.errorCode );

  17:     NumToStr ( svLine , oDoc.parseError.line );

  18:     NumToStr ( svLinePos , oDoc.parseError.linepos );

  19:     MessageBox ( "The XML File did not load correctly.\n" +

  20:                  "Error Code: " + svError + "\n" +

  21:                  "Error Line: " + svLine + "\n" +

  22:                  "Error Line Position: " + svLinePos + "\n" +

  23:                  oDoc.parseError.reason , 0 );

  24: else

  25:     svXPathQuery = "//XPathQuery";

26:

  27:     try

  28:         set oNodeList = objDOMDOC.selectNodes( strXPathQuery );

  29:     catch

  30:         nTemp = Err.Number;

  31:         NumToStr(svTemp, nTemp);

  32:         MessageBox("Error while selecting " + strXPathQuery + " (Error + " + svTemp + ")", 0);

  33:     endcatch;

34:

  35:     if (oNodeList.length == 0) then

  36:        MessageBox( "No " + strXPathQuery + " elements found.", 0 );

  37:     else

  38:         for i = 0 to ( oNodeList.length - 1 );

  39:             set oNode = oNodeList.nextNode;

  40:             try

  41:                 svValue= oNode.text;

  42:                 //svValue = oNode.attributes.getNamedItem( strAttributeName ).value; // to get attribute value

  43:             catch

  44:                 MessageBox("No value found for " + strXPathQuery, 0);

  45:             endcatch;

  46:         endfor;

  47:     endif;

  48: endif;

Bhai Log indoor cricket game (Grading game)

2009-03-30T14:12:00.000+13:00

Our virgin game night (first game for our indoor season)…and in all honesty that’s exactly how we played .

The game was highly anticipated by most players but especially me as I was captaining our squad this season after giving the veteran captain (Jacinth) a rest. Big shoes to fill considering we won the last season we played when Jacinth was captain.

It did not start well for me…our first game and I had to sit out due to sickness but nonetheless we had enough players. Luckily it was a grading game so it wasn’t that important.

Everyone got to the game in time…this is a rarity as we all follow IST (Indian Standard Time ) except this one dude who apparently forgot we had a game…Yes you know who you are . But then we did get a hold of him and managed to get him down to the venue in time.

Our batting performance was good, getting 140ish in the first game is not a bad effort at all but we were let down in the fielding department. Not to mention that we nearly won the game too…the other team needed one run off the last ball to win as the scores was tied…it was a dot ball which the keeper struggled with (who can blame him…king does bowl which such sheer pace). The batsmen had time to take a single and win the game…

Vengeance will be in our eyes next time …opps wrong emoticon…I meant

Change

2009-03-30T14:05:00.001+13:00

I have read quite a few blogs of people mentioning this word. I am not going to provide a definitive answer and neither am I trying to “change” your viewpoint of what “change” is….I used the word “change” three times already without even analysing exactly of its definition.

What is change?

As per Google:
Definitions of change on the Web:

cause to change; make different; cause a transformation; "The advent of the automobile may have altered the growth pattern of the city"; "The discussion has changed my thinking about the issue"
an event that occurs when something passes from one state or phase to another; "the change was intended to increase sales"; "this storm is ...
undergo a change; become different in essence; losing one's or its original nature; "She changed completely as she grew older"; "The weather changed last night"
a relational difference between states; especially between states before and after some event; "he attributed the change to their marriage"
become different in some particular way, without permanently losing one's or its former characteristics or essence; "her mood changes in accordance with the weather"; "The supermarket's selection of vegetables varies according to the season"
the action of changing something; "the change of government had no impact on the economy"; "his change on abortion cost him the election"
switch: lay aside, abandon, or leave for another; "switch to a different brand of beer"; "She switched psychiatrists"; "The car changed lanes"
the result of alteration or modification; "there were marked changes in the lining of the lungs"; "there had been no change in the mountains"
change clothes; put on different clothes; "Change before you go to the opera"
the balance of money received when the amount you tender is greater than the amount due; "I paid with a twenty and pocketed the change"
exchange or replace with another, usually of the same kind or category; "Could you convert my dollars into pounds?"; "He changed his name"; "convert centimeters into inches"; "convert holdings into shares"
a thing that is different; "he inspected several changes before selecting one"
exchange: give to, and receive from, one another; "Would you change places with me?"; "We have been exchanging letters for a year"
a different or fresh set of clothes; "she brought a change in her overnight bag"
transfer: change from one vehicle or transportation line to another; "She changed in Chicago on her way to the East coast"
wordnet.princeton.edu/perl/webwn

Rather complicated isn’t it…

How do I see change
Change is a mindset. An inevitability which occurs sometimes even without you knowing. You often change your mind, clothes, time changes, the weather changes, etc… Can you change something without actually changing it, absolutely! Well, that’s at least what I am getting at. A change can be made simply by how you think about things. You are changing your thinking and according to me that’s the most important kind of change and not to mention the most powerful change of all. I do agree as humans we cannot change things which are out of our control…weather is a good example of that although if you can change a mind (your own or some else's) it is an amazing feat in a league of its own. The greatest leaders in history, sporting legends, coaches, teachers are those who convince their disciples/students to change their way of thinking. In effect changing their mind. We are affecting free will, well not directly but nonetheless we are.

You must be thinking…blah blah blah, I know all of this which is true…everyone probably knows the above although this is not what the blog is about. I am trying to determine and hopefully change (there the word CHANGE) the way you see “change”.

When you get faced with a change, how do you generally react? I go through a range of feelings generally:

nervous
excited
anxious
scared
confidence

Now the above will definitely depend on whether the change was voluntary or involuntary and also how big a change is. When you go through this emotions do you often take into consideration the implications of your change? How often do you go through a “what-if” analysis trying out different paths of your decision making. How often do you document or remember of what the reasoning behind your change was? In all honesty I don’t think any person would go through this kind of analysis for a small to medium size changed…forget that…most people wouldn’t even do those kind of analysis for making bigger life changes (i.e. moving countries, changing jobs, marriage, etc). Lets face it, we have big expectations from our brains, we attempt to remember the reasons for the change, completely possible to do…although how long will you remember this reasoning?

This forced me to think, can we make the process of change more reliable by remembering why and when we made a change. Will this help us make better changes in the future? This is a more generic solution, what I am currently in the process of doing is looking at this from a software developers perspective.

A software developer perspective…
Many a times have I done some work and come back to it and had trouble remember why and when the change was made. If you work for a company surely they’ll have some sort of mechanism to document exactly this although more often than you think it will fall short of your personal expectations. Maybe you are compulsive organiser like how I am and start writing endless pages of notes of why a change was required, where it was required, what other modules will the change effect, the tests you did to choose the optimum implementation of the change, etc etc. Finally this will become hard to manage simply due to so much manual writing, sorting and especially searching back through pages of written work. Isn’t there a better solution?

Surely there are better solutions out there…which you may have to pay for or other solutions which maybe completely generic and do not cater for your particular flavour of change management. I really want something which I can use, modify and persist over years. Something like a blog…but only for your coding changes. This is when it came to me, I really want a visual DSL which can cater for my obtuse needs as they arise. I can also use this wherever I go irrespective of the change I am making.

This system could not only help you document what change you made but also help you in determining how successful your change was 1-2 years down the line. Did you make a change to fix your change, how did your change scale for the future, did you change too much so that you simply ended up writing a whole new feature (which defeats the purpose of change nonetheless it is still technically a change).

I will be documenting on how I went about designing such a DSL in later Blogs. Hopefully it will give me a better understanding on how to manage change outside the IT sector and apply it to more generic changes…such as company decisions and risk analysis.

Keep an eye out…

Versioning DLLs in C#

2009-03-30T13:21:00.001+13:00

Often I design and implement .NET projects never really worrying about their versions until sometime in the future someone comes back and says, "I have this problem, can you fix it", and then you end up thinking that you have provided a fix, just not sure which version the fix was in. Problems also arise when you are trying to find a threshold point of when an interface in a particular DLL changes so that other files using it are not supported. Welcome to the age old problem of DLL versioning. Mind you, at this point in time I am talking about singular DLL versioning and not versioning at a broader scale (product based).

I am not saying this is the best way or the only way, all I am saying is this is how I have addressed the problem in the past.

After surfing around and finding various versioning tools/articles like:

All the above versioning schemes are great although I chose to go with AssemblyInfoTask. There are various (albeit more elegant ways) of using this simple tool but let us examine how I used it.

Step 1:
Well obviously download and install the tool from here. The help file within the installer comes in very handy and it does explain how you can go about changing the version number according to whatever scheme you like.

Step 2:
Edit your project file to include the new versioning task in it. This can be done by unloading your project in Visual Studio...

then you can right click on the unloaded project and go "Edit <ProjectName>". This will open up your project as an XML file in the VS editor. Most commonly your last Import statement will read the following:

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

Add another line below it which tells your project to also invoke the AssemblyInfoTask targets, your project file will then look like:

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<Import Project="$(MSBuildExtensionsPath)\Microsoft\AssemblyInfoTask\Microsoft.VersionNumber.Targets" />

Save the XML file and reload your project now.

Step 3:

Build the your project and you can see the DLL version skip every time you do a build according to the rules you defined in your AssemblyInfo target file.

Above you see that the file version is 1.0.327.0. According to my target file I have set up the build number as the current date and the revision number simply increments every time I do a build. I chose M-DD format as that allows me to go all year without changing my revision scheme. But wait…this does create a problem when you cycle around a year end. I thought of this and decided that if we do cycle around a year end I can simply change the minor versioning scheme. This may not always be feasible depending on company regulations and also depends on your release cycle. Well all I am saying is, use a scheme which works for you. Depending on your project and it’s release cycle your versioning scheme will differ too.

Step 4:

Great, so now you have a fully functioning versioning scheme. Note that the above versioning propagates through to the DLL via the AssemblyInfo.cs file.

What happens if you use some sort of source control in which your files are locked?

A nice little error will be produced informing you that AssemblyInfo.cs file cannot be edited because it is read-only. This happened for me as I was using Visual Source Safe, not sure exactly how other source control mechanisms react. Anyways there is a simple solution: Simply check out AssemblyInfo.cs file.

Checking out AssemblyInfo.cs

This will work well and good if you have only one project in your entire solution, although here are the problems you’ll come across:

What happens if there are 20 projects in your solution, will you be checking out each and every AssemblyInfo.cs file?

What happens if there are multiple developers working on different aspects of the solution, who decides when to check in such an AssemblyInfo.cs file?

A developer may do multiple builds every day, does that mean we are changing the revision every time?

Simply checking out the AssemblyInfo.cs file won’t work…what we need is some intelligent way of deciding when to kick off this AssemblyInfoTask target. This is when conditional logic comes in handy. Simply change your project XML file (we all know how to edit them now) to look like this:

<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<Import Project="$(MSBuildExtensionsPath)\Microsoft\AssemblyInfoTask\Microsoft.VersionNumber.Targets" Condition=" '$(Configuration)' == 'SpecialRelease' " />

All the above statement says is that we only want to invoke our AssemblyInfoTask target when our configuration is “SpecialRelease”. What is SpecialRelease, it is an arbitrary string. What is $(Configuration), it is the build configuration you use. You may already know that every generic C# project comes with two configurations already added for you: Debug and Release.

We could have simply used release but I thought that as developers we may use “Release” for some special test cases which may not occur on a “Debug” build. Anyways, so what we do now is add a new configuration called “SpecialRelease”. Easily done by clicking on “Configuration Manager…” and the following window opens up:

There are two aspects to the above window: Solution Configurations and configurations for each project shown below. Visual Studio comes in really handy in this case…we can add an entire new solution configuration and automatically propagate it down to every project within our solution.

Click new
Type in “SpecialRelease” and copy settings from “Release” (because we are only changing the version numbers on every release or whatever you want). Make sure the check box which says “Create new project configurations” is checked.
Voila! Your configuration manager will now look like:

One more quirk!!!!!!

Doing the above will result in a build error:

This is because simply adding new configurations does not guarantee that we have done all the necessary steps to cater for this new configuration. We edit our project XML again and add a block of XML (After the last PropertyGroup):

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'SpecialRelease|AnyCPU' ">
<OutputPath>bin\ReleaseQA\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>AnyCPU</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
</PropertyGroup>

You’ll find that doing the above, setting your configuration as “SpecialRelease” and building your solution will still not work. This is because $(Configuration) will be coming in as an empty string unfortunately. I haven’t fully researched understood this issue but I did manage a workaround…use MSBuild.exe to build your solution. Using MSBuild is really trivial, this is how you use it for the above mentioned “ClassLibrary1” solution:

MSbuild.exe “$(SolutionDir)\$(SolutionName)” /t:build /p:Configuration="SpecialRelease"

MSBuild.exe can be found in “C:\WINDOWS\Microsoft.NET\Framework\v3.5\”. And also remember that there are different versions of MSBuild.exe depending on your .NET version so make sure you build your solution with the correct version of MSBuild. More help on MSBuild here.

You can do this easily using automated build tools which allow you to checkout groups of files (AssemblyInfo.cs) and check them in afterwards.

Blogs to come

2009-03-30T13:06:00.002+13:00

I am just about to get into blogging and every time I do so I find it hard to come up with a topic...I have decided that I am going to blog about random bits from work, sport and in general every day moments. In the near future I am planning to blog about the following things:

Reading a list of computers/users on a given domain
Comes in really handy while remote desktoping into a computer only to find someone else is already using it.
Guest lecturing at university
I am about to give two lectures at uni about my recent thesis, that will be an interesting experience.
WPF quirks and weirdness
Will be compiling a list of those soon.

CS732 & SE450 Guest Lecture

2009-03-30T13:06:00.001+13:00

I recently finished my ME at Auckland University and was privileged to be invited to give a couple of guest lectures to the current undergraduates. It was a great opportunity and something definitely worth writing about.

I prepared a presentation outlining my research etc and used that as a teaching aid. I was extremely nervous before giving the first lecture, it was a computer science honours class and I wasn't at all familiar with any of the students there but nervousness soon faded away and then it just felt like I was talking about my work to my peers. I did feel like I rushed the presentation but I guess that happens naturally when you are slightly nervous. Although one positive did come out of that, I had plenty of time to give a live demo of my tool which is always a good thing while talking.

The second lecture I was meant to give was on the next day but unfortunately I could not stick to that schedule as I was feeling a bit under the weather. So we rescheduled and finally managed to give the lecture two days later. This time it was a 4th year software engineering class. Great class and the students were nothing like how "we" were back in university, they did actually listen...this time around the lecture seemed easier as I was familiar with the students and had tutored them the year before. The lecture went well but unfortunately I could not give them a live demo of the tool as my laptop had no battery left :(. Nonetheless the lecture finished early so I am sure the students must have been glad.

To sum things up...it was a great experience. Giving a talk about something you spent a whole year on...designing and implementing is really easy. Mind you this is me talking in hindsight...at the time I was shaking in my boots :)

Downloads: Presentation