/// <summary>
/// Does something on threadpool, executes continuation on current sync context thread, executes onError if the async request fails.
/// There does probably exist something like this in the .NET library, but I could not find it. //cocytus
/// </summary>
/// <typeparam name="T">Result to be passed from doMe to continueWith</typeparam>
/// <param name="doMe">The stuff we want to do. Should return whatever continueWith expects.</param>
/// <param name="continueWith">Do this on original sync context.</param>
/// <param name="onError">Do this on original sync context if doMe barfs.</param>
public static Task <T> DoAsync <T>(Func <T> doMe, Action <T> continueWith, Action <AsyncErrorEventArgs> onError)
{
AsyncLoader loader = new AsyncLoader();
loader.LoadingError += (sender, e) => onError(e);
return(loader.Load(doMe, continueWith));
}
/// <summary>
/// Invokes <paramref name="loadContent"/> on the thread pool, then executes <paramref name="continueWith"/> on the current synchronisation context.
/// </summary>
/// <remarks>
/// Note this method does not perform any cancellation of prior loads, nor does it support cancellation upon disposal.
/// If you require those features, use an instance of <see cref="AsyncLoader"/> instead.
/// </remarks>
/// <typeparam name="T">Type of data returned by <paramref name="loadContent"/> and accepted by <paramref name="continueWith"/>.</typeparam>
/// <param name="loadContent">A function to invoke on the thread pool that returns a value to be passed to <paramref name="continueWith"/>.</param>
/// <param name="continueWith">An action to invoke on the original synchronisation context with the return value from <paramref name="loadContent"/>.</param>
/// <param name="onError">
/// An optional callback for notification of exceptions from <paramref name="loadContent"/>.
/// Invoked on the original synchronisation context.
/// Invoked once per exception, so may be called multiple times.
/// Handlers must set <see cref="AsyncErrorEventArgs.Handled"/> to <c>true</c> to prevent any exceptions being re-thrown and faulting the async operation.
/// </param>
public static async Task <T> DoAsync <T>(Func <T> loadContent, Action <T> continueWith, Action <AsyncErrorEventArgs> onError = null)
{
using (var loader = new AsyncLoader())
{
if (onError != null)
{
loader.LoadingError += (_, e) => onError(e);
}
return(await loader.LoadAsync(loadContent, continueWith).ConfigureAwait(false));
}
}
public static Task DoAsync(Action doMe, Action continueWith)
{
AsyncLoader loader = new AsyncLoader();
return(loader.Load(doMe, continueWith));
}
public static Task <T> DoAsync <T>(Func <T> doMe, Action <T> continueWith)
{
AsyncLoader loader = new AsyncLoader();
return(loader.Load(doMe, continueWith));
}
public static void DoAsync <T>(Func <T> doMe, Action <T> continueWith)
{
AsyncLoader loader = new AsyncLoader();
loader.Load(doMe, continueWith);
}
public static void DoAsync(Action doMe, Action continueWith)
{
AsyncLoader loader = new AsyncLoader();
loader.Load(doMe, continueWith);
}