App api diff between preview 7 and preview 8 (#3161)

* App api diff between preview 7 and preview 8

* Correcting out of box packages

* removing pipeline from asp.net

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8.md

@@ -0,0 +1,10 @@
+# API Difference netcoreapp3.0-preview7 vs netcoreapp3.0-preview8
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.VisualBasic](3.0-preview8_Microsoft.VisualBasic.md)
+* [System.Collections.Generic](3.0-preview8_System.Collections.Generic.md)
+* [System.Text.Encodings.Web](3.0-preview8_System.Text.Encodings.Web.md)
+* [System.Text.Json](3.0-preview8_System.Text.Json.md)
+* [System.Text.Json.Serialization](3.0-preview8_System.Text.Json.Serialization.md)

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8_Microsoft.VisualBasic.md

@@ -0,0 +1,22 @@
+# Microsoft.VisualBasic
+
+``` diff
+ namespace Microsoft.VisualBasic {
++    public sealed class Financial {
++        public static double DDB(double Cost, double Salvage, double Life, double Period, double Factor = 2);
++        public static double FV(double Rate, double NPer, double Pmt, double PV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double IPmt(double Rate, double Per, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double IRR(ref double[] ValueArray, double Guess = 0.1);
++        public static double MIRR(ref double[] ValueArray, double FinanceRate, double ReinvestRate);
++        public static double NPer(double Rate, double Pmt, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double NPV(double Rate, ref double[] ValueArray);
++        public static double Pmt(double Rate, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double PPmt(double Rate, double Per, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double PV(double Rate, double NPer, double Pmt, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double Rate(double NPer, double Pmt, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod, double Guess = 0.1);
++        public static double SLN(double Cost, double Salvage, double Life);
++        public static double SYD(double Cost, double Salvage, double Life, double Period);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8_System.Collections.Generic.md

@@ -0,0 +1,11 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
+     public class SortedList<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+-        void System.Collections.ICollection.CopyTo(Array array, int index);
++        void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8_System.Text.Encodings.Web.md

@@ -0,0 +1,14 @@
+# System.Text.Encodings.Web
+
+``` diff
+ namespace System.Text.Encodings.Web {
+     public abstract class JavaScriptEncoder : TextEncoder {
++        public static JavaScriptEncoder UnsafeRelaxedJsonEscaping { get; }
+     }
+     public abstract class TextEncoder {
++        public virtual OperationStatus EncodeUtf8(ReadOnlySpan<byte> utf8Source, Span<byte> utf8Destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public virtual int FindFirstCharacterToEncodeUtf8(ReadOnlySpan<byte> utf8Text);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8_System.Text.Json.Serialization.md

@@ -0,0 +1,19 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+     public abstract class JsonConverterFactory : JsonConverter {
+-        protected internal JsonConverterFactory();
++        protected JsonConverterFactory();
+-        protected abstract JsonConverter CreateConverter(Type typeToConvert);
+
++        public abstract JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options);
+     }
+     public sealed class JsonStringEnumConverter : JsonConverterFactory {
+-        protected override JsonConverter CreateConverter(Type typeToConvert);
+
++        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/.Net/3.0-preview8_System.Text.Json.md

@@ -0,0 +1,53 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public sealed class JsonDocument : IDisposable {
++        public void WriteTo(Utf8JsonWriter writer);
+     }
+     public readonly struct JsonElement {
+-        public void WriteProperty(ReadOnlySpan<byte> utf8PropertyName, Utf8JsonWriter writer);
+
+-        public void WriteProperty(ReadOnlySpan<char> propertyName, Utf8JsonWriter writer);
+
+-        public void WriteProperty(string propertyName, Utf8JsonWriter writer);
+
+-        public void WriteProperty(JsonEncodedText propertyName, Utf8JsonWriter writer);
+
++        public void WriteTo(Utf8JsonWriter writer);
+-        public void WriteValue(Utf8JsonWriter writer);
+
+     }
+     public readonly struct JsonEncodedText : IEquatable<JsonEncodedText> {
+-        public static JsonEncodedText Encode(ReadOnlySpan<byte> utf8Value);
+
++        public static JsonEncodedText Encode(ReadOnlySpan<byte> utf8Value, JavaScriptEncoder encoder = null);
+-        public static JsonEncodedText Encode(ReadOnlySpan<char> value);
+
++        public static JsonEncodedText Encode(ReadOnlySpan<char> value, JavaScriptEncoder encoder = null);
+-        public static JsonEncodedText Encode(string value);
+
++        public static JsonEncodedText Encode(string value, JavaScriptEncoder encoder = null);
+     }
+     public readonly struct JsonProperty {
++        public void WriteTo(Utf8JsonWriter writer);
+     }
+     public static class JsonSerializer {
+-        public static string Serialize(object value, Type inputType, JsonSerializerOptions options = null);
++        public static string Serialize(object value, Type type, JsonSerializerOptions options = null);
+-        public static void Serialize(Utf8JsonWriter writer, object value, Type inputType, JsonSerializerOptions options = null);
++        public static void Serialize(Utf8JsonWriter writer, object value, Type type, JsonSerializerOptions options = null);
+-        public static Task SerializeAsync(Stream utf8Json, object value, Type inputType, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task SerializeAsync(Stream utf8Json, object value, Type type, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
+-        public static byte[] SerializeToUtf8Bytes(object value, Type inputType, JsonSerializerOptions options = null);
++        public static byte[] SerializeToUtf8Bytes(object value, Type type, JsonSerializerOptions options = null);
+     }
+     public sealed class JsonSerializerOptions {
++        public JavaScriptEncoder Encoder { get; set; }
+     }
+     public struct JsonWriterOptions {
++        public JavaScriptEncoder Encoder { get; set; }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/.Net/standalone-packages/3.0-preview8-standalone-packages.md

@@ -0,0 +1,7 @@
+# API Difference netcoreapp3.0-preview7 vs netcoreapp3.0-preview8
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System.IO.Pipelines](3.0-preview8-standalone-packages_System.IO.Pipelines.md)
+

release-notes/3.0/preview/api-diff/preview8/.Net/standalone-packages/3.0-preview8-standalone-packages_System.IO.Pipelines.md

@@ -0,0 +1,29 @@
+# System.IO.Pipelines
+
+``` diff
+ namespace System.IO.Pipelines {
+     public class PipeOptions {
+-        public PipeOptions(MemoryPool<byte> pool = null, PipeScheduler readerScheduler = null, PipeScheduler writerScheduler = null, long pauseWriterThreshold = (long)65536, long resumeWriterThreshold = (long)32768, int minimumSegmentSize = 4096, bool useSynchronizationContext = true);
++        public PipeOptions(MemoryPool<byte> pool = null, PipeScheduler readerScheduler = null, PipeScheduler writerScheduler = null, long pauseWriterThreshold = (long)-1, long resumeWriterThreshold = (long)-1, int minimumSegmentSize = -1, bool useSynchronizationContext = true);
+     }
+     public abstract class PipeReader {
++        public virtual ValueTask CompleteAsync(Exception exception = null);
+-        public abstract void OnWriterCompleted(Action<Exception, object> callback, object state);
++        public virtual void OnWriterCompleted(Action<Exception, object> callback, object state);
+     }
+     public abstract class PipeWriter : IBufferWriter<byte> {
++        public virtual ValueTask CompleteAsync(Exception exception = null);
+-        public abstract void OnReaderCompleted(Action<Exception, object> callback, object state);
++        public virtual void OnReaderCompleted(Action<Exception, object> callback, object state);
+     }
+     public class StreamPipeReaderOptions {
+-        public StreamPipeReaderOptions(MemoryPool<byte> pool = null, int bufferSize = 4096, int minimumReadSize = 1024, bool leaveOpen = false);
++        public StreamPipeReaderOptions(MemoryPool<byte> pool = null, int bufferSize = -1, int minimumReadSize = -1, bool leaveOpen = false);
+     }
+     public class StreamPipeWriterOptions {
+-        public StreamPipeWriterOptions(MemoryPool<byte> pool = null, int minimumBufferSize = 4096, bool leaveOpen = false);
++        public StreamPipeWriterOptions(MemoryPool<byte> pool = null, int minimumBufferSize = -1, bool leaveOpen = false);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8.md

@@ -0,0 +1,40 @@
+# API Difference aspnetcoreapp3.0-preview7 vs aspnetcoreapp3.0-preview8
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Builder](3.0-preview8_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components](3.0-preview8_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.Browser](3.0-preview8_Microsoft.AspNetCore.Components.Browser.md)
+* [Microsoft.AspNetCore.Components.Browser.Rendering](3.0-preview8_Microsoft.AspNetCore.Components.Browser.Rendering.md)
+* [Microsoft.AspNetCore.Components.CompilerServices](3.0-preview8_Microsoft.AspNetCore.Components.CompilerServices.md)
+* [Microsoft.AspNetCore.Components.Forms](3.0-preview8_Microsoft.AspNetCore.Components.Forms.md)
+* [Microsoft.AspNetCore.Components.Layouts](3.0-preview8_Microsoft.AspNetCore.Components.Layouts.md)
+* [Microsoft.AspNetCore.Components.Rendering](3.0-preview8_Microsoft.AspNetCore.Components.Rendering.md)
+* [Microsoft.AspNetCore.Components.RenderTree](3.0-preview8_Microsoft.AspNetCore.Components.RenderTree.md)
+* [Microsoft.AspNetCore.Components.Routing](3.0-preview8_Microsoft.AspNetCore.Components.Routing.md)
+* [Microsoft.AspNetCore.Components.Server](3.0-preview8_Microsoft.AspNetCore.Components.Server.md)
+* [Microsoft.AspNetCore.Components.Web](3.0-preview8_Microsoft.AspNetCore.Components.Web.md)
+* [Microsoft.AspNetCore.Connections](3.0-preview8_Microsoft.AspNetCore.Connections.md)
+* [Microsoft.AspNetCore.DataProtection.Cng.Internal](3.0-preview8_Microsoft.AspNetCore.DataProtection.Cng.Internal.md)
+* [Microsoft.AspNetCore.DataProtection.Internal](3.0-preview8_Microsoft.AspNetCore.DataProtection.Internal.md)
+* [Microsoft.AspNetCore.Hosting.Server.Abstractions](3.0-preview8_Microsoft.AspNetCore.Hosting.Server.Abstractions.md)
+* [Microsoft.AspNetCore.Http](3.0-preview8_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.Features](3.0-preview8_Microsoft.AspNetCore.Http.Features.md)
+* [Microsoft.AspNetCore.Identity](3.0-preview8_Microsoft.AspNetCore.Identity.md)
+* [Microsoft.AspNetCore.Mvc.ActionConstraints](3.0-preview8_Microsoft.AspNetCore.Mvc.ActionConstraints.md)
+* [Microsoft.AspNetCore.Mvc.Diagnostics](3.0-preview8_Microsoft.AspNetCore.Mvc.Diagnostics.md)
+* [Microsoft.AspNetCore.Mvc.Infrastructure](3.0-preview8_Microsoft.AspNetCore.Mvc.Infrastructure.md)
+* [Microsoft.AspNetCore.Mvc.ViewFeatures](3.0-preview8_Microsoft.AspNetCore.Mvc.ViewFeatures.md)
+* [Microsoft.AspNetCore.Routing.Internal](3.0-preview8_Microsoft.AspNetCore.Routing.Internal.md)
+* [Microsoft.AspNetCore.Routing.Template](3.0-preview8_Microsoft.AspNetCore.Routing.Template.md)
+* [Microsoft.AspNetCore.Routing.Tree](3.0-preview8_Microsoft.AspNetCore.Routing.Tree.md)
+* [Microsoft.AspNetCore.SignalR](3.0-preview8_Microsoft.AspNetCore.SignalR.md)
+* [Microsoft.Extensions.Hosting.Internal](3.0-preview8_Microsoft.Extensions.Hosting.Internal.md)
+* [Microsoft.JSInterop](3.0-preview8_Microsoft.JSInterop.md)
+* [Microsoft.JSInterop.Internal](3.0-preview8_Microsoft.JSInterop.Internal.md)
+* [System.Drawing](3.0-preview8_System.Drawing.md)
+* [System.Drawing.Printing](3.0-preview8_System.Drawing.Printing.md)
+* [System.Media](3.0-preview8_System.Media.md)
+* [System.Security.Cryptography.X509Certificates](3.0-preview8_System.Security.Cryptography.X509Certificates.md)
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Builder.md

@@ -0,0 +1,76 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
++    public sealed class ComponentEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
++        public void Add(Action<EndpointBuilder> convention);
++    }
+     public static class ComponentEndpointConventionBuilderExtensions {
++        public static ComponentEndpointConventionBuilder AddComponent(this ComponentEndpointConventionBuilder builder, Type componentType, string selector);
+-        public static ComponentEndpointConventionBuilder AddComponent(this ComponentEndpointConventionBuilder builder, Type componentType, string selector);
+
+     }
+     public static class ComponentEndpointRouteBuilderExtensions {
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Action<HttpConnectionDispatcherOptions> configureOptions);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Action<HttpConnectionDispatcherOptions> configureOptions);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type type, string selector);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type type, string selector);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type type, string selector, Action<HttpConnectionDispatcherOptions> configureOptions);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type type, string selector, Action<HttpConnectionDispatcherOptions> configureOptions);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type componentType, string selector, string path);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type componentType, string selector, string path);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type componentType, string selector, string path, Action<HttpConnectionDispatcherOptions> configureOptions);
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, Type componentType, string selector, string path, Action<HttpConnectionDispatcherOptions> configureOptions);
+-        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector) where TComponent : IComponent;
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector) where TComponent : IComponent;
+-        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, Action<HttpConnectionDispatcherOptions> configureOptions) where TComponent : IComponent;
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, Action<HttpConnectionDispatcherOptions> configureOptions) where TComponent : IComponent;
+-        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, string path) where TComponent : IComponent;
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, string path) where TComponent : IComponent;
+-        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, string path, Action<HttpConnectionDispatcherOptions> configureOptions) where TComponent : IComponent;
+
++        public static ComponentEndpointConventionBuilder MapBlazorHub<TComponent>(this IEndpointRouteBuilder endpoints, string selector, string path, Action<HttpConnectionDispatcherOptions> configureOptions) where TComponent : IComponent;
+     }
++    public sealed class ConnectionEndpointRouteBuilder : IEndpointConventionBuilder {
++        public void Add(Action<EndpointBuilder> convention);
++    }
+     public static class ConnectionEndpointRouteBuilderExtensions {
+-        public static IEndpointConventionBuilder MapConnectionHandler<TConnectionHandler>(this IEndpointRouteBuilder endpoints, string pattern) where TConnectionHandler : ConnectionHandler;
+
++        public static ConnectionEndpointRouteBuilder MapConnectionHandler<TConnectionHandler>(this IEndpointRouteBuilder endpoints, string pattern) where TConnectionHandler : ConnectionHandler;
+-        public static IEndpointConventionBuilder MapConnectionHandler<TConnectionHandler>(this IEndpointRouteBuilder endpoints, string pattern, Action<HttpConnectionDispatcherOptions> configureOptions) where TConnectionHandler : ConnectionHandler;
+
++        public static ConnectionEndpointRouteBuilder MapConnectionHandler<TConnectionHandler>(this IEndpointRouteBuilder endpoints, string pattern, Action<HttpConnectionDispatcherOptions> configureOptions) where TConnectionHandler : ConnectionHandler;
+-        public static IEndpointConventionBuilder MapConnections(this IEndpointRouteBuilder endpoints, string pattern, HttpConnectionDispatcherOptions options, Action<IConnectionBuilder> configure);
+
++        public static ConnectionEndpointRouteBuilder MapConnections(this IEndpointRouteBuilder endpoints, string pattern, HttpConnectionDispatcherOptions options, Action<IConnectionBuilder> configure);
+-        public static IEndpointConventionBuilder MapConnections(this IEndpointRouteBuilder endpoints, string pattern, Action<IConnectionBuilder> configure);
+
++        public static ConnectionEndpointRouteBuilder MapConnections(this IEndpointRouteBuilder endpoints, string pattern, Action<IConnectionBuilder> configure);
+     }
++    public sealed class HubEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
++        public void Add(Action<EndpointBuilder> convention);
++    }
+     public static class HubEndpointRouteBuilderExtensions {
+-        public static HubEndpointConventionBuilder MapHub<THub>(this IEndpointRouteBuilder endpoints, string pattern) where THub : Hub;
+
++        public static HubEndpointConventionBuilder MapHub<THub>(this IEndpointRouteBuilder endpoints, string pattern) where THub : Hub;
+-        public static HubEndpointConventionBuilder MapHub<THub>(this IEndpointRouteBuilder endpoints, string pattern, Action<HttpConnectionDispatcherOptions> configureOptions) where THub : Hub;
+
++        public static HubEndpointConventionBuilder MapHub<THub>(this IEndpointRouteBuilder endpoints, string pattern, Action<HttpConnectionDispatcherOptions> configureOptions) where THub : Hub;
+     }
++    public interface IHubEndpointConventionBuilder : IEndpointConventionBuilder
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Browser.Rendering.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Components.Browser.Rendering
+
+``` diff
+-namespace Microsoft.AspNetCore.Components.Browser.Rendering {
+ {
+-    public class RemoteRendererException : Exception {
+ {
+-        public RemoteRendererException(string message);
+
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Browser.md

@@ -0,0 +1,26 @@
+# Microsoft.AspNetCore.Components.Browser
+
+``` diff
+-namespace Microsoft.AspNetCore.Components.Browser {
+ {
+-    public static class RendererRegistryEventDispatcher {
+ {
+-        public static Task DispatchEvent(RendererRegistryEventDispatcher.BrowserEventDescriptor eventDescriptor, string eventArgsJson);
+
+-        public class BrowserEventDescriptor {
+ {
+-            public BrowserEventDescriptor();
+
+-            public int BrowserRendererId { get; set; }
+
+-            public string EventArgsType { get; set; }
+
+-            public EventFieldInfo EventFieldInfo { get; set; }
+
+-            public int EventHandlerId { get; set; }
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.CompilerServices.md

@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Components.CompilerServices
+
+``` diff
++namespace Microsoft.AspNetCore.Components.CompilerServices {
++    public static class RuntimeHelpers {
++        public static EventCallback<T> CreateInferredEventCallback<T>(object receiver, Action<T> callback, T value);
++        public static EventCallback<T> CreateInferredEventCallback<T>(object receiver, Func<T, Task> callback, T value);
++        public static T TypeCheck<T>(T value);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Forms.md

@@ -0,0 +1,72 @@
+# Microsoft.AspNetCore.Components.Forms
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Forms {
+     public class DataAnnotationsValidator : ComponentBase {
+-        protected override void OnInit();
+
++        protected override void OnInitialized();
+     }
+     public class EditForm : ComponentBase {
+-        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; private set; }
++        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; set; }
+-        public RenderFragment<EditContext> ChildContent { get; private set; }
++        public RenderFragment<EditContext> ChildContent { get; set; }
+-        public EditContext EditContext { get; private set; }
++        public EditContext EditContext { get; set; }
+-        public object Model { get; private set; }
++        public object Model { get; set; }
+-        public EventCallback<EditContext> OnInvalidSubmit { get; private set; }
++        public EventCallback<EditContext> OnInvalidSubmit { get; set; }
+-        public EventCallback<EditContext> OnSubmit { get; private set; }
++        public EventCallback<EditContext> OnSubmit { get; set; }
+-        public EventCallback<EditContext> OnValidSubmit { get; private set; }
++        public EventCallback<EditContext> OnValidSubmit { get; set; }
+     }
+     public abstract class InputBase<T> : ComponentBase {
+-        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; private set; }
++        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; set; }
+-        public string Class { get; private set; }
+
+-        protected EditContext EditContext { get; }
++        protected EditContext EditContext { get; set; }
+-        protected FieldIdentifier FieldIdentifier { get; }
++        protected FieldIdentifier FieldIdentifier { get; set; }
+-        public string Id { get; private set; }
+
+-        public T Value { get; private set; }
++        public T Value { get; set; }
+-        public EventCallback<T> ValueChanged { get; private set; }
++        public EventCallback<T> ValueChanged { get; set; }
+-        public Expression<Func<T>> ValueExpression { get; private set; }
++        public Expression<Func<T>> ValueExpression { get; set; }
+-        public override Task SetParametersAsync(ParameterCollection parameters);
+
++        public override Task SetParametersAsync(ParameterView parameters);
+     }
+     public class InputDate<T> : InputBase<T> {
+-        public string ParsingErrorMessage { get; private set; }
++        public string ParsingErrorMessage { get; set; }
+     }
+     public class InputNumber<T> : InputBase<T> {
+-        public string ParsingErrorMessage { get; private set; }
++        public string ParsingErrorMessage { get; set; }
++        protected override string FormatValueAsString(T value);
+     }
+     public class InputSelect<T> : InputBase<T> {
+-        public RenderFragment ChildContent { get; private set; }
++        public RenderFragment ChildContent { get; set; }
+     }
+     public class ValidationMessage<T> : ComponentBase, IDisposable {
+-        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; private set; }
++        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; set; }
+-        public Expression<Func<T>> For { get; private set; }
++        public Expression<Func<T>> For { get; set; }
+     }
+     public class ValidationSummary : ComponentBase, IDisposable {
+-        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; private set; }
++        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; set; }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Layouts.md

@@ -0,0 +1,22 @@
+# Microsoft.AspNetCore.Components.Layouts
+
+``` diff
+-namespace Microsoft.AspNetCore.Components.Layouts {
+ {
+-    public class LayoutAttribute : Attribute {
+ {
+-        public LayoutAttribute(Type layoutType);
+
+-        public Type LayoutType { get; }
+
+-    }
+-    public abstract class LayoutComponentBase : ComponentBase {
+ {
+-        protected LayoutComponentBase();
+
+-        protected RenderFragment Body { get; }
+
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.RenderTree.md

@@ -0,0 +1,70 @@
+# Microsoft.AspNetCore.Components.RenderTree
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.RenderTree {
++    public readonly struct ArrayBuilderSegment<T> : IEnumerable, IEnumerable<T> {
++        public T[] Array { get; }
++        public int Count { get; }
++        public int Offset { get; }
++        public T this[int index] { get; }
++        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++    }
+-    public class RenderTreeBuilder {
++    public sealed class RenderTreeBuilder : IDisposable {
+-        public const string ChildContent = "ChildContent";
+
++        public RenderTreeBuilder();
+-        public RenderTreeBuilder(Renderer renderer);
+
+-        public void AddAttribute(int sequence, string name, Action value);
+
+-        public void AddAttribute(int sequence, string name, Action<UIEventArgs> value);
+
+-        public void AddAttribute(int sequence, string name, Func<UIEventArgs, Task> value);
+
+-        public void AddAttribute(int sequence, string name, Func<Task> value);
+
+-        public void AddElementReferenceCapture(int sequence, Action<ElementRef> elementReferenceCaptureAction);
+
++        public void AddElementReferenceCapture(int sequence, Action<ElementReference> elementReferenceCaptureAction);
++        public void CloseRegion();
++        public void OpenRegion(int sequence);
++        void System.IDisposable.Dispose();
+     }
+     public readonly struct RenderTreeDiff {
++        public readonly ArrayBuilderSegment<RenderTreeEdit> Edits;
+-        public readonly ArraySegment<RenderTreeEdit> Edits;
+
+     }
+     public readonly struct RenderTreeFrame {
+-        [System.Runtime.InteropServices.FieldOffsetAttribute(24)]
+-        public readonly Action<ElementRef> ElementReferenceCaptureAction;
+
++        [System.Runtime.InteropServices.FieldOffsetAttribute(24)]
++        public readonly Action<ElementReference> ElementReferenceCaptureAction;
+     }
+-    public enum RenderTreeFrameType {
++    public enum RenderTreeFrameType : short {
+-        Attribute = 3,
++        Attribute = (short)3,
+-        Component = 4,
++        Component = (short)4,
+-        ComponentReferenceCapture = 7,
++        ComponentReferenceCapture = (short)7,
+-        Element = 1,
++        Element = (short)1,
+-        ElementReferenceCapture = 6,
++        ElementReferenceCapture = (short)6,
+-        Markup = 8,
++        Markup = (short)8,
+-        None = 0,
++        None = (short)0,
+-        Region = 5,
++        Region = (short)5,
+-        Text = 2,
++        Text = (short)2,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Rendering.md

@@ -0,0 +1,54 @@
+# Microsoft.AspNetCore.Components.Rendering
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Rendering {
+     public class HtmlRenderer : Renderer {
++        public HtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, Func<string, string> htmlEncoder);
+-        public HtmlRenderer(IServiceProvider serviceProvider, Func<string, string> htmlEncoder, IDispatcher dispatcher);
+
++        public override Dispatcher Dispatcher { get; }
+-        public Task<ComponentRenderedText> RenderComponentAsync(Type componentType, ParameterCollection initialParameters);
+
++        public Task<ComponentRenderedText> RenderComponentAsync(Type componentType, ParameterView initialParameters);
+-        public Task<ComponentRenderedText> RenderComponentAsync<TComponent>(ParameterCollection initialParameters) where TComponent : IComponent;
+
++        public Task<ComponentRenderedText> RenderComponentAsync<TComponent>(ParameterView initialParameters) where TComponent : IComponent;
+     }
+-    public interface IDispatcher {
+ {
+-        Task Invoke(Action action);
+
+-        Task<TResult> Invoke<TResult>(Func<TResult> function);
+
+-        Task InvokeAsync(Func<Task> asyncAction);
+
+-        Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> asyncFunction);
+
+-    }
+     public readonly struct RenderBatch {
+-        public ArrayRange<int> DisposedEventHandlerIDs { get; }
++        public ArrayRange<ulong> DisposedEventHandlerIDs { get; }
+     }
+     public abstract class Renderer : IDisposable {
+-        public Renderer(IServiceProvider serviceProvider);
+
+-        public Renderer(IServiceProvider serviceProvider, IDispatcher dispatcher);
+
++        public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory);
++        public abstract Dispatcher Dispatcher { get; }
+-        public static IDispatcher CreateDefaultDispatcher();
+
+-        public virtual Task DispatchEventAsync(int eventHandlerId, EventFieldInfo fieldInfo, UIEventArgs eventArgs);
+
++        public virtual Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, UIEventArgs eventArgs);
+-        public virtual Task Invoke(Action workItem);
+
+-        public virtual Task InvokeAsync(Func<Task> workItem);
+
+-        protected Task RenderRootComponentAsync(int componentId, ParameterCollection initialParameters);
+
++        protected Task RenderRootComponentAsync(int componentId, ParameterView initialParameters);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Routing.md

@@ -0,0 +1,42 @@
+# Microsoft.AspNetCore.Components.Routing
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Routing {
+-    public class NavLink : IComponent, IDisposable {
++    public class NavLink : ComponentBase, IDisposable {
+-        public string ActiveClass { get; private set; }
++        public string ActiveClass { get; set; }
++        public IReadOnlyDictionary<string, object> AdditionalAttributes { get; set; }
++        public RenderFragment ChildContent { get; set; }
++        protected string CssClass { get; set; }
+-        public NavLinkMatch Match { get; private set; }
++        public NavLinkMatch Match { get; set; }
++        protected override void BuildRenderTree(RenderTreeBuilder builder);
+-        public void Configure(RenderHandle renderHandle);
+
++        protected override void OnInitialized();
++        protected override void OnParametersSet();
+-        public Task SetParametersAsync(ParameterCollection parameters);
+
+     }
+-    public class Router : IComponent, IDisposable {
++    public class Router : IComponent, IDisposable, IHandleAfterRender {
+-        public Assembly AppAssembly { get; private set; }
++        public Assembly AppAssembly { get; set; }
+-        public RenderFragment AuthorizingContent { get; private set; }
++        public RenderFragment AuthorizingContent { get; set; }
+-        public RenderFragment<AuthenticationState> NotAuthorizedContent { get; private set; }
++        public RenderFragment<AuthenticationState> NotAuthorizedContent { get; set; }
+-        public RenderFragment NotFoundContent { get; private set; }
++        public RenderFragment NotFoundContent { get; set; }
++        public void Attach(RenderHandle renderHandle);
+-        public void Configure(RenderHandle renderHandle);
+
++        Task Microsoft.AspNetCore.Components.IHandleAfterRender.OnAfterRenderAsync();
+-        public Task SetParametersAsync(ParameterCollection parameters);
+
++        public Task SetParametersAsync(ParameterView parameters);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Server.md

@@ -0,0 +1,32 @@
+# Microsoft.AspNetCore.Components.Server
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Server {
+-    public class CircuitOptions {
++    public sealed class CircuitOptions {
++        public bool DetailedErrors { get; set; }
++        public int DisconnectedCircuitMaxRetained { get; set; }
++        public TimeSpan JSInteropDefaultCallTimeout { get; set; }
+-        public int MaxRetainedDisconnectedCircuits { get; set; }
+
+     }
+-    public sealed class ComponentEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
+ {
+-        public void Add(Action<EndpointBuilder> convention);
+
+-    }
+     public class ComponentPrerenderingContext {
+-        public ParameterCollection Parameters { get; set; }
++        public ParameterView Parameters { get; set; }
+     }
+-    public static class WasmMediaTypeNames {
+ {
+-        public static class Application {
+ {
+-            public const string Wasm = "application/wasm";
+
+-        }
+-    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.Web.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Components.Web
+
+``` diff
++namespace Microsoft.AspNetCore.Components.Web {
++    public static class RendererRegistryEventDispatcher {
++        public static Task DispatchEvent(RendererRegistryEventDispatcher.BrowserEventDescriptor eventDescriptor, string eventArgsJson);
++        public class BrowserEventDescriptor {
++            public BrowserEventDescriptor();
++            public int BrowserRendererId { get; set; }
++            public string EventArgsType { get; set; }
++            public EventFieldInfo EventFieldInfo { get; set; }
++            public ulong EventHandlerId { get; set; }
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Components.md

@@ -0,0 +1,497 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
+     public class AuthorizeView : AuthorizeViewCore {
+-        public string Policy { get; private set; }
++        public string Policy { get; set; }
+-        public object Resource { get; private set; }
+
+-        public string Roles { get; private set; }
++        public string Roles { get; set; }
+     }
+     public abstract class AuthorizeViewCore : ComponentBase {
+-        public AuthorizeViewCore();
++        protected AuthorizeViewCore();
+-        public RenderFragment<AuthenticationState> Authorized { get; private set; }
++        public RenderFragment<AuthenticationState> Authorized { get; set; }
+-        public RenderFragment Authorizing { get; private set; }
++        public RenderFragment Authorizing { get; set; }
+-        public RenderFragment<AuthenticationState> ChildContent { get; private set; }
++        public RenderFragment<AuthenticationState> ChildContent { get; set; }
+-        public RenderFragment<AuthenticationState> NotAuthorized { get; private set; }
++        public RenderFragment<AuthenticationState> NotAuthorized { get; set; }
++        public object Resource { get; set; }
+     }
++    public static class BindConverter {
++        public static bool FormatValue(bool value, CultureInfo culture = null);
++        public static string FormatValue(DateTime value, CultureInfo culture = null);
++        public static string FormatValue(DateTime value, string format, CultureInfo culture = null);
++        public static string FormatValue(DateTimeOffset value, CultureInfo culture = null);
++        public static string FormatValue(DateTimeOffset value, string format, CultureInfo culture = null);
++        public static string FormatValue(Decimal value, CultureInfo culture = null);
++        public static string FormatValue(double value, CultureInfo culture = null);
++        public static string FormatValue(int value, CultureInfo culture = null);
++        public static string FormatValue(long value, CultureInfo culture = null);
++        public static Nullable<bool> FormatValue(Nullable<bool> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<DateTime> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<DateTime> value, string format, CultureInfo culture = null);
++        public static string FormatValue(Nullable<DateTimeOffset> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<DateTimeOffset> value, string format, CultureInfo culture = null);
++        public static string FormatValue(Nullable<Decimal> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<double> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<int> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<long> value, CultureInfo culture = null);
++        public static string FormatValue(Nullable<float> value, CultureInfo culture = null);
++        public static string FormatValue(float value, CultureInfo culture = null);
++        public static string FormatValue(string value, CultureInfo culture = null);
++        public static object FormatValue<T>(T value, CultureInfo culture = null);
++        public static bool TryConvertTo<T>(object obj, CultureInfo culture, out T value);
++        public static bool TryConvertToBool(object obj, CultureInfo culture, out bool value);
++        public static bool TryConvertToDateTime(object obj, CultureInfo culture, out DateTime value);
++        public static bool TryConvertToDateTime(object obj, CultureInfo culture, string format, out DateTime value);
++        public static bool TryConvertToDateTimeOffset(object obj, CultureInfo culture, out DateTimeOffset value);
++        public static bool TryConvertToDateTimeOffset(object obj, CultureInfo culture, string format, out DateTimeOffset value);
++        public static bool TryConvertToDecimal(object obj, CultureInfo culture, out Decimal value);
++        public static bool TryConvertToDouble(object obj, CultureInfo culture, out double value);
++        public static bool TryConvertToFloat(object obj, CultureInfo culture, out float value);
++        public static bool TryConvertToInt(object obj, CultureInfo culture, out int value);
++        public static bool TryConvertToLong(object obj, CultureInfo culture, out long value);
++        public static bool TryConvertToNullableBool(object obj, CultureInfo culture, out Nullable<bool> value);
++        public static bool TryConvertToNullableDateTime(object obj, CultureInfo culture, out Nullable<DateTime> value);
++        public static bool TryConvertToNullableDateTime(object obj, CultureInfo culture, string format, out Nullable<DateTime> value);
++        public static bool TryConvertToNullableDateTimeOffset(object obj, CultureInfo culture, out Nullable<DateTimeOffset> value);
++        public static bool TryConvertToNullableDateTimeOffset(object obj, CultureInfo culture, string format, out Nullable<DateTimeOffset> value);
++        public static bool TryConvertToNullableDecimal(object obj, CultureInfo culture, out Nullable<Decimal> value);
++        public static bool TryConvertToNullableDouble(object obj, CultureInfo culture, out Nullable<double> value);
++        public static bool TryConvertToNullableFloat(object obj, CultureInfo culture, out Nullable<float> value);
++        public static bool TryConvertToNullableInt(object obj, CultureInfo culture, out Nullable<int> value);
++        public static bool TryConvertToNullableLong(object obj, CultureInfo culture, out Nullable<long> value);
++        public static bool TryConvertToString(object obj, CultureInfo culture, out string value);
++    }
+     public sealed class BindInputElementAttribute : Attribute {
+-        public BindInputElementAttribute(string type, string suffix, string valueAttribute, string changeAttribute);
+
++        public BindInputElementAttribute(string type, string suffix, string valueAttribute, string changeAttribute, bool isInvariantCulture, string format);
++        public string Format { get; }
++        public bool IsInvariantCulture { get; }
+     }
+-    public static class BindMethods {
+ {
+-        public static EventCallback GetEventHandlerValue<T>(EventCallback value) where T : UIEventArgs;
+
+-        public static EventCallback<T> GetEventHandlerValue<T>(EventCallback<T> value) where T : UIEventArgs;
+
+-        public static MulticastDelegate GetEventHandlerValue<T>(Action value) where T : UIEventArgs;
+
+-        public static MulticastDelegate GetEventHandlerValue<T>(Action<T> value) where T : UIEventArgs;
+
+-        public static MulticastDelegate GetEventHandlerValue<T>(Func<Task> value) where T : UIEventArgs;
+
+-        public static MulticastDelegate GetEventHandlerValue<T>(Func<T, Task> value) where T : UIEventArgs;
+
+-        public static string GetEventHandlerValue<T>(string value) where T : UIEventArgs;
+
+-        public static string GetValue(DateTime value, string format);
+
+-        public static T GetValue<T>(T value);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<bool> setter, bool existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<DateTime> setter, DateTime existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<DateTime> setter, DateTime existingValue, string format);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Decimal> setter, Decimal existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<double> setter, double existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<int> setter, int existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<long> setter, long existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<bool>> setter, Nullable<bool> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<Decimal>> setter, Nullable<Decimal> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<double>> setter, Nullable<double> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<int>> setter, Nullable<int> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<long>> setter, Nullable<long> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<Nullable<float>> setter, Nullable<float> existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<float> setter, float existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler(Action<string> setter, string existingValue);
+
+-        public static Action<UIEventArgs> SetValueHandler<T>(Action<T> setter, T existingValue);
+
+-    }
+     public class CascadingAuthenticationState : ComponentBase, IDisposable {
+-        public RenderFragment ChildContent { get; private set; }
++        public RenderFragment ChildContent { get; set; }
+-        protected override void OnInit();
+
++        protected override void OnInitialized();
+     }
+     public class CascadingValue<T> : IComponent {
+-        public RenderFragment ChildContent { get; private set; }
++        public RenderFragment ChildContent { get; set; }
+-        public bool IsFixed { get; private set; }
++        public bool IsFixed { get; set; }
+-        public string Name { get; private set; }
++        public string Name { get; set; }
+-        public T Value { get; private set; }
++        public T Value { get; set; }
++        public void Attach(RenderHandle renderHandle);
+-        public void Configure(RenderHandle renderHandle);
+
+-        public Task SetParametersAsync(ParameterCollection parameters);
+
++        public Task SetParametersAsync(ParameterView parameters);
+     }
+     public abstract class ComponentBase : IComponent, IHandleAfterRender, IHandleEvent {
+-        protected Task Invoke(Action workItem);
+
++        protected Task InvokeAsync(Action workItem);
++        void Microsoft.AspNetCore.Components.IComponent.Attach(RenderHandle renderHandle);
+-        void Microsoft.AspNetCore.Components.IComponent.Configure(RenderHandle renderHandle);
+
+-        protected virtual void OnInit();
+
+-        protected virtual Task OnInitAsync();
+
++        protected virtual void OnInitialized();
++        protected virtual Task OnInitializedAsync();
+-        public virtual Task SetParametersAsync(ParameterCollection parameters);
+
++        public virtual Task SetParametersAsync(ParameterView parameters);
+     }
++    public abstract class Dispatcher {
++        protected Dispatcher();
++        public abstract bool CheckAccess();
++        public static Dispatcher CreateDefault();
++        public abstract Task InvokeAsync(Action workItem);
++        public abstract Task InvokeAsync(Func<Task> workItem);
++        public abstract Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem);
++        public abstract Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem);
++        protected void OnUnhandledException(UnhandledExceptionEventArgs e);
++    }
+-    public readonly struct ElementRef {
+ {
+-        public string __internalId { get; }
+
+-    }
++    public readonly struct ElementReference
+     public readonly struct EventCallback<T> {
++        public static readonly EventCallback<T> Empty;
+     }
+     public sealed class EventCallbackFactory {
+-        public string Create<T>(object receiver, string callback);
+
+     }
+     public static class EventCallbackFactoryBinderExtensions {
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<bool> setter, bool existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<bool> setter, bool existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTime> setter, DateTime existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTime> setter, DateTime existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTime> setter, DateTime existingValue, string format);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTime> setter, DateTime existingValue, string format, CultureInfo culture = null);
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTimeOffset> setter, DateTimeOffset existingValue, CultureInfo culture = null);
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<DateTimeOffset> setter, DateTimeOffset existingValue, string format, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Decimal> setter, Decimal existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Decimal> setter, Decimal existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<double> setter, double existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<double> setter, double existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<int> setter, int existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<int> setter, int existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<long> setter, long existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<long> setter, long existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<bool>> setter, Nullable<bool> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<bool>> setter, Nullable<bool> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<DateTime>> setter, Nullable<DateTime> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<DateTime>> setter, Nullable<DateTime> existingValue, CultureInfo culture = null);
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<DateTime>> setter, Nullable<DateTime> existingValue, string format, CultureInfo culture = null);
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<DateTimeOffset>> setter, Nullable<DateTimeOffset> existingValue, CultureInfo culture = null);
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<DateTimeOffset>> setter, Nullable<DateTimeOffset> existingValue, string format, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<Decimal>> setter, Nullable<Decimal> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<Decimal>> setter, Nullable<Decimal> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<double>> setter, Nullable<double> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<double>> setter, Nullable<double> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<int>> setter, Nullable<int> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<int>> setter, Nullable<int> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<long>> setter, Nullable<long> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<long>> setter, Nullable<long> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<float>> setter, Nullable<float> existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<Nullable<float>> setter, Nullable<float> existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<float> setter, float existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<float> setter, float existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<string> setter, string existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<string> setter, string existingValue, CultureInfo culture = null);
+-        public static EventCallback<UIChangeEventArgs> CreateBinder<T>(this EventCallbackFactory factory, object receiver, Action<T> setter, T existingValue);
+
++        public static EventCallback<UIChangeEventArgs> CreateBinder<T>(this EventCallbackFactory factory, object receiver, Action<T> setter, T existingValue, CultureInfo culture = null);
+     }
+     public static class EventCallbackFactoryUIEventArgsExtensions {
+-        public static EventCallback<UIClipboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIClipboardEventArgs> callback);
+
+-        public static EventCallback<UIDragEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIDragEventArgs> callback);
+
+-        public static EventCallback<UIErrorEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIErrorEventArgs> callback);
+
+-        public static EventCallback<UIFocusEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIFocusEventArgs> callback);
+
+-        public static EventCallback<UIKeyboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIKeyboardEventArgs> callback);
+
+-        public static EventCallback<UIMouseEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIMouseEventArgs> callback);
+
+-        public static EventCallback<UIPointerEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIPointerEventArgs> callback);
+
+-        public static EventCallback<UIProgressEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIProgressEventArgs> callback);
+
+-        public static EventCallback<UITouchEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UITouchEventArgs> callback);
+
+-        public static EventCallback<UIWheelEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIWheelEventArgs> callback);
+
+-        public static EventCallback<UIClipboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIClipboardEventArgs, Task> callback);
+
+-        public static EventCallback<UIDragEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIDragEventArgs, Task> callback);
+
+-        public static EventCallback<UIErrorEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIErrorEventArgs, Task> callback);
+
+-        public static EventCallback<UIFocusEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIFocusEventArgs, Task> callback);
+
+-        public static EventCallback<UIKeyboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIKeyboardEventArgs, Task> callback);
+
+-        public static EventCallback<UIMouseEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIMouseEventArgs, Task> callback);
+
+-        public static EventCallback<UIPointerEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIPointerEventArgs, Task> callback);
+
+-        public static EventCallback<UIProgressEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIProgressEventArgs, Task> callback);
+
+-        public static EventCallback<UITouchEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UITouchEventArgs, Task> callback);
+
+-        public static EventCallback<UIWheelEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIWheelEventArgs, Task> callback);
+
+     }
+-    public struct EventCallbackWorkItem
++    public readonly struct EventCallbackWorkItem
+-    public static class HttpClientJsonExtensions {
+ {
+-        public static Task<T> GetJsonAsync<T>(this HttpClient httpClient, string requestUri);
+
+-        public static Task PostJsonAsync(this HttpClient httpClient, string requestUri, object content);
+
+-        public static Task<T> PostJsonAsync<T>(this HttpClient httpClient, string requestUri, object content);
+
+-        public static Task PutJsonAsync(this HttpClient httpClient, string requestUri, object content);
+
+-        public static Task<T> PutJsonAsync<T>(this HttpClient httpClient, string requestUri, object content);
+
+-        public static Task SendJsonAsync(this HttpClient httpClient, HttpMethod method, string requestUri, object content);
+
+-        public static Task<T> SendJsonAsync<T>(this HttpClient httpClient, HttpMethod method, string requestUri, object content);
+
+-    }
+     public interface IComponent {
++        void Attach(RenderHandle renderHandle);
+-        void Configure(RenderHandle renderHandle);
+
+-        Task SetParametersAsync(ParameterCollection parameters);
+
++        Task SetParametersAsync(ParameterView parameters);
+     }
++    public interface IHostEnvironmentAuthenticationStateProvider {
++        void SetAuthenticationState(Task<AuthenticationState> authenticationStateTask);
++    }
+-    public class InjectAttribute : Attribute
++    public sealed class InjectAttribute : Attribute
++    public sealed class LayoutAttribute : Attribute {
++        public LayoutAttribute(Type layoutType);
++        public Type LayoutType { get; }
++    }
++    public abstract class LayoutComponentBase : ComponentBase {
++        protected LayoutComponentBase();
++        public RenderFragment Body { get; set; }
++    }
+     public class PageDisplay : IComponent {
+-        public RenderFragment AuthorizingContent { get; private set; }
++        public RenderFragment AuthorizingContent { get; set; }
+-        public RenderFragment<AuthenticationState> NotAuthorizedContent { get; private set; }
++        public RenderFragment<AuthenticationState> NotAuthorizedContent { get; set; }
+-        public Type Page { get; private set; }
++        public Type Page { get; set; }
+-        public IDictionary<string, object> PageParameters { get; private set; }
++        public IDictionary<string, object> PageParameters { get; set; }
++        public void Attach(RenderHandle renderHandle);
+-        public void Configure(RenderHandle renderHandle);
+
+-        public Task SetParametersAsync(ParameterCollection parameters);
+
++        public Task SetParametersAsync(ParameterView parameters);
+     }
+-    public readonly struct Parameter {
+ {
+-        public bool Cascading { get; }
+
+-        public string Name { get; }
+
+-        public object Value { get; }
+
+-    }
+-    public readonly struct ParameterCollection {
+ {
+-        public static ParameterCollection Empty { get; }
+
+-        public static ParameterCollection FromDictionary(IDictionary<string, object> parameters);
+
+-        public ParameterEnumerator GetEnumerator();
+
+-        public T GetValueOrDefault<T>(string parameterName);
+
+-        public T GetValueOrDefault<T>(string parameterName, T defaultValue);
+
+-        public IReadOnlyDictionary<string, object> ToDictionary();
+
+-        public bool TryGetValue<T>(string parameterName, out T result);
+
+-    }
+-    public static class ParameterCollectionExtensions {
+ {
+-        public static void SetParameterProperties(this in ParameterCollection parameterCollection, object target);
+
+-    }
+-    public struct ParameterEnumerator {
+ {
+-        public Parameter Current { get; }
+
+-        public bool MoveNext();
+
+-    }
++    public readonly struct ParameterValue {
++        public bool Cascading { get; }
++        public string Name { get; }
++        public object Value { get; }
++    }
++    public readonly struct ParameterView {
++        public static ParameterView Empty { get; }
++        public static ParameterView FromDictionary(IDictionary<string, object> parameters);
++        public ParameterView.Enumerator GetEnumerator();
++        public T GetValueOrDefault<T>(string parameterName);
++        public T GetValueOrDefault<T>(string parameterName, T defaultValue);
++        public void SetParameterProperties(object target);
++        public IReadOnlyDictionary<string, object> ToDictionary();
++        public bool TryGetValue<T>(string parameterName, out T result);
++        public struct Enumerator {
++            public ParameterValue Current { get; }
++            public bool MoveNext();
++        }
++    }
+     public readonly struct RenderHandle {
++        public Dispatcher Dispatcher { get; }
+-        public Task Invoke(Action workItem);
+
+-        public Task InvokeAsync(Func<Task> workItem);
+
+     }
+-    public class RouteAttribute : Attribute
++    public sealed class RouteAttribute : Attribute
+-    public static class RuntimeHelpers {
+ {
+-        public static T TypeCheck<T>(T value);
+
+-    }
+     public class UIEventArgs {
+-        public static readonly UIEventArgs Empty;
+
+     }
+-    public static class UIEventArgsRenderTreeBuilderExtensions {
+ {
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIChangeEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIClipboardEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIDragEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIErrorEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIFocusEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIKeyboardEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIMouseEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIPointerEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIProgressEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UITouchEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Action<UIWheelEventArgs> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIChangeEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIClipboardEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIDragEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIErrorEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIFocusEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIKeyboardEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIMouseEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIPointerEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIProgressEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UITouchEventArgs, Task> value);
+
+-        public static void AddAttribute(this RenderTreeBuilder builder, int sequence, string name, Func<UIWheelEventArgs, Task> value);
+
+-    }
++    public static class WebEventCallbackFactoryUIEventArgsExtensions {
++        public static EventCallback<UIClipboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIClipboardEventArgs> callback);
++        public static EventCallback<UIDragEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIDragEventArgs> callback);
++        public static EventCallback<UIErrorEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIErrorEventArgs> callback);
++        public static EventCallback<UIFocusEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIFocusEventArgs> callback);
++        public static EventCallback<UIKeyboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIKeyboardEventArgs> callback);
++        public static EventCallback<UIMouseEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIMouseEventArgs> callback);
++        public static EventCallback<UIPointerEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIPointerEventArgs> callback);
++        public static EventCallback<UIProgressEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIProgressEventArgs> callback);
++        public static EventCallback<UITouchEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UITouchEventArgs> callback);
++        public static EventCallback<UIWheelEventArgs> Create(this EventCallbackFactory factory, object receiver, Action<UIWheelEventArgs> callback);
++        public static EventCallback<UIClipboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIClipboardEventArgs, Task> callback);
++        public static EventCallback<UIDragEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIDragEventArgs, Task> callback);
++        public static EventCallback<UIErrorEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIErrorEventArgs, Task> callback);
++        public static EventCallback<UIFocusEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIFocusEventArgs, Task> callback);
++        public static EventCallback<UIKeyboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIKeyboardEventArgs, Task> callback);
++        public static EventCallback<UIMouseEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIMouseEventArgs, Task> callback);
++        public static EventCallback<UIPointerEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIPointerEventArgs, Task> callback);
++        public static EventCallback<UIProgressEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIProgressEventArgs, Task> callback);
++        public static EventCallback<UITouchEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UITouchEventArgs, Task> callback);
++        public static EventCallback<UIWheelEventArgs> Create(this EventCallbackFactory factory, object receiver, Func<UIWheelEventArgs, Task> callback);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Connections.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Connections
+
+``` diff
+ namespace Microsoft.AspNetCore.Connections {
+     public interface IConnectionFactory {
+         ValueTask<ConnectionContext> ConnectAsync(EndPoint endPoint, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.DataProtection.Cng.Internal.md

@@ -0,0 +1,25 @@
+# Microsoft.AspNetCore.DataProtection.Cng.Internal
+
+``` diff
+-namespace Microsoft.AspNetCore.DataProtection.Cng.Internal {
+ {
+-    public abstract class CngAuthenticatedEncryptorBase : IAuthenticatedEncryptor, IDisposable {
+ {
+-        protected CngAuthenticatedEncryptorBase();
+
+-        public byte[] Decrypt(ArraySegment<byte> ciphertext, ArraySegment<byte> additionalAuthenticatedData);
+
+-        protected unsafe abstract byte[] DecryptImpl(byte* pbCiphertext, uint cbCiphertext, byte* pbAdditionalAuthenticatedData, uint cbAdditionalAuthenticatedData);
+
+-        public abstract void Dispose();
+
+-        public byte[] Encrypt(ArraySegment<byte> plaintext, ArraySegment<byte> additionalAuthenticatedData);
+
+-        public byte[] Encrypt(ArraySegment<byte> plaintext, ArraySegment<byte> additionalAuthenticatedData, uint preBufferSize, uint postBufferSize);
+
+-        protected unsafe abstract byte[] EncryptImpl(byte* pbPlaintext, uint cbPlaintext, byte* pbAdditionalAuthenticatedData, uint cbAdditionalAuthenticatedData, uint cbPreBuffer, uint cbPostBuffer);
+
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.DataProtection.Internal.md

@@ -0,0 +1,14 @@
+# Microsoft.AspNetCore.DataProtection.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.Internal {
+-    public class DataProtectionBuilder : IDataProtectionBuilder {
+ {
+-        public DataProtectionBuilder(IServiceCollection services);
+
+-        public IServiceCollection Services { get; }
+
+-    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Hosting.Server.Abstractions.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Hosting.Server.Abstractions
+
+``` diff
++namespace Microsoft.AspNetCore.Hosting.Server.Abstractions {
++    public interface IHostContextContainer<TContext> {
++        TContext HostContext { get; set; }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Http.Features.md

@@ -0,0 +1,37 @@
+# Microsoft.AspNetCore.Http.Features
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Features {
++    public interface IHttpResponseBodyFeature {
++        Stream Stream { get; }
++        PipeWriter Writer { get; }
++        Task CompleteAsync();
++        void DisableBuffering();
++        Task SendFileAsync(string path, long offset, Nullable<long> count, CancellationToken cancellationToken = default(CancellationToken));
++        Task StartAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
+-    public interface IHttpResponseCompletionFeature {
+ {
+-        Task CompleteAsync();
+
+-    }
+-    public interface IHttpResponseStartFeature {
+ {
+-        Task StartAsync(CancellationToken token = default(CancellationToken));
+
+-    }
+-    public interface IResponseBodyPipeFeature {
+ {
+-        PipeWriter Writer { get; }
+
+-    }
+-    public class ResponseBodyPipeFeature : IResponseBodyPipeFeature {
+ {
+-        public ResponseBodyPipeFeature(HttpContext context);
+
+-        public PipeWriter Writer { get; }
+
+-    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Http.md

@@ -0,0 +1,30 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
+     public abstract class HttpResponse {
++        public virtual Task CompleteAsync();
+     }
+-    public interface IDefaultHttpContextContainer {
+ {
+-        DefaultHttpContext HttpContext { get; }
+
+-    }
++    public static class SendFileFallback {
++        public static Task SendFileAsync(Stream destination, string filePath, long offset, Nullable<long> count, CancellationToken cancellationToken);
++    }
++    public class StreamResponseBodyFeature : IHttpResponseBodyFeature {
++        public StreamResponseBodyFeature(Stream stream);
++        public StreamResponseBodyFeature(Stream stream, IHttpResponseBodyFeature priorFeature);
++        public IHttpResponseBodyFeature PriorFeature { get; }
++        public Stream Stream { get; }
++        public PipeWriter Writer { get; }
++        public virtual Task CompleteAsync();
++        public virtual void DisableBuffering();
++        public void Dispose();
++        public virtual Task SendFileAsync(string path, long offset, Nullable<long> count, CancellationToken cancellationToken);
++        public virtual Task StartAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Identity.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Identity
+
+``` diff
+ namespace Microsoft.AspNetCore.Identity {
+     public class ExternalLoginInfo : UserLoginInfo {
++        public AuthenticationProperties AuthenticationProperties { get; set; }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Mvc.ActionConstraints.md

@@ -0,0 +1,14 @@
+# Microsoft.AspNetCore.Mvc.ActionConstraints
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ActionConstraints {
++    public class HttpMethodActionConstraint : IActionConstraint, IActionConstraintMetadata {
++        public static readonly int HttpMethodConstraintOrder;
++        public HttpMethodActionConstraint(IEnumerable<string> httpMethods);
++        public IEnumerable<string> HttpMethods { get; }
++        public int Order { get; }
++        public virtual bool Accept(ActionConstraintContext context);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Mvc.Diagnostics.md

@@ -0,0 +1,481 @@
+# Microsoft.AspNetCore.Mvc.Diagnostics
+
+``` diff
++namespace Microsoft.AspNetCore.Mvc.Diagnostics {
++    public sealed class AfterActionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterAction";
++        public AfterActionEventData(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public HttpContext HttpContext { get; }
++        public RouteData RouteData { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterActionFilterOnActionExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecuted";
++        public AfterActionFilterOnActionExecutedEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutedContext ActionExecutedContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterActionFilterOnActionExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecuting";
++        public AfterActionFilterOnActionExecutingEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutingContext ActionExecutingContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterActionFilterOnActionExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnActionExecution";
++        public AfterActionFilterOnActionExecutionEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutedContext ActionExecutedContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterActionResultEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterActionResult";
++        public AfterActionResultEventData(ActionContext actionContext, IActionResult result);
++        public ActionContext ActionContext { get; }
++        protected override int Count { get; }
++        public IActionResult Result { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterAuthorizationFilterOnAuthorizationEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnAuthorization";
++        public AfterAuthorizationFilterOnAuthorizationEventData(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public AuthorizationFilterContext AuthorizationContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterControllerActionMethodEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterControllerActionMethod";
++        public AfterControllerActionMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, object controller, IActionResult result);
++        public ActionContext ActionContext { get; }
++        public IReadOnlyDictionary<string, object> Arguments { get; }
++        public object Controller { get; }
++        protected override int Count { get; }
++        public IActionResult Result { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterExceptionFilterOnExceptionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnException";
++        public AfterExceptionFilterOnExceptionEventData(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public ExceptionContext ExceptionContext { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterHandlerMethodEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterHandlerMethod";
++        public AfterHandlerMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance, IActionResult result);
++        public ActionContext ActionContext { get; }
++        public IReadOnlyDictionary<string, object> Arguments { get; }
++        protected override int Count { get; }
++        public HandlerMethodDescriptor HandlerMethodDescriptor { get; }
++        public object Instance { get; }
++        public IActionResult Result { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterPageFilterOnPageHandlerExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecuted";
++        public AfterPageFilterOnPageHandlerExecutedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerExecutedContext HandlerExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterPageFilterOnPageHandlerExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecuting";
++        public AfterPageFilterOnPageHandlerExecutingEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerExecutingContext HandlerExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterPageFilterOnPageHandlerExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerExecution";
++        public AfterPageFilterOnPageHandlerExecutionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IAsyncPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IAsyncPageFilter Filter { get; }
++        public PageHandlerExecutedContext HandlerExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterPageFilterOnPageHandlerSelectedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerSelected";
++        public AfterPageFilterOnPageHandlerSelectedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerSelectedContext HandlerSelectedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterPageFilterOnPageHandlerSelectionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnPageHandlerSelection";
++        public AfterPageFilterOnPageHandlerSelectionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IAsyncPageFilter Filter { get; }
++        public PageHandlerSelectedContext HandlerSelectedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResourceFilterOnResourceExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecuted";
++        public AfterResourceFilterOnResourceExecutedEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutedContext ResourceExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResourceFilterOnResourceExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecuting";
++        public AfterResourceFilterOnResourceExecutingEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutingContext ResourceExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResourceFilterOnResourceExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResourceExecution";
++        public AfterResourceFilterOnResourceExecutionEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutedContext ResourceExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResultFilterOnResultExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecuted";
++        public AfterResultFilterOnResultExecutedEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutedContext ResultExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResultFilterOnResultExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecuting";
++        public AfterResultFilterOnResultExecutingEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutingContext ResultExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterResultFilterOnResultExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterOnResultExecution";
++        public AfterResultFilterOnResultExecutionEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutedContext ResultExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class AfterViewComponentEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterViewComponent";
++        public AfterViewComponentEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IViewComponentResult viewComponentResult, object viewComponent);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public object ViewComponent { get; }
++        public ViewComponentContext ViewComponentContext { get; }
++        public IViewComponentResult ViewComponentResult { get; }
++    }
++    public sealed class AfterViewEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.AfterView";
++        public AfterViewEventData(IView view, ViewContext viewContext);
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public IView View { get; }
++        public ViewContext ViewContext { get; }
++    }
++    public sealed class AfterViewPageEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.Razor.AfterViewPage";
++        public AfterViewPageEventData(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public HttpContext HttpContext { get; }
++        public IRazorPage Page { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public ViewContext ViewContext { get; }
++    }
++    public sealed class BeforeActionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeAction";
++        public BeforeActionEventData(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public HttpContext HttpContext { get; }
++        public RouteData RouteData { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeActionFilterOnActionExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecuted";
++        public BeforeActionFilterOnActionExecutedEventData(ActionDescriptor actionDescriptor, ActionExecutedContext actionExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutedContext ActionExecutedContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeActionFilterOnActionExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecuting";
++        public BeforeActionFilterOnActionExecutingEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutingContext ActionExecutingContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeActionFilterOnActionExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnActionExecution";
++        public BeforeActionFilterOnActionExecutionEventData(ActionDescriptor actionDescriptor, ActionExecutingContext actionExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public ActionExecutingContext ActionExecutingContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeActionResultEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeActionResult";
++        public BeforeActionResultEventData(ActionContext actionContext, IActionResult result);
++        public ActionContext ActionContext { get; }
++        protected override int Count { get; }
++        public IActionResult Result { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeAuthorizationFilterOnAuthorizationEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnAuthorization";
++        public BeforeAuthorizationFilterOnAuthorizationEventData(ActionDescriptor actionDescriptor, AuthorizationFilterContext authorizationContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        public AuthorizationFilterContext AuthorizationContext { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeControllerActionMethodEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeControllerActionMethod";
++        public BeforeControllerActionMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> actionArguments, object controller);
++        public IReadOnlyDictionary<string, object> ActionArguments { get; }
++        public ActionContext ActionContext { get; }
++        public object Controller { get; }
++        protected sealed override int Count { get; }
++        protected sealed override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeExceptionFilterOnException : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnException";
++        public BeforeExceptionFilterOnException(ActionDescriptor actionDescriptor, ExceptionContext exceptionContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public ExceptionContext ExceptionContext { get; }
++        public IFilterMetadata Filter { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeHandlerMethodEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeHandlerMethod";
++        public BeforeHandlerMethodEventData(ActionContext actionContext, IReadOnlyDictionary<string, object> arguments, HandlerMethodDescriptor handlerMethodDescriptor, object instance);
++        public ActionContext ActionContext { get; }
++        public IReadOnlyDictionary<string, object> Arguments { get; }
++        protected override int Count { get; }
++        public HandlerMethodDescriptor HandlerMethodDescriptor { get; }
++        public object Instance { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforePageFilterOnPageHandlerExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecuted";
++        public BeforePageFilterOnPageHandlerExecutedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutedContext handlerExecutedContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerExecutedContext HandlerExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforePageFilterOnPageHandlerExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecuting";
++        public BeforePageFilterOnPageHandlerExecutingEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerExecutingContext HandlerExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforePageFilterOnPageHandlerExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerExecution";
++        public BeforePageFilterOnPageHandlerExecutionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerExecutingContext handlerExecutionContext, IAsyncPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IAsyncPageFilter Filter { get; }
++        public PageHandlerExecutingContext HandlerExecutionContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforePageFilterOnPageHandlerSelectedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerSelected";
++        public BeforePageFilterOnPageHandlerSelectedEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IPageFilter Filter { get; }
++        public PageHandlerSelectedContext HandlerSelectedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforePageFilterOnPageHandlerSelectionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnPageHandlerSelection";
++        public BeforePageFilterOnPageHandlerSelectionEventData(CompiledPageActionDescriptor actionDescriptor, PageHandlerSelectedContext handlerSelectedContext, IAsyncPageFilter filter);
++        public CompiledPageActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IAsyncPageFilter Filter { get; }
++        public PageHandlerSelectedContext HandlerSelectedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResourceFilterOnResourceExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuted";
++        public BeforeResourceFilterOnResourceExecutedEventData(ActionDescriptor actionDescriptor, ResourceExecutedContext resourceExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutedContext ResourceExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResourceFilterOnResourceExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuting";
++        public BeforeResourceFilterOnResourceExecutingEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutingContext ResourceExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResourceFilterOnResourceExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResourceExecution";
++        public BeforeResourceFilterOnResourceExecutionEventData(ActionDescriptor actionDescriptor, ResourceExecutingContext resourceExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResourceExecutingContext ResourceExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResultFilterOnResultExecutedEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted";
++        public BeforeResultFilterOnResultExecutedEventData(ActionDescriptor actionDescriptor, ResultExecutedContext resultExecutedContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutedContext ResultExecutedContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResultFilterOnResultExecutingEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecuting";
++        public BeforeResultFilterOnResultExecutingEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutingContext ResultExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeResultFilterOnResultExecutionEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeOnResultExecution";
++        public BeforeResultFilterOnResultExecutionEventData(ActionDescriptor actionDescriptor, ResultExecutingContext resultExecutingContext, IFilterMetadata filter);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public IFilterMetadata Filter { get; }
++        public ResultExecutingContext ResultExecutingContext { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++    }
++    public sealed class BeforeViewComponentEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeViewComponent";
++        public BeforeViewComponentEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, object viewComponent);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public object ViewComponent { get; }
++        public ViewComponentContext ViewComponentContext { get; }
++    }
++    public sealed class BeforeViewEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.BeforeView";
++        public BeforeViewEventData(IView view, ViewContext viewContext);
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public IView View { get; }
++        public ViewContext ViewContext { get; }
++    }
++    public sealed class BeforeViewPageEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.Razor.BeforeViewPage";
++        public BeforeViewPageEventData(IRazorPage page, ViewContext viewContext, ActionDescriptor actionDescriptor, HttpContext httpContext);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        public HttpContext HttpContext { get; }
++        public IRazorPage Page { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public ViewContext ViewContext { get; }
++    }
++    public abstract class EventData : IEnumerable, IEnumerable<KeyValuePair<string, object>>, IReadOnlyCollection<KeyValuePair<string, object>>, IReadOnlyList<KeyValuePair<string, object>> {
++        protected const string EventNamespace = "Microsoft.AspNetCore.Mvc.";
++        protected EventData();
++        protected abstract int Count { get; }
++        int System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.Count { get; }
++        KeyValuePair<string, object> System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.this[int index] { get; }
++        protected abstract KeyValuePair<string, object> this[int index] { get; }
++        IEnumerator<KeyValuePair<string, object>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<string, object>> {
++            public KeyValuePair<string, object> Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public void Dispose();
++            public bool MoveNext();
++            void System.Collections.IEnumerator.Reset();
++        }
++    }
++    public sealed class ViewComponentAfterViewExecuteEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.ViewComponentAfterViewExecute";
++        public ViewComponentAfterViewExecuteEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public IView View { get; }
++        public ViewComponentContext ViewComponentContext { get; }
++    }
++    public sealed class ViewComponentBeforeViewExecuteEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.ViewComponentBeforeViewExecute";
++        public ViewComponentBeforeViewExecuteEventData(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, IView view);
++        public ActionDescriptor ActionDescriptor { get; }
++        protected override int Count { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public IView View { get; }
++        public ViewComponentContext ViewComponentContext { get; }
++    }
++    public sealed class ViewFoundEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.ViewFound";
++        public ViewFoundEventData(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IView view);
++        public ActionContext ActionContext { get; }
++        protected override int Count { get; }
++        public bool IsMainPage { get; }
++        public ActionResult Result { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public IView View { get; }
++        public string ViewName { get; }
++    }
++    public sealed class ViewNotFoundEventData : EventData {
++        public const string EventName = "Microsoft.AspNetCore.Mvc.ViewNotFound";
++        public ViewNotFoundEventData(ActionContext actionContext, bool isMainPage, ActionResult result, string viewName, IEnumerable<string> searchedLocations);
++        public ActionContext ActionContext { get; }
++        protected override int Count { get; }
++        public bool IsMainPage { get; }
++        public ActionResult Result { get; }
++        public IEnumerable<string> SearchedLocations { get; }
++        protected override KeyValuePair<string, object> this[int index] { get; }
++        public string ViewName { get; }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Mvc.Infrastructure.md

@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Mvc.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Infrastructure {
++    public class AmbiguousActionException : InvalidOperationException {
++        protected AmbiguousActionException(SerializationInfo info, StreamingContext context);
++        public AmbiguousActionException(string message);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Mvc.ViewFeatures.md

@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Mvc.ViewFeatures
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ViewFeatures {
+     public class ViewExecutor {
++        protected DiagnosticListener DiagnosticListener { get; }
+-        protected DiagnosticListener DiagnosticSource { get; }
+
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Routing.Internal.md

@@ -0,0 +1,51 @@
+# Microsoft.AspNetCore.Routing.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.Routing.Internal {
+-    public enum SegmentState {
+ {
+-        Beginning = 0,
+
+-        Inside = 1,
+
+-    }
+-    public class UriBuildingContext {
+ {
+-        public UriBuildingContext(UrlEncoder urlEncoder);
+
+-        public bool AppendTrailingSlash { get; set; }
+
+-        public SegmentState BufferState { get; }
+
+-        public bool LowercaseQueryStrings { get; set; }
+
+-        public bool LowercaseUrls { get; set; }
+
+-        public TextWriter PathWriter { get; }
+
+-        public TextWriter QueryWriter { get; }
+
+-        public SegmentState UriState { get; }
+
+-        public bool Accept(string value);
+
+-        public bool Accept(string value, bool encodeSlashes);
+
+-        public bool Buffer(string value);
+
+-        public void Clear();
+
+-        public void EndSegment();
+
+-        public void Remove(string literal);
+
+-        public PathString ToPathString();
+
+-        public QueryString ToQueryString();
+
+-        public override string ToString();
+
+-    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Routing.Template.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Routing.Template
+
+``` diff
+ namespace Microsoft.AspNetCore.Routing.Template {
+     public class TemplateBinder {
+-        public TemplateBinder(UrlEncoder urlEncoder, ObjectPool<UriBuildingContext> pool, RoutePattern pattern, RouteValueDictionary defaults, IEnumerable<string> requiredKeys, IEnumerable<ValueTuple<string, IParameterPolicy>> parameterPolicies);
+
+-        public TemplateBinder(UrlEncoder urlEncoder, ObjectPool<UriBuildingContext> pool, RouteTemplate template, RouteValueDictionary defaults);
+
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.Routing.Tree.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.Routing.Tree
+
+``` diff
+ namespace Microsoft.AspNetCore.Routing.Tree {
+     public class TreeRouteBuilder {
+-        public TreeRouteBuilder(ILoggerFactory loggerFactory, ObjectPool<UriBuildingContext> objectPool, IInlineConstraintResolver constraintResolver);
+
+     }
+     public class TreeRouter : IRouter {
+-        public TreeRouter(UrlMatchingTree[] trees, IEnumerable<OutboundRouteEntry> linkGenerationEntries, UrlEncoder urlEncoder, ObjectPool<UriBuildingContext> objectPool, ILogger routeLogger, ILogger constraintLogger, int version);
+
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.AspNetCore.SignalR.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.SignalR
+
+``` diff
+ namespace Microsoft.AspNetCore.SignalR {
+     public class HubConnectionContextOptions {
++        public Nullable<long> MaximumReceiveMessageSize { get; set; }
+     }
+-    public sealed class HubEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
+ {
+-        public void Add(Action<EndpointBuilder> convention);
+
+-    }
+-    public interface IHubEndpointConventionBuilder : IEndpointConventionBuilder
+
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.Extensions.Hosting.Internal.md

@@ -0,0 +1,15 @@
+# Microsoft.Extensions.Hosting.Internal
+
+``` diff
+ namespace Microsoft.Extensions.Hosting.Internal {
+     public class ConsoleLifetime : IDisposable, IHostLifetime {
+-        public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime);
+
+-        public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory);
+
++        public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, IOptions<HostOptions> hostOptions);
++        public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, IOptions<HostOptions> hostOptions, ILoggerFactory loggerFactory);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.JSInterop.Internal.md

@@ -0,0 +1,10 @@
+# Microsoft.JSInterop.Internal
+
+``` diff
+-namespace Microsoft.JSInterop.Internal {
+ {
+-    public sealed class JSAsyncCallResult
+
+-}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_Microsoft.JSInterop.md

@@ -0,0 +1,28 @@
+# Microsoft.JSInterop
+
+``` diff
+ namespace Microsoft.JSInterop {
+     public static class DotNetDispatcher {
+-        public static void EndInvoke(long asyncHandle, bool succeeded, JSAsyncCallResult result);
+
++        public static void EndInvoke(string arguments);
+     }
+     public sealed class DotNetObjectRef<TValue> : IDisposable where TValue : class {
+-        public DotNetObjectRef();
+
+-        public long __dotNetObject { get; set; }
+
+     }
+     public interface IJSRuntime {
++        Task<TValue> InvokeAsync<TValue>(string identifier, IEnumerable<object> args, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public abstract class JSRuntimeBase : IJSRuntime {
++        protected Nullable<TimeSpan> DefaultAsyncTimeout { get; set; }
+-        protected abstract void BeginInvokeJS(long asyncHandle, string identifier, string argsJson);
++        protected abstract void BeginInvokeJS(long taskId, string identifier, string argsJson);
++        protected internal abstract void EndInvokeDotNet(string callId, bool success, object resultOrError, string assemblyName, string methodIdentifier, long dotNetObjectId);
++        public Task<T> InvokeAsync<T>(string identifier, IEnumerable<object> args, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_System.Drawing.Printing.md

@@ -0,0 +1,16 @@
+# System.Drawing.Printing
+
+``` diff
+ namespace System.Drawing.Printing {
++    public class MarginsConverter : ExpandableObjectConverter {
++        public MarginsConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_System.Drawing.md

@@ -0,0 +1,56 @@
+# System.Drawing
+
+``` diff
++namespace System.Drawing {
++    public class FontConverter : TypeConverter {
++        public FontConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context);
++        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++        public override bool GetPropertiesSupported(ITypeDescriptorContext context);
++        public sealed class FontNameConverter : TypeConverter, IDisposable {
++            public FontNameConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++            public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
++            public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
++            void System.IDisposable.Dispose();
++        }
++        public class FontUnitConverter : EnumConverter {
++            public FontUnitConverter();
++            public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++        }
++    }
++    public class IconConverter : ExpandableObjectConverter {
++        public IconConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++    }
++    public class ImageConverter : TypeConverter {
++        public ImageConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++        public override bool GetPropertiesSupported(ITypeDescriptorContext context);
++    }
++    public class ImageFormatConverter : TypeConverter {
++        public ImageFormatConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_System.Media.md

@@ -0,0 +1,41 @@
+# System.Media
+
+``` diff
++namespace System.Media {
++    public class SoundPlayer : Component, ISerializable {
++        public SoundPlayer();
++        public SoundPlayer(Stream stream);
++        protected SoundPlayer(SerializationInfo serializationInfo, StreamingContext context);
++        public SoundPlayer(string soundLocation);
++        public bool IsLoadCompleted { get; }
++        public int LoadTimeout { get; set; }
++        public string SoundLocation { get; set; }
++        public Stream Stream { get; set; }
++        public object Tag { get; set; }
++        public event AsyncCompletedEventHandler LoadCompleted;
++        public event EventHandler SoundLocationChanged;
++        public event EventHandler StreamChanged;
++        public void Load();
++        public void LoadAsync();
++        protected virtual void OnLoadCompleted(AsyncCompletedEventArgs e);
++        protected virtual void OnSoundLocationChanged(EventArgs e);
++        protected virtual void OnStreamChanged(EventArgs e);
++        public void Play();
++        public void PlayLooping();
++        public void PlaySync();
++        public void Stop();
++        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo info, StreamingContext context);
++    }
++    public class SystemSound {
++        public void Play();
++    }
++    public static class SystemSounds {
++        public static SystemSound Asterisk { get; }
++        public static SystemSound Beep { get; }
++        public static SystemSound Exclamation { get; }
++        public static SystemSound Hand { get; }
++        public static SystemSound Question { get; }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview8/ASP.Net/3.0-preview8_System.Security.Cryptography.X509Certificates.md

@@ -0,0 +1,18 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
++namespace System.Security.Cryptography.X509Certificates {
++    public sealed class X509Certificate2UI {
++        public X509Certificate2UI();
++        public static void DisplayCertificate(X509Certificate2 certificate);
++        public static void DisplayCertificate(X509Certificate2 certificate, IntPtr hwndParent);
++        public static X509Certificate2Collection SelectFromCollection(X509Certificate2Collection certificates, string title, string message, X509SelectionFlag selectionFlag);
++        public static X509Certificate2Collection SelectFromCollection(X509Certificate2Collection certificates, string title, string message, X509SelectionFlag selectionFlag, IntPtr hwndParent);
++    }
++    public enum X509SelectionFlag {
++        MultiSelection = 1,
++        SingleSelection = 0,
++    }
++}
+```
+