Implement C# Generic Timeout

by

The really tricky part here was killing the long running task through passing the executor thread from the Action back to a place where it could be aborted. I accomplished this with the use of a wrapped delegate that passes out the thread to kill into a local variable in the method that created the lambda.

I submit this example, for your enjoyment. The method you are really interested in is CallWithTimeout. This will cancel the long running thread by aborting it, and swallowing the ThreadAbortException:

Usage:

class Program
{

    static void Main(string[] args)
    {
        //try the five second method with a 6 second timeout
        CallWithTimeout(FiveSecondMethod, 6000);

        //try the five second method with a 4 second timeout
        //this will throw a timeout exception
        CallWithTimeout(FiveSecondMethod, 4000);
    }

    static void FiveSecondMethod()
    {
        Thread.Sleep(5000);
    }

The static method doing the work:

    static void CallWithTimeout(Action action, int timeoutMilliseconds)
    {
        Thread threadToKill = null;
        Action wrappedAction = () =>
        {
            threadToKill = Thread.CurrentThread;
            try
            {
                action();
            }
            catch(ThreadAbortException ex){
               Thread.ResetAbort();// cancel hard aborting, lets to finish it nicely.
            }
        };

        IAsyncResult result = wrappedAction.BeginInvoke(null, null);
        if (result.AsyncWaitHandle.WaitOne(timeoutMilliseconds))
        {
            wrappedAction.EndInvoke(result);
        }
        else
        {
            threadToKill.Abort();
            throw new TimeoutException();
        }
    }

}

More Related Contents:

  1. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  2. What is the difference between asynchronous programming and multithreading?
  3. How to protect resources that may be used in a multi-threaded or async environment?
  4. Set timeout to an operation
  5. Async process start and wait for it to finish
  6. “async Task then await Task” vs “Task then return task” [duplicate]
  7. Benefits of using async and await keywords
  8. Named Mutex with await
  9. What thread runs the code after the `await` keyword?
  10. Calling async method on button click
  11. Calling async methods from non-async code
  12. Is .GetAwaiter().GetResult(); safe for general use?
  13. C# Threading/Async: Running a task in the background while UI is interactable
  14. Async thread body loop, It just works, but how?
  15. Async WebApi Thread.CurrentCulture
  16. I thought await continued on the same thread as the caller, but it seems not to
  17. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  18. Synchronous implementation of interface that returns Task
  19. What is the difference between .Wait() vs .GetAwaiter().GetResult()?
  20. Write to a file from multiple threads asynchronously c#
  21. Async and Await with For Loop [duplicate]
  22. Calling an async method from a synchronous method
  23. Pause and Resume Subscription on cold IObservable
  24. Calling TaskCompletionSource.SetResult in a non blocking manner
  25. How to use HttpWebRequest (.NET) asynchronously?
  26. Is the ++ operator thread safe? [duplicate]
  27. Cancelling a Task is throwing an exception
  28. How to check if Thread finished execution
  29. ToArrayAsync() throws “The source IQueryable doesn’t implement IAsyncEnumerable”
  30. Return a value from an Event — is there a Good Practice for this?

Leave a Comment