public static T RunSync <T>(Func <Task <T> > workItem)
{
var prevContext = SynchronizationContext.Current;
try
{
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await workItem();
}
catch (Exception e)
{
synch.ObjectException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
return(ret);
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevContext);
}
}
/// <summary>
/// Execute's an async <see cref="Task{TResult}"/> method which has a T return type synchronously
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task"><see cref="Task{TResult}"/> method to execute</param>
/// <returns></returns>
public static T RunSync <T>(Func <Task <T> > task)
{
var synch = new ExclusiveSynchronizationContext();
using (new SetSynchronizationContext(synch))
{
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await task();
}
catch (Exception e)
{
synch.InnerExceptionDispatchInfo = ExceptionDispatchInfo.Capture(e);
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
return(ret);
}
}
/// <summary>
/// Execute's an async Task<T> method which has a T return type synchronously
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task">Task<T> method to execute</param>
/// <returns></returns>
public static T RunSync <T>(Task <T> task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T rs = default(T);
synch.Post(async _ =>
{
try
{
rs = await task.ConfigureAwait(false);
}
catch (System.Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(rs);
}
/// <summary>
/// Execute's an async Task<T> method which has a void return value synchronously
/// </summary>
/// <param name="task">Task<T> method to execute</param>
public static void RunSync(Func <Task> task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await task();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
}
/// <summary>
/// Executes synchronously an async <see cref="Task"/> method which has a void return value
/// </summary>
/// <param name="task"><see cref="Task"/> method to execute</param>
/// <exception cref="ArgumentNullException"><paramref name="task"/> is null</exception>
public static void RunSync(Func <Task> task)
{
if (task == null)
{
throw Logger.Fatal <ArgumentNullException>(nameof(task));
}
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await task().ConfigureAwait(false);
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
}
/// <summary>
/// Execute's an async Task<T> method which has a T return type synchronously
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task">Task<T> method to execute</param>
/// <returns></returns>
public static T RunSync <T>(Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await task();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
/// <summary>
/// Execute's an async Task<T> method which has a void return value synchronously
/// </summary>
/// <param name="task">Task<T> method to execute</param>
public static void RunSync(Func<Task> task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await task();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
}
public static T RunSync <T>(Func <Task <T> > task, Action <Exception> onError = null)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await task().ConfigureAwait(false);
}
catch (Exception e)
{
synch.InnerException = e;
onError?.Invoke(e);
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
/// <summary>
/// Execute's an async Task method which has a T return type synchronously
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task">Task method to execute</param>
/// <returns></returns>
public static T RunSync <T>(Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
using (var synch = new ExclusiveSynchronizationContext())
{
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(_ =>
{
try
{
ret = task().ConfigureAwait(false).GetAwaiter().GetResult();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
}
/// <summary>
/// Executes synchronously an async <see cref="Task{T}"/> method which has a <typeparamref name="T"/> return type
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task"><see cref="Task{T}"/> method to execute</param>
/// <returns>Return value ot the task</returns>
/// <exception cref="ArgumentNullException"><paramref name="task"/> is null</exception>
public static T RunSync <T>(Func <Task <T> > task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
var ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await task().ConfigureAwait(false);
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
/// <summary>
/// Constructs the AsyncBridge by capturing the current
/// SynchronizationContext and replacing it with a new
/// ExclusiveSynchronizationContext.
/// </summary>
internal AsyncBridge()
{
_oldContext = SynchronizationContext.Current;
_currentContext =
new ExclusiveSynchronizationContext(_oldContext);
SynchronizationContext
.SetSynchronizationContext(_currentContext);
}
public static T RunSync <T>(this Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default !;
/// <summary>
/// Constructs the AsyncBridge by capturing the current
/// SynchronizationContext and replacing it with a new
/// ExclusiveSynchronizationContext.
/// </summary>
internal AsyncBridge()
{
OldContext = SynchronizationContext.Current;
CurrentContext =
new ExclusiveSynchronizationContext(OldContext);
SynchronizationContext
.SetSynchronizationContext(CurrentContext);
}
public void AwaitableSyncContexts()
{
var r = new ExclusiveSynchronizationContext();
Task.Factory.StartNew(async() => {
SynchronizationContext.Current.AssertDoesNotEqual(r);
await r;
SynchronizationContext.Current.AssertEquals(r);
}).Unwrap().AssertRanToCompletion();
}
public static void RunSync(Func <Task> task)
{
ExclusiveSynchronizationContext synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(delegate(object _) {
< > c__DisplayClass0_0.<< RunSync > b__0 > d local;
local.< > 4__this = (< > c__DisplayClass0_0) this;
local.< > t__builder = AsyncVoidMethodBuilder.Create();
local.< > 1__state = -1;
local.< > t__builder.Start << > c__DisplayClass0_0.<< RunSync > b__0 > d > (ref local);
}, null);
public ExclusiveSynchronizationContext(SynchronizationContext old)
{
ExclusiveSynchronizationContext oldEx =
old as ExclusiveSynchronizationContext;
if (null != oldEx)
{
this._items = oldEx._items;
}
else
{
this._items = new EventQueue();
}
}
public void NoOverlap()
{
var r = new ExclusiveSynchronizationContext();
var n = 0;
for (var i = 0; i < 1000; i++)
{
r.Post(z => {
Assert.IsTrue(Interlocked.Increment(ref n) == 1);
Assert.IsTrue(Interlocked.Decrement(ref n) == 0);
}, null);
}
var a = new TaskCompletionSource();
r.Post(z => a.SetRanToCompletion(), null);
a.Task.AssertRanToCompletion();
}
public static T RunSync <T>(Func <Task <T> > task)
{
var result = default(T);
Stopwatch sp = Stopwatch.StartNew();
var oldContext = SynchronizationContext.Current;
try
{
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
result = await task().ConfigureAwait(false);
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
sp.Stop();
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
}
catch (AggregateException ex)
{
var exception = ex.ExtractSingleInnerException();
if (exception is OperationCanceledException)
{
throw new TimeoutException("Operation timed out after: " + sp.Elapsed, ex);
}
ExceptionDispatchInfo.Capture(exception).Throw();
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldContext);
}
return(result);
}
public static T RunSync <T>(Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await task();
}
catch (Exception e)
{
try
{
var exc = ((IoTConnect.Model.IoTConnectException)e);
if (exc != null && exc.error != null)
{
synch.InnerException = new Exception(exc.error.FirstOrDefault().Message);
}
else
{
synch.InnerException = new Exception(e.InnerException.Message);
}
throw;
}
catch (Exception ex)
{
synch.InnerException = new Exception(e.Message);
throw;
}
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
public void NoInterference()
{
var r = new ExclusiveSynchronizationContext();
var n = 0;
var t = Task.WhenAll(Enumerable.Range(0, 5).Select(async e => await Task.Factory.StartNew(() => {
for (var i = 0; i < 500; i++)
{
r.Post(z => {
n += 1;
}, null);
}
var a = new TaskCompletionSource();
r.Post(z => a.SetRanToCompletion(), null);
a.Task.AssertRanToCompletion();
})));
t.AssertRanToCompletion(timeout: TimeSpan.FromSeconds(20)); // lots of work, long timeout
Assert.IsTrue(n == 500 * 5);
}
public static ServiceReturn <List <ScheduledAppointment> > RunSync(Func <Task <List <ScheduledAppointment> > > task)
{
#region uimessage
var uiMessages = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(""))
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, "");
}
else
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, "Erro ao concluir a marcação");
}
if (!string.IsNullOrEmpty(""))
{
uiMessages.Add(ServiceReturnHandling.SuccessMessageKey, "");
}
#endregion
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
List <ScheduledAppointment> ret = default(List <ScheduledAppointment>);
synch.Post(async _ =>
{
try
{
ret = await task();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ServiceReturnHandling.BuildSuccessCallReturn <List <ScheduledAppointment> >(ret, uiMessages));
}
/// <summary>
/// GetSpecialtyByID -> Sincrono
/// Usado para ir buscar a especialidade no caso do utilizador selecionar primeiro o ato médico
/// </summary>
/// <param name="task"></param>
/// <returns>Returna uma especialidade</returns>
public static ServiceReturn <Specialty> RunSync(Func <Task <ServiceReturn <Specialty> > > task)
{
#region uimessage
var uiMessages = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(""))
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, "");
}
else
{
uiMessages.Add(ServiceReturnHandling.GenericMessageKey, "Erro ao obter a especialidade");
}
if (!string.IsNullOrEmpty(""))
{
uiMessages.Add(ServiceReturnHandling.SuccessMessageKey, "");
}
#endregion
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
ServiceReturn <Specialty> ret = default(ServiceReturn <Specialty>);
synch.Post(async _ =>
{
try
{
ret = await task();
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);//ServiceReturnHandling.BuildSuccessCallReturn<Specialty>(ret, uiMessages);
}
public static void Run(Func <Task> item)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await item();
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
}
/// <summary>
/// Execute's an async Task<T> method which has a T return type synchronously
/// </summary>
/// <typeparam name="T">Return Type</typeparam>
/// <param name="task">Task<T> method to execute</param>
/// <returns></returns>
public static T RunSync <T>(Func <Task <T> > task, int timeout)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
if (timeout == 0)
{
ret = await task();
}
else
{
var t = task();
var res = await Task.WhenAny(t, Task.Delay(timeout));
if (res != t)
{
throw new TaskCanceledException();
}
ret = t.Result;
}
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
/// <summary>
/// Выполняет задачу синхронно
/// </summary>
/// <typeparam name="T">Тип объекта, который возвращает задача</typeparam>
/// <param name="task">задача</param>
/// <returns>Объект, который вернула задача</returns>
public static T RunSync <T>([NotNull] Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
try
{
SynchronizationContext.SetSynchronizationContext(synch);
var ret = default(T);
synch.Post(async _ =>
{
try
{
var running = task();
if (running == null)
{
throw new NullReferenceException("task");
}
ret = await running;
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
return(ret);
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldContext);
}
}
/// <summary>
/// 同步调用异步方法并避免死锁，https://github.com/tejacques/AsyncBridge
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="task"></param>
/// <returns></returns>
public static T RunSync <T>(this Func <Task <T> > task)
{
var oldContext = SynchronizationContext.Current;
var currentContext = new ExclusiveSynchronizationContext(oldContext);
SynchronizationContext.SetSynchronizationContext(currentContext);
T result = default(T);
try
{
currentContext.Post(async _ =>
{
try
{
result = await task();
}
catch (Exception e)
{
currentContext.InnerException = e;
}
finally
{
currentContext.EndMessageLoop();
}
}, null);
currentContext.BeginMessageLoop();
}
catch (AggregateException e)
{
throw e?.InnerException ?? e;
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldContext);
}
return(result);
}
public static T Run <T>(Func <Task <T> > item)
{
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
T ret = default(T);
synch.Post(async _ =>
{
try
{
ret = await item();
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
return(ret);
}
public static void RunSync(Func <Task> task)
{
logger.DebugLog("Start AsyncHelpers");
var oldContext = SynchronizationContext.Current;
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await task();
}
catch (Exception e)
{
var exc = ((IoTConnect.Model.IoTConnectException)e);
if (exc != null && exc.error != null)
{
synch.InnerException = new Exception(exc.error.FirstOrDefault().Message);
}
else
{
synch.InnerException = new Exception(e.InnerException.Message);
}
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
SynchronizationContext.SetSynchronizationContext(oldContext);
}
public static void RunSync(Func <Task> task)
{
var oldContext = SynchronizationContext.Current;
try
{
var synch = new ExclusiveSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synch);
synch.Post(async _ =>
{
try
{
await task().ConfigureAwait(false);
}
catch (Exception e)
{
synch.InnerException = e;
throw;
}
finally
{
synch.EndMessageLoop();
}
}, null);
synch.BeginMessageLoop();
}
catch (AggregateException ex)
{
var exception = ex.ExtractSingleInnerException();
ExceptionDispatchInfo.Capture(exception).Throw();
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldContext);
}
}
public SyncRunnerScope()
{
_oldContext = SynchronizationContext.Current;
_currentContext = new ExclusiveSynchronizationContext(_oldContext);
SynchronizationContext.SetSynchronizationContext(_currentContext);
}
private AsyncRunner()
{
OldContext = SynchronizationContext.Current;
CurrentContext = new ExclusiveSynchronizationContext(OldContext);
SynchronizationContext.SetSynchronizationContext(CurrentContext);
}
