RobJDavey

Creating a Side by Side Manifest (sxs) to allow Registration Free Activation of COM in C#

2012-04-26T14:50:00.005+01:00

This is a topic that I found many posts on, but none gave a simple method for generating a side by side manifest and getting it to work. In this example I will use MyCOMLib.dll as an example. So here we go:

In this step we will generate the Type Library for the COM assembly. If you already have the .tlb file go to step 2.
This is a very simple process. First, open Visual Studio and click File -> Open -> File...
In the Open dialog select your COM dll. The assembly will be shown as a tree view. In the tree view you should see a node called "TYPELIB". Expand this and you should see at least one item in this category, usually called 1. Right click on this and select Export....
Save this file as a .tlb (e.g. MyCOMLib.tlb) in the same folder as your .dll is located. You can now close Visual Studio again.
To generate our side by side manifest we will use Mt.exe. This should be available if you open the Visual Studio command prompt. The command to use is as follows:
mt.exe -tlb:"MyCOMLib.tlb" -dll:"MyCOMLib.dll" -identity:"MyCOMLib.sxs, version=1.0.0.0, type=win32" -out:"MyCOMLib.sxs.manifest"
Simply replace the MyCOMLib with the name of your assembly and this command should generate a new manifest file that contains all the information needed for side by side.
To use the newly created side by side manifest, open your visual studio project and then add a reference to the manifest. This will automatically create any necessary Interops (sign them if necessary) and then, provided any dependencies for your library are available in the Debug folder, the local version of the COM assembly will be used rather than the registered version. You should note that if you are using a 64-bit machine, it may be necessary to set the platform target to x86.

That's it! So simple once you know what to do but this took me a long time to figure out. You can now use your side by side COM anywhere you like by simply referencing this manifest file in your project references. Enjoy!

Using Git and Dropbox to keep Minecraft world history

2012-03-05T17:00:00.000+00:00

Introduction
I am a huge fan of Minecraft, although bizarrely although I have a copy of the game, I spend more time watching Lets Play videos from people like Guude and BdoubleO than playing it myself. One thing I do notice however is that these guys (and indeed almost anyone you'll find posting pictures on /r/minecraft) have incredibly detailed worlds that they have spent hundreds, if not thousands of hours playing on.
Recently Jeb has started releasing snapshots on a regular basis but these snapshots always come with a risk of incompatibility if you want to revert back to the current stable release, and the problem for many of the guys making Lets Play videos is their fans want to see them playing these snapshots, but they don't want to risk corrupting their whole world if they either choose to go back to the stable, or another change before the next release makes their now 'beta' world invalid.
In this post I will explain how to use a combination of Git (a tool used for source code versioning) and Dropbox (a cloud based storage provider) to keep full histories of all your past worlds so that in the event something goes wrong you can revert back to any previous point in that worlds history (provided you remembered to save). As it will be passing a copy of this data to Dropbox you can also retrieve it if your PC gets corrupted etc.
Installation
The first step is to get Git and Dropbox installed. You will also need an account on Dropbox if you've not already got one. This is not a guide to installing and these tools are fairly self explanitory so I'll skip over the actual installation, but this guide will be written based on a Windows installation with the following file paths:
Dropbox Folder: C:\Users\username\Dropbox
Minecraft Saves Folder: C:\Users\username\AppData\Roaming\.minecraft\saves
If these are not the same paths that you are using, you will need to adjust any steps in this guide accordingly.
Open up Bash
For all the steps from this point on we will need to use the Git Bash shell. This will have been included with your installation and you should be able to find it at Start -> All Programs -> Git -> Git Bash. It should also be noted that all these commands should be run wile Minecraft is CLOSED! Running it with the program open (especially if you're in your world) will cause you an infinite amount of trouble. Anything you need to type is in bold monospaced font. The text in normal monospaced font is additional output you will see in the bash window. Bash is a Unix environment so the C:\ drive is now /C/ and you should use / instead of the Windows \. Also your home folder (Usually /C/Users/username/ ) has a shortcut symbol of ~ which I will use in this post rather than typing the full path.
Create the Dropbox Repository
The Dropbox Repository will act like a backup location. We will create this as what Git calls a Bare repository. A bare repository does not contain a copy of the files saved in the repository (or at least not in a form visible to the user). The nice feature about having this backup is that we can send the history to it whenever we like and it will still include all the history of our saves, while at the same time not actually including a 'real' copy of the files.
First in our bash window we need to navigate to the dropbox folder. Type the command in Bold to change to the correct folder (replacing username with your actual username). You can also use the tab key for auto-completion on these paths.

user@machine ~
$ cd ~/Dropbox/
user@machine ~/Dropbox
$

Now we want to create our repository folder called minecraft and move inside that folder:

user@machine ~/Dropbox
$ mkdir minecraft
user@machine ~/Dropbox
$ cd minecraft/
user@machine ~/Dropbox/minecraft
$

With that done it's time to initialize this to an new bare repository:

user@machine ~/Dropbox/minecraft
$ git init --bare
Initialized empty Git repository in c:/Users/username/Dropbox/minecraft/
user@machine ~/Dropbox/minecraft (BARE:master)
$

That's it. We've created what will be our backup location. Easy wasn't it? Notice how the command prompt path is now suffixed with (BARE:master). The bare means we are inside a bare repository (it will only contain history and not a visible copy of the files) and the master is the name of our current branch. We won't worry about branch names for the moment but keep that name in mind as we'll use the branch name master a lot.
Create the Minecraft Saves Repository
Next we want to create a normal (not bare) repository in our Minecraft saves folder, and add all our current saves to it. First lets move the bash window to the correct folder and create the repository:

user@machine ~/Dropbox/minecraft (BARE:master)
$ cd ~/AppData/Roaming/.minecraft/saves/
user@machine ~/AppData/Roaming/.minecraft/saves
$ git init
Initialized empty Git repository in c:/Users/username/AppData/Roaming/.minecraft/saves/.git/
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

Just like before we now have our branch name (master) at the end of our command line however this does not include the word BARE because this is not a BARE repository. This will contain real versions of the files so of course now we have created our repository lets add all our existing saves to it! To do this we will tell Git to add all the files to the repository, and then save them (or as Git calls it, commit them) with the message "Adding existing worlds".

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git add .
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git commit -a -m "Adding existing worlds"
[master (root-commit) .......] Adding existing worlds
 ...

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

Now we've added all our current data into the repository. We can check this by running the command

$ git log

which will show us the most recent log items from the repository as well as each entries unique ID.
Linking the repositories together
As we have created our two repositories we need to link them together so that every now and then we can push the history from our save folder repository to our backup repository. To do this we need to set the Dropbox repository as a 'remote'.

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git remote add Dropbox ~/Dropbox/minecraft/
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

This has added the Dropbox folder as a remote repository with the name 'Dropbox'. We can now send our history to that folder. Lets do that now so that we have a backup of our first commit. To do this we use a command called push. We want to tell Git to push our current repository to the Dropbox repository using the branch master (remember I told you we'd use that name later).

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git push Dropbox master
Counting objects: 9, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (7/7), done.
Writing objects: 100% (9/9), 1.59 MiB, done.
Total 9 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (9/9), done.
To c:/Users/username/Dropbox/minecraft/
 * [new branch]      master -> master
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

Done! Now we have successfully backed up our history to our Dropbox backup for the first time. If you were to go back to the Dropbox folder and say 'git log' you'd see the log entry for 'Adding existing worlds' in that repository now.
Saving after we've played
Now that we're all set up we can carry on playing Minecraft as normal. Whenever you decide you want to create a restore point (I call it a restore point but it's basically a point in time that you can get back to in the future if you want to) you will have to run some of the same commands we ran before:

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git add .
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git commit -a -m "<Some Message>"
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

What these commands say are:

Add any new files that have been created to the repository
Save all the new files and any change files with the log message "<Some Message>".

The value of <Some Message> can be anything you like, so it might describe what you did before you saved (e.g. "Added roof to my house and made a pond outside") or just a time and date.
We can repeat this process as often as we like but you should note that this is only adding it to our save repository. After we've saved to our local repository a few times we might want to back up all of these saves to our Dropbox.
Again this is a simple command we used before.

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git push --tags Dropbox master
Counting objects: 17, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (7/7), done.
Writing objects: 100% (9/9), 2.37 MiB, done.
Total 9 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (9/9), done.
To c:/Users/username/Dropbox/minecraft/
   4a82680..01db97f  master -> master
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

And this will push our save repository to the Dropbox. Simple! Although not strictly necessary, the --tags flag in the command ensures that if we ever create some tags (see next section) these will be pushed to the Dropbox backup too.
Tagging a save
Using this method there is a chance you will save after each time you play, and that's good it means you will always have a regular history of your minecraft save files. Each of these saves has a unique name (a long combination of letters and numbers it creates automatically) but there may be times that you want to create a Tag for a particular save (basically give that save a name). An example of this might be when you finally finished creating your house. You may want to name that particular save "FinishedHouse" that way you can easily identify it. Tagging is very easy, first we need to use the log command to identify the unique ID of the save we want to tag, then we use the tag command to create the tag.

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git log
commit e02727c676936ee9f8914191c3f5bb4a031af87c
Author: Robert Davey <email@address.com>
Date:   Tue Mar 6 12:37:49 2012 +0000

    Finished building my house

commit 01db97f91baf8300d246fc57eb9ca5c37c172e71
Author: Robert Davey <email@address.com>
Date:   Tue Mar 6 12:28:23 2012 +0000

    Knocked down a tree

commit 4a826804414420cf43b07c4e970811a9d6c805b8
Author: Robert Davey <email@address.com>
Date:   Tue Mar 6 11:44:43 2012 +0000

    Adding existing worlds

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git tag FinishedHouse e027
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

Above you can see that I got my log for my saves. I identified the save I wanted to tag based on its log message ("Finished building my house") and so I can see that the save I want has ID e02727c676936ee9f8914191c3f5bb4a031af87c. I can then tag it by using the git tag command followed by the name we want to tag it with (keep the name small with no punctuation and not spaces) and then the ID of the commit. You may note however that I only used the first 4 letters of the ID in my command. Git is very clever and so you only need to give it a small part of the ID (as long as it can uniquely identify the ID from those letters, if there were two IDs that have an identical first 4 letters I may have to provide 5 letters etc...) then the rest of the ID is not necessary.

Getting back to an older version
Eventually the time may come when you want to go back to an older version of your saved worlds. This is where things can get a little more complicated (but not too much). First you need to work out what version you want to get back to. If the save is one that you tagged (see above) then this is easy to identify because we have a tag name, otherwise we will need to find the ID using the log command (also see above). Once we have our ID (either a tag name or a commit ID) then we can run the following command (replacing the 4a82 with your ID):

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git reset --hard 4a82
HEAD is now at 4a82680 Adding existing worlds
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

This command resets our repository to the state it was in at that particular commit. If you had a tag name then in the above example you would replace the 4a82 with the tag name. It should be noted that running this command will lose any information you've not saved, so you may want to create a save point before doing this or you'll never be able to change your mind! Now if you load up Minecraft you'll find that your world is back how it was when you saved at that commit. Magic! :D
But what if we change our mind and we want to go forward again to the point at which we were before we saved. It's the same command, but there's a problem: The log command will only show us the log for things that happened before our current save and so we can't get the ID of the 'future' save we want to go back to. Don't worry though we can get the full log using this command:

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git log --all

This will include the log entries that come after our current save so we're ok, we can run the reset command again to change our save point back.
After this we can continue saving like we did before. If you do this you may find that encounter the following error when trying to push the new saves to your Dropbox backup.

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git push --tags Dropbox master
To c:/Users/username/Dropbox/minecraft/
 ! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to 'c:/Users/username/Dropbox/minecraft/'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes (e.g. 'git pull') before pushing again.  See the
'Note about fast-forwards' section of 'git push --help' for details.

If this does happen then you can get around it by running the following set of commands instead:

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git merge Dropbox/master -s ours
Merge made by the 'ours' strategy.

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$ git push --tags Dropbox master
Counting objects: 5, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 424 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
To c:/Users/username/Dropbox/minecraft/
   a824abd..b023ad0  master -> master

user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

And this should successfully push your files to the Dropbox backup. You can then go back to the normal push method afterwards.
Getting your saves from your backup
If you've ended up on a fresh copy of minecraft without your saves and you want to get them back out of your Dropbox backup it's simple. Navigate the bash window to your empty saves folder and run the following command:

user@machine ~/AppData/Roaming/.minecraft/saves
$ git clone -o Dropbox ~/Dropbox/minecraft .
Cloning into '.'...
done.
user@machine ~/AppData/Roaming/.minecraft/saves (master)
$

You should now be back in a state where you can save and push just like before.
Summary
Using this technique you can ensure that your Minecraft worlds are always saved and backed up in a safe manner that allows you to always get back to a previous point in time if things go wrong or you just fancy doing something a little different. If you have any questions about ways to use this then please post in the comments. Enjoy :)

Raising Events in C#

2012-02-27T17:00:00.000+00:00

The chances are that you've seen a lot of different posts about how events should be raised in C#. The general rules to follow are this:

Always create an invocator for raising events
This method should create a copy of the event handler
The handler should be checked for null.
Then call the handler with the required arguments.

So lets have a look at what a basic event invocator should look like:

public event EventHandler Started;

/// <summary>
/// Our basic event that we want to invoke.
/// </summary>
public event EventHandler Connected;

/// <summary>
/// Our event invocator.
/// </summary>
private void OnConnected(object sender, EventArgs e)
{
    //Create a copy
    EventHandler handler = Connected;
    //Check for null
    if(handler != null)
    {
        //Call the handler
        handler(sender, e);
    }
}

That's all very well and good but we are likely to want to do this for every event we have. So lets make this a bit more generic and pass in the event handler we want to raise. We may also want to create a version for the EventHandler<T> delegate for when we have specialised event arguments.

private void RaiseEvent(EventHandler handler, object sender, EventArgs e)
{
    EventHandler temp = handler;
    if(temp != null)
    {
        temp(sender, e);
    }
}

private void RaiseEvent<T>(EventHandler<T> handler, object sender, T e)
    where T : EventArgs
{
    EventHandler<T> temp = handler;
    if(temp != null)
    {
        temp(sender, e);
    }
}

So now we have some basic event invocators that can invoke any (standard) event. We can even take this a step further and make this an extension method:

public static class EventHandlerExtensions
{
    public static void RaiseEvent(this EventHandler handler, object sender, EventArgs e)
        { /* ... */ }

    public static void RaiseEvent<T>(this EventHandler<T> handler, object sender, T e)
        where T : EventArgs { /* ... */ }
}

As you may have seen from my posts in the past however, I am a huge fan of Asynchronous programming, and the functionality provided. So what if we could make these event invocators async. It's not as simple as my earlier post on Making Methods Async. In that post we were creating a delegate to a single method and invoking it asynchronously. The problem with event delegates is that they are likely to have multiple methods registered in their invocation list, and BeginInvoke will fail if the delegate contains more than one method in the invocation list. To get around this we must call each method individually using BeginInvoke. Here's the code for both asynchronous event invocators and their corresponding callback methods:

public static void BeginRaiseEvent(this EventHandler handler, object sender, EventArgs e)
{
    EventHandler temp = handler;
    if(temp != null)
    {
        foreach(EventHandler eventHandler in temp.GetInvocationList())
        {
            eventHandler.BeginInvoke(sender, e, EndRaiseEvent, eventHandler);
        }
    }
}

private static void EndRaiseEvent(IAsyncResult result)
{
    var handler = ((AsyncResult)result).AsyncDelegate as EventHandler;
    if(handler != null)
    {
        try
        {
            handler.EndInvoke(result);
        }
        catch(Exception ex)
        {
            Debug.WriteLine(ex.ToString());
        }
    }
}

public static void BeginRaiseEvent<T>(this EventHandler<T> handler, object sender, T e)
    where T : EventArgs
{
    EventHandler<T> temp = handler;
    if(temp != null)
    {
        foreach(EventHandler<T> eventHandler in temp.GetInvocationList())
        {
            eventHandler.BeginInvoke(sender, e, EndRaiseEvent<T>, eventHandler);
        }
    }
}

private static void EndRaiseEvent<T>(IAsyncResult result)
    where T : EventArgs
{
    var handler = ((AsyncResult)result).AsyncDelegate as EventHandler<T>;
    if(handler != null)
    {
        try
        {
            handler.EndInvoke(result);
        }
        catch(Exception ex)
        {
            Debug.WriteLine(ex.ToString());
        }
    }
}

Now we can invoke any event we like asynchronously by simply calling the BeginRaiseEvent method like this:

MyEvent.BeginRaiseEvent(this, EventArgs.Empty);

Enjoy :)

Creating an asynchronous TCP Server

2012-02-20T17:00:00.000+00:00

Creating an asynchronous TCP Server
How do I make an asynchronous TCP server? This is a question that gets asked regularly by C# developers but isn't documented well in many places. When I was doing my degree I studied this subject in some detail as I was creating my own TCP based Client/Server application. There are a lot of examples on the net that I've seen in the past, some good, some bad, but none that I feel are as effective as the method I used to create my server. First off here's a few ways that you shouldn't do it...
Polling
This isn't asynchronous, it just spins around in a loop using unnecessary processor cycles checking to see if clients have anything new to tell it, and if they do the other clients will have to wait until it's finished dealing with the current request. This method is simple (because it's single threaded) but definitely the worst way to implement something that definitely needs to be asynchronous.
Creating threads
Of course you can create a thread for each client that connects to your listener and let it poll itself, or block that thread until the user sends some information. The problem with this I find is that now you're in charge of that thread. It's your responsibility to ensure that thread is managed correctly. If the user goes to close the app and you have a blocking call on that thread, you could end up with the application hanging in the background. This can make debugging a huge pain.
So what's the best way
In my opinion the best way to create an asynchronous server in C# is using callbacks. A callback allows a method to go away and execute in a system managed thread and once it's finished executing, it will call one of our methods and give us the result of the operation. This is good because it means:
a) if the system managed thread needs to block and the application closes, the system will ensure that thread is joined so the application can close successfully
b) we don't have to keep track of the threads ourself, the system does all that for us and passes control back to us at the relevant times
c) we can't overload the server, as these threads are borrowed from the systems thread pool it means that if we are currently using all the available threads in the pool, the actions will get queued up until a thread becomes available
Creating the server
For this example I will use the TcpListener and TcpClient. These are wrappers around the Socket class so they have slightly lower performance but they make what I am trying to do more obvious in this example. Changing this code to use the Socket class should not take too much work as it supports a similar set of methods.
The first thing we need to do is the standard creation of a listener and hooking it up to the correct port. There's no point in us doing this asynchronously as we have to wait for this to be complete before we can start accepting incoming clients so we'll just do this in the standard synchronous way.

listener = new TcpListener(IPAddress.Any, port);
listener.Start();

Now that we have an active listener we will start an asynchronous accept of a tcp client. Normally the AcceptTcpClient method will block until a client connects. By using callbacks we can tell the system to go away and block in a different thread, then when a client connects, call our designated callback method. The callback methods must always match the signature of an AsyncCallback which means it must have a return type of void and a single parameter that is an IAsyncResult. I tend to name all my callbacks as the synchronous method name followed by Callback. We don't need to use the return value of the call as we will be given the same object in the callback, which is where we will use it. We also don't need to pass anything in the state parameter as we don't need any additional information in the callback that isn't available as an instance member.

listener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);

In our callback method we need to end the asynchronous method call which will give us back our new TcpClient that just connected. We will then tell the server to begin accepting the next client.

private void AcceptTcpClientCallback(IAsyncResult asyncResult)
{
    TcpClient client = listener.EndAcceptTcpClient(asyncResult);
    listener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
}

This method is not yet complete. There are a few issues we need to solve. Firstly, if an exception is thrown in the AcceptTcpClient method then we need to handle this in some way. Normally a user of a synchronous server would wrap the call in a try catch block themselves, however currently we are not on the users thread so they have no way to enclose our method like that. Instead I favour adding an event onto our class of type EventHandler<ErrorEventArgs>. The ErrorEventArgs class can wrap up an exception which we can then pass back to the user (assuming they are listening to the event) to deal with.

public event EventHandler Error;

public void OnError(object sender, Exception ex)
{
    EventHandler handler = Error;
    if(handler != null)
    {
        ErrorEventArgs e = new ErrorEventArgs(ex);
        handler(sender, e);
    }
}

private void AcceptTcpClientCallback(IAsyncResult asyncResult)
{
    TcpClient client;
    try
    {
        client = listener.EndAcceptTcpClient(asyncResult);
    }
    catch (Exception ex)
    {
        OnError(listener, ex);
        Stop();
        return;
    }
    listener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
}

For ease we could do to wrap the client up in a simple object that will allow us to keep it with its buffer. We can expand this at a later date so lets make the wrapper now.

public class Client
{
    private readonly TcpClient tcpClient;
    private readonly byte[] buffer;

    public Client(TcpClient tcpClient)
    {
        this.tcpClient = tcpClient;
        int bufferSize = tcpClient.ReceiveBufferSize;
        buffer = new byte[bufferSize];
    }

    public TcpClient TcpClient
    {
        get { return tcpClient; }
    }

    public byte[] Buffer
    {
        get { return buffer; }
    }

    public NetworkStream NetworkStream
    {
        get { return tcpClient.GetStream(); }
    }
}

Now we have this wrapper we can create a list to store the connected clients and tell the client to start reading into our buffer.

private void AcceptTcpClientCallback(IAsyncResult asyncResult)
{
    // ...
    listener.BeginAcceptTcpClient(AcceptTcpClientCallback, null);
    Client client = new Client(tcpClient);
    connectedClients.Add(client);
    NetworkStream networkStream = client.NetworkStream;
    networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
}

So now our client has been accepted asynchronously, our listener is now trying to accept the next client asynchronously, and our new client is asynchronously listening for new data. Of course now we need to implement the read callback we've used above. As before this needs to match the AsyncCallback delegate, which takes an IAsyncResult and returns void. The first thing we need to do is get hold of the client this callback belongs to. This is why we passed the client object as the state parameter. Once we have the client we can get the correct network stream object that will allow us to end the asynchronous call. When we end the read it will tell us how many bytes have been read from the client. It should be noted that if you read from the client, and the number of bytes read is 0 (zero) this means that the client has disconnected from us. We can then copy the data that has been read to a new buffer, raise the data read event, and send the client back off to do another asynchronous read.

private void ReadCallback(IAsyncResult asyncResult)
{
    Client client = asyncResult.AsyncState as Client;
    if (client != null)
    {
        NetworkStream networkStream = client.NetworkStream;
        int read;
        try
        {
            read = networkStream.EndRead(asyncResult);
        }
        catch (Exception ex)
        {
            OnError(client, ex);
            return;
        }

        if (read == 0)
        {
            OnClientDisconnected(client.TcpClient);
            connectedClients.Remove(client);
            return;
        }

        byte[] data = new byte[read];
        Buffer.BlockCopy(client.Buffer, 0, data, 0, read);
        OnDataRead(client.TcpClient, data);
        networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);
    }
}

Summary
This is the basics of an asynchronous server using callbacks. The listener will just keep accepting clients in the background, the clients will keep reading in the background, and your main thread isn't blocked ever. You can even add the write methods to be asynchronous so that even when you write to the clients you aren't blocked. If you want to know when data has been sent successfully you could always assign each write operation a Guid and then event the Guid when the write ends successfully. If I get chance I'll post a full example at a later date. Enjoy.

String validation in C#

2012-02-16T17:00:00.000+00:00

There are times when we need to check that all the characters in a string are within our acceptable range. In this post I will demonstrate how to create various useful methods for validating the characters in strings. The information in this post will use LINQ and Lambda Expressions, so it's necessary to be using C# 3.5+.
First lets look at what we might want to check. Lets say we want to ensure that a string does not contain any control characters. We can check for these with Char.IsControl method. This method is what we would call a Char predicate, in other words, it takes a Char as an input, and returns true or false depending on whether the char meets the criteria.
So here's a simple method that would check a string for containing control characters:

public static bool ContainsControlCharacters(string str)
{
    foreach(char c in str)
    {
        if (char.IsControl(c))
        {
            return true;
        }
    }
    return false;
}

This is all very good, but because IsControl is a char predicate, we can use it as a parameter for some of the LINQ extension methods. As we're checking to see if there are any control characters we want to use the extension method 'Any'. So lets try that again:

public static bool ContainsControlCharacters(string str)
{
    return str.Any(char.IsControl);
}

It's very neat and simple. It almost reads like English... "return whether string has any char that is control". However the Char class actually has a lot of these char predicates, so lets make this a bit more generic, lets allow the user to pass any predicate they like (as long as it takes a char, and returns a bool).

public static bool Contains(string str, Func<char, bool> predicate)
{
    return str.Any(predicate);
}

So now the user can call our method with whatever they like, so they may say:

bool result = Contains("Hello World!", char.IsControl);

or they could pass a lambda expression:

bool result = Contains("Hello World!", c => c > 'D' && c < 'I');

For anyone that doesn't understand lambda the expression above matches the signature bool Method(char). The c => means we have an input we called c, which we know must be a char based on the method signature. Then we return from the method the result of (c > 'D' && c < 'I'). So basically this is a predicate that matches the characters 'E', 'F', 'G', and 'H'. Not very useful I know but an example all the same!
So now we can check a string for multiple conditions, but what if we want to know things like "Is this string only made up of this type of character?", or "Does this string not contain any of these characters?". We could call this method in various ways, but wouldn't it be much easier to create some methods we can use for this type of question.

public static bool OnlyContains(string str, Func<char,bool> predicate)

{
    return str.All(predicate);
}

public static bool DoesNotContain(string str, Func<char,bool> predicate)
{
    return !str.Any(predicate);
}

These methods can tell us if a string is only made up of, or does not contain any of, a particular type of character. Of course sometimes we may want to say "Only made up of letters, numbers, whitespace and puctuation". Well of course this would fail in the above code because we'd have to check these individually, or write a new complex predicate to test all these. So why not make it so the code can take multiple predicates?


public static bool OnlyContains(string str, params Func<char, bool>[] predicates)
{
    return str.All(c => predicates.Any(p => p(c)));
}

public static bool DoesNotContain(string str, params Func<char, bool>[] predicates)
{
    return !str.Any(c => predicates.Any(p => p(c)));
}

Now these methods can take a variety of predicates into each one so we can perform complex statements such as:

string str = "Hello World!";
bool result = OnlyContains(str, char.IsLetter, char.IsPunctuation, char.IsWhiteSpace) &&
              DoesNotContain(str, char.IsControl, c => (c == '@'));

The above statement says "Ensure that str only contains letters, punctuation and whitespace but does not contain control characters or the letter @". Very useful. The only thing I'd use to top this off, it to make the methods an extension, by changing the method signature to

public static bool OnlyContains(this string str, params Func<char, bool>[] predicates)

which then allows us to simply say

str.DoesNotContain(char.IsControl);

Simple! :D

Async in C# - Part 2: Making methods async

2012-02-14T17:00:00.000+00:00

Contents
Async in C#

Introduction
In Part 1 I talked about what asynchronous programming is and how it is implemented within the .NET framework (or more specifically C#) currently. In this part I'll look at how we can take any method we like and make it asynchronous. So lets pick a random synchronous method in the .NET framework and create our own asynchronous implementation. For this I'm going to use the Console.ReadKey. It's not a method that you're often going to use as an asynchronous method, however it has an input parameter, a return type, and it blocks the program while you're waiting for the user to press a key, which makes it perfect for us to use as an example.
Breaking down the signature
The signature for the Console.ReadKey overload that we're going to use is:

public static ConsoleKeyInfo ReadKey(bool intercept)

So the first thing we will need to do is create a delegate that matches this signature. We'll call this delegate ReadKeyDelegate.

public delegate ConsoleKeyInfo ReadKeyDelegate(bool intercept);

Please note that although I have created this delegate explicitly this is not necessary. Instead you can use the

Func<bool, consolekeyinfo>

delegate when required and get the same effect.
As we saw before, to make a method asynchronous we need to create two methods, a Begin and an End. The Begin method will take the parameters from our synchronous method, and the End method will return the result. As we also discussed before, a Begin method should always have a return type of IAsyncResult, and always have the parameters from the synchronous method, followed by an AsyncCallback delegate and an object. Lets create the signature for our begin method now:

public static IAsyncResult BeginReadKey(bool intercept,
    AsyncCallback callback, object state)

So there we have it, a method that is called Begin[methodname] with a return type of IAsyncResult and the parameters are the same as the synchronous method followed by an AsyncCallback and an object. It should also be noted that as the synchronous method was static, I've made this method static too. We don't want to make our users have to create an instance of a class just to use a static method asynchronously. So now lets look at the End method, this needs to have a return type that matches the synchronous methods return type, so ConsoleKetInfo in this case, and also take a single parameter of an IAsyncResult. Lets create this now:

public static ConsoleKeyInfo EndReadKey(IAsyncResult asyncResult)

Again I have made this static, your Begin and End methods should always be either both static or both instance members, and best practice would be to make them always match their synchronous counterpart.
Implementing the methods
Now that we have our method signatures and our delegate, the actual implementation of the methods is extremely easy. Lets start with the begin method. First we need to create an instance of our delegate and connect it to the synchronous method:

ReadKeyDelegate readKey = Console.ReadKey;

As I mentioned before, if you do not want to create an explicit delegate you can of course use the built in Func delegate like this:

Func<bool, consolekeyinfo> readKey = Console.ReadKey;

For the moment however we'll stick to our explicit delegate. So now we have a delegate created we want to asynchronously invoke this method using the parameters the user has passed in. To do this we will use the BeginInvoke method from our delegate. This method will match our Begin signature exactly, and so we can just return its result to the user:

return readKey.BeginInvoke(intercept, callback, state);

That's it, the begin method is now complete. I told you it was easy. Now lets look at the End method. The first thing we need to do is get the delegate that matches the call. An End call must always be performed on the same delegate that the Begin was called on, so if we were to create a new ReadKeyDelegate and assign it to ReadKey again, the End call would fail because this is a different instance of the delegate. Luckily for us, the IAsyncResult we are passed actually knows what the delegate it was called on was! This is because internally it is actually an AsyncResult object. So lets get hold of our delegate:

ReadKeyDelegate readKey =
    (ReadKeyDelegate)((AsyncResult)asyncResult).AsyncDelegate;

Now that we've got our original delegate it's simply a case of calling EndInvoke on the delegate and passing the result back to the user (when I said this was easy, I meant it):

return readKey.EndInvoke(asyncResult);

So just to recap, here's all our code so far in full:

public delegate ConsoleKeyInfo ReadKeyDelegate(bool intercept);

public static IAsyncResult BeginReadKey(bool intercept,
    AsyncCallback callback, object state)
{
    ReadKeyDelegate readKey = Console.ReadKey;
    return readKey.BeginInvoke(intercept, callback, state);
}

public static ConsoleKeyInfo EndReadKey(IAsyncResult asyncResult)
{
    ReadKeyDelegate readKey = 
        (ReadKeyDelegate)((AsyncResult)asyncResult).AsyncDelegate;
    return readKey.EndInvoke(asyncResult);
}

Summary
So effectively that's it. That is everything that is required to make any method in C# asynchronous.

Create a delegate that matches the methods signature
Create a Begin method that creates an instance of the delegate and calls BeginInvoke.
Create an End method that retrieves the instance of our delegate and calls EndInvoke.

Now you or your user can use these methods in the same way I described in Part 1. Enjoy

Async in C# - Part 1: What is async?

2012-02-14T01:00:00.177+00:00

Contents
Async in C#

Introduction
First lets start with a quick explanation of what asynchronous is. In a normal computer program operations are synchronous. It does one thing, when it's done it moves onto the next. This is synchronous behaviour. It only focuses on one task at once. When something happens asynchronously it means the computer can start one task, and while that task is running it can be doing something else. At a later point in time it can catch up with the previous task to get the result of it when it's needed. This can be extremely useful if you have a task that will take a long time to run, but you do not need the result of it immediately. You can start the task as soon as possible and then later on when you need to use the result of the task you can either get it immediately (if the task has now finished) or you can wait at that point for it to finish (but this wait will be shorter than if you only just started the task of course).
Async in C#
When we perform tasks asynchronously in C# they occur on a different thread. Of course it is possible to manually create the thread yourself and tell it what method to execute and so on, but then you have to keep track of the thread yourself and it's all your responsibility. Why go to all that effort when C# already has the technology built in to do it for you.
A C# example
To begin lets look at an example method in C# that already has an asynchronous implementation. The synchronous method is Dns.GetHostAddresses. This method looks up the IPAddresses for a particular host name (e.g. www.google.co.uk). Of course if the addresses aren't already in your ARP table your machine will need to talk to your DNS server, and any communication over a network can take time. If we don't want out program to stop while it's looking these values up then we can use the Asynchronous version of it. This comes in the form of two different methods, Dns.BeginGetHostAddresses and Dns.EndGetHostAddresses, and we need to use both to complete an asynchronous operation.
The Begin... method
The "Begin" method starts the asynchronous operation on a different thread. In addition to whatever parameters were required for the synchronous method, it will also take an AsyncCallback delegate and an object. The method signature for an AsyncCallback is:

public delegate void AsyncCallback(IAsyncResult ar);

This delegate is the method that will get called when our asynchronous operation is completed. The object, usually known as state, can be any object which you would like to be available to you from within the callback method.
The End... method
The "End" method is used to complete the asynchronous operation. When this is called it will return the value that was returned from the method called asynchronously, so in our example above EndGetHostAddresses will return an IPAddress[]. It always takes a single parameter which is an IAsyncResult interface. The object passed in here must be the same one that was generated by the Begin method otherwise it will throw an exception. If you are using the callback mechanism this will be sorted for you so you don't need to worry but I'll explain more on that in a minute.
Signatures
So now lets see how the method signature of our synchronous method breaks down into our two asynchronous methods. Our original method signature was:

public static IPAddress[] GetHostAddresses(string hostNameOrAddress)

The begin method signature is:

public static IAsyncResult BeginGetHostAddresses(string hostNameOrAddress,
    AsyncCallback requestCallback, Object state)

and the end method signaure is:

public static IPAddress[] EndGetHostAddresses(IAsyncResult asyncResult)

As you can see from the colour coding the whole signature is there, it's just spread over the two methods. We can also see from the purple text the additional parts of a signature that should always be present in the begin and end methods for asynchronous calls.
Usage
There are two different ways in which the asynchronous methods can be used to retrieve a value asynchronously. These are by using callbacks (we'll call this the "Callback" method for now) or by keeping track of the IAsyncResult that is generated (we'll call this the "Variable" method).
Callback Method
To use the callback method we must declare a method that will be called when the method completes. This method must match the signature of an AsyncCallback. Within this method is where we will call our End method. Here's some example code of this in use.

namespace RDavey
{
    public class AsyncTest
    {
        public void Foo()
        {
            Dns.BeginGetHostAddresses(
                // The usual host name parameter
                "www.google.com",
                // The AsyncCallback delegate to call when we're done
                GetHostAddressesCallback,
                // Our state is null, we don't need to send any additional info
                null);
        }

        public void GetHostAddressesCallback(IAsyncResult ar)
        {
            // We pass the IAsyncResult into the End method.
            IPAddress[] addresses = Dns.EndGetHostAddresses(ar);
            // We can now do what we want with 'addresses'.
            // We may just wish to store it as a member variable.
            // If we had set the 'state' object we could retrieve it like this:
            object state = ar.AsyncState;
            // Of course in this example it is null because we passed null!
        }
    }
}

Variable Method
The variable method is best suited to asynchronous operations where we will need the result of the operation later in the same method. When we call begin it will give us back the IAsyncResult that corresponds to our asynchronous operation. We can then use this at a later date to call the End method. If the End method has not yet finished, it will then block (effectively becoming synchronous) until it is done. Here's some code to demonstrate this method.

namespace RDavey
{
    public class AsyncTest
    {
        public void Foo()
        {
            IAsyncResult ar = Dns.BeginGetHostAddresses(
                // The usual host name parameter
                "www.google.com",
                // We're not using the callback method so this can be null
                null,
                // Our state is null, we don't need to send any additional info
                null);
            // Now we can do other stuff here
            // ...
            // While the GetHostAddresses occurs in the background
            // ...
            // And once we're ready to use the IP Addresses we call
            IPAddress[] addresses = Dns.EndGetHostAddresses(ar);
        }
    }
}

Next...
In Part 2 I'll discuss how to make our own asynchronous version of methods.

Casting bytes to structures in C#

2012-02-13T17:00:00.001+00:00

Sometimes you'll end up in a situation where you've read some data in it's binary form and you want to get this data formatted as a structure. In C++ you could just cast the memory location to the type of structure you want and away you go, but as C# is managed it's not that easy.
Here's a fast and easy set of extension methods that can do this for you. For this to work the structure used must be set to either LayoutKind.Sequential or LayoutKind.Explicit. Although structures are generally sequential automatically this shouldn't be relied on and should be set explicitly. This can be done using a StructLayoutAttribute.
The ByteCaster class can be used in one of two ways, as a static call

MyStruct myStruct = ByteCaster.GetStructure<MyStruct>(bytes);

or as an extension method

MyStruct myStruct = bytes.GetStructure<MyStruct>();

There is also a "try" version of the method which will not throw but will return a boolean to inform the caller if the operation succeeded. If this boolean is false, the structure will be a valid struct, but the data within it will not be representative of the data so this value should always be checked.

namespace RDavey
{
    /// <summary>
    /// Allows the manipulation of bytes into structures.
    /// </summary>
    public static class ByteCaster
    {
        /// <summary>
        /// Attempts to get a byte array as a structure.
        /// </summary>
        /// <typeparam name="T">The type of structure we wish to represent the bytes as.</typeparam>
        /// <param name="bytes">The bytes to convert to a structure.</param>
        /// <param name="structure">The structure we wish to populate.</param>
        /// <returns>True if the operation succeeded, false if there was an error.</returns>
        public static bool TryGetStructure<T>(this byte[] bytes, out T structure) where T : struct
        {
            try
            {
                structure = GetStructure<T>(bytes);
                return true;
            }
            catch
            {
                structure = default(T);
                return false;
            }
        }

        /// <summary>
        /// Gets a strucure representation of a byte array.
        /// </summary>
        /// <typeparam name="T">The type of structure we wish to represent the bytes as.</typeparam>
        /// <param name="bytes">The bytes to convert to a structure.</param>
        /// <exception cref="ArgumentException">The structureType parameter layout is not sequential or explicit.
        /// -or-
        /// The structureType parameter is a generic type.</exception>
        /// <returns>The structure populated with the data from the byte array.</returns>
        public static T GetStructure<T>(this byte[] bytes) where T : struct
        {
            GCHandle gch = GCHandle.Alloc(bytes, GCHandleType.Pinned);
            IntPtr ptr = gch.AddrOfPinnedObject();
            T result;
            try
            {
                result = (T)Marshal.PtrToStructure(ptr, typeof(T));
            }
            finally
            {
                gch.Free();
            }
            return result;
        }
    }
}

New Blog

2012-02-11T17:00:00.002+00:00

I've decided to move over to Blogger (as every other service I use comes from Google and I'm a huge fan of their new dynamic templates).
I'll start to migrate my old data over to this website over the coming weeks (although I want to re-write many of the examples to be more user friendly so it may take a short while).