public static void InvokeOnGui(this DispatcherObject application, DispatcherPriority priority, Action action)
{
Safeguard.EnsureNotNull("application", application);
Safeguard.EnsureNotNull("action", action);
Dispatcher dispatcher = application.Dispatcher;
if (dispatcher == null || dispatcher.CheckAccess())
{
action();
}
else
{
dispatcher.Invoke(priority, action);
}
}
/// <summary>
/// Executes the specified <see cref="Action"/> asynchronously on the
/// thread the <see cref="Dispatcher"/> is associated with.
/// </summary>
/// <param name="dispatcherObject">The dispatcher object, usually a UI control to use for thread-safe invocation</param>
/// <param name="action">The delegate to invoke through the dispatcher.</param>
public static void CheckAndBeginInvoke(this DispatcherObject dispatcherObject, Action action)
{
if (dispatcherObject != null)
{
var dispatcher = dispatcherObject.Dispatcher;
if (dispatcher.CheckAccess())
{
action();
}
else
{
dispatcher.BeginInvoke(action);
}
}
}
protected virtual void DispatchOnPropertyChanged(DispatcherObject obj, object sender, DispatcherPriority priority = DispatcherPriority.Normal, [CallerMemberName] string name = null)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var dispatcher = obj?.Dispatcher ?? Dispatcher.CurrentDispatcher;
if (dispatcher == null || dispatcher.HasShutdownStarted || dispatcher.HasShutdownFinished)
{
return;
}
dispatcher.Invoke(() => OnPropertyChanged(sender, new PropertyChangedEventArgs(name)), priority);
}
public static void InvokeAsync(DispatcherObject dispatcherObject, Action action, DispatcherPriority priority = DispatcherPriority.Normal, AsyncInvokeMode mode = AsyncInvokeMode.AsyncOnly)
{
if (dispatcherObject == null || dispatcherObject.Dispatcher == null)
{
return;
}
if (mode == AsyncInvokeMode.AllowSyncInvoke && dispatcherObject.Dispatcher.CheckAccess())
{
action.Invoke();
}
else
{
dispatcherObject.Dispatcher.BeginInvoke(action, priority);
}
}
/// <summary>
/// ListBoxLogMessageAdd
/// </summary>
/// <param name="message"></param>
/// <param name="color"></param>
public void ListBoxLogMessageAdd(string message, System.Windows.Media.Brush color)
{
if (DispatcherObject.Thread != Thread.CurrentThread)
{
DispatcherObject.Invoke(new DMessageAdd(ListBoxLogMessageAdd), DispatcherPriority.ApplicationIdle, message, color);
}
else
{
MessageList.Add(new ListBoxLogMessageString(String.Format("{0} {1}", ++_counter, message), color, FontWeights.Normal, 14));
listBox_LogMessages.SelectedIndex = listBox_LogMessages.Items.Count - 1;
listBox_LogMessages.ScrollIntoView(listBox_LogMessages.SelectedItem);
if (MessageList.Count > MAX_MESSGAES)
{
MessageList.RemoveAt(0);
}
}
}
public static void Invoke(Action action)
{
DispatcherObject dispatcher =
Application.Current;
if (dispatcher == null ||
dispatcher.CheckAccess() ||
dispatcher.Dispatcher == null
)
{
action();
}
else
{
SafeInvoke(action);
}
}
public static void RunOnUIThread(this DispatcherObject d, Action action)
{
Dispatcher dispatcher = d?.Dispatcher;
if (dispatcher == null)
{
return;
}
if (dispatcher.CheckAccess())
{
action();
}
else
{
dispatcher.BeginInvoke((Delegate)action, Array.Empty <object>());
}
}
/// <summary>
/// 不会重复的行为，短时间内双击等操作都不会重复触发行为
/// </summary>
/// <param name="obj"></param>
/// <param name="action"></param>
public static void NotRepeatedAction(this DispatcherObject obj, Guid actionId, Action <Action> action)
{
EventProtector <Action> protector = null;
if (!_protectors.TryGetValue(actionId, out protector))
{
lock (_protectors)
{
if (!_protectors.TryGetValue(actionId, out protector))
{
protector = new EventProtector <Action>();
_protectors.Add(actionId, protector);
}
}
}
protector.Start(action, () => { protector.End(); });
}
/// <summary>
/// Returns a dispatcher for multi-threaded scenarios
/// </summary>
/// <returns></returns>
internal static Dispatcher GetDispatcher(this DispatcherObject source)
{
//use the application's dispatcher by default
if (Application.Current != null)
{
return(Application.Current.Dispatcher);
}
//fallback for WinForms environments
if (source.Dispatcher != null)
{
return(source.Dispatcher);
}
//ultimatively use the thread's dispatcher
return(Dispatcher.CurrentDispatcher);
}
protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs args)
{
if (this.CollectionChanged != null)
{
foreach (NotifyCollectionChangedEventHandler handler in this.CollectionChanged.GetInvocationList())
{
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;
if (dispatcherObject != null)
{
dispatcherObject.Dispatcher.Invoke(handler, handler, args);
}
else
{
handler(handler, args);
}
}
}
}
protected virtual void OnPropertyChanged(DispatcherObject obj, object sender, [CallerMemberName] string name = null)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
var dispatcher = obj?.Dispatcher ?? Dispatcher.CurrentDispatcher;
if (dispatcher != null && !dispatcher.CheckAccess())
{
dispatcher.Invoke(() => OnPropertyChanged(sender, new PropertyChangedEventArgs(name)));
}
else
{
OnPropertyChanged(sender, new PropertyChangedEventArgs(name));
}
}
public static T Invoke <T>([NotNull] this DispatcherObject dispatcherObject, [NotNull] Func <T> func)
{
if (dispatcherObject == null)
{
throw new ArgumentNullException(nameof(dispatcherObject));
}
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
if (dispatcherObject.Dispatcher.CheckAccess())
{
return(func());
}
return((T)dispatcherObject.Dispatcher.Invoke(func));
}
/// <summary>
/// WPF使用的带异常处理的BeginInvoke
/// </summary>
public static void TryBeginInvoke(this DispatcherObject ctrl, Action action, Action <Exception> errorAction = null)
{
ctrl.Dispatcher.BeginInvoke(new Action(() =>
{
try
{
action();
}
catch (Exception ex)
{
if (errorAction != null)
{
errorAction(ex);
}
LogUtil.Error(ex);
}
}));
}
public static void DispatcherInvoke <T>(this DispatcherObject dispatcherObj, Action <T> action, T param)
{
if (!dispatcherObj.Dispatcher.CheckAccess())
{
dispatcherObj.Dispatcher.Invoke(new DispatcherInvokeOneParamActionDelegate <T>(DispatcherInvoke), dispatcherObj, action, param);
}
else
{
try
{
action(param);
}
catch (Exception e)
{
Logger.Error("DispatcherInvoke - error while action execution", e);
}
}
}
public static T Invoke <T>(this DispatcherObject dispatcher, Func <T> func)
{
try
{
if (dispatcher.CheckAccess())
{
return(func());
}
else
{
return(dispatcher.Dispatcher.Invoke(func));
}
}
catch (TaskCanceledException ex)
{
Console.WriteLine(ex);
Console.WriteLine("执行代码中,控件可能已释放...");
return(default);
/// <summary>
/// Checks if to CAO have the same context affinity. This is for example important for
/// ContainerVisual.Children.Add to ensure that the scene graph is homogenously build out
/// of object that have the same context affinity.
/// </summary>
/// <param name="reference">Reference to which to compare to. This argument is usually the this
/// pointer and can not be null.</param>
/// <param name="other">Object for which the check is performed.</param>
/// <remarks>
/// Example:
///
/// class Visual
/// {
/// ...
/// void Add(Visual child)
/// {
/// VerifyContext(this);
/// AssertSameContext(this, child);
/// ...
/// }
/// }
///
/// Note that VerifyContext(A) AND AssertSameContext(A, B) implies that VerifyContext(B) holds. Hence you
/// don't need to check the context for each argument if you assert the same context.
/// </remarks>
internal static void AssertSameContext(
DispatcherObject reference,
DispatcherObject other)
{
Debug.Assert(reference != null, "The reference object can not be null.");
// DispatcherObjects may be created with the option of becoming unbound.
// An unbound DO may be created without a Dispatcher or may detach from
// its Dispatcher (e.g., a Freezable). Unbound DOs return null for their
// Dispatcher and should be accepted anywhere.
if (other != null &&
reference.Dispatcher != null &&
other.Dispatcher != null &&
reference.Dispatcher != other.Dispatcher)
{
throw new ArgumentException(SR.Get(SRID.MediaSystem_ApiInvalidContext));
}
}
/// <summary>
/// Overriden for speed improvements, see: http://shevaspace.spaces.live.com/Blog/cns!FD9A0F1F8DD06954!547.entry
/// </summary>
/// <param name="e"></param>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
if (this.CollectionChanged != null)
{
using (IDisposable disposable = this.BlockReentrancy())
{
foreach (Delegate del in this.CollectionChanged.GetInvocationList())
{
NotifyCollectionChangedEventHandler handler = (NotifyCollectionChangedEventHandler)del;
DispatcherObject dispatcherInvoker = del.Target as DispatcherObject;
ISynchronizeInvoke syncInvoker = del.Target as ISynchronizeInvoke;
if (dispatcherInvoker != null)
{
// We are running inside DispatcherSynchronizationContext,
// so we should invoke the event handler in the correct dispatcher.
dispatcherInvoker.Dispatcher.Invoke(DispatcherPriority.Normal, new ThreadStart(delegate
{
try
{
handler(this, e);
}
catch (Exception)
{
// MWA: Swallow the exception here because it usually is the result of something else
}
}));
}
else if (syncInvoker != null)
{
// We are running inside WindowsFormsSynchronizationContext,
// so we should invoke the event handler in the correct context.
syncInvoker.Invoke(del, new Object[] { this, e });
}
else
{
// We are running in free threaded context, so just directly invoke the event handler.
handler(this, e);
}
}
}
}
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
}
public static void DoEvents(this DispatcherObject obj, DispatcherPriority dispatcherPriority)
{
if (!obj.Dispatcher.CheckAccess())
{
#if DEBUG
Debugger.Break();
#endif
//new ThreadStart();
obj.Dispatcher.Invoke(DispatcherPriority.Normal, (Action <UIElement, DispatcherPriority>)DoEvents, obj, dispatcherPriority);
return;
}
obj.Dispatcher.Invoke(dispatcherPriority, EmptyDelegate);
//var frame = new DispatcherFrame();
//obj.Dispatcher.BeginInvoke(dispatcherPriority,
// new ExitFrameHandler(frm => frm.Continue = false), frame);
//Dispatcher.PushFrame(frame); // blocks until Continue == false, which happens only when all operations with priority greater than Background have been processed by the Dispatcher.
}
public static T InvokeIfNecessary <T>(this DispatcherObject dispatcherObject, Func <T> func)
{
if (dispatcherObject == null)
{
throw new ArgumentNullException(nameof(dispatcherObject));
}
if (func == null)
{
throw new ArgumentNullException(nameof(func));
}
if (dispatcherObject.Dispatcher.CheckAccess())
{
return(func());
}
else
{
return((T)dispatcherObject.Dispatcher.Invoke(func));
}
}
public static void RunInBackground(Action backgroundAction, DispatcherObject control, Action uiAction)
{
BackgroundWorker bgWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = false
};
var arg = new RunInBackgroundArgument()
{
Control = control,
BackgroundAction = backgroundAction,
UIAction = uiAction
};
bgWorker.DoWork += RunInBackground_DoWork;
bgWorker.RunWorkerCompleted += RunInBackground_RunWorkerComplete;
bgWorker.RunWorkerAsync(arg);
}
internal void RemoveOwner(DispatcherObject owner)
{
UIElement frameworkElement = owner as UIElement;
if (frameworkElement != null && this.ownerFEs != null)
{
this.ownerFEs.Remove(frameworkElement);
if (this.ownerFEs.Count == 0)
{
this.ownerFEs = null;
}
}
if (owner == this.inheritanceContext)
{
this.RemoveInheritanceContextFromValues();
this.inheritanceContext = null;
}
this.RemoveOwnerFromAllMergedDictionaries(owner);
}
public static void Invoke([NotNull] this DispatcherObject dispatcherObject, [NotNull] Action invokeAction)
{
if (dispatcherObject == null)
{
throw new ArgumentNullException(nameof(dispatcherObject));
}
if (invokeAction == null)
{
throw new ArgumentNullException(nameof(invokeAction));
}
if (dispatcherObject.Dispatcher.CheckAccess())
{
invokeAction();
}
else
{
dispatcherObject.Dispatcher.Invoke(invokeAction);
}
}
/// <summary>
/// This collection changed event performs thread safe event raising.
/// </summary>
/// <param name="e">The event argument.</param>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
// Recommended is to avoid reentry
// in collection changed event while collection
// is getting changed on other thread.
using (BlockReentrancy())
{
if (!this.suspendCollectionChangeNotification)
{
NotifyCollectionChangedEventHandler eventHandler =
this.CollectionChanged;
if (eventHandler == null)
{
return;
}
// Walk thru invocation list.
Delegate[] delegates = eventHandler.GetInvocationList();
foreach
(NotifyCollectionChangedEventHandler handler in delegates)
{
// If the subscriber is a DispatcherObject and different thread.
DispatcherObject dispatcherObject
= handler.Target as DispatcherObject;
if (dispatcherObject != null &&
!dispatcherObject.CheckAccess())
{
// Invoke handler in the target dispatcher's thread...
// asynchronously for better responsiveness.
dispatcherObject.Dispatcher.BeginInvoke
(DispatcherPriority.DataBind, handler, this, e);
}
else
{
// Execute handler as is.
handler(this, e);
}
}
}
}
}
string WpfToXaml(DispatcherObject dispObj)
{
if (dispObj != null)
{
// Get the XAML for the template.
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = new String(' ', 4);
settings.NewLineOnAttributes = true;
StringBuilder sb = new StringBuilder();
XmlWriter writer = XmlWriter.Create(sb, settings);
XamlWriter.Save(dispObj, writer);
return(sb.ToString());
}
else
{
return("NULL");
}
}
protected void OnFrameReady(IFrame frame)
{
if (FrameReady != null)
{
DeviceFrameReadyHandler eventHandler = FrameReady;
Delegate[] delegates = eventHandler.GetInvocationList();
foreach (DeviceFrameReadyHandler handler in delegates)
{
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, this, frame);
}
else
{
handler(this, frame);
}
}
}
}
public override void OnInvoke(MethodInterceptionArgs args)
{
DispatcherObject dispatcherObject = (DispatcherObject)args.Instance;
if (this.Async)
{
// Invoke the method asynchronously on the GUI thread.
dispatcherObject.Dispatcher.BeginInvoke(this.priority, new Action(args.Proceed));
}
else if (dispatcherObject.CheckAccess())
{
// We have access to the GUI object. Invoke the method synchronously.
args.Proceed();
}
else
{
// We don't have access to the GUI thread. Invoke the method synchronously on that thread.
dispatcherObject.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(args.Proceed));
}
}
private void OnBitmapFrameCaptured(BitmapFrame frame)
{
if (BitmapFrameCaptured != null)
{
BitmapFrameCapturedHandler eventHandler = BitmapFrameCaptured;
Delegate[] delegates = eventHandler.GetInvocationList();
foreach (BitmapFrameCapturedHandler handler in delegates)
{
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, frame);
}
else
{
handler(frame);
}
}
}
}
protected void OnButtonStateChanged(Button button, bool pressed)
{
if (ButtonStateChanged != null)
{
ButtonStateChangedHandler eventHandler = ButtonStateChanged;
Delegate[] delegates = eventHandler.GetInvocationList();
foreach (ButtonStateChangedHandler handler in delegates)
{
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, button, pressed);
}
else
{
handler(button, pressed);
}
}
}
}
public static void Invoke(DispatcherObject obj, Action action)
{
Debug.Assert(!obj.Dispatcher.CheckAccess( ));
try
{
obj.Dispatcher.Invoke(
() => Execute(action),
DispatcherPriority.Background);
}
catch (Exception exc)
{
_ = exc;
if (Debugger.IsAttached && !(exc is TaskCanceledException))
{
Debugger.Break( );
}
throw;
}
}
protected void OnControllerAxisChanged(ControllerJoystick joystick, ControllerJoystickAxis axis, byte oldValue, byte newValue)
{
if (AxisChanged != null)
{
ControllerAxisChangedHandler eventHandler = AxisChanged;
Delegate[] delegates = eventHandler.GetInvocationList();
foreach (ControllerAxisChangedHandler handler in delegates)
{
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, joystick, axis, oldValue, newValue);
}
else
{
handler(joystick, axis, oldValue, newValue);
}
}
}
}
