Type-Strong Asynchronous Execution

Download source - 0.8 KB

Introduction

This static class allows the programmer to run a method asynchronously with a single line of code with typed arguments.

Background

Sometimes, a programmer just want some work to be done in the background, and the .NET framework provides several ways of doing just that. You can start a thread and make it call a function, or you can use the ThreadPool.QueueUserWorkItem, but I always felt it was kind of messy. Using ThreadPool forces you to use a WaitCallback delegate if you want to specify any parameters, these need to be boxed into an object and unboxed in the WaitCallback function called.

So, what I wanted was a simple function to call, Util.RunAsync(function, arg1,arg2,arg3...), in a sort of fire and forget way.

Using the Code

The static class Util contains an overloaded function called RunAsync. It is used as such:

public static void Main(string[] args)
{
    string someString = "Hello There";
    int someInteger = 42;
    DateTime someTime = DateTime.Now;

    Util.RunAsync(Function1, someString, someInteger, someTime);
}

public static void Function1(string aString, int anInteger, DateTime time)
{
    Console.WriteLine("{0} {1} {2}", aString, anInteger, time);
}

Points of Interest

The functionality is achieved using the ThreadPool.QueueUserWorkItem the function, and its arguments are wrapped in an ActionJob object that has a subclass for each amount of arguments usable with Util.RunSync. Because it is based on the Action delegate and the generic versions of it Action<T>, Action<T,V>, Action<T,V,X>, and Action<T,V,X,Y>, it can only execute functions with at most four arguments.

You should be able to change the code to work as a Work Queue for invoking with Windows Forms. Instead of running ThreadPool.QueueUserWorkItem, you could do something like this:

public static void DoInvoke<T, V, X, Y>(
              this System.Windows.Forms.Control control, 
              Action<T, V, X, Y> function, T a, V b, X c, Y d)
{
    if (control.InvokeRequired)
    {
        control.Invoke(function, a, b, c, d);
    }
    else
    {
        function(a, b, c, d);
    }
}

Conclusion

That's it. I like this little convenience, and I hope you do too :)

History

5 January 2008: Article submitted.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Jacob Korsgaard

Other
Aalborg University

Denmark

Member

Jacob is a Computer Science student at Aalborg University Denmark.

He has a special interest in Object Oriented and Managed programming languages such as Java and especially C#.

Jacob has been developing software professionally and for fun in his spare time for more than 7 years during his studies.

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

Error: Using the generic type 'System.Action' requires '1' type arguments

CoderJ

2:04 19 Feb '08

I'm new to threading and am having difficulty testing this example. I keep getting this error: Using the generic type 'System.Action<T>' requires '1' type arguments Could you please post a sample program using the class or tell me what obvious mistake I've made here? Thank you
Sign In·View Thread·Permalink

Re: Error: Using the generic type 'System.Action' requires '1' type arguments

Jacob Korsgaard

3:26 19 Feb '08

Are you able to compile the classes? The first bit of code is an example of usage. Contrary to the article, this code requires at least C# 3.0 because the Action generic with more than one variable is only available in the later versions.
Sign In·View Thread·Permalink

Re: Error: Using the generic type 'System.Action' requires '1' type arguments

CoderJ

3:49 19 Feb '08

I changed the application's target framework to 3.0 and still had the same error. Then I changed it to 3.5 and was able to successfully build the application. Thank you very much.
Sign In·View Thread·Permalink	2.00/5 (1 vote)

Re: Error: Using the generic type 'System.Action' requires '1' type arguments

ml_black

7:22 24 Feb '10

Exact same thing worked for me. I had the same line of code in two projects inside the same solution. No error in one project, but did get this error on the same line of code in the other, even though both projects were targeting the 3.5 Framework. For the one that had the error, I briefly targeted 3.0, then changed back to 3.5--problem fixed! Thanks!
Sign In·View Thread·Permalink

An easier way?

Henrik Jonsson

7:51 7 Jan '08

Thanks for sharing this idea.

I like this way of using generic delegates to simplify calls and still obtain compilation type-safety.

One simplification however might be to use BeginInvoke instead to execute the delegate in the background like this:



public static IAsyncResult RunAsync<T, V>(Action<T, V> function, T a, V b)

{

     function.BeginInvoke(a, b, null, null);

}

In this way you do not have to declare ActionJob classes and get a IAsyncResult reference as a return value that can be used to query and/or wait for completion.

Re: An easier way?

FeLiZk

0:27 8 Jan '08

It doesn't seem like a bad idea, but after I googled it a little I'm worried that calling BeginInvoke without calling EndInvoke might result in a memory leak, see: http://www.yoda.arachsys.com/csharp/threads/threadpool.shtml[^]

It is certainly an idea that can be used to create an asynchronous execution of Func delegates. Because it would allow you to End the IASyncResult and get a return value.

I applied the job idea to running a Func asynchronously:



    public static void RunAsync(Func function, Action callBack, V a)

    {

        FuncJob job = new FuncJob(function, callBack);

        function.BeginInvoke(a, new AsyncCallback(job.End), job);

    }

 

    public class FuncJob

    {

        public Func Func { get; protected set; }

        public Action Callback { get; protected set; }

        public FuncJob(Func func, Action callback) 

        {

            this.Func = func;

            this.Callback = callback;

        }

 

        public void End(IAsyncResult result)

        {

            FuncJob job = (FuncJob)result.AsyncState;

 

            T a = job.Func.EndInvoke(result);

 

            job.Callback(a);

        }

    }

This RunAsync function takes a Func delegate to run and a Action to call when execution of the func has ended. It is not as "fire and forget" as the action idea, but it does allow you to get a result and apply it, all with type safety.

Re: An easier way?

Henrik Jonsson

8:47 10 Jan '08

Thank you for the reference. Smile | :)

After more performance testing I found that the solution with BeginInvoke is absolutely not to recommend. It is much slower than your implementation with ThreadPool, and in Performance Monitor you can see that OS handles are created on each call.

Thus it is also better to implement the version with Func not using BeginInvoke, e.g. like this:



public static void RunAsync2<V,T>(Func<V,T> function, Action<T> callBack, V a)

{

   FuncJob2<V,T> job = new FuncJob2<V,T>(function, callBack,a);

   ThreadPool.QueueUserWorkItem(new WaitCallback(job.Perform), null);

}

 

public class FuncJob2<V,T> 

{

    public Func<V,T> Func { get; protected set; }

    public Action<T> Callback { get; protected set; }

    public V Arg { get; protected set; }

 

    public FuncJob2(Func<V,T> func, Action<T> callback, V arg)

    {

       this.Func = func;

       this.Callback = callback;

       this.Arg = arg;

    }

 

    public void Perform(object dummy)

    {

       T res = Func(Arg);

       Callback(res);

    }

}