/// <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>
/// 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>
/// 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>
/// 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 new 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);
}
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<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 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);
}
}
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 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);
}
/// <summary>
/// Execute's an async task with a void return type
/// from a synchronous context
/// </summary>
/// <param name="task">Task to execute</param>
/// <param name="callback">Optional callback</param>
public void Run(Task task, Action <Task> callback = null)
{
CurrentContext.Post(async _ =>
{
try
{
Increment();
await task;
callback?.Invoke(task);
}
catch (Exception e)
{
CurrentContext.InnerException = e;
}
finally
{
Decrement();
}
}, null);//new object()
}
/// <summary>
/// Execute's an async task with a void return type
/// from a synchronous context
/// </summary>
/// <param name="task">Task to execute</param>
/// <param name="callback">Optional callback</param>
public void Run(Task task, Action <Task> callback = null)
{
CurrentContext.Post(async _ =>
{
try
{
Increment();
await task;
if (null != callback)
{
callback(task);
}
}
catch (Exception e)
{
CurrentContext.InnerException = e;
}
finally
{
Decrement();
}
}, null);
}
/// <summary>
/// Execute's an async task with a void return type
/// from a synchronous context
/// </summary>
/// <param name="task">Task to execute</param>
/// <param name="callback">Optional callback</param>
public void Run(Task task, Action <Task> callback = null)
{
_hasAsyncTasks = true;
_currentContext.Post(
async _ => {
try {
Increment();
await task.ConfigureAwait(true);
callback?.Invoke(task);
} catch (Exception e) {
_currentContext.InnerException = e;
} finally {
Decrement();
}
},
null);
}
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 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>
/// Execute's an async task with a void return type
/// from a synchronous context
/// </summary>
/// <param name="task">Task to execute</param>
/// <param name="callback">Optional callback</param>
public void Run(Task task, Action <Task> callback = null)
{
_currentContext.Post(async _ =>
{
try
{
Increment();
await task;
callback?.Invoke(task);
}
catch (Exception e)
{
_currentContext.InnerException = ExceptionDispatchInfo.Capture(e);
}
finally
{
Decrement();
}
}, null);
}
/// <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);
}
/// <summary>
/// Executes an async Task method which has a void return value synchronously
/// </summary>
/// <param name="task">Task execute</param>
public void RunSync(Task task, Action <Task> continuation = null)
{
_currentContext.Post(async _ =>
{
try
{
Increment();
await task;
continuation?.Invoke(task);
}
catch (Exception e)
{
_currentContext.InnerException = e;
}
finally
{
Decrement();
}
}, null);
_currentContext.BeginMessageLoop();
}
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);
}
}