public static void BeginInvoke(this Control control, Action action)
{
if (control.InvokeRequired)
control.BeginInvoke(action);
else
action();
}
public static void SafeInvoke(this Control ui_element,
Action updater, bool force_synchronous)
{
if (ui_element == null)
return;
if (ui_element.InvokeRequired) {
if (force_synchronous) {
ui_element.Invoke ((Action) delegate {
SafeInvoke (ui_element, updater, force_synchronous);
});
} else {
ui_element.BeginInvoke ((Action) delegate {
SafeInvoke (ui_element, updater, force_synchronous);
});
}
} else {
if (ui_element.IsDisposed)
throw new ObjectDisposedException ("Control is already disposed.");
updater ();
}
}
public static void Invoke(this Control uiElement, Action updater, bool forceSynchronous = true)
{
if (uiElement == null)
{
throw new ArgumentNullException("uiElement");
}
if (uiElement.InvokeRequired)
{
if (forceSynchronous)
{
try
{
uiElement.Invoke((Action)delegate { Invoke(uiElement, updater, forceSynchronous); });
}
catch (Exception e) { }
}
else
{
uiElement.BeginInvoke((Action)delegate { Invoke(uiElement, updater, forceSynchronous); });
}
}
else
{
if (!uiElement.IsDisposed)
{
updater();
}
}
}
public static void Invoke(this UserControl c, Action a)
{
if (!c.InvokeRequired)
a();
else if (!c.IsDisposed && !c.Disposing && c.Created)
c.BeginInvoke(a);
}
/*
* Executes the action asynchronously on the UI thread, without blocking the calling thread.
*/
internal static void InvokeOnUiThreadIfRequired(this Control control, Action action) {
if(control.InvokeRequired) {
control.BeginInvoke(action);
} else {
action.Invoke();
}
}
/// <summary>
/// Executes the specified action asynchronously on the thread the Dispatcher is associated with, after the specified timeout.
/// </summary>
/// <param name="dispatcher">The dispatcher instance.</param>
/// <param name="timeout">The <see cref="TimeSpan"/> representing the amount of time to delay before the action is invoked.</param>
/// <param name="action">The <see cref="Action"/> to execute.</param>
public static void BeginInvokeAfterTimeout(this Dispatcher dispatcher, TimeSpan timeout, Action action)
{
if (!dispatcher.CheckAccess())
{
dispatcher.BeginInvoke(() => dispatcher.BeginInvokeAfterTimeout(timeout, action));
}
else
{
var dispatcherTimer = new DispatcherTimer()
{
Interval = timeout
};
dispatcherTimer.Tick += (s, e) =>
{
dispatcherTimer.Stop();
dispatcherTimer = null;
action();
};
dispatcherTimer.Start();
}
}
public static void FireAndForget(this Action action, object state = null)
{
lock (_invokedActions)
{
_invokedActions.Add(action.BeginInvoke(Forget, state), action);
}
}
/// <summary>
/// A simple threading extension method, to invoke a delegate
/// on the correct thread asynchronously if it is not currently
/// on the correct thread which can be used with DispatcherObject types.
/// </summary>
/// <param name="dispatcher">The Dispatcher object on which to
/// perform the Invoke</param>
/// <param name="action">The delegate to run</param>
public static void InvokeAsynchronouslyInBackground(this Dispatcher dispatcher, Action action)
{
if (dispatcher != null)
dispatcher.BeginInvoke(DispatcherPriority.Background, action);
else
action();
}
/// <summary>
/// Функция упрощающая использование Invoke() для Windows Forms приложений
/// </summary>
/// <param name="ctrl">Элемент управления для которого необходимо вызвать Invoke()</param>
/// <param name="cmd"></param>
/// <example>myCtrl.SafeInvoke(() => myCtrl.Enabled = false);</example>
public static void SafeInvoke(this Control ctrl, Action cmd)
{
if (ctrl.InvokeRequired)
ctrl.BeginInvoke(cmd);
else
cmd();
}
public static void PerformOnMainThread(this Control control, Action action)
{
if (control.InvokeRequired)
control.BeginInvoke(action);
else
action();
}
/// <summary>
/// Set text to the control thread-safely.
/// </summary>
/// <param name="c"></param>
/// <param name="m"></param>
public static void SetText(this Control c, string m)
{
if (c.InvokeRequired)
c.BeginInvoke(new MethodInvoker(() => { c.Text = m; }));
else
c.Text = m;
}
public static void adoptAsync(this Dispatcher dispatcher, Action del)
{
if(dispatcher.CheckAccess())
del();
else
dispatcher.BeginInvoke(del);
}
public static void adoptAsync(this Dispatcher dispatcher, Action del)
{
if (Thread.CurrentThread == dispatcher.Thread)
del();
else
dispatcher.BeginInvoke(del);
}
public static void BeginInvoke(this Control c, MethodInvoker code)
{
//c.BeginInvoke(code);
if (c.InvokeRequired)
c.BeginInvoke(code);
else
c.Invoke(code);
}
public static void BeginInvokeIfRequired(this Control control, MethodInvoker action)
{
if (control.InvokeRequired) {
control.BeginInvoke(action);
} else {
action();
}
}
public static void BeginInvoke(this Form window, Action action)
{
if (window.IsDisposed || !window.IsHandleCreated)
{
return;
}
window.BeginInvoke(new BeginInvokeDelegate(action));
}
public static void InvokeOrExecute(this Dispatcher dispatcher, Action action)
{
if (dispatcher.CheckAccess()) {
action();
} else {
dispatcher.BeginInvoke(DispatcherPriority.Normal, action);
}
}
/// <summary>
/// Executes the Action asynchronously on the UI thread, does not block execution on the calling thread.
/// </summary>
/// <param name="control"></param>
/// <param name="code"></param>
public static void UIThread(this Control @this, Action code)
{
if (@this.InvokeRequired) {
@this.BeginInvoke(code);
} else {
code.Invoke();
}
}
public static DispatcherOperation BeginInvoke(
this IDispatcherService dispatcher,
Action action,
DispatcherPriority priority
)
{
return dispatcher.BeginInvoke(action, priority);
}
public static void DoEvents(this Dispatcher dispatcher)
{
var frame = new DispatcherFrame();
dispatcher.BeginInvoke(
DispatcherPriority.Background,
new DispatcherOperationCallback(ExitFrame),
frame);
Dispatcher.PushFrame(frame);
}
public static void UiThread(this Control control, Action action)
{
if (control.InvokeRequired)
{
control.BeginInvoke(action);
return;
}
action.Invoke();
}
public static void BeginInvokeIfRequired(this Form f, Action a)
{
if (f.InvokeRequired)
{
f.BeginInvoke(a);
return;
}
a();
}
public static PageAsyncTask ToPageAsyncTask(this Func<CancellationToken, Task> func)
{
var cts = new CancellationTokenSource();
return new PageAsyncTask(
(sender, e, cb, extraData) => func.BeginInvoke(cts.Token, cb, extraData),
ar => func.EndInvoke(ar).Wait(),
ar => cts.Cancel(),
null);
}
public static void UIThread(this Control control, Action code)
{
if (control.InvokeRequired)
{
control.BeginInvoke(code);
return;
}
code.Invoke();
}
private static void Do(this Dispatcher dispatcher, Action action)
{
if (!dispatcher.CheckAccess())
{
dispatcher.BeginInvoke(action, DispatcherPriority.Background);
return;
}
action();
}
/// <summary>
/// Executes the specified action with the specified arguments synchronously on the thread the Dispatcher is associated with.
/// </summary>
/// <param name="dispatcher">The dispatcher.</param>
/// <param name="action">The action.</param>
/// <exception cref="ArgumentNullException">The <paramref name="action" /> is <c>null</c>.</exception>
/// <remarks>For target frameworks where the <see cref="Dispatcher" /> class does not contain the <c>Invoke</c> method, the <c>BeginInvoke</c>
/// method will be used instead.</remarks>
public static void Invoke(this Dispatcher dispatcher, Action action)
{
Argument.IsNotNull("action", action);
if (dispatcher != null && !dispatcher.CheckAccess())
{
#if NET
dispatcher.Invoke(action, null);
#elif NETFX_CORE
dispatcher.BeginInvoke(action);
#else
dispatcher.BeginInvoke(action);
#endif
}
else
{
action.Invoke();
}
}
/// <summary>
/// Run all outstanding events queued on the provided Dispatcher
/// </summary>
/// <param name="dispatcher"></param>
public static void DoEvents(this Dispatcher dispatcher)
{
var frame = new DispatcherFrame();
Action<DispatcherFrame> action = _ => { frame.Continue = false; };
dispatcher.BeginInvoke(
DispatcherPriority.SystemIdle,
action,
frame);
Dispatcher.PushFrame(frame);
}
public static void Invoke(this Forms.Control me, Action action)
{
if (me.InvokeRequired)
{
try { me.BeginInvoke((Delegate)action); }
catch (System.InvalidOperationException) { }
}
else
action();
}
/// <summary>
/// Executes the specified delegate with the specified arguments synchronously on the thread the Dispatcher is associated with.
/// </summary>
/// <param name="dispatcher">The dispatcher.</param>
/// <param name="method">A delegate to a method that takes parameters specified in args, which is pushed onto the Dispatcher event queue.</param>
/// <param name="args">An array of objects to pass as arguments to the given method. Can be <c>null</c>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="method" /> is <c>null</c>.</exception>
/// <remarks>For target frameworks where the <see cref="Dispatcher" /> class does not contain the <c>Invoke</c> method, the <c>BeginInvoke</c>
/// method will be used instead.</remarks>
public static void Invoke(this Dispatcher dispatcher, Delegate method, params object[] args)
{
Argument.IsNotNull("method", method);
if (dispatcher != null && !dispatcher.CheckAccess())
{
#if NET
dispatcher.Invoke(method, args);
#elif NETFX_CORE
dispatcher.BeginInvoke(() => method.DynamicInvoke(args));
#else
dispatcher.BeginInvoke(method, args);
#endif
}
else
{
method.DynamicInvoke(args);
}
}
public static async Task InvokeAsync(this Dispatcher source, Action action)
{
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
source.BeginInvoke(() =>
{
action();
tcs.SetResult(null);
});
await tcs.Task;
}