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; }