namespace System.Threading.Tasks
{
 public static class TaskEx
 {
 public static TaskAwaiter GetAwaiter(this Task task)
 {
  return new TaskAwaiter(task);
 }
 public static TaskAwaiter<T> GetAwaiter<T>(this Task<T> task)
 {
  return new TaskAwaiter<T>(task);
 }
 }
 public struct TaskAwaiter : INotifyCompletion
 {
 readonly Task task;
 internal TaskAwaiter(Task task)
 {
  this.task = task;
 }
 internal static TaskScheduler TaskScheduler
 {
  get
  {
  if (SynchronizationContext.Current == null)
   return TaskScheduler.Default;
  else
   return TaskScheduler.FromCurrentSynchronizationContext();
  }
 }
 public bool IsCompleted
 {
  get { return task.IsCompleted; }
 }
 public void OnCompleted(Action continuation)
 {
  this.task.ContinueWith(
  delegate (Task task) {
   continuation();
  }, TaskAwaiter.TaskScheduler);
 }
 public void GetResult()
 {
  try
  {
  task.Wait();
  }
  catch (AggregateException ex)
  {
  throw ex.InnerExceptions[0];
  }
 }
 }
 public struct TaskAwaiter<T> : INotifyCompletion
 {
 readonly Task<T> task;
 internal TaskAwaiter(Task<T> task)
 {
  this.task = task;
 }
 public bool IsCompleted
 {
  get { return task.IsCompleted; }
 }
 public void OnCompleted(Action continuation)
 {
  this.task.ContinueWith(
  delegate (Task<T> task) {
   continuation();
  }, TaskAwaiter.TaskScheduler);
 }
 public T GetResult()
 {
  try
  {
  return task.Result;
  }
  catch (AggregateException ex)
  {
  throw ex.InnerExceptions[0];
  }
 }
 }
}
namespace System.Runtime.CompilerServices
{
 public interface INotifyCompletion
 {
 void OnCompleted(Action continuation);
 }
 public interface ICriticalNotifyCompletion : INotifyCompletion
 {
 [SecurityCritical]
 void UnsafeOnCompleted(Action continuation);
 }
 public interface IAsyncStateMachine
 {
 void MoveNext();
 void SetStateMachine(IAsyncStateMachine stateMachine);
 }
 public struct AsyncVoidMethodBuilder
 {
 public static AsyncVoidMethodBuilder Create()
 {
  return new AsyncVoidMethodBuilder();
 }
 public void SetException(Exception exception)
 {
  throw exception;
 }
 public void SetResult()
 {
 }
 public void SetStateMachine(IAsyncStateMachine stateMachine)
 {
  // Should not get called as we don't implement the optimization that this method is used for.
  throw new NotImplementedException();
 }
 public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
 {
  stateMachine.MoveNext();
 }
 public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  awaiter.OnCompleted(stateMachine.MoveNext);
 }
 public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  awaiter.OnCompleted(stateMachine.MoveNext);
 }
 }
 public struct AsyncTaskMethodBuilder
 {
 TaskCompletionSource<object> tcs;
 public Task Task { get { return tcs.Task; } }
 public static AsyncTaskMethodBuilder Create()
 {
  AsyncTaskMethodBuilder b;
  b.tcs = new TaskCompletionSource<object>();
  return b;
 }
 public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
 {
  stateMachine.MoveNext();
 }
 public void SetStateMachine(IAsyncStateMachine stateMachine)
 {
  // Should not get called as we don't implement the optimization that this method is used for.
  throw new NotImplementedException();
 }
 public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  awaiter.OnCompleted(stateMachine.MoveNext);
 }
 public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  awaiter.OnCompleted(stateMachine.MoveNext);
 }
 public void SetResult()
 {
  tcs.SetResult(null);
 }
 public void SetException(Exception exception)
 {
  tcs.SetException(exception);
 }
 }
 public struct AsyncTaskMethodBuilder<T>
 {
 TaskCompletionSource<T> tcs;
 public Task<T> Task { get { return tcs.Task; } }
 public static AsyncTaskMethodBuilder<T> Create()
 {
  AsyncTaskMethodBuilder<T> b;
  b.tcs = new TaskCompletionSource<T>();
  return b;
 }
 public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
 {
  stateMachine.MoveNext();
 }
 public void SetStateMachine(IAsyncStateMachine stateMachine)
 {
  // Should not get called as we don't implement the optimization that this method is used for.
  throw new NotImplementedException();
 }
 public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  awaiter.OnCompleted(stateMachine.MoveNext);
 }
 public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
 {
  AwaitOnCompleted(ref awaiter, ref stateMachine);
 }
 public void SetResult(T result)
 {
  tcs.SetResult(result);
 }
 public void SetException(Exception exception)
 {
  tcs.SetException(exception);
 }
 }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace CefSharp
{
 public class TaskEx
 {
 public static Task<T> FromResult<T>(T t)
 {
  return Task.Factory.StartNew<T>(() => t);
 }
 public static Task Run(Action action)
 {
  var tcs = new TaskCompletionSource<object>();
  new Thread(() => {
   try
   {
   action();
   tcs.SetResult(null);
   }
   catch (Exception ex)
   {
   tcs.SetException(ex);
   }
  })
  { IsBackground = true }.Start();
  return tcs.Task;
 }
 public static Task<TResult> Run<TResult>(Func<TResult> function)
 {
  var tcs = new TaskCompletionSource<TResult>();
  new Thread(() =>
  {
   try
   {
   tcs.SetResult(function());
   }
   catch (Exception ex)
   {
   tcs.SetException(ex);
   }
  })
  { IsBackground = true }.Start();
  return tcs.Task;
 }
 public static Task Delay(int milliseconds)
 {
  var tcs = new TaskCompletionSource<object>();
  var timer = new System.Timers.Timer(milliseconds) { AutoReset = false };
  timer.Elapsed += delegate { timer.Dispose(); tcs.SetResult(null); };
  timer.Start();
  return tcs.Task;
 }
 }
}