I’ve decided to kick this blog off again, after much time off, and for my first post … I’ll introduce my Cached, Compiled, XSL Web Control. 

Ever used the XSL control?  It looks something like this:

 <asp:Xml ID="xml1" DocumentSource="/MyData.xml" TransformSource="/MyStyle.xsl" />

I was working on a XML content driven project recently where I had to do many XML transforms on a page, and the above simly did not cut it, for the following reasons:

1. No Caching – Everytime I want to perform a Transform, the control has to read my XSL from disk
2. Due to the lack of caching, the XSL has to be compiled for each transform.
3. Can’t pass paramaters via markup, they all have to be done via the code behind, which can be slighly more difficult to manage
4. XML either from disk or via string, why do I have to ToString my XMLDocument/XDocument?

Mainly it was the lack of caching that annoyed me

My solution? come up with my own XsltControl

I started off with a basic XsltControl, wrapped a WebControl around it and added caching CompiledTransforms.  Extra support was added for adding paramaters via markup.

So, now, you I can write

<custom:XsltControl ID="MyTransform" runat="server">
            <custom:Argument Name="markup" Value="This text came from a paramater added via markup" />
            <custom:Argument Name="resource" meta:resourcekey="Resource" />
</custom:XsltControl>

The control also allows you to set the path of a xsl include directory which it will cache and add cache dependencies to the Xsl for, so when the Xsl changes, or an includes file changes the cached version is invalidated and the new version picked up on the next transform.

Code for XsltControl

XsltControl
Visual Studio 2008 Solution. [you'll have to rename the file to .zip]

The GAC

Way back as part of .NET 1.1, Microsoft introduced a feature called the Global Assembly Cache, or GAC. The GAC is a virtual folder which holds references to assemblies on the hard disk.

You can view assemblies in the GAC by navigating to C:\Windows\Assembly (or whatever your root drive is) and what you should see is a unusual looking folder with lots of assemblies in it. Scroll through and should find all the .NET assemblies as well as a few for other applications you have installed.

The GAC can only store CLR assemblies, and as you might have noticed each one has a public key, which suggests that they have been signed. Each assembly also has a version, and a culture (a blank culture defaults to neutral culture. Together with the name these 3 pieces of information make up the identity of an individual assembly.

The purpose of the GAC is to allow the sharing of assemblies across multiple applications. Imagine a scenario where you have 3 applications installed on the same server using a common Utilities assembly, if you added a reference the Utilities assembly to each project individually, then on that server you would have find 3 copies of the assembly, 1 in each bin folder. By installing the Utilities assembly it the GAC you would only need to have 1 copy.

It may sound a replacement for COM, but it’s not, the GAC is for .NET assemblies only and.NET applications are the only applications that can directly access an assembly in GAC. For legacy or non .NET applications you still have to use COM.

When you need multiple applications to use the same assembly then the GAC could be the best place to install it. You only have 1 copy per server which eases management; you only have to update 1 assembly to update all applications. All the .NET Framework assemblies are installed in GAC, that’s why you never see the .NET Framework assemblies such as the System.dll and System.Collections.dll in your applications bin folder.

Signing

To install an assembly into the GAC you first need to sign it. This can be done though Visual Studio by going to the Project properties, and clicking on the Signing tab. There you will have to check the “Sign the Assembly” checkbox and then either choose an existing string name key or let Visual Studio create a strong name key for you.

A strong name key consists of a private/public pair. First a hash of your assembly is created, and then the hash is encrypted with the private key part of. To distribute the assembly you provide the assembly and the public key to the receiver. The receiver decrypts the assembly using the public key and generates a hash. If the hash generated by the receiver matches the hash they decrypted then the assembly can be verified as being un-tampered with.

It may sound like the same as a Digital certificate, but it isn’t. Digital certificates are created by a certificate authority who is a trusted party and verifies that a certificate you attach to an assembly belongs to you. With a strong names there’s nobody to provide that facility and therefore somebody could replace your key with their own, there’s no mechanism to verify who the key belongs to. Knowing this if you plan to distribute an assembly outside of your department or company then you should obtain a digital certificate from a trusted certificate authority.

Another method to create a strong name key is to use the Visual Studio Command Prompt and run the following

sn -k

After you have assigned a key to your project the assembly will be signed when built.

Deployment

Once you have built your assembly you can install it into the GAC by drag-dropping it into the C:\Windows\Assemby folder or by running the following command in the Visual Studio Command Prompt.

gacutil -i

You can also create a setup project to deploy your assembly via an installer which is a much cleaner method for deployment.

Once deployed you can use your assembly like any other .NET assembly by adding a reference to it into your .config file:

<assemblies>
   <add assembly="<assemblyName>, Version=<version>, Culture=<culture>, PublicKeyToken=<publicKey>"/>
</assemblies>

“Hold on”, i hear you say, who adds references manually to their .config file like above? normally you’d right click on your references folder in Visual Studio and add it from there. Unfortunately the Add Reference dialog is not driven from the GAC, its driven from the registry, so you’ll have to add a registry key for this level of functionality; another reason to use a setup project for deployment.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\AssemblyFolders\\[Default String Key with value =

Version Management

When you do have a shared assembly, you want to be able to version it, so that in the future you can create a new version and not break the existing one. Make sure you have a versioning strategy in place, it doesn’t have t be complex, you don’t have to make use of the minor digits, a simple X.0.0.0 version will do.

When you deploy your new version it will be a completely separate install so make sure you’ve archived your previous version, and the source files to go with it in case a bug crops up in the future that you need to fix. Your new assembly will not affect the old assembly as long as the version numbers are different.

Once you’ve deployed the new version you’ll do 1 of three things.

1. Use your new version for new applications and let applications using the old version carry on using the old version.

2. Force some applications on a server to use the new version: In this case you have to add a binding redirect element ton your applications .config file.

<configuration>
   <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <dependentAssembly>
            <assemblyIdentity name="<assemblyName>"
                              publicKeyToken="<publicKey>"
                              culture="<culture>" />
            <bindingRedirect oldVersion="1.0.0.0"
                             newVersion="2.0.0.0"/>
         </dependentAssembly>
      </assemblyBinding>
   </runtime>
</configuration>

3. Force all applications on a server to use the new version (only likely to do this if a version is backwards compatible): You’ll have configure this using the Microsoft .NET Framework Configuration Tool via Control Panel > Administration Tools.

Expand the My Computer node, expand the Configured Assemblies Node, click on Configure and Assembly and then choose an Assembly to configure. This will add the Assembly to the list of Configured Assemblies and from here you can set the binding policy.

As you can see, the GAC is a very handy feature and easy to use, if you need to deploy an assembly which will be shared by multiple applications, then the GAC is the way to go.

Threading

If you don’t know what a process is, click Crtl + Shift + Esc to bring up the task manager, click on the processes tab and you’ll see all the processes running on your PC (You might need to uncheck “Show processes from all users” to see all of the processes).

A process is a programs container to which the operating system assigns security privileges, memory and processing priority (as well as a few other things). Open up Microsoft Word and you’ll see the WORD process pop up on the list.

In the Task Manager click on View, on the toolbar, select Columns, check Thread Count and click OK. You’ll see a new column displaying the number of threads contained within a process. The threads are what actually execute code, and most applications will have several threads running. For example Microsoft Word might have 1 thread for the window where you type another listening for events (clicking an icon, typing a character etc). It might also have some sleeping threads, threads waiting for something to occur, for example Word will auto-save your document every 5 minutes, As auto-saving doesn’t happen all the time, Word might put this into a Wait state (Sleep) until required.

Multi-threading allows Microsoft Word to provide you with a responsive experience, where a lot of processing occurs, but you would never tell from the speed of the application.

Threading in .NET allows you to create your own multi-threaded applications so your users can have a smoother user experience, and you can make better use of your processor.

Lets jump into an example.

public static class Program
{
public static void Main()
{
SimpleThreadingDemo simple = new SimpleThreadingDemo();
simple.FirstThread();
Console.ReadLine();
}
}

internal class SimpleThreadingDemo
{
public void FirstThread()
{
ThreadStart ts = new ThreadStart(DoWork);
Thread newThread = new Thread(ts);
newThread.Start();
Console.WriteLine(“First Thread”);

}

private void DoWork()
{
Console.WriteLine(“Second Thread”);
}
}

See that delegate. Arn’t you glad you read Part 1 now?

You’ll also notice as were doing 2 things at the same time, they’re running asynchronously! Although it’s not truly Asynchronous programming as DoWork() can’t return data to FirstThread().

Lets do something slightly more intresting

public static class Program
{
public static void Main()
{
SimpleThreadingDemo simple = new SimpleThreadingDemo();
simple.FirstThread();
Console.ReadLine();
}
}

internal class SimpleThreadingDemo
{
public void FirstThread()
{
ThreadStart ts = new ThreadStart(DoWork);
Thread newThread = new Thread(ts);
newThread.Start();
for (int i = 0; i < 10; i++)
{
Console.WriteLine(“First Thread: {0}”, DateTime.Now.Ticks);
Thread.Sleep(100);
}

}

private void DoWork()
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine(“Second Thread: {0}”, DateTime.Now.Ticks);
Thread.Sleep(100);
}
}
}

When you run this you’ll see that both threads are defiantly running at the same time, and if you have a fairly modern CPU (Dual/Quad Core or Hyper Threaded) you’ll see that some of the messages get written to the console screen at exactly the same time!

You’ll notice the Thread.Sleep method. This method pauses the thread for the specified number of seconds. What’s important to remember here is that it will only pause the current thread (the that thread which executes that line of code). You can’t call Sleep on other threads.

Parameters

What if we wanted to pass some data to the DoWork method? Use the ParameterizedThreadStart delegate.

public static class Program
{
public static void Main()
{
SimpleThreadingDemo simple = new SimpleThreadingDemo();
simple.FirstThread();
Console.ReadLine();
}
}

internal class SimpleThreadingDemo
{
public void FirstThread()
{
ParameterizedThreadStart ts = new ParameterizedThreadStart(DoWork);
Thread newThread = new Thread(ts);
newThread.Start(“This String Will be Cast Into an Object”);
for (int i = 0; i < 10; i++)
{
Console.WriteLine(“First Thread”);
Thread.Sleep(100);
}

}

private void DoWork(object myObject)
{
string s = (string)myObject;

for (int i = 0; i < 10; i++)
{
Console.WriteLine(s);
Thread.Sleep(100);
}
}
}

Hopefully you will have noticed above that I had to pass the parameter as an object. With ParameterizedThreadStart you can only pass 1 parameter and it has to be an object type. Personally I really dislike passing objects as parameters but there’s no other option here.

Locking

When running a muti-threaded application, special care must be taken when modifying shared data. For example imagine you had a counter which was incremented every time a method was called. Being multi-threaded it’s likely that the method will be called twice (or more) at exactly the same time, in which case your counter might not work as intended.

public static class Program
{
public static void Main()
{
SimpleThreadingDemo simple = new SimpleThreadingDemo();
simple.FirstThread();
Console.ReadLine();
}
}

internal class SimpleThreadingDemo
{
public void FirstThread()
{
Thread[] threads = new Thread[10];
SharedCounter shared = new SharedCounter()

for (int looper = 0; looper < 10; looper++)
{
Thread th = new Thread(new ThreadStart(shared.Increment));
threads[looper] = th;
th.Start();
}

for (int looper = 0; looper < 10; looper++)
{
threads[looper].Join();
}

Console.WriteLine(“Value is: ” + shared.counter);
}
}

internal class SharedCounter
{
public int counter;

public void Increment()
{
for (int i = 0; i < 100000; i++)
{
counter += 1;
}
Console.WriteLine(“Finished a loop”);
}
}

10 threads are created; each one executes the increment method on the same SharedCounter instance. This means that the counter variable is effectively shared between them

The above code created 10 threads and each thread calls a method which increments the counter 100,000 times. The result we expect is 100,000 x 10 = 1,000,000, but it’s not.

That’s because the counter variable is stored in memory somewhere, and every time a thread needs to increment it, it has to retrieve the value from memory, add 1, and save it again. If during this process another thread retrieves the value from memory, then it will overwrite what the previous thread saved.

Using the Join() method on the threads above tells the main thread (the thread which had to run the loop to create the 10 threads) to wait until each thread is finished. If we don’t include this then the value of counter will be displayed before all the threads have finished executing (try it).

How can we solve this? By using the Interlocked.Increment method.

internal class SharedCounter
{
public int counter;

public void Increment()
{
for (int i = 0; i < 100000; i++)
{
Interlocked.Increment(ref counter);
}
Console.WriteLine(“Finished a loop”);
}
}

When a thread attempts to increment counter, a lock will be created on counter variable, and all other threads will have to queue up and wait until it is unlocked. Now when we run the code, we get the desired result.

There’s a limitation in using Interlocked.Increment() in that it only works with integers. What if we need to modify a string, or any other object instead of just an int? In this situation we need to use a Synchronization (Sync) Lock.

internal class SharedCounter
{
public int counter;

public void Increment()
{
lock (this)
{
for (int i = 0; i < 100000; i++)
{
counter++;
}
}
Console.WriteLine(“Finished a loop”);
}
}

This time, as soon as a thread gets to the lock(this) keyword, the first thread creates a lock on the entire object (SharedCounter) until the end of the lock is reached. When the next thread reaches the lock keyword, it will wait until the object is unlocked.

Under the covers the lock keyword uses the Monitor class to perform its task, and if you need a greater amount of control, then the Monitor class allows you to specify timeouts for locks and allows you to reacquire a lock after you lose it. Its unlikely that you’ll ever need this amount of control in your day to day coding, but its good know.

internal class SharedCounter
{
public int counter;

public void Increment()
{
Monitor.Enter(this);
try
{
for (int i = 0; i < 100000; i++)
{
counter++;
}
}
finally
{
Monitor.Exit(this);
}
Console.WriteLine(“Finished a loop”);
}
}

If the code within the try… catch were to throw an exception then the lock would never be released, hence the try… catch.. finally… block.

Thread Pool

All the above code samples involve you creating your own threads. What if your multi-thread application had hundreds of users logged on at the same time? Then you’d be creating hundreds of threads and as you might imagine this would decrease the performance of your application as each thread requires processor time to execute. You’d probably have to create a class to limit the number of threads created, and if all threads are being used then queue up work so it can be executed once a thread becomes available. That’s what the ThreadPool does.

To use the ThreadPool you do the following

private void ThreadPool(object sender, EventArgs e)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), 20);
}

It’s that easy.

The default maximum number of threads is 20, to change this you can add the following into your web.config.

IO threads as the name suggests are used for IO operations (e.g. reading/writing to disk) and generally you’ll have more IO threads than worker threads. There’s no magic formula for calculating the best number of Threads for your application, it’s a case of testing and tweaking to an individual applications needs.

There is one slight caveat when using the ThreadPool, all of the threads are created as background threads (the Thread.IsBackground property is set to true). What this means is that if the thread which created those background threads, the main thread, ends or aborts then the background threads will also be aborted and will never be executed. For example, if your web page completes all its processing and returns to the user before you’ve done the work on the ThreadPool thread. To avoid this it’s best to perform short operations on background threads and use normal threads ( foreground threads) for more time consuming or critical work.

That’s it for part 2 of Asynchronous Programming, in the final part I’ll combine Threading, Delegates and Events to show of the Asynchronous Programming model.

]]>

Custom configuration sections were revamped in .net 2.0 and are a great way to validate and manage your applications configuration with a minimal amount of work.

Instead of storing multiple keys in the you can consolidate your keys into their own cleaner and clearer section. Consider the following section. This is a really simple example, the below appSettings would likely contain a mix of other keys.

<appSettings>
	<add key="euTax" value="on" />
	<add key="euRate" value="15" />
	<add key="euName" value="Tax" />
	<add key="euTaxRegion" value="Europe" />

	<add key="ukTax" value="off" />
	<add key="ukRate" value="17.5" />
	<add key="ukName" value="VAT" />
	<add key="ukTaxRegion" value="UK" />

	<add key="usTax" value="on" />
	<add key="usRate" value="10" />
	<add key="usName" value="Tax" />
	<add key="usTaxRegion" value="WorldWide" />
</appSettings>

This would be better if it was condensed into

<taxSettings>
	<euTax mode="on" rate="15" name="Tax" taxRegion ="Europe"/>
	<ukTax mode="off" rate="17.5" name="VAT" taxRegion ="UK" />
	<usTax mode="on" rate="10" name="Tax" taxRegion ="WorldWide" />
</taxSettings>

It’s clear that the TaxSettings configuration is a lot easier to read than the appSettings. Its also easier to manage and maintain.

With appSettings, if a key was missing how would you handle that? You’d have to create a class to access the keys, throw exceptions if required key is missing, write code to use default values if a non-required key was missing; essentially create your own Configuration Management Class.

.Net alrady hs this built it! By inheriting the ConfigurationSection and ConfigurationElement types, you can let .Net do a lot of the work for you.

Step 1 – Create classes to represent your config data

its pretty much your standard class format. I’ve defined a TaxSettings class almost as a base for each countries tax settings, and then in the TaxConfiguration class i’ve defined TaxSettings for EuTax, UkTax and UsTax.

public class TaxConfiguration
{
public TaxSetting EuTax
{
get { return ; }
}

public TaxSetting UkTax
{
get { return ; }
}

public TaxSetting UsTax
{
get { return ; }
}
}

public class TaxSetting
{
public Mode Mode
{
get { return ; }
}

public string Name
{
get { return ; }
}

public decimal Rate
{
get { return ; }
}

public TaxRegionType TaxRegion
{
get { return ; }
}
}

public enum TaxRegionType
{
UK,
Europe,
WorldWide
}

public enum Mode
{
On,
Off
}

Step 2 – Inherit & Decorate

Your the class which will represent your root node should inherit from ConfigurationSection
, with other classes which represent child nodes inheriting from ConfigurationElement.

Decorate each property you want to retrive from the config with ConfigurationProperty, defining the name of the node or attribute that you will use in the .config file. .Net will automagically map your .config file to your custom classes, to return a particular item just return this["nameOfyourNode"] and cast it to the appropriate type. (nameOfYourNode = the same name you used in the attribute)

The ConfigurationProperty has a number of parameters including DefaultValue and IsRequired which you can set too. I’ve also included a StringValidator on one of the attributes, theres a Regex Validator and IntValidator avaliable to use too you can even create your own!

public class TaxConfiguration : ConfigurationSection
{
[ConfigurationProperty("euTax")]
public TaxSetting EuTax
{
get { return (TaxSetting)this["euTax"]; }
}

[ConfigurationProperty("ukTax")]
public TaxSetting UkTax
{
get { return (TaxSetting)this["ukTax"]; }
}

[ConfigurationProperty("usTax")]
public TaxSetting UsTax
{
get { return (TaxSetting)this["usTax"]; }
}
}

public class TaxSetting : ConfigurationElement
{
[ConfigurationProperty("mode", DefaultValue = Mode.On, IsRequired = false)]
public Mode Mode
{
get { return (Mode)this["mode"]; }
}

[ConfigurationProperty("name", IsRequired = true)]
[StringValidator(MaxLength=10, InvalidCharacters="?@~#%$£&*()!_-'£")]
public string Name
{
get { return (string)this["name"]; }
}

[ConfigurationProperty("rate", IsRequired = true)]
public decimal Rate
{
get { return (decimal)this["rate"]; }
}

[ConfigurationProperty("taxRegion", IsRequired = true)]
public TaxRegionType TaxRegion
{
get { return (TaxRegionType)this["taxRegion"]; }
}
}

public enum TaxRegionType
{
UK,
Europe,
WorldWide
}

public enum Mode
{
On,
Off
}

Step 3 – Configure Your .Config

Add a configSection to your .config, the name can be anything you want and will be use to map to the class derived from ConfigurationSection (TaxConfiguration in our case), the type consists of 2 parts, the first is the full name of the class deriving from ConfigurationSection, the second is the name of the Assembly (you can get this from the project properties dialog)

<?xml version="1.0" encoding="utf-8" ?>

<configuration>
    <configSections>
        <section name="TaxSettings" type="ConfigurationTest.TaxConfiguration, ConfigurationTest" />
    </configSections>

    <taxSettings>
        <euTax mode="On" rate="15" name="Tax" taxRegion ="Europe"/>
        <ukTax mode="Off" rate="17.5" name="VAT" taxRegion ="UK" />
        <usTax mode="On" rate="10" name="Tax" taxRegion ="WorldWide" />
    </taxSettings>
</configuration>

Step 4: Access your Custom Configuration

What I usually do is wrap this up in a static class (as static properties) so that I don’t have to cast the ConfigSection to my type every time I want to access the data.

class Program
{
static void Main(string[] args)
{
//You could do this everytime you needed to access the config data
decimal UkTaxRate = ((TaxConfiguration)ConfigurationManager.GetSection(“TaxSettings”)).UkTax.Rate;

//Or you could do this, by creating a static class as below
string taxName = MyConfiguration.EuTaxSettings.Name;
}

}

public static class MyConfiguration
{
public static TaxSetting EuTaxSettings
{
get { return ((TaxConfiguration)ConfigurationManager.GetSection(“TaxSettings”)).EuTax; }
}

public static TaxSetting UkTaxSettings
{
get { return ((TaxConfiguration)ConfigurationManager.GetSection(“TaxSettings”)).UkTax; }
}

public static TaxSetting UsTaxSettings
{
get { return ((TaxConfiguration)ConfigurationManager.GetSection(“TaxSettings”)).UsTax; }
}
}

Collections

What I’ve done above is okay, but it’s not easy to extend. Every time I wasnt to add a new country Ill have to create new properties in the TaxConfiguration and MyConiguration classes. What I’d rather do is have the following fomat so I don’t have to edit my Configuration handlers every time I need to add a new country:

<taxSettings>
    <settings>
        <add key="EU" mode="On" rate="15" name="Tax" taxRegion ="Europe"/>
        <add key="UK" mode="Off" rate="17.5" name="VAT" taxRegion ="UK" />
        <add key="US" mode="On" rate="10" name="Tax" taxRegion ="WorldWide" />
    </settings>
</taxSettings>

To do this were going to have to inheirt from ConfigurationElementCollection. The complete modified class is below.

class Program
{
static void Main(string[] args)
{
string taxName = MyConfiguration.TaxSettings["EU"].Name;
}

}

public static class MyConfiguration
{
public static TaxSettingsCollection TaxSettings
{
get { return ((TaxConfiguration)ConfigurationManager.GetSection(“TaxSettings”)).TaxSettingsCollection; }
}
}

public class TaxConfiguration : ConfigurationSection
{
[ConfigurationProperty("Settings", IsDefaultCollection=false)]
[ConfigurationCollection(typeof(TaxSetting))]
public TaxSettingsCollection TaxSettingsCollection
{
get { return (TaxSettingsCollection)this["Settings"]; }
}
}

public class TaxSettingsCollection : ConfigurationElementCollection
{
[ConfigurationProperty("euTax")]
public TaxSetting EuTax
{
get { return (TaxSetting)this["euTax"]; }
}

public TaxSetting this[int index]
{
get { return (TaxSetting)BaseGet(index); }
}

public TaxSetting this[string key]
{
get {
for(int i = 0; i < Count; i++)
if (this[i].Key == key)
return this[i];
throw new KeyNotFoundException();
}
}

protected override object GetElementKey(ConfigurationElement element)
{
return ((TaxSetting)element).Key;
}

protected override ConfigurationElement CreateNewElement()
{
return new TaxSetting();

}
}

public class TaxSetting : ConfigurationElement
{
[ConfigurationProperty("key", IsRequired=true, IsKey=true)] //note the use of IsKey
public string Key
{
get { return (string)this["key"]; }
}

[ConfigurationProperty("mode", DefaultValue = Mode.On, IsRequired = false)]
public Mode Mode
{
get { return (Mode)this["mode"]; }
}

[ConfigurationProperty("name", IsRequired = true)]
[StringValidator(MaxLength=10, InvalidCharacters="?@~#%$£&*()!_-'£")]
public string Name
{
get { return (string)this["name"]; }
}

[ConfigurationProperty("rate", IsRequired = true)]
public decimal Rate
{
get { return (decimal)this["rate"]; }
}

[ConfigurationProperty("taxRegion", IsRequired = true)]
public TaxRegionType TaxRegion
{
get { return (TaxRegionType)this["taxRegion"]; }
}
}

public enum TaxRegionType
{
UK,
Europe,
WorldWide
}

public enum Mode
{
On,
Off
}

Today whilst trying to validate an XML document in Sql Server 2005, which had been passed in as a paramater from .Net, I came accross an issue with DateTime serialization.

XML Date Time Sepcification

The W3C XML Schema Scpeification specifies that a valid datetime is the following

2008-04-28T22:45:32+01:00

The first portion before the ‘T’ is obviously the date. The second portion consists of the UTC time, plus an offset value. This allows times to be compared around in a standard manner, with the ability to obtain the local time. +01:00 means UTC+1, or British Summer Time for us in the UK.

Instead of having an offset of +00:00 for a UTC time with no offset, the specification allow for this to be replaced with a Z, so that

2008-04-28T22:45:32+00:00

becomes

2008-04-28T22:45:32Z

In addition, the scpeification allows for fractional seconds, so that a precise UTC+0 datetime can be represented as

2008-04-28T22:45:32.1845Z

Where does .Net & SQL fit into all of this?

Well, imagine like me you want to take advantage of the XML schema feature of Sql Server 2005. You can create a schema, register it within 2005 and then rather than pass in individual paramaters to a stored procedure, you can pass in an XML document.

Consider the implications this has when inserting data like a Shopping Bag object. Typically you would insert the Shopping Bag Order Header first to retrive some form of reference id from the database, and then iterate over each of the Order Lines, creating a command and inserting one at a time. For each order line you will be firing off TCP packets to the database, and each packet will contain some overhead. Having to wait for a reply from the database prior to inserting the next Order Line can also cause a delay.

So, rather than processing each line at a time, we could make our Shopping Bag object serializable, create an XML schema to validate this Shopping Bag, register the schema with the database and create a Sql Script to validate and parse the serialized XML and insert the data into the correct tables (using the OPENXML methods).

We don’t have to make multiple calls to the database, reducing the chance of failure and any application could call the Stored Procedure without having to know the specific order in which data needs to be inserted. With the typical method we need to call the stored procedure to insert the order Header first and then insert the Order Lines; with the XML method all of this is handled within the stored procedure.

More than likely your Shopping Bag object will have a DateTime type property. When .Net serializes this property it will be a standard XML Schema Specification valid DateTime, with a fractional component and a DateTime offset, like 2008-04-28T22:45:32.0128+01:00

T-SQL however cannot cast this format to a T-SQL DateTime, and although the XML you pass to Sql will validate against the XML Schema held in the database, you won’t be able to insert the value into a column. What T-Sql actually requires is the following 2008-04-28T22:45:32Z. No fractional component and no UTC offset. Once the date is in the database all concept of UTC is lost, T-SQL doesn;t not understand what UTC is.

Becuase you’re going to be using the XMLSerializer class to serialize the Shopping Bag object you can’t control how the DateTime property is serialized, there’s no ‘XmlDateTime’ attribute. Instead, we have to format the data in the get method of our property.

public DateTime _myDate;

public DateTime MyDate
{
get { return DateTime.SpecifyKind(DateTime.Parse(_myDate.ToString(“u”)), DateTimeKind.Utc); }
set { _myDate = value; }
}

_myDate.ToString(“u”) makes sure we lose any fractional component. The format string u is known as an invaritant DateTime format. This does not however remove the offset value. Todo this we need to tell .Net that this is a UTC timezone time (rather than British Summer Time, UTC+1), hence the use of DateTime.SpecifyKind().

Now when this is serialized .Net will serialize our DateTime as a T-SQL compabtible datetime., and we havn’t lost the exact datetime that was originally set, however we would need to create method to access this.

Today whilst trying to validate an XML document in Sql Server 2005, which had been passed in as a paramater from .Net, I came accross an issue with DateTime serialization.

XML Date Time Sepcification

The W3C XML Schema Scpeification specifies that a valid datetime is the following

2008-04-28T22:45:32+01:00

The first portion before the ‘T’ is obviously the date. The second portion consists of the UTC time, plus an offset value. This allows times to be compared around in a standard manner, with the ability to obtain the local time. +01:00 means UTC+1, or British Summer Time for us in the UK.

Instead of having an offset of +00:00 for a UTC time with no offset, the specification allow for this to be replaced with a Z, so that

2008-04-28T22:45:32+00:00

becomes

2008-04-28T22:45:32Z

In addition, the scpeification allows for fractional seconds, so that a precise UTC+0 datetime can be represented as

2008-04-28T22:45:32.1845Z

Where does .Net & SQL fit into all of this?

Well, imagine like me you want to take advantage of the XML schema feature of Sql Server 2005. You can create a schema, register it within 2005 and then rather than pass in individual paramaters to a stored procedure, you can pass in an XML document.

Consider the implications this has when inserting data like a Shopping Bag object. Typically you would insert the Shopping Bag Order Header first to retrive some form of reference id from the database, and then iterate over each of the Order Lines, creating a command and inserting one at a time. For each order line you will be firing off TCP packets to the database, and each packet will contain some overhead. Having to wait for a reply from the database prior to inserting the next Order Line can also cause a delay.

So, rather than processing each line at a time, we could make our Shopping Bag object serializable, create an XML schema to validate this Shopping Bag, register the schema with the database and create a Sql Script to validate and parse the serialized XML and insert the data into the correct tables (using the OPENXML methods).

We don’t have to make multiple calls to the database, reducing the chance of failure and any application could call the Stored Procedure without having to know the specific order in which data needs to be inserted. With the typical method we need to call the stored procedure to insert the order Header first and then insert the Order Lines; with the XML method all of this is handled within the stored procedure.

More than likely your Shopping Bag object will have a DateTime type property. When .Net serializes this property it will be a standard XML Schema Specification valid DateTime, with a fractional component and a DateTime offset, like 2008-04-28T22:45:32.0128+01:00

T-SQL however cannot cast this format to a T-SQL DateTime, and although the XML you pass to Sql will validate against the XML Schema held in the database, you won’t be able to insert the value into a column. What T-Sql actually requires is the following 2008-04-28T22:45:32Z. No fractional component and no UTC offset. Once the date is in the database all concept of UTC is lost, T-SQL doesn;t not understand what UTC is.

Becuase you’re going to be using the XMLSerializer class to serialize the Shopping Bag object you can’t control how the DateTime property is serialized, there’s no ‘XmlDateTime’ attribute. Instead, we have to format the data in the get method of our property.

public DateTime _myDate;

public DateTime MyDate
{
get { return DateTime.SpecifyKind(DateTime.Parse(_myDate.ToString(“u”)), DateTimeKind.Utc); }
set { _myDate = value; }
}

_myDate.ToString(“u”) makes sure we lose any fractional component. The format string u is known as an invaritant DateTime format. This does not however remove the offset value. Todo this we need to tell .Net that this is a UTC timezone time (rather than British Summer Time, UTC+1), hence the use of DateTime.SpecifyKind().

Now when this is serialized .Net will serialize our DateTime as a T-SQL compabtible datetime., and we havn’t lost the exact datetime that was originally set, however we would need to create method to access this.

Asynchronous Programming Part 1 – Delegates

Asynchronous Programming is the ability to perform multiple operations at the same time. For example, connect to a web service whilst at the same time connecting to a database and still responding to user input (avoiding a ‘frozen’ window).

To understand and be able to use Asynchronous programming techniques there are a couple of .Net features that need to be covered first, and this 3 part blog will provide you will all the knowledge you need to assess when and understand how to implement Asynchronous code.

At the core of Async is a feature known as delegates.

Delegates have been around since .Net 1. You’re using delegates every time you build any application with a UI, and behind the scenes Visual Studio .Net implements the delegates on your behalf.

To wire a button to an event, in your client side .aspx you’d usually write the following:

And in your server side .cs:

protected void btnOne_Click(object sender, EventArgs e)
{
// do work
}

But how does .Net actually call the btnOne_Click method?

Event Handlers = Delegate

In .Net 1.0 you had to explicitly define Event Handlers, in .Net 2.0 this is all performed at runtime during page initialization. What .Net 2.0 actually does during page initialization is create and run the following:

protected void Page_Init(object sender, EventArgs e)
{
btnOne.Click += new EventHandler(btnOne_Click);
}

As you can see, I’ve done this in the Page_Init event, and I’ve had to append to the btnOne.Click event an EventHandler class, which takes the btnOne_Click method as its parameter.

The EventHandler class is a special type of class whose sole purpose it is to wrap up calls to another method.

By using the EventHandler above, we can assign as many methods as we like to the btnOne.Click event without btnOne.Click having to know the names of our methods. Then when btnOne is clicked it can execute each of those methods.

protected void Page_Init(object sender, EventArgs e)
{
//All the 3 below do eactly the same thing
EventHandler handler = new EventHandler(btnOne_Click_1);
btnOne.Click += handler;

btnOne.Click += new EventHandler(btnOne_Click_2);

btnOne.Click += btnOne_Click_3;

//Events are similar to arrays, we can remove delagates from them
btnOne_Click -= new EventHandler(btnOne_Click_1);
}

Note: you can’t depend on the delegates to be invoked in any specific order

If delegates are a special type of class, then surly you can create your own? Absolutely. A delegate is basically a method signature (no code body, just the name, parameters and return value of a method). Also it’s good practice to include the word ‘Handler’ as a name suffix so that other coders can immediately tell that it’s a delegate.

public partial class WebForm1 : System.Web.UI.Page
{
delegate int MyCustomHandler(int a, int b);

The delegate above requires that any method to be wrapped up by MyCustomHandler must return an int and must have 2 int’s as it’s parameters.

You can then define a method, use the delegate to wrap up the method and call the invoke method on the delegate to execute the wrapped up method.

delegate int MyCustomHandler(int a, int b);

protected int DoWork(int a, int b)
{
return a + b;
}

protected void PageLoad(object sender, EventArgs e)
{
MyCustomHandler = new MyCustomHandler(DoWork);
ExecuteDelegate(handler);
}

protected void ExecuteDelegate(MyCustomHandler handler)
{
int myInt = handler.Invoke(3, 7);
// myInt = 10
}

As you will have noticed, the delegate can be passed around and you can use anything you want as the parameters, however it’s standard practice to pass an object (the object which raised the event) and EventArgs (or a class deriving from it) as the delegates parameters.

public partial class WebForm1 : System.Web.UI.Page
{

delegate int MyCustomHandler(object sender, MathsArgs e);

protected void PageLoad(object sender, EventArgs e)
{
MyCustomHandler = new MyCustomHandler(DoWork);
ExecuteDelegate(handler);
}

protected void ExecuteDelegate(MyCustomHandler handler)
{
MathsArgs args = new MathsArgs(3, 7);
int myInt = handler.Invoke(this, args);
// myInt = 10
}

protected int DoWork(object sender, MathsArgs e)
{
// by allowing the calling object to be
// passed it as a paramater you can easily obtain
// a reference to it, very handy when working
// with asp.net controls
// WebForm1 form = (WebForm1)sender;

return e.A + e.B;
}
}

public class MathsArgs : EventArgs
{
public int A;
public int B;

public MathsArgs(int a, int b)
{
A = a;
B = b;
}
}

Finally a quick look at events, an event basically has the job of containing and calling the invoke method on multiple delegates. Using delegates you subscribe to the event, and when the event is raised (by calling Invoke) the delegates have their Invoke methods called.

It’s important to check that the event actually contains a delegate, else the event will be a null object and attempting to invoke it will throw an error.

namespace DelegatesAndEvents
{
// You would probably store this is in an assembly which could be used by
// other applications
public class UserController
{
// declare a delegate which will define the signature
// of the methods which can subscribe to the event
public delegate void LoginHandler(object sender, EventArgs e);

//declare an event and define the type of delagte it allows
public event LoginHandler LoginEvent;

protected void Login(object sender, EventArgs e)
{
//Log the user into the system

//Then invoke the Login Event
if (LoginEvent != null)
LoginEvent.Invoke(this, new EventArgs());
}
}

public class WebForm1 : Page
{
UserController userController;

public void Page_Load(object sender, EventArgs e)
{
if(!Page.IsPostBack)
{
userController = new UserController();

userController.LoginEvent += new UserController.LoginHandler(SendEmail);
userController.LoginEvent += new UserController.LoginHandler(LogtoDB);
}
}

protected void SendEmail(object sender, EventArgs e)
{
// send an email alert informing people that somebody
// has logged in
}

protected void LogtoDB(object sender, EventArgs e)
{
// write data to the database becuase somebody has logged in
}
}
}

Note: the C# compiler allows you to leave the Invoke method, so you could call the above by calling MyCustomEvent(this, new EventArgs())

That concludes Asynchronous programming Part 1; in Part 2 I will be covering Threading.