Run generic tasks async (fluent-ly)

<< LINQ to SQL Entities and DDD | Home | Find/Replace on Render – an MVC alternative to Response Filters >>

Run generic tasks async (fluent-ly)

I saw a post entitled Run Async tasks with Fluent Interface written in response to another post entitled Async without the pain. I suppose this post is my response to those posts.

While I liked what I saw there, there were some things I wanted to add (like the ability to block until tasks complete), so I wrote my own class along the same lines. There are still some things I’d like to add (like the ability to queue tasks into jobs that run in order), but this works for me right now for what I’m doing.

        1: public class AsyncQueueManager

       2:     {

       3:         private ILog _logger = log4net.LogManager.GetLogger(typeof(AsyncQueueManager));

       4:         private ManualResetEvent _WaitHandle = new ManualResetEvent(true);

       5:         private int _QueueCount = 0;

       6:         object locker = new object();

       7:  

       8:         private Action<object> GetActionWrapper(Action<object> action)

       9:         {

            Action<object> actionWrapper = (object obj) =>

                        {

                            try

                            {

                                action(obj);

                            }

                            catch(Exception ex)

                            {

                                LogException(action, ex);

                            }

                            finally

                            {

                                lock (locker)

                                    _QueueCount = _QueueCount - 1;

                                SetWaitHandle();

                            }

                        };

            return actionWrapper;

        }

        public AsyncQueueManager Queue(Action<object> action)

        {

            lock(locker)

                _QueueCount = _QueueCount + 1;

            _WaitHandle.Reset();            

            Action<object> actionWrapper = GetActionWrapper(action);

            WaitCallback waitCallback = new WaitCallback(actionWrapper);

            ThreadPool.QueueUserWorkItem(waitCallback);

            return this;

        }

        private void SetWaitHandle()

        {

            if (_QueueCount == 0)

            {

                _WaitHandle.Set();

            }

        }

  

        public void WaitOne()

        {

            _WaitHandle.WaitOne();

        }

  

        public void WaitOne(TimeSpan timeout)

        {

            _WaitHandle.WaitOne(timeout);

        }

  

        private void LogException(Action<object> action, Exception ex)

        {

            string exceptionString = "Exception occured while running async operation." + 

                "  Details below." + Environment.NewLine +

                "Method name:" + action.Method.Name + Environment.NewLine +

                "Exception:" + ex.ToString();

            _logger.Error(exceptionString);

        }

    }

Running code is as simple as:

       1: int resultA;

       2: int resultB;

       3: int resultC;

       4: var async = new AsyncQueueManager();

       5: async.Queue((object obj) => {

       6:     int result = 0;

       7:     for (int i = 0; i < 1000000; i++)

       8:         result++;

       9:     resultA = result;

      10: });

      11: async.Queue((object obj) => {

      12:     int result = 1;

      13:     for (int i = 0; i < 1000000; i++)

      14:         result += 2;

      15:     resultB = result;

      16: });

      17: async.Queue((object obj) => {

      18:     int result = 1;

      19:     for (int i = 0; i < 1000000; i++)

      20:         result += 3;

      21:     resultC = result;

      22: });

      23: async.Wait(); // wait for these to complete in no particular order

      24:  

      25: Console.WriteLine("resultA: " + resultA);

      26: Console.WriteLine("resultB: " + resultB);

      27: Console.WriteLine("resultC: " + resultC);

Now you’d have to have a pretty slow machine for this to actually take any noticeable time, but you get the idea.

Notice of course how I can set local variables within my in-line Actions. This is because, as I understand it, the compiler actually creates a separate class to handle these since it knows where you’re going with this. Of course you could also call methods or do whatever you want here.

Print | posted on Monday, November 09, 2009 11:40 AM | Filed Under [ c# ]

Feedback

# re: Run generic tasks async (fluent-ly)

Very nice!
Is there any way to cancel a running operation using this?

3/23/2010 8:37 PM | Alex

# re: Run generic tasks async (fluent-ly)

how is this Fluent ?

4/26/2010 11:28 AM | Erhan Hosca

Post Comment

Title
Name
Email
Url
Comment
Remember Me?
Please add 5 and 3 and type the answer here: Enter the code shown above:

{STATIC} hippo

My Links

Archives

Post Categories