Design concept for Dispatcher

Part of: #11610

This change brings forward the Dispatcher as a more primary and more
expandable concept.
- Dispatcher shows up in more places
- Dispatcher is an abstract class for horizontal scalability
- Dispatcher has parallels with S.Windows.Threading.Dispatcher where
possible

Looking for feedback on this approach. I feel pretty strongly that
making this an abstract class is the right choice, I want to see
opinions on how much to push it into people's faces.

Author: Ryan Nowak

src/Components/Blazor/Build/test/RazorIntegrationTestBase.cs

@@ -385,7 +385,7 @@ protected RenderTreeFrame[] GetRenderTree(IComponent component)
         protected private RenderTreeFrame[] GetRenderTree(TestRenderer renderer, IComponent component)
         {
             renderer.AttachComponent(component);
-            var task = renderer.InvokeAsync(() => component.SetParametersAsync(ParameterCollection.Empty));
+            var task = renderer.Dispatcher.InvokeAsync(() => component.SetParametersAsync(ParameterCollection.Empty));
             // we will have to change this method if we add a test that does actual async work.
             Assert.True(task.Status.HasFlag(TaskStatus.RanToCompletion) || task.Status.HasFlag(TaskStatus.Faulted));
             if (task.IsFaulted)

src/Components/Blazor/Build/test/RenderingRazorIntegrationTest.cs

@@ -332,7 +332,7 @@ public async Task SupportsTwoWayBindingForTextboxes()
             // Trigger the change event to show it updates the property
             //
             // This should always complete synchronously.
-            var task = renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = "Modified value", }));
+            var task = renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = "Modified value", }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 
@@ -367,7 +367,7 @@ public async Task SupportsTwoWayBindingForTextareas()
             // Trigger the change event to show it updates the property
             //
             // This should always complete synchronously.
-            var task = renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = "Modified value", }));
+            var task = renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = "Modified value", }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 
@@ -404,7 +404,7 @@ public async Task SupportsTwoWayBindingForDateValues()
             //
             // This should always complete synchronously.
             var newDateValue = new DateTime(2018, 3, 5, 4, 5, 6);
-            var task = renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = newDateValue.ToString(), }));
+            var task = renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = newDateValue.ToString(), }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 
@@ -440,7 +440,7 @@ public async Task SupportsTwoWayBindingForDateValuesWithFormatString()
             // Trigger the change event to show it updates the property
             //
             // This should always complete synchronously.
-            var task = renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = new DateTime(2018, 3, 5).ToString(testDateFormat), }));
+            var task = renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = new DateTime(2018, 3, 5).ToString(testDateFormat), }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 
@@ -559,7 +559,7 @@ public async Task SupportsTwoWayBindingForBoolValues()
             // Trigger the change event to show it updates the property
             //
             // This should always complete synchronously.
-            var task =  renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs() { Value = false, }));
+            var task =  renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs() { Value = false, }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 
@@ -595,7 +595,7 @@ public async Task SupportsTwoWayBindingForEnumValues()
             // Trigger the change event to show it updates the property
             //
             // This should always complete synchronously.
-            var task = renderer.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = MyEnum.SecondValue.ToString(), }));
+            var task = renderer.Dispatcher.InvokeAsync(() => setter.InvokeAsync(new UIChangeEventArgs { Value = MyEnum.SecondValue.ToString(), }));
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
             await task;
 

src/Components/Components/perf/RenderTreeDiffBuilderBenchmark.cs

@@ -88,7 +88,7 @@ public void ComputeDiff_SingleFormField()
         private class FakeRenderer : Renderer
         {
             public FakeRenderer()
-                : base(new TestServiceProvider(), NullLoggerFactory.Instance, new RendererSynchronizationContext())
+                : base(new TestServiceProvider(), NullLoggerFactory.Instance, new RendererSynchronizationContextDispatcher())
             {
             }
 

src/Components/Components/ref/Microsoft.AspNetCore.Components.netstandard2.0.cs

@@ -82,6 +82,16 @@ public DataTransfer() { }
         public Microsoft.AspNetCore.Components.UIDataTransferItem[] Items { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
         public string[] Types { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
     }
+    public abstract partial class Dispatcher
+    {
+        protected Dispatcher() { }
+        public abstract event System.UnhandledExceptionEventHandler UnhandledException;
+        public abstract bool CheckAccess();
+        public abstract System.Threading.Tasks.Task InvokeAsync(System.Action workItem);
+        public abstract System.Threading.Tasks.Task InvokeAsync(System.Func<System.Threading.Tasks.Task> workItem);
+        public abstract System.Threading.Tasks.Task<TResult> InvokeAsync<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> workItem);
+        public abstract System.Threading.Tasks.Task<TResult> InvokeAsync<TResult>(System.Func<TResult> workItem);
+    }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
     public readonly partial struct ElementRef
     {
@@ -295,13 +305,6 @@ public partial interface IComponentContext
     {
         bool IsConnected { get; }
     }
-    public partial interface IDispatcher
-    {
-        System.Threading.Tasks.Task InvokeAsync(System.Action workItem);
-        System.Threading.Tasks.Task InvokeAsync(System.Func<System.Threading.Tasks.Task> workItem);
-        System.Threading.Tasks.Task<TResult> InvokeAsync<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> workItem);
-        System.Threading.Tasks.Task<TResult> InvokeAsync<TResult>(System.Func<TResult> workItem);
-    }
     public partial interface IHandleAfterRender
     {
         System.Threading.Tasks.Task OnAfterRenderAsync();
@@ -386,9 +389,8 @@ public readonly partial struct RenderHandle
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
+        public Microsoft.AspNetCore.Components.Dispatcher Dispatcher { get { throw null; } }
         public bool IsInitialized { get { throw null; } }
-        public System.Threading.Tasks.Task InvokeAsync(System.Action workItem) { throw null; }
-        public System.Threading.Tasks.Task InvokeAsync(System.Func<System.Threading.Tasks.Task> workItem) { throw null; }
         public void Render(Microsoft.AspNetCore.Components.RenderFragment renderFragment) { }
     }
     [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=true, Inherited=false)]
@@ -649,7 +651,7 @@ public EventFieldInfo() { }
     }
     public partial class HtmlRenderer : Microsoft.AspNetCore.Components.Rendering.Renderer
     {
-        public HtmlRenderer(System.IServiceProvider serviceProvider, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, Microsoft.AspNetCore.Components.IDispatcher dispatcher, System.Func<string, string> htmlEncoder) : base (default(System.IServiceProvider), default(Microsoft.Extensions.Logging.ILoggerFactory)) { }
+        public HtmlRenderer(System.IServiceProvider serviceProvider, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, Microsoft.AspNetCore.Components.Dispatcher dispatcher, System.Func<string, string> htmlEncoder) : base (default(System.IServiceProvider), default(Microsoft.Extensions.Logging.ILoggerFactory)) { }
         protected override void HandleException(System.Exception exception) { }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task<Microsoft.AspNetCore.Components.Rendering.ComponentRenderedText> RenderComponentAsync(System.Type componentType, Microsoft.AspNetCore.Components.ParameterCollection initialParameters) { throw null; }
@@ -668,18 +670,17 @@ public readonly partial struct RenderBatch
     public abstract partial class Renderer : System.IDisposable
     {
         public Renderer(System.IServiceProvider serviceProvider, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory) { }
-        public Renderer(System.IServiceProvider serviceProvider, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, Microsoft.AspNetCore.Components.IDispatcher dispatcher) { }
+        public Renderer(System.IServiceProvider serviceProvider, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, Microsoft.AspNetCore.Components.Dispatcher dispatcher) { }
+        public Microsoft.AspNetCore.Components.Dispatcher Dispatcher { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } }
         public event System.UnhandledExceptionEventHandler UnhandledSynchronizationException { add { } remove { } }
         protected internal virtual void AddToRenderQueue(int componentId, Microsoft.AspNetCore.Components.RenderFragment renderFragment) { }
         protected internal int AssignRootComponentId(Microsoft.AspNetCore.Components.IComponent component) { throw null; }
-        public static Microsoft.AspNetCore.Components.IDispatcher CreateDefaultDispatcher() { throw null; }
+        public static Microsoft.AspNetCore.Components.Dispatcher CreateDefaultDispatcher() { throw null; }
         public virtual System.Threading.Tasks.Task DispatchEventAsync(int eventHandlerId, Microsoft.AspNetCore.Components.Rendering.EventFieldInfo fieldInfo, Microsoft.AspNetCore.Components.UIEventArgs eventArgs) { throw null; }
         public void Dispose() { }
         protected virtual void Dispose(bool disposing) { }
         protected abstract void HandleException(System.Exception exception);
         protected Microsoft.AspNetCore.Components.IComponent InstantiateComponent(System.Type componentType) { throw null; }
-        public virtual System.Threading.Tasks.Task InvokeAsync(System.Action workItem) { throw null; }
-        public virtual System.Threading.Tasks.Task InvokeAsync(System.Func<System.Threading.Tasks.Task> workItem) { throw null; }
         protected System.Threading.Tasks.Task RenderRootComponentAsync(int componentId) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         protected System.Threading.Tasks.Task RenderRootComponentAsync(int componentId, Microsoft.AspNetCore.Components.ParameterCollection initialParameters) { throw null; }

src/Components/Components/src/ComponentBase.cs

@@ -148,15 +148,15 @@ protected virtual Task OnAfterRenderAsync()
         /// </summary>
         /// <param name="workItem">The work item to execute.</param>
         protected Task InvokeAsync(Action workItem)
-            => _renderHandle.InvokeAsync(workItem);
+            => _renderHandle.Dispatcher.InvokeAsync(workItem);
 
         /// <summary>
         /// Executes the supplied work item on the associated renderer's
         /// synchronization context.
         /// </summary>
         /// <param name="workItem">The work item to execute.</param>
         protected Task InvokeAsync(Func<Task> workItem)
-            => _renderHandle.InvokeAsync(workItem);
+            => _renderHandle.Dispatcher.InvokeAsync(workItem);
 
         void IComponent.Configure(RenderHandle renderHandle)
         {

src/Components/Components/src/IDispatcher.cs renamed to src/Components/Components/src/Dispatcher.cs

@@ -10,34 +10,46 @@ namespace Microsoft.AspNetCore.Components
     /// <summary>
     /// Dispatches external actions to be executed on the context of a <see cref="Renderer"/>.
     /// </summary>
-    public interface IDispatcher
+    public abstract class Dispatcher
     {
+        /// <summary>
+        /// Provides notifications of unhandled exceptions that occur within the dispatcher.
+        /// </summary>
+        public abstract event UnhandledExceptionEventHandler UnhandledException;
+
+        /// <summary>
+        /// Returns a value that determines whether using the dispatcher to invoke a work item is required
+        /// from the current context.
+        /// </summary>
+        /// <returns><c>true</c> if invoking is required, otherwise <c>false</c>.</returns>
+        public abstract bool CheckAccess();
+
         /// <summary>
         /// Invokes the given <see cref="Action"/> in the context of the associated <see cref="Renderer"/>.
         /// </summary>
         /// <param name="workItem">The action to execute.</param>
         /// <returns>A <see cref="Task"/> that will be completed when the action has finished executing.</returns>
-        Task InvokeAsync(Action workItem);
+        public abstract Task InvokeAsync(Action workItem);
 
         /// <summary>
         /// Invokes the given <see cref="Func{TResult}"/> in the context of the associated <see cref="Renderer"/>.
         /// </summary>
         /// <param name="workItem">The asynchronous action to execute.</param>
         /// <returns>A <see cref="Task"/> that will be completed when the action has finished executing.</returns>
-        Task InvokeAsync(Func<Task> workItem);
+        public abstract Task InvokeAsync(Func<Task> workItem);
 
         /// <summary>
         /// Invokes the given <see cref="Func{TResult}"/> in the context of the associated <see cref="Renderer"/>.
         /// </summary>
         /// <param name="workItem">The function to execute.</param>
         /// <returns>A <see cref="Task{TResult}"/> that will be completed when the function has finished executing.</returns>
-        Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem);
+        public abstract Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem);
 
         /// <summary>
         /// Invokes the given <see cref="Func{TResult}"/> in the context of the associated <see cref="Renderer"/>.
         /// </summary>
         /// <param name="workItem">The asynchronous function to execute.</param>
         /// <returns>A <see cref="Task{TResult}"/> that will be completed when the function has finished executing.</returns>
-        Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem);
+        public abstract Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem);
     }
 }

src/Components/Components/src/RenderHandle.cs

@@ -2,13 +2,12 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.Rendering;
 
 namespace Microsoft.AspNetCore.Components
 {
     /// <summary>
-    /// Allows a component to notify the renderer that it should be rendered.
+    /// Allows a component to interact with its renderer.
     /// </summary>
     public readonly struct RenderHandle
     {
@@ -21,9 +20,25 @@ internal RenderHandle(Renderer renderer, int componentId)
             _componentId = componentId;
         }
 
+        /// <summary>
+        /// Gets the <see cref="Microsoft.AspNetCore.Components.Dispatcher" /> associated with the component.
+        /// </summary>
+        public Dispatcher Dispatcher
+        {
+            get
+            {
+                if (_renderer == null)
+                {
+                    ThrowNotInitialized();
+                }
+
+                return _renderer.Dispatcher;
+            }
+        }
+
         /// <summary>
         /// Gets a value that indicates whether the <see cref="RenderHandle"/> has been
-        /// initialised and is ready to use.
+        /// initialized and is ready to use.
         /// </summary>
         public bool IsInitialized
             => _renderer != null;
@@ -36,38 +51,15 @@ public void Render(RenderFragment renderFragment)
         {
             if (_renderer == null)
             {
-                throw new InvalidOperationException("The render handle is not yet assigned.");
+                ThrowNotInitialized();
             }
 
             _renderer.AddToRenderQueue(_componentId, renderFragment);
         }
 
-        /// <summary>
-        /// Executes the supplied work item on the renderer's
-        /// synchronization context.
-        /// </summary>
-        /// <param name="workItem">The work item to execute.</param>
-        public Task InvokeAsync(Action workItem)
+        private static void ThrowNotInitialized()
         {
-            if (_renderer == null)
-            {
-                throw new InvalidOperationException("The render handle is not yet assigned.");
-            }
-            return _renderer.InvokeAsync(workItem);
-        }
-
-        /// <summary>
-        /// Executes the supplied work item on the renderer's
-        /// synchronization context.
-        /// </summary>
-        /// <param name="workItem">The work item to execute.</param>
-        public Task InvokeAsync(Func<Task> workItem)
-        {
-            if (_renderer == null)
-            {
-                throw new InvalidOperationException("The render handle is not yet assigned.");
-            }
-            return _renderer.InvokeAsync(workItem);
+            throw new InvalidOperationException("The render handle is not yet assigned.");
         }
     }
 }

src/Components/Components/src/Rendering/HtmlRenderer.cs

@@ -28,9 +28,9 @@ public class HtmlRenderer : Renderer
         /// </summary>
         /// <param name="serviceProvider">The <see cref="IServiceProvider"/> to use to instantiate components.</param>
         /// <param name="loggerFactory">The <see cref="ILoggerFactory"/>.</param>
-        /// <param name="dispatcher">The <see cref="IDispatcher"/> to be for invoking user actions into the <see cref="Renderer"/> context.</param>
+        /// <param name="dispatcher">The <see cref="Dispatcher"/> to be for invoking user actions into the <see cref="Renderer"/> context.</param>
         /// <param name="htmlEncoder">A <see cref="Func{T, TResult}"/> that will HTML encode the given string.</param>
-        public HtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IDispatcher dispatcher, Func<string, string> htmlEncoder)
+        public HtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, Dispatcher dispatcher, Func<string, string> htmlEncoder)
             : base(serviceProvider, loggerFactory, dispatcher)
         {
             _htmlEncoder = htmlEncoder;