add api diff for between rc1 and rc2

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2.md

@@ -0,0 +1,11 @@
+# API Difference net5.0-rc1 vs net5.0-rc2
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System.Diagnostics](5.0-rc2_System.Diagnostics.md)
+* [System.Globalization](5.0-rc2_System.Globalization.md)
+* [System.Net](5.0-rc2_System.Net.md)
+* [System.Net.Connections](5.0-rc2_System.Net.Connections.md)
+* [System.Net.Http](5.0-rc2_System.Net.Http.md)
+

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2_System.Diagnostics.md

@@ -0,0 +1,11 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public readonly struct ActivityContext : IEquatable<ActivityContext> {
+-        public ActivityContext(ActivityTraceId traceId, ActivitySpanId spanId, ActivityTraceFlags traceOptions, string traceState = null, bool isRemote = false);
++        public ActivityContext(ActivityTraceId traceId, ActivitySpanId spanId, ActivityTraceFlags traceFlags, string traceState = null, bool isRemote = false);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2_System.Globalization.md

@@ -0,0 +1,11 @@
+# System.Globalization
+
+``` diff
+ namespace System.Globalization {
+     public sealed class CompareInfo : IDeserializationCallback {
+-        public bool IsPrefix(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, out int matchLength);
++        public bool IsPrefix(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, out int matchLength);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2_System.Net.Connections.md

@@ -0,0 +1,125 @@
+# System.Net.Connections
+
+``` diff
+-namespace System.Net.Connections {
+ {
+-    public abstract class Connection : ConnectionBase {
+ {
+-        protected Connection();
+
+-        public IDuplexPipe Pipe { get; }
+
+-        public Stream Stream { get; }
+
+-        protected virtual IDuplexPipe CreatePipe();
+
+-        protected virtual Stream CreateStream();
+
+-        public static Connection FromPipe(IDuplexPipe pipe, bool leaveOpen = false, IConnectionProperties properties = null, EndPoint localEndPoint = null, EndPoint remoteEndPoint = null);
+
+-        public static Connection FromStream(Stream stream, bool leaveOpen = false, IConnectionProperties properties = null, EndPoint localEndPoint = null, EndPoint remoteEndPoint = null);
+
+-    }
+-    public abstract class ConnectionBase : IAsyncDisposable, IDisposable {
+ {
+-        protected ConnectionBase();
+
+-        public abstract IConnectionProperties ConnectionProperties { get; }
+
+-        public abstract EndPoint LocalEndPoint { get; }
+
+-        public abstract EndPoint RemoteEndPoint { get; }
+
+-        public ValueTask CloseAsync(ConnectionCloseMethod method = ConnectionCloseMethod.GracefulShutdown, CancellationToken cancellationToken = default(CancellationToken));
+
+-        protected abstract ValueTask CloseAsyncCore(ConnectionCloseMethod method, CancellationToken cancellationToken);
+
+-        public void Dispose();
+
+-        public ValueTask DisposeAsync();
+
+-    }
+-    public enum ConnectionCloseMethod {
+ {
+-        Abort = 1,
+
+-        GracefulShutdown = 0,
+
+-        Immediate = 2,
+
+-    }
+-    public static class ConnectionExtensions {
+ {
+-        public static ConnectionFactory Filter(this ConnectionFactory factory, Func<Connection, IConnectionProperties, CancellationToken, ValueTask<Connection>> filter);
+
+-        public static bool TryGet<T>(this IConnectionProperties properties, out T property);
+
+-    }
+-    public abstract class ConnectionFactory : IAsyncDisposable, IDisposable {
+ {
+-        protected ConnectionFactory();
+
+-        public abstract ValueTask<Connection> ConnectAsync(EndPoint endPoint, IConnectionProperties options = null, CancellationToken cancellationToken = default(CancellationToken));
+
+-        public void Dispose();
+
+-        protected virtual void Dispose(bool disposing);
+
+-        public ValueTask DisposeAsync();
+
+-        protected virtual ValueTask DisposeAsyncCore();
+
+-    }
+-    public abstract class ConnectionListener : IAsyncDisposable, IDisposable {
+ {
+-        protected ConnectionListener();
+
+-        public abstract IConnectionProperties ListenerProperties { get; }
+
+-        public abstract EndPoint LocalEndPoint { get; }
+
+-        public abstract ValueTask<Connection> AcceptAsync(IConnectionProperties options = null, CancellationToken cancellationToken = default(CancellationToken));
+
+-        public void Dispose();
+
+-        protected virtual void Dispose(bool disposing);
+
+-        public ValueTask DisposeAsync();
+
+-        protected virtual ValueTask DisposeAsyncCore();
+
+-    }
+-    public abstract class ConnectionListenerFactory : IAsyncDisposable, IDisposable {
+ {
+-        protected ConnectionListenerFactory();
+
+-        public void Dispose();
+
+-        protected virtual void Dispose(bool disposing);
+
+-        public ValueTask DisposeAsync();
+
+-        protected virtual ValueTask DisposeAsyncCore();
+
+-        public abstract ValueTask<ConnectionListener> ListenAsync(EndPoint endPoint, IConnectionProperties options = null, CancellationToken cancellationToken = default(CancellationToken));
+
+-    }
+-    public interface IConnectionProperties {
+ {
+-        bool TryGet(Type propertyKey, out object property);
+
+-    }
+-    public class SocketsConnectionFactory : ConnectionFactory {
+ {
+-        public SocketsConnectionFactory(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType);
+
+-        public SocketsConnectionFactory(SocketType socketType, ProtocolType protocolType);
+
+-        public override ValueTask<Connection> ConnectAsync(EndPoint endPoint, IConnectionProperties options = null, CancellationToken cancellationToken = default(CancellationToken));
+
+-        protected virtual Socket CreateSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, EndPoint endPoint, IConnectionProperties options);
+
+-    }
+-}
+```
+

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2_System.Net.Http.md

@@ -0,0 +1,24 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
++    public sealed class SocketsHttpConnectionContext {
++        public DnsEndPoint DnsEndPoint { get; }
++        public HttpRequestMessage InitialRequestMessage { get; }
++    }
+     public sealed class SocketsHttpHandler : HttpMessageHandler {
++        public Func<SocketsHttpConnectionContext, CancellationToken, ValueTask<Stream>> ConnectCallback { get; set; }
+-        public ConnectionFactory ConnectionFactory { get; set; }
+
+-        public Func<HttpRequestMessage, Connection, CancellationToken, ValueTask<Connection>> PlaintextFilter { get; set; }
+
++        public Func<SocketsHttpPlaintextStreamFilterContext, CancellationToken, ValueTask<Stream>> PlaintextStreamFilter { get; set; }
+     }
++    public sealed class SocketsHttpPlaintextStreamFilterContext {
++        public HttpRequestMessage InitialRequestMessage { get; }
++        public Version NegotiatedHttpVersion { get; }
++        public Stream PlaintextStream { get; }
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/.Net/5.0-rc2_System.Net.md

@@ -0,0 +1,37 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+-    public enum NetworkError {
+ {
+-        ConnectionAborted = 6,
+
+-        ConnectionRefused = 4,
+
+-        ConnectionReset = 7,
+
+-        EndPointInUse = 1,
+
+-        HostNotFound = 2,
+
+-        OperationAborted = 5,
+
+-        Other = 0,
+
+-        TimedOut = 3,
+
+-    }
+-    public class NetworkException : IOException {
+ {
+-        public NetworkException(NetworkError error, Exception innerException = null);
+
+-        protected NetworkException(SerializationInfo serializationInfo, StreamingContext streamingContext);
+
+-        public NetworkException(string message, NetworkError error, Exception innerException = null);
+
+-        public NetworkError NetworkError { get; }
+
+-    }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2.md

@@ -0,0 +1,11 @@
+# API Difference net5.0-rc1 vs net5.0-rc2
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Builder](5.0-rc2_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage](5.0-rc2_Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.md)
+* [Microsoft.AspNetCore.Components.Web.Virtualization](5.0-rc2_Microsoft.AspNetCore.Components.Web.Virtualization.md)
+* [Microsoft.JSInterop](5.0-rc2_Microsoft.JSInterop.md)
+* [Microsoft.JSInterop.Implementation](5.0-rc2_Microsoft.JSInterop.Implementation.md)
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2_Microsoft.AspNetCore.Builder.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+     public static class ControllerEndpointRouteBuilderExtensions {
++        public static void MapDynamicControllerRoute<TTransformer>(this IEndpointRouteBuilder endpoints, string pattern, object state, int order) where TTransformer : DynamicRouteValueTransformer;
+     }
+     public static class RazorPagesEndpointRouteBuilderExtensions {
++        public static void MapDynamicPageRoute<TTransformer>(this IEndpointRouteBuilder endpoints, string pattern, object state, int order) where TTransformer : DynamicRouteValueTransformer;
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2_Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.md

@@ -0,0 +1,24 @@
+# Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage
+
+``` diff
++namespace Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage {
++    public abstract class ProtectedBrowserStorage {
++        public ValueTask DeleteAsync(string key);
++        public ValueTask<ProtectedBrowserStorageResult<TValue>> GetAsync<TValue>(string key);
++        public ValueTask<ProtectedBrowserStorageResult<TValue>> GetAsync<TValue>(string purpose, string key);
++        public ValueTask SetAsync(string key, object value);
++        public ValueTask SetAsync(string purpose, string key, object value);
++    }
++    public readonly struct ProtectedBrowserStorageResult<TValue> {
++        public bool Success { get; }
++        public TValue Value { get; }
++    }
++    public sealed class ProtectedLocalStorage : ProtectedBrowserStorage {
++        public ProtectedLocalStorage(IJSRuntime jsRuntime, IDataProtectionProvider dataProtectionProvider);
++    }
++    public sealed class ProtectedSessionStorage : ProtectedBrowserStorage {
++        public ProtectedSessionStorage(IJSRuntime jsRuntime, IDataProtectionProvider dataProtectionProvider);
++    }
++}
+```
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2_Microsoft.AspNetCore.Components.Web.Virtualization.md

@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Components.Web.Virtualization
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Web.Virtualization {
+     public sealed class Virtualize<TItem> : ComponentBase, IAsyncDisposable, IVirtualizeJsCallbacks {
++        public int OverscanCount { get; set; }
++        public Task RefreshDataAsync();
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2_Microsoft.JSInterop.Implementation.md

@@ -0,0 +1,20 @@
+# Microsoft.JSInterop.Implementation
+
+``` diff
++namespace Microsoft.JSInterop.Implementation {
++    public class JSInProcessObjectReference : JSObjectReference, IAsyncDisposable, IDisposable, IJSInProcessObjectReference, IJSObjectReference {
++        protected internal JSInProcessObjectReference(JSInProcessRuntime jsRuntime, long id);
++        public void Dispose();
++        public TValue Invoke<TValue>(string identifier, params object[] args);
++    }
++    public class JSObjectReference : IAsyncDisposable, IJSObjectReference {
++        protected internal JSObjectReference(JSRuntime jsRuntime, long id);
++        protected internal long Id { get; }
++        public ValueTask DisposeAsync();
++        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object[] args);
++        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object[] args);
++        protected void ThrowIfDisposed();
++    }
++}
+```
+

release-notes/5.0/preview/api-diff/rc2/Asp.Net/5.0-rc2_Microsoft.JSInterop.md

@@ -0,0 +1,58 @@
+# Microsoft.JSInterop
+
+``` diff
+ namespace Microsoft.JSInterop {
++    public interface IJSInProcessObjectReference : IAsyncDisposable, IDisposable, IJSObjectReference {
++        TValue Invoke<TValue>(string identifier, params object[] args);
++    }
+     public interface IJSInProcessRuntime : IJSRuntime {
+-        T Invoke<T>(string identifier, params object[] args);
+
++        TResult Invoke<TResult>(string identifier, params object[] args);
+     }
++    public interface IJSObjectReference : IAsyncDisposable {
++        ValueTask<TValue> InvokeAsync<TValue>(string identifier, object[] args);
++        ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object[] args);
++    }
++    public interface IJSUnmarshalledObjectReference : IAsyncDisposable, IDisposable, IJSInProcessObjectReference, IJSObjectReference {
++        TResult InvokeUnmarshalled<T0, T1, T2, TResult>(string identifier, T0 arg0, T1 arg1, T2 arg2);
++        TResult InvokeUnmarshalled<T0, T1, TResult>(string identifier, T0 arg0, T1 arg1);
++        TResult InvokeUnmarshalled<T0, TResult>(string identifier, T0 arg0);
++        TResult InvokeUnmarshalled<TResult>(string identifier);
++    }
+-    public class JSInProcessObjectReference : JSObjectReference {
+ {
+-        public TValue Invoke<TValue>(string identifier, params object[] args);
+
+-    }
++    public static class JSInProcessObjectReferenceExtensions {
++        public static void InvokeVoid(this IJSInProcessObjectReference jsObjectReference, string identifier, params object[] args);
++    }
+-    public class JSObjectReference : IAsyncDisposable {
+ {
+-        public ValueTask DisposeAsync();
+
+-        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, params object[] args);
+
+-        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, params object[] args);
+
+-        public ValueTask InvokeVoidAsync(string identifier, params object[] args);
+
+-        protected void ThrowIfDisposed();
+
+-    }
++    public static class JSObjectReferenceExtensions {
++        public static ValueTask<TValue> InvokeAsync<TValue>(this IJSObjectReference jsObjectReference, string identifier, params object[] args);
++        public static ValueTask<TValue> InvokeAsync<TValue>(this IJSObjectReference jsObjectReference, string identifier, CancellationToken cancellationToken, params object[] args);
++        public static ValueTask<TValue> InvokeAsync<TValue>(this IJSObjectReference jsObjectReference, string identifier, TimeSpan timeout, params object[] args);
++        public static ValueTask InvokeVoidAsync(this IJSObjectReference jsObjectReference, string identifier, params object[] args);
++        public static ValueTask InvokeVoidAsync(this IJSObjectReference jsObjectReference, string identifier, CancellationToken cancellationToken, params object[] args);
++        public static ValueTask InvokeVoidAsync(this IJSObjectReference jsObjectReference, string identifier, TimeSpan timeout, params object[] args);
++    }
+     public abstract class JSRuntime : IJSRuntime {
+-        protected static JSCallResultType ResultTypeFromGeneric<TResult>();
+
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/rc2/README.md

@@ -0,0 +1,6 @@
+# .NET 5.0 rc2 API Changes
+
+The following API changes were made in .NET 5.0 Preview 8:
+
+- [.NET](./.Net/5.0-rc2.md)
+- [ASP.NET](./Asp.Net/5.0-rc2.md)