[1] Implement CancelDelayed() and PostDelayed() for DispatcherSynchronizationContext.

[2] Add DispatcherScheduledAction.

Author: hamster620

Avalonia.Tests/MainWindow.axaml.cs

@@ -4,13 +4,16 @@
 using Avalonia.Controls.Shapes;
 using Avalonia.Markup.Xaml;
 using Avalonia.Media;
+using Avalonia.Threading;
 using CarinaStudio.Controls;
 using CarinaStudio.Input.Platform;
+using CarinaStudio.Threading;
 using System;
+using System.Diagnostics;
 
 namespace CarinaStudio
 {
-    partial class MainWindow : Avalonia.Controls.Window
+    partial class MainWindow : Controls.Window
     {
         static readonly DirectProperty<MainWindow, DateTime?> DateTimeValueProperty = AvaloniaProperty.RegisterDirect<MainWindow, DateTime?>(nameof(DateTimeValue), 
             w => w.dateTimeValue, 
@@ -25,11 +28,23 @@ partial class MainWindow : Avalonia.Controls.Window
         DateTime? dateTimeValue = DateTime.Now;
         IPAddress? ipAddressObject = IPAddress.Loopback;
         string longText = "";
+        readonly DispatcherScheduledAction scheduledAction;
+        readonly Stopwatch stopwatch = new Stopwatch().Also(it => it.Start());
 
         public MainWindow()
         {
             this.RefreshLongText();
             AvaloniaXamlLoader.Load(this);
+
+            var startTime = 0L;
+            this.scheduledAction = new(this, () =>
+            {
+                var duration = (this.stopwatch.ElapsedMilliseconds - startTime);
+            }, DispatcherPriority.Send);
+
+            startTime = this.stopwatch.ElapsedMilliseconds;
+            this.scheduledAction.Schedule(5566);
+            //this.scheduledAction.Cancel();
         }
 
 

Avalonia/Threading/DispatcherScheduledAction.cs

@@ -0,0 +1,64 @@
+using Avalonia.Threading;
+using System;
+using System.Threading;
+
+namespace CarinaStudio.Threading;
+
+/// <summary>
+/// <see cref="ScheduledAction"/> which schedules the action with specific <see cref="DispatcherPriority"/>.
+/// </summary>
+public class DispatcherScheduledAction : ScheduledAction
+{
+    // Fields.
+    readonly DispatcherPriority priority;
+    
+    
+    /// <summary>
+    /// Initialize new <see cref="DispatcherScheduledAction"/> instance with <see cref="DispatcherPriority.Default"/> priority.
+    /// </summary>
+    /// <param name="synchronizationContext"><see cref="DispatcherSynchronizationContext"/> to perform action.</param>
+    /// <param name="action">Action.</param>
+    public DispatcherScheduledAction(DispatcherSynchronizationContext synchronizationContext, Action action) : this(synchronizationContext, action, DispatcherPriority.Default)
+    { }
+    
+    
+    /// <summary>
+    /// Initialize new <see cref="DispatcherScheduledAction"/> instance.
+    /// </summary>
+    /// <param name="synchronizationContext"><see cref="DispatcherSynchronizationContext"/> to perform action.</param>
+    /// <param name="action">Action.</param>
+    /// <param name="priority">Priority.</param>
+    public DispatcherScheduledAction(DispatcherSynchronizationContext synchronizationContext, Action action, DispatcherPriority priority) : base(synchronizationContext, action)
+    {
+        this.priority = priority;
+    }
+    
+    
+    /// <summary>
+    /// Initialize new <see cref="DispatcherScheduledAction"/> instance with <see cref="DispatcherPriority.Default"/> priority.
+    /// </summary>
+    /// <param name="synchronizable"><see cref="ISynchronizable"/> to provide <see cref="DispatcherSynchronizationContext"/> to perform action.</param>
+    /// <param name="action">Action.</param>
+    public DispatcherScheduledAction(ISynchronizable synchronizable, Action action) : this((DispatcherSynchronizationContext)synchronizable.SynchronizationContext, action, DispatcherPriority.Default)
+    { }
+
+
+    /// <summary>
+    /// Initialize new <see cref="DispatcherScheduledAction"/> instance.
+    /// </summary>
+    /// <param name="synchronizable"><see cref="ISynchronizable"/> to provide <see cref="DispatcherSynchronizationContext"/> to perform action.</param>
+    /// <param name="action">Action.</param>
+    /// <param name="priority">Priority.</param>
+    public DispatcherScheduledAction(ISynchronizable synchronizable, Action action, DispatcherPriority priority) : this((DispatcherSynchronizationContext)synchronizable.SynchronizationContext, action, priority)
+    { }
+
+
+    /// <inheritdoc/>
+    protected override bool CancelAction(object token) =>
+        ((DispatcherSynchronizationContext)this.SynchronizationContext).CancelDelayed(token);
+
+
+    /// <inheritdoc/>
+    protected override object PostAction(SendOrPostCallback action, object? state, int delayMillis) =>
+        ((DispatcherSynchronizationContext)this.SynchronizationContext).PostDelayed(action, state, this.priority, delayMillis);
+}

Avalonia/Threading/DispatcherSynchronizationContext.cs

@@ -9,6 +9,66 @@ namespace CarinaStudio.Threading;
 /// </summary>
 public class DispatcherSynchronizationContext : SynchronizationContext
 {
+    // Stub of delayed call-back.
+    class DelayedCallbackStub : IDelayedCallbackStub
+    {
+        // Fields.
+        readonly Action? actionCallback;
+        public readonly Dispatcher Dispatcher;
+        volatile bool isCancellable = true;
+        volatile bool isCancelled;
+        readonly DispatcherPriority priority;
+        readonly SendOrPostCallback? sendOrPostCallback;
+        readonly object? state;
+        
+        // Constructor.
+        public DelayedCallbackStub(Dispatcher dispatcher, Action action, DispatcherPriority priority)
+        {
+            this.actionCallback = action;
+            this.Dispatcher = dispatcher;
+            this.priority = priority;
+        }
+        public DelayedCallbackStub(Dispatcher dispatcher, SendOrPostCallback callback, object? state, DispatcherPriority priority)
+        {
+            this.Dispatcher = dispatcher;
+            this.priority = priority;
+            this.sendOrPostCallback = callback;
+            this.state = state;
+        }
+
+        /// <inheritdoc/>
+        void IDelayedCallbackStub.Callback() =>
+            this.Dispatcher.Post(this.CallbackEntry, this.priority);
+        
+        // Entry of call-back.
+        void CallbackEntry()
+        {
+            lock (this)
+            {
+                if (this.isCancelled)
+                    return;
+                this.isCancellable = false;
+            }
+            if (this.actionCallback is not null)
+                this.actionCallback();
+            else if (this.sendOrPostCallback is not null)
+                this.sendOrPostCallback(this.state);
+        }
+
+        /// <inheritdoc/>
+        bool IDelayedCallbackStub.Cancel()
+        {
+            lock (this)
+            {
+                if (this.isCancelled || !this.isCancellable)
+                    return false;
+                this.isCancelled = true;
+            }
+            return true;
+        }
+    }
+    
+    
     // Static fields.
     static volatile DispatcherSynchronizationContext? UIThreadInstance;
 
@@ -25,6 +85,23 @@ public DispatcherSynchronizationContext(Dispatcher dispatcher)
     {
         this.dispatcher = dispatcher;
     }
+    
+    
+    /// <summary>
+    /// Cancel posted delayed call-back.
+    /// </summary>
+    /// <param name="token">Token returned from <see cref="PostDelayed(SendOrPostCallback, object?, DispatcherPriority, int)"/> or <see cref="PostDelayed(Action, DispatcherPriority, int)"/>.</param>
+    /// <returns>True if call-back cancelled successfully.</returns>
+    public bool CancelDelayed(object token)
+    {
+        if (!DelayedCallbacks.TryGetCallbackStub(token, out var callbackStub)
+            || callbackStub is not DelayedCallbackStub delayedCallbackStub
+            || delayedCallbackStub.Dispatcher != this.dispatcher)
+        {
+            return false;
+        }
+        return DelayedCallbacks.Cancel(token);
+    }
 
 
     /// <summary>
@@ -76,6 +153,29 @@ public void Post(SendOrPostCallback d, object? state, DispatcherPriority priorit
     /// <param name="priority">Priority.</param>
     public void Post(Action action, DispatcherPriority priority) =>
         this.dispatcher.Post(action, priority);
+    
+    
+    /// <summary>
+    /// Post delayed call-back.
+    /// </summary>
+    /// <param name="callback">Call-back.</param>
+    /// <param name="priority">Priority.</param>
+    /// <param name="delayMillis">Delayed time in milliseconds.</param>
+    /// <returns>Token of posted delayed call-back.</returns>
+    public object PostDelayed(Action callback, DispatcherPriority priority, int delayMillis) =>
+        DelayedCallbacks.Schedule(new DelayedCallbackStub(this.dispatcher, callback, priority), delayMillis);
+
+
+    /// <summary>
+    /// Post delayed call-back.
+    /// </summary>
+    /// <param name="callback">Call-back.</param>
+    /// <param name="state">Custom state pass to call-back.</param>
+    /// <param name="priority">Priority.</param>
+    /// <param name="delayMillis">Delayed time in milliseconds.</param>
+    /// <returns>Token of posted delayed call-back.</returns>
+    public object PostDelayed(SendOrPostCallback callback, object? state, DispatcherPriority priority, int delayMillis) =>
+        DelayedCallbacks.Schedule(new DelayedCallbackStub(this.dispatcher, callback, state, priority), delayMillis);
 
 
     /// <inheritdoc/>

Core/Core.csproj

@@ -25,6 +25,9 @@
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
             <_Parameter1>$(AssemblyName).Tests</_Parameter1>
         </AssemblyAttribute>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>CarinaStudio.AppBase.Avalonia</_Parameter1>
+        </AssemblyAttribute>
     </ItemGroup>
 
 </Project>