Development

Initialising Castle ActiveRecord in a WAS-hosted WCF service

Ryan Schreiber — Fri, 16 Jul 2010 09:25:53 GMT

I stumbled upon an interesting problem this morning where Castle ActiveRecord was being initialised correctly in the development environment, but as soon as everything was rolled out to the lab environment, the application would throw errors about AR not being initialised. The error message was along the lines of:

An ActiveRecord class (Darkside.Domain.Person) was used but the framework seems not properly initialized. Did you forget about ActiveRecordStarter.Initialize() ?

A bit of background info: As is custom in our web projects, we use an HttpModule to do the AR initialisation. In this case, the web project is actually a WAS host for our WCF services. After doing a bit of research, I found out that HttpModules are not executed when running WCF services. The reason we had the illusion it was working in dev is because of a default page that was started when the project was run. This caused the HttpModule to run, which in turn initialised AR for that session.

Our solution to this problem was to make use of a custom service host factory. I’ve touched on the custom service host factory subject here before, and this solution is just another use of it.

public class CustomServiceHostFactory : ServiceHostFactory

    private static readonly object m_InitActiveRecordLock = new object();

    public override System.ServiceModel.ServiceHostBase CreateServiceHost(string constructorString, Uri[] baseAddresses)

        //Initialise ActiveRecord...

        if (!ActiveRecordStarter.IsInitialized)

            lock (m_InitActiveRecordLock)

                if (!ActiveRecordStarter.IsInitialized)

                    ActiveRecordStarter.Initialize(Assembly.Load("Darkside.Domain"), ActiveRecordSectionHandler.Instance);

        //Hand off the real host creation to the base class..

        return (base.CreateServiceHost(constructorString, baseAddresses));

You then need to add the Factory attribute into your .SVC file

<%@ ServiceHost Language="C#" Debug="false" Service="Darkside.Services.CRUDService, Darkside.Services" Factory="Darkside.WAS.CustomServiceHostFactory" %>

Now, if a new service host is created in your app, AR will be initialised first, if needed.

Configuring and using the SQLite database in Castle ActiveRecord

Ryan Schreiber — Wed, 07 Jul 2010 17:36:16 GMT

There are a few solutions out on the web for this – here’s my implementation for you to use (and for me to safe-keep). I use this primarily for testing my ActiveRecord objects, as I haven’t really found any use for this mechanism in any production environment

Firstly, the configuration. Notice that I specify my own connection provider (make sure you correctly swap out the relevant portions with your own namespaces). Also, there’s a slight twist in the connection string that you may want to take note of. The rest is straight forward.

  <activerecord isDebug="true" isWeb="false">

    <config>

      <add key="connection.provider"

           value="Darkside.ARLibrary.SqLiteConnectionProvider, Darkside.ARLibrary"/>

      <add key="dialect" value="NHibernate.Dialect.SQLiteDialect"/>

      <add key="connection.driver_class" value="NHibernate.Driver.SQLite20Driver"/>

      <add key="connection.connection_string" value="Data Source=:memory:;Version=3;New=True;"/>

      <add key="proxyfactory.factory_class"

           value="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle" />

      <add key="show_sql" value="true"/>

    </config>

  </activerecord>

Next, you’ll need to implement your own connection provider. The reason this needs to be done is because when you close a connection on a SQLite database which you’ve configured to be in-memory, the entire contents (tables and data) is lost.

You simply inherit from NHibernate.Connection.DriverConnectionProvider and override the GetConnection() and CloseConnection() methods. In your implementation of GetConnection(), you cache an instance of the connection and always return the same one. In CloseConnection(), you do nothing – you don’t need or want to close the connection.

    public class SqLiteConnectionProvider : NHibernate.Connection.DriverConnectionProvider

        private static System.Data.IDbConnection m_Connection;

        public override System.Data.IDbConnection GetConnection()

            if (m_Connection == null)

                m_Connection = base.GetConnection();

            return m_Connection;

        public override void CloseConnection(System.Data.IDbConnection conn)

            //Do nothing

Compress and decompress a byte array

Ryan Schreiber — Tue, 11 May 2010 18:23:43 GMT

A colleague asked me this morning if I already had a code snippet that compressed and decompressed byte arrays that he could make use of. He needed it to compress a variable before passing it as an argument to a WCF call, and decompress in the service itself. I’ve never made use of the System.IO.Compression namespace (I’d always used SharpZipLib), so I thought this would be a quick and useful experiment.

After referencing the local MSDN and then the customary 30 second google, I decided I’d make my own, better, wheel :) I’m still convinced it’s less verbose than the first ten results I looked at, by the way.

The compress part was easy enough (and follows the same logic as just about every example I found). What I couldn’t understand was why everyone implemented long-winded decompress routines. The answer to that question (found in MSDN) is that the Length property of the DeflateStream is not implemented and always throws an exception, meaning that you can’t determine the length of the byte array you’ll need.

Here’s my quick-and-easy solution to the problem:

    public static class CompressionUtils

        const int BUFFERSIZE = 1024;

        public static byte[] Compress(byte[] data)

            var memoryStream = new MemoryStream();

            var deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress);

            deflateStream.Write(data, 0, data.Length);

            deflateStream.Flush();

            deflateStream.Close();

            return memoryStream.ToArray();

        public static byte[] Decompress(byte[] data)

            var buffer = new byte[BUFFERSIZE];

            var returnVal = new List<byte>();

            var deflateStream = new DeflateStream(new MemoryStream(data), CompressionMode.Decompress);

            int count;

            while ((count = deflateStream.Read(buffer, 0, BUFFERSIZE)) > 0)

                if (count != BUFFERSIZE)

                    var tmpBuffer = new byte[count];

                    Array.Copy(buffer, tmpBuffer, count);

                    returnVal.AddRange(tmpBuffer);

                else

                    returnVal.AddRange(buffer);

            return returnVal.ToArray();

An example of speculative execution

Ryan Schreiber — Thu, 19 Nov 2009 17:53:39 GMT

Speculative execution is a term applied to the execution of code that you may not need the results of. With the abundance of spare processing power on servers these days (and workstations for that matter), you can easily make an application be far more responsive to the user or make processing tasks on a server application quicker.

A contrived example that I've come up: Consider a process that runs periodically on a server that:

Finds a list of all your customers from the SQL Server-based accounting system that have purchased an item from your online store in the past 24 hours (quick DB call) (1 sec in total)
For each customer, sum up the values of all their transactions for the past 6 months - it's a longer process because you have to fetch the data from data warehouse tables on a different SQL Server (2 sec per call)
For customers who have purchased more than ZAR100*, check if they have received a cheesy gift from the online loyalty app that you outsource to. (2 sec per call).
If they haven't received the gift yet, make another call to the online loyalty app to request that a gift be delivered (2 sec)

Most likely you have these running sequentially; looking at the tasks that need to be performed, they all seem to be dependant on the previous step. A quick tally based on a made of set of results returned in each step:

5 customers are returned. Total running time elapsed: 1 sec
Sum up the values of each customer @ 2 seconds/call. Total running time elapsed: 11 sec
Let's say only 2 make it to this step that need to be checked. Total running time elapsed: 15 sec
One has already received a gift, so it's only 1 call left. Total running time elapsed: 16 sec

Here's an example of what the code may look like:

IList<Customer> customers = GetListOfCustomers();

foreach (var customer in customers)

    if (GetPurchaseTotalForSixMonths(customer) > 100)

        if (!HasCustomerReceivedGift(customer))

            RequestGiftForCustomer(customer);

Considering that in every step from the process your server application is waiting for a response from another server, it's most likely idling away. So let's run some of the tasks in parallel. We can run each call made in (2) at the same time as the call that may or may not have been made initially in (3). We can make the call to the online loyalty app, and if the result from the call in two requires the data from the call in (3), you use it. If not, too bad - you just discard the results. Your code may look something like this:

        private static void Speculative()

            IList<Customer> customers = GetListOfCustomers();

            foreach (var customer in customers)

                var c = customer;   //**

                bool meetsPurchaseLimit=false;

                bool hasReceivedGift=false;

                Fork.Begin()

                    .Call(() => meetsPurchaseLimit = (GetPurchaseTotalForSixMonths(c) > 100))

                    .Call(() => hasReceivedGift = HasCustomerReceivedGift(c))

                    .End();

                if (meetsPurchaseLimit && !hasReceivedGift)

                    RequestGiftForCustomer(customer);

The Fork code that you see here is the same as what I've described in the article "An easy to use asynchronous fork".

Re-doing the calculation on the elapsed time, but now using speculative execution on the call made in (3), we get:

5 customers are returned. Total running time elapsed: 1 sec
Sum up the values of each customer @ 2 seconds/call, but at the same time check if the customer received a gift. Total running time elapsed: 11 sec
Marrying up the results from the parallel calls, make the single call for the gift. Total running time elapsed: 12 sec

Back to the example: As you can see, you have a 25% saving in time. Yes, this is a contrived example with naive timing, but the general idea is what matters most. Don't feel bad about using your CPU's idle time to get work done, even if you're going to throw it away later.

* ZAR100 is equivalent to about USD500 or GBP300. Ok, it isn't so. Check here if you really want to.

** You may or may not be wondering why I have the line:

                var c = customer;

It's to remove the warning I get from ReSharper - it complains about a possible "access to a modified closure". Have a look at this article from Eric Lippert explaining it.

C++ Compile Error - C2664

Ryan Schreiber — Mon, 16 Nov 2009 12:19:13 GMT

If you find you’re getting compile errors something along the lines of

error C2664: 'CreateFileW' : cannot convert parameter 1 from 'char [261]' to 'LPCWSTR'

error C2664: 'CreateProcessW' : cannot convert parameter 2 from 'char *' to 'LPWSTR'

I got plenty of these when compiling code which I C&P’d, which was working perfectly in one project, to a new project I had just created; All the errors were related to converting char/char arrays to LPWSTR. There are plenty of programmatic ways of converting this data, and keep in mind you may still want to check these out, rather than my “simple” fix, which is change the “Character Set” property in the project configuration settings to “Multi-Byte”

A look at two card shuffling techniques

Ryan Schreiber — Thu, 12 Nov 2009 08:37:45 GMT

I was asked by a colleague about how I might go about shuffling a deck of cards in C#. I found a few takes on this general problem on Google, and make no mistake: this has been covered by numerous persons over the last 80 years according to some of the research I found. So, yes, this is mostly likely a Wheel Version 2.0 piece of code, but here it is and hopefully it’ll be useful to someone.

Firstly, you need to decide on a Random Number Generator. If you’re just interested in solving this card-shuffling problem as part of a hobby-type application, using the System.Random class provided, or in my case the System.Security.Cryptography.RandomNumberGenerator, will suffice. To make this really strong, you may want to look at a pseudo-random algorithm along the lines of the Mersenne twister or one of it’s improved variants, or the simpler to implement Multiply-with-carry. Random number generators are really a topic all on their own and way out of the scope of this post.

Now, onto the relatively simple part: Shuffling a 52 card deck. I’ve designed a simple Deck class to make it easier for displaying results, but the algorithms can easily be transferred to whatever structure you’re using to store your cards/deck. I’ve also added my RNG as a static local variable to the class to increase its effectiveness. (Also, part of the RNG-related topic)

public class Deck : IEnumerable<Deck.SuitCard>

{

public enum Suit { Spade, Diamond, Club, Heart }

public enum Card { A, N2, N3, N4, N5, N6, N7, N8, N9, N10, J, Q, K }

public class SuitCard

{

public long Index { get; set; }

public Card Card { get; set; }

public Suit Suit { get; set; }

public override string ToString()

{

return Card.ToString().Replace("N", "") + " " + Suit;

}

private readonly List<SuitCard> m_List = new List<SuitCard>();

private static readonly RandomNumberGenerator m_Random = RandomNumberGenerator.Create();

public Deck ()

{

int i = 0;

foreach (Suit suit in Enum.GetValues(typeof(Suit)))

{

foreach (Card card in Enum.GetValues(typeof(Card)))

{

m_List.Add(new SuitCard() { Card = card, Suit = suit, Index=i++ });

}

The first shuffle I’ve implemented is based on the Knuth-Fisher-Yates shuffle and as you can see by the code, is amazingly simple to implement.

1 public void Shuffle()

2 {

3 //Knuth-Fisher-Yates shuffle algorithm

4 for (int i = m_List.Count - 1; i > 0; i--)

5 {

6 var data = new byte[1];

7 m_Random.GetBytes(data);

8 Swap(i, data[0] % (i + 1));

9 }

10 }

12 private void Swap(int x, int y)

13 {

14 Debug.Assert(x >= y); //Just to make sure...

15 SuitCard tmp = m_List[x];

16 m_List[x] = m_List[y];

17 m_List[y] = tmp;

18 }

Quoted from Wikipedia: The basic process of Fisher–Yates shuffling is similar to randomly picking numbered tickets out of a hat, or cards from a deck, one after another until there are no more left. What the specific algorithm provides is a way of doing this numerically in an efficient and rigorous manner that, properly done, guarantees an unbiased result.

That being said, this computation as I’ve implemented in the source code is is prone to an effect known as modulo bias – you can seen the mod that is done on line 8.

Another amazingly clever, yet simple, method of shuffling the cards is randomising a number, assigning it to the first card in the deck, and repeating the process for each card. Once you’ve completed, you order the cards by the random number, and your deck is shuffled.

61 public void Shuffle()

62 {

63 for (int i = 0; i < m_List.Count; i++)

64 {

65 var data = new byte[4];

66 m_Random.GetBytes(data);

67 m_List[i].Index = data[0] + (data[1] * 256) + (data[2] * 65536) + (data[3] * 16777216);

69 }

70 m_List.Sort(new Comparison<SuitCard>(delegate(SuitCard x, SuitCard y)

71 {

72 if (x.Index < y.Index) return (-1);

73 if (x.Index > y.Index) return (1);

74 return 0;

75 }));

76 }

I use the same RNG, and then convert the four bytes to a long (line 67) – this is the field that I “sort” the deck by, to give you a shuffled deck.

And that’s my two ways of shuffling a deck of cards in C#.

Overloading the implicit operator for casting

Ryan Schreiber — Fri, 14 Aug 2009 08:08:01 GMT

Seeing as I have to search for this code snippet on most occasions that I use it, I’ve decided to put it here as a post. I often find that I have to repeat the same code over and over when converting between two similar types (e.g. Person domain object and PersonDto object). If you see something like this crop up too often:

var personDto =  new PersonDto

    Id = person.Id,

    FirstName = person.FirstName,

    LastName = person.LastName,

    Age = person.Age

};

You have two options: 1) Refactor your code into an extension method so you have something like this:

var personDto = person.ConvertToPersonDto();

or, refactor you code into an implicit operator overload, so that your code looks like this:

var personDto = (PersonDto) person;

I prefer the latter, primarily because my refactored code can be part of the same class, and not have to be placed in separate static classes, as with all extension methods. The overloading of the operator looks like this:

public static implicit operator PersonDto (Person person)

    return new PersonDto

                   Id = person.Id,

                   FirstName = person.FirstName,

                   LastName = person.LastName,

                   Age = person.Age

};

Creating your own dynamic proxy

Ryan Schreiber — Wed, 12 Aug 2009 22:00:00 GMT

This is (another) look at implementing a dynamic proxy using Reflection Emit. Why would you need a dynamic proxy? Well, there are times when functionality needs to be injected into existing code that can not be modified. My dynamic proxy generator allow you to supply two Action parameters the will be executed as pre- and post-call methods. The tests that I have provided with my sample application show an example of injecting timing code into existing methods. It could also be used to insert logging and tracing information into code.

The route that I have followed to create my dynamic proxy has its limitations, as have many other such as the Castle Dynamic Proxy and LinFu – only virtual methods can successfully be “proxied”. For my needs, the dynamic proxy type had to adhere to the Liskov Substitution Principle. Also, and very importantly, my sample is merely an exercise in academics – I’ve been fiddling with emitting code for the last week, so this post evolved from that. If you need a fully fledged dynamic proxy, try out one of links above.

Download: Darkside.DynamicProxy.zip

I’ve implemented a static method in a generic class to allow for strongly typed implementation.

public static T CreateDynamicProxy<T>(Action preCall, Action postCall) where T:class , new()

First on the list of tasks is to create a dynamic assembly, module and type.

   15 //Do some setup work on the name of the assembly and type

   16 var typeName = typeof (T).FullName;

   17 var dynamicTypeName = typeName + "DynamicProxyType";

   18 var name = new AssemblyName { Name = dynamicTypeName };

   20 //Define a new dynamic assembly

   21 AssemblyBuilder assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);

   22 //Now define a new module

   23 ModuleBuilder module = assembly.DefineDynamicModule(dynamicTypeName + ".dll");

   24 //And create a new type which inherits the base type you've passed in

   25 TypeBuilder type = module.DefineType(dynamicTypeName, TypeAttributes.Public, typeof(T));

I do some setup work creating a new assembly name, as well as a new name for my dynamic type which I use throughout the method. A point of interest is on line 21, the last parameter of the DefineDynamicAssembly method; The AssemblyBuilderAccess.Run can be changed to AssemblyBuilderAccess.RunAndSave which is useful if you decide to save the new assembly to disk, meaning that in future you wouldn’t have to regenerate the dynamic type, you could simply load it from the assembly.

Next on the list is the constructor – I add a new constructor to the type that takes two parameters; thesewill be the two parameters of type Action that are the actual pre- and post-call methods passed to the method. Before I actually emit the code to assign these parameters to internal fields, I emit code to call the default constructor in the base class.

   33 //Define a new constructor for the dynamic type, which takes two arguments of type Action

   34 ConstructorBuilder newConstructorBuilder = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[]{typeof(Action), typeof(Action)});

   35 var newConstructorGenerator = newConstructorBuilder.GetILGenerator();

   36 //Emit code to call the base default constructor

   37 newConstructorGenerator.Emit(OpCodes.Ldarg_0);

   38 newConstructorGenerator.Emit(OpCodes.Call, typeof(T).GetConstructors()[0]);

   40 //Emit code to save the first parameter passed to the constructor

   41 newConstructorGenerator.Emit(OpCodes.Ldarg_0);

   42 newConstructorGenerator.Emit(OpCodes.Ldarg_1);

   43 newConstructorGenerator.Emit(OpCodes.Stfld, preCallFieldBuilder);

   45 //Emit code to save the second parameter passed to the constructor

   46 newConstructorGenerator.Emit(OpCodes.Ldarg_0);

   47 newConstructorGenerator.Emit(OpCodes.Ldarg_2);

   48 newConstructorGenerator.Emit(OpCodes.Stfld, postCallFieldBuilder);

   49 newConstructorGenerator.Emit(OpCodes.Ret);

I then emit two private methods that actually make the calls. The methods are what are added to the overriden methods which I emit later on.

   51 //Build a method for the pre call

   52 //Define a new private method. Once again, the name is just an attempt at being unique in the code

   53 MethodBuilder preCallMethodBuilder = type.DefineMethod("__dyn_PreCall", MethodAttributes.Private);

   54 var genPreCall = preCallMethodBuilder.GetILGenerator();

   55 genPreCall.Emit(OpCodes.Ldarg_0);

   56 genPreCall.Emit(OpCodes.Ldfld, preCallFieldBuilder);

   57 genPreCall.Emit(OpCodes.Callvirt, typeof (Action).GetMethod("Invoke"));

   58 genPreCall.Emit(OpCodes.Ret);

   60 //Build a method for the post call

   61 MethodBuilder postCallMethodBuilder = type.DefineMethod("__dyn_PostCall", MethodAttributes.Private);

   62 var genPostCall = postCallMethodBuilder.GetILGenerator();

   63 genPostCall.Emit(OpCodes.Ldarg_0);

   64 genPostCall.Emit(OpCodes.Ldfld, postCallFieldBuilder);

   65 genPostCall.Emit(OpCodes.Callvirt, typeof (Action).GetMethod("Invoke"));

   66 genPostCall.Emit(OpCodes.Ret);

I could have called the fields directly, but added the methods in so that I could modify to do other things. Just in case :) After that, all that’s left to do in constructing the dynamic is to loop through the methods from the original/base type, and emit new method calls for them.

   68 //Loop through all the methods that are public, virtual and instance methods

   69 foreach (var methodInfo in typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Instance).Where(mi => mi.IsVirtual))

   70 {

   71     //Define a new method

   72     MethodBuilder mb = type.DefineMethod(methodInfo.Name,

   73                                          MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual,

   74                                          methodInfo.ReturnType,

   75                                          methodInfo.GetParameters().Select(pi => pi.ParameterType).ToArray());

   77     var mbGen = mb.GetILGenerator();

   79     //Only emit the code that makes a call to the PreCall if it is defined

   80     mbGen.Emit(OpCodes.Ldarg_0);

   81     mbGen.Emit(OpCodes.Call, preCallMethodBuilder);

   83     //Setup up the parameters that were passed into this call for the base class call

   84     mbGen.Emit(OpCodes.Ldarg_0);

   85     //Loop through all the parameters and emit statements

   86     for (int i = 1; i <= methodInfo.GetParameters().Count(); i++)

   87         mbGen.Emit(OpCodes.Ldarg_S, i);

   88     //Emit the code that makes the base call

   89     mbGen.Emit(OpCodes.Call, methodInfo);

   91     //Only emit the code that makes a call to the PostCall method if it is defined

   92     mbGen.Emit(OpCodes.Ldarg_0);

   93     mbGen.Emit(OpCodes.Call, postCallMethodBuilder);

   94     mbGen.Emit(OpCodes.Ret);

   95 }

   96 //Create the type

   97 type.CreateType();

The final act of the factory method is to instantiate a new instance of the dynamic type, passing to it the two action parameters from the method call. I do a null check on the parameters and substitute it with a dummy call if it is.

  103 //Return an instance of the type

  104 return assembly.CreateInstance(dynamicTypeName, false,

  105                                BindingFlags.CreateInstance,

  106                                null,

  107                                new[]

  108                                    {

  109                                        preCall ??

  110                                        new Action(delegate {

  111                                                                return;

  112                                        }),

  113                                        postCall ??

  114                                        new Action(delegate {

  115                                                                return;

  116                                        })

  117                                    },

  118                                CultureInfo.CurrentCulture, null) as T;

In the first test method, my code looks as follows:

var fb = new FooBar();

fb.Foo();

fb.Foo(42);

int x = fb.Bar();

Assert.AreEqual(42,x);

and when using the dynamic proxy creation method, my code changes to this:

var fb = DynamicProxyFactory.CreateDynamicProxy<FooBar>(null, null);

fb.Foo();

fb.Foo(42);

int x = fb.Bar();

Assert.AreEqual(42, x);

You’ll notice that, barring the instantiation of the class, the rest of the code stays the same. The next example shows much the same, except demonstrates how to add timing to the methods passed as parameters:

var sw = new Stopwatch();

Action preCall = sw.Start;

Action postCall = sw.Stop;

var fb = DynamicProxyFactory.CreateDynamicProxy<FooBar>(preCall, postCall);

fb.Foo();

fb.Foo(42);

int x = fb.Bar();

Assert.AreEqual(42, x);

Console.WriteLine("Time taken: " + sw.ElapsedMilliseconds); //Should be 100ms or more :)

One-line integer swap in C#

Ryan Schreiber — Thu, 06 Aug 2009 04:55:00 GMT

After doing some random surfing this morning (I think I started off with binging “operator precedence C#”, I landed on this page about one line variable swaps, which then got me thinking about how to do this in C#. My only solution I could come up with was using arithmetic to solve the problem:

int x = 11;

int y = 42;

y = (y + x) - (x = (y + x) - x);

Debug.Assert(x == 42);

Debug.Assert(y == 11);

Please don't use this code, unless you're on some type of job security mission :)

UPDATE: 12 Aug 2009 – Ok, so I wasted more time on it. Savage also submitted a refactored version of my previous try

int x = 11;

int y = 42;

x = y ^ x ^ (y = x);

Debug.Assert(x == 42);

Debug.Assert(y == 11);

An easy to use asynchronous fork

Ryan Schreiber — Fri, 24 Apr 2009 07:15:00 GMT

I’ve been making use of Roger Alsing’s Async Fork for a few months as an alternative to the “for testing purposes only” Microsoft Parallel Extensions. With the release of C# 4.0 on the horizon, I decided to modify the internal workings of the Fork class to make use of the parallel extensions, which would result in very few modifications to my existing code. My reason for the modifications are to take advantage of the inner working of parallels extensions.

Here is the modified version of the Fork class:

    public class Fork

        private readonly IList<Action> _Actions ;

        private Fork()

            _Actions = new List<Action>();

        /// <summary>

        /// Starts an async fork

        /// </summary>

        /// <returns>Returns a new fork instance</returns>

        public static Fork Begin()

            return new Fork();

        /// <summary>

///

        /// </summary>

        /// <param name="action">Delegate that should be executed async</param>

        /// <returns>Returns self</returns>

        public Fork Call(Action action)

            _Actions.Add(action);

            return this;

        /// <summary>

        /// Executes all the calls async and waits untill all of them are finished

        /// </summary>

        public void End()

            var taskManager = new TaskManager();

            Parallel.Invoke(_Actions.ToArray(), taskManager, TaskCreationOptions.Detached);

And making use of the exact same example in the original article, you can use it like this:

            //declare the variables we want to assign

            string str = null;

            int val = 0;

            //start a new async fork

            //assign the variables inside the fork

            Fork.Begin()

                .Call(() => str = CallSomeWebService(123, "abc"))

                .Call(() => val = ExecSomeStoredProc("hello"))

                .End();

            //the fork has finished

            //we can use the variables now

            Console.WriteLine("{0} {1}", str, val);