using System;

using System.Diagnostics;

using System.Threading;

using System.Threading.Tasks;

​

public class Program

{

    public static void Main()

    {

        var sw = Stopwatch.StartNew();

        var t = Task.Factory.StartNew(() =>

        {

            //LongRunningTask("Entering task1")

            Thread.Sleep(500); //this does NOT get automagically cancelled because of TimeoutAfter

            Console.WriteLine($"{sw.ElapsedMilliseconds}ms: Task Finished");

            return 0;

        }

​

        ).TimeoutAfter(250);

        try

        {

            t.Wait();

        }

        catch (AggregateException e)when (e.InnerException.GetType() == typeof (TimeoutException))

        {

            Console.WriteLine($"{sw.ElapsedMilliseconds}ms: caught {e.InnerException.GetType()}");

        }

​

        Console.WriteLine($"{sw.ElapsedMilliseconds}ms: task.Wait() done");

        Thread.Sleep(300); // needed for dotnetfiddle, otherwise console.writeline calls from task would happen after Main() is done and would be ignored

    }

}

​

public static class ExtensionMethods

{

    public static Task<Result> TimeoutAfter<Result>(this Task<Result> task, int millisecondsTimeout)

    {

        // Short-circuit #1: infinite timeout or task already completed

        if (task.IsCompleted || (millisecondsTimeout == Timeout.Infinite))

        {

            Console.WriteLine("task.IsCompleted");

            // Either the task has already completed or timeout will never occur.

            // No proxy necessary.

            return task;

        }

​

        // tcs.Task will be returned as a proxy to the caller

        var tcs = new TaskCompletionSource<Result>();

        // Short-circuit #2: zero timeout

        if (millisecondsTimeout == 0)

        {

            //                Console.WriteLine("millisecondsTimeout == 0");

            // We've already timed out.

            tcs.SetException(new TimeoutException());

            return tcs.Task;

        }

​

        // Set up a timer to complete after the specified timeout period

        var timer = new Timer(state => tcs.TrySetException(new TimeoutException()), null, millisecondsTimeout, Timeout.Infinite);

        // Wire up the logic for what happens when source task completes

        task.ContinueWith(antecedent =>

        {

            timer.Dispose();

            MarshalTaskResults(antecedent, tcs);

        }

​

        , CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

        return tcs.Task;

    }

​

    public static void MarshalTaskResults<TResult>(Task source, TaskCompletionSource<TResult> proxy)

    {

        switch (source.Status)

        {

            case TaskStatus.Faulted:

                proxy.TrySetException(source.Exception);

                break;

            case TaskStatus.Canceled:

                proxy.TrySetCanceled();

                break;

            case TaskStatus.RanToCompletion:

                Task<TResult> castedSource = source as Task<TResult>;

                proxy.TrySetResult(castedSource == null ? default (TResult) : // source is a Task

 castedSource.Result); // source is a Task<TResult>

                break;

        }

    }

}