preview4 api diff vs 3.1 (#4656)

* preview4 api diff vs 3.1

* feedback from preview2

* remove ? -> nullable chnage from diff

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

@@ -0,0 +1,43 @@
+# API Difference netcoreapp3.1 vs netcore5.0-preview4
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.VisualBasic](5.0-preview4_Microsoft.VisualBasic.md)
+* [Microsoft.VisualBasic.CompilerServices](5.0-preview4_Microsoft.VisualBasic.CompilerServices.md)
+* [Microsoft.Win32.SafeHandles](5.0-preview4_Microsoft.Win32.SafeHandles.md)
+* [System](5.0-preview4_System.md)
+* [System.Buffers](5.0-preview4_System.Buffers.md)
+* [System.Buffers.Binary](5.0-preview4_System.Buffers.Binary.md)
+* [System.Collections.Concurrent](5.0-preview4_System.Collections.Concurrent.md)
+* [System.Collections.Generic](5.0-preview4_System.Collections.Generic.md)
+* [System.Collections.Immutable](5.0-preview4_System.Collections.Immutable.md)
+* [System.Diagnostics](5.0-preview4_System.Diagnostics.md)
+* [System.Diagnostics.CodeAnalysis](5.0-preview4_System.Diagnostics.CodeAnalysis.md)
+* [System.Globalization](5.0-preview4_System.Globalization.md)
+* [System.IO](5.0-preview4_System.IO.md)
+* [System.IO.Pipes](5.0-preview4_System.IO.Pipes.md)
+* [System.Linq](5.0-preview4_System.Linq.md)
+* [System.Net](5.0-preview4_System.Net.md)
+* [System.Net.Http](5.0-preview4_System.Net.Http.md)
+* [System.Net.Http.Json](5.0-preview4_System.Net.Http.Json.md)
+* [System.Net.Mail](5.0-preview4_System.Net.Mail.md)
+* [System.Net.NetworkInformation](5.0-preview4_System.Net.NetworkInformation.md)
+* [System.Net.Security](5.0-preview4_System.Net.Security.md)
+* [System.Net.Sockets](5.0-preview4_System.Net.Sockets.md)
+* [System.Numerics](5.0-preview4_System.Numerics.md)
+* [System.Runtime.CompilerServices](5.0-preview4_System.Runtime.CompilerServices.md)
+* [System.Runtime.ExceptionServices](5.0-preview4_System.Runtime.ExceptionServices.md)
+* [System.Runtime.InteropServices](5.0-preview4_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](5.0-preview4_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.X86](5.0-preview4_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography](5.0-preview4_System.Security.Cryptography.md)
+* [System.Security.Cryptography.X509Certificates](5.0-preview4_System.Security.Cryptography.X509Certificates.md)
+* [System.Text](5.0-preview4_System.Text.md)
+* [System.Text.Json](5.0-preview4_System.Text.Json.md)
+* [System.Text.Json.Serialization](5.0-preview4_System.Text.Json.Serialization.md)
+* [System.Text.RegularExpressions](5.0-preview4_System.Text.RegularExpressions.md)
+* [System.Threading](5.0-preview4_System.Threading.md)
+* [System.Threading.Channels](5.0-preview4_System.Threading.Channels.md)
+* [System.Threading.Tasks](5.0-preview4_System.Threading.Tasks.md)
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_Microsoft.VisualBasic.CompilerServices.md

@@ -0,0 +1,10 @@
+# Microsoft.VisualBasic.CompilerServices
+
+``` diff
+ namespace Microsoft.VisualBasic.CompilerServices {
+     public sealed class Utils {
++        public static string GetResourceString(string ResourceKey, params string[] Args);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_Microsoft.VisualBasic.md

@@ -0,0 +1,33 @@
+# Microsoft.VisualBasic
+
+``` diff
+ namespace Microsoft.VisualBasic {
+     public sealed class ErrObject {
++        public int HelpContext { get; set; }
++        public string HelpFile { get; set; }
++        public string Source { get; set; }
+     }
+     public sealed class Information {
++        public static int Erl();
+     }
+     public sealed class Interaction {
++        public static void AppActivate(int ProcessId);
++        public static void AppActivate(string Title);
++        public static object Choose(double Index, params object[] Choice);
++        public static string Command();
++        public static void DeleteSetting(string AppName, string Section = null, string Key = null);
++        public static string Environ(int Expression);
++        public static string Environ(string Expression);
++        public static string[,] GetAllSettings(string AppName, string Section);
++        public static object GetObject(string PathName = null, string Class = null);
++        public static string GetSetting(string AppName, string Section, string Key, string Default = "");
++        public static string InputBox(string Prompt, string Title = "", string DefaultResponse = "", int XPos = -1, int YPos = -1);
++        public static MsgBoxResult MsgBox(object Prompt, MsgBoxStyle Buttons = MsgBoxStyle.ApplicationModal, object Title = null);
++        public static string Partition(long Number, long Start, long Stop, long Interval);
++        public static void SaveSetting(string AppName, string Section, string Key, string Setting);
++        public static int Shell(string PathName, AppWinStyle Style = AppWinStyle.MinimizedFocus, bool Wait = false, int Timeout = -1);
++        public static object Switch(params object[] VarExpr);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_Microsoft.Win32.SafeHandles.md

@@ -0,0 +1,11 @@
+# Microsoft.Win32.SafeHandles
+
+``` diff
+ namespace Microsoft.Win32.SafeHandles {
+     public sealed class SafeProcessHandle : SafeHandleZeroOrMinusOneIsInvalid {
+-        public override bool IsInvalid { get; }
+
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Buffers.Binary.md

@@ -0,0 +1,25 @@
+# System.Buffers.Binary
+
+``` diff
+ namespace System.Buffers.Binary {
+     public static class BinaryPrimitives {
++        public static double ReadDoubleBigEndian(ReadOnlySpan<byte> source);
++        public static double ReadDoubleLittleEndian(ReadOnlySpan<byte> source);
++        public static float ReadSingleBigEndian(ReadOnlySpan<byte> source);
++        public static float ReadSingleLittleEndian(ReadOnlySpan<byte> source);
++        public static bool TryReadDoubleBigEndian(ReadOnlySpan<byte> source, out double value);
++        public static bool TryReadDoubleLittleEndian(ReadOnlySpan<byte> source, out double value);
++        public static bool TryReadSingleBigEndian(ReadOnlySpan<byte> source, out float value);
++        public static bool TryReadSingleLittleEndian(ReadOnlySpan<byte> source, out float value);
++        public static bool TryWriteDoubleBigEndian(Span<byte> destination, double value);
++        public static bool TryWriteDoubleLittleEndian(Span<byte> destination, double value);
++        public static bool TryWriteSingleBigEndian(Span<byte> destination, float value);
++        public static bool TryWriteSingleLittleEndian(Span<byte> destination, float value);
++        public static void WriteDoubleBigEndian(Span<byte> destination, double value);
++        public static void WriteDoubleLittleEndian(Span<byte> destination, double value);
++        public static void WriteSingleBigEndian(Span<byte> destination, float value);
++        public static void WriteSingleLittleEndian(Span<byte> destination, float value);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Buffers.md

@@ -0,0 +1,12 @@
+# System.Buffers
+
+``` diff
+ namespace System.Buffers {
+     public ref struct SequenceReader<T> where T : struct, IEquatable<T> {
++        public ReadOnlySequence<T> UnreadSequence { get; }
++        public void AdvanceToEnd();
++        public bool TryPeek(long offset, out T value);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Collections.Concurrent.md

@@ -0,0 +1,10 @@
+# System.Collections.Concurrent
+
+``` diff
+ namespace System.Collections.Concurrent {
+     public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public bool TryRemove(KeyValuePair<TKey, TValue> item);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Collections.Generic.md

@@ -0,0 +1,25 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
+-    public class HashSet<T> : ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISerializable, ISet<T>
++    public class HashSet<T> : ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, ISet<T>
++    public interface IReadOnlySet<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T> {
++        bool Contains(T item);
++        bool IsProperSubsetOf(IEnumerable<T> other);
++        bool IsProperSupersetOf(IEnumerable<T> other);
++        bool IsSubsetOf(IEnumerable<T> other);
++        bool IsSupersetOf(IEnumerable<T> other);
++        bool Overlaps(IEnumerable<T> other);
++        bool SetEquals(IEnumerable<T> other);
++    }
++    public sealed class ReferenceEqualityComparer : IEqualityComparer, IEqualityComparer<object> {
++        public static ReferenceEqualityComparer Instance { get; }
++        public new bool Equals(object x, object y);
++        public int GetHashCode(object obj);
++    }
+-    public class SortedSet<T> : ICollection, ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISerializable, ISet<T>
++    public class SortedSet<T> : ICollection, ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, ISet<T>
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Collections.Immutable.md

@@ -0,0 +1,23 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+-    public sealed class ImmutableHashSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IReadOnlyCollection<T>, ISet<T> {
++    public sealed class ImmutableHashSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
+         public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
++            public bool TryGetValue(T equalValue, out T actualValue);
+         }
+     }
+     public static class ImmutableInterlocked {
++        public static bool Update<T, TArg>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, TArg, ImmutableArray<T>> transformer, TArg transformerArgument);
++        public static bool Update<T>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, ImmutableArray<T>> transformer);
+     }
+-    public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ISet<T> {
++    public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> {
+         public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
++            public bool TryGetValue(T equalValue, out T actualValue);
+         }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Diagnostics.CodeAnalysis.md

@@ -0,0 +1,18 @@
+# System.Diagnostics.CodeAnalysis
+
+``` diff
+ namespace System.Diagnostics.CodeAnalysis {
++    public sealed class MemberNotNullAttribute : Attribute {
++        public MemberNotNullAttribute(string member);
++        public MemberNotNullAttribute(params string[] members);
++        public string[] Members { get; }
++    }
++    public sealed class MemberNotNullWhenAttribute : Attribute {
++        public MemberNotNullWhenAttribute(bool returnValue, string member);
++        public MemberNotNullWhenAttribute(bool returnValue, params string[] members);
++        public string[] Members { get; }
++        public bool ReturnValue { get; }
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Diagnostics.md

@@ -0,0 +1,96 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+-    public class Activity {
++    public class Activity : IDisposable {
++        public ActivityContext Context { get; }
++        public string DisplayName { get; set; }
++        public IEnumerable<ActivityEvent> Events { get; }
++        public bool IsAllDataRequested { get; set; }
++        public ActivityKind Kind { get; }
++        public IEnumerable<ActivityLink> Links { get; }
++        public ActivitySource Source { get; }
++        public Activity AddEvent(ActivityEvent e);
++        public void Dispose();
++        protected virtual void Dispose(bool disposing);
++        public object GetCustomProperty(string propertyName);
++        public void SetCustomProperty(string propertyName, object propertyValue);
+     }
++    public readonly struct ActivityContext : IEquatable<ActivityContext> {
++        public ActivityContext(ActivityTraceId traceId, ActivitySpanId spanId, ActivityTraceFlags traceOptions, string traceState = null);
++        public ActivitySpanId SpanId { get; }
++        public ActivityTraceFlags TraceFlags { get; }
++        public ActivityTraceId TraceId { get; }
++        public string TraceState { get; }
++        public bool Equals(ActivityContext value);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public static bool operator ==(ActivityContext left, ActivityContext right);
++        public static bool operator !=(ActivityContext left, ActivityContext right);
++    }
++    public readonly struct ActivityCreationOptions<T> {
++        public ActivityKind Kind { get; }
++        public IEnumerable<ActivityLink> Links { get; }
++        public string Name { get; }
++        public T Parent { get; }
++        public ActivitySource Source { get; }
++        public IEnumerable<KeyValuePair<string, string>> Tags { get; }
++    }
++    public enum ActivityDataRequest {
++        AllData = 2,
++        AllDataAndRecorded = 3,
++        None = 0,
++        PropagationData = 1,
++    }
++    public readonly struct ActivityEvent {
++        public ActivityEvent(string name);
++        public ActivityEvent(string name, IEnumerable<KeyValuePair<string, object>> attributes);
++        public ActivityEvent(string name, DateTimeOffset timestamp);
++        public ActivityEvent(string name, DateTimeOffset timestamp, IEnumerable<KeyValuePair<string, object>> attributes);
++        public IEnumerable<KeyValuePair<string, object>> Attributes { get; }
++        public string Name { get; }
++        public DateTimeOffset Timestamp { get; }
++    }
++    public enum ActivityKind {
++        Client = 2,
++        Consumer = 4,
++        Internal = 0,
++        Producer = 3,
++        Server = 1,
++    }
++    public readonly struct ActivityLink : IEquatable<ActivityLink> {
++        public ActivityLink(ActivityContext context);
++        public ActivityLink(ActivityContext context, IEnumerable<KeyValuePair<string, object>> attributes);
++        public IEnumerable<KeyValuePair<string, object>> Attributes { get; }
++        public ActivityContext Context { get; }
++        public bool Equals(ActivityLink value);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public static bool operator ==(ActivityLink left, ActivityLink right);
++        public static bool operator !=(ActivityLink left, ActivityLink right);
++    }
++    public sealed class ActivityListener : IDisposable {
++        public ActivityListener();
++        public Action<Activity> ActivityStarted { get; set; }
++        public Action<Activity> ActivityStopped { get; set; }
++        public GetRequestedData<ActivityContext> GetRequestedDataUsingContext { get; set; }
++        public GetRequestedData<string> GetRequestedDataUsingParentId { get; set; }
++        public Func<ActivitySource, bool> ShouldListenTo { get; set; }
++        public void Dispose();
++    }
++    public sealed class ActivitySource : IDisposable {
++        public ActivitySource(string name, string version = "");
++        public string Name { get; }
++        public string Version { get; }
++        public static void AddActivityListener(ActivityListener listener);
++        public void Dispose();
++        public bool HasListeners();
++        public Activity StartActivity(string name, ActivityKind kind = ActivityKind.Internal);
++        public Activity StartActivity(string name, ActivityKind kind, ActivityContext parentContext, IEnumerable<KeyValuePair<string, string>> tags = null, IEnumerable<ActivityLink> links = null, DateTimeOffset startTime = default(DateTimeOffset));
++        public Activity StartActivity(string name, ActivityKind kind, string parentId, IEnumerable<KeyValuePair<string, string>> tags = null, IEnumerable<ActivityLink> links = null, DateTimeOffset startTime = default(DateTimeOffset));
++    }
++    public delegate ActivityDataRequest GetRequestedData<T>(ref ActivityCreationOptions<T> options);
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Globalization.md

@@ -0,0 +1,119 @@
+# System.Globalization
+
+``` diff
+ namespace System.Globalization {
+-    public class CompareInfo : IDeserializationCallback {
++    public sealed class CompareInfo : IDeserializationCallback {
+-        public virtual string Name { get; }
++        public string Name { get; }
+-        public virtual int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2);
++        public int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2);
+-        public virtual int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2, CompareOptions options);
++        public int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2, CompareOptions options);
+-        public virtual int Compare(string string1, int offset1, string string2, int offset2);
++        public int Compare(string string1, int offset1, string string2, int offset2);
+-        public virtual int Compare(string string1, int offset1, string string2, int offset2, CompareOptions options);
++        public int Compare(string string1, int offset1, string string2, int offset2, CompareOptions options);
+-        public virtual int Compare(string string1, string string2);
++        public int Compare(string string1, string string2);
+-        public virtual int Compare(string string1, string string2, CompareOptions options);
++        public int Compare(string string1, string string2, CompareOptions options);
+-        public virtual int GetHashCode(string source, CompareOptions options);
++        public int GetHashCode(string source, CompareOptions options);
+-        public virtual SortKey GetSortKey(string source);
++        public SortKey GetSortKey(string source);
+-        public virtual SortKey GetSortKey(string source, CompareOptions options);
++        public SortKey GetSortKey(string source, CompareOptions options);
+-        public virtual int IndexOf(string source, char value);
++        public int IndexOf(string source, char value);
+-        public virtual int IndexOf(string source, char value, CompareOptions options);
++        public int IndexOf(string source, char value, CompareOptions options);
+-        public virtual int IndexOf(string source, char value, int startIndex);
++        public int IndexOf(string source, char value, int startIndex);
+-        public virtual int IndexOf(string source, char value, int startIndex, CompareOptions options);
++        public int IndexOf(string source, char value, int startIndex, CompareOptions options);
+-        public virtual int IndexOf(string source, char value, int startIndex, int count);
++        public int IndexOf(string source, char value, int startIndex, int count);
+-        public virtual int IndexOf(string source, char value, int startIndex, int count, CompareOptions options);
++        public int IndexOf(string source, char value, int startIndex, int count, CompareOptions options);
+-        public virtual int IndexOf(string source, string value);
++        public int IndexOf(string source, string value);
+-        public virtual int IndexOf(string source, string value, CompareOptions options);
++        public int IndexOf(string source, string value, CompareOptions options);
+-        public virtual int IndexOf(string source, string value, int startIndex);
++        public int IndexOf(string source, string value, int startIndex);
+-        public virtual int IndexOf(string source, string value, int startIndex, CompareOptions options);
++        public int IndexOf(string source, string value, int startIndex, CompareOptions options);
+-        public virtual int IndexOf(string source, string value, int startIndex, int count);
++        public int IndexOf(string source, string value, int startIndex, int count);
+-        public virtual int IndexOf(string source, string value, int startIndex, int count, CompareOptions options);
++        public int IndexOf(string source, string value, int startIndex, int count, CompareOptions options);
+-        public virtual bool IsPrefix(string source, string prefix);
++        public bool IsPrefix(string source, string prefix);
+-        public virtual bool IsPrefix(string source, string prefix, CompareOptions options);
++        public bool IsPrefix(string source, string prefix, CompareOptions options);
+-        public virtual bool IsSuffix(string source, string suffix);
++        public bool IsSuffix(string source, string suffix);
+-        public virtual bool IsSuffix(string source, string suffix, CompareOptions options);
++        public bool IsSuffix(string source, string suffix, CompareOptions options);
+-        public virtual int LastIndexOf(string source, char value);
++        public int LastIndexOf(string source, char value);
+-        public virtual int LastIndexOf(string source, char value, CompareOptions options);
++        public int LastIndexOf(string source, char value, CompareOptions options);
+-        public virtual int LastIndexOf(string source, char value, int startIndex);
++        public int LastIndexOf(string source, char value, int startIndex);
+-        public virtual int LastIndexOf(string source, char value, int startIndex, CompareOptions options);
++        public int LastIndexOf(string source, char value, int startIndex, CompareOptions options);
+-        public virtual int LastIndexOf(string source, char value, int startIndex, int count);
++        public int LastIndexOf(string source, char value, int startIndex, int count);
+-        public virtual int LastIndexOf(string source, char value, int startIndex, int count, CompareOptions options);
++        public int LastIndexOf(string source, char value, int startIndex, int count, CompareOptions options);
+-        public virtual int LastIndexOf(string source, string value);
++        public int LastIndexOf(string source, string value);
+-        public virtual int LastIndexOf(string source, string value, CompareOptions options);
++        public int LastIndexOf(string source, string value, CompareOptions options);
+-        public virtual int LastIndexOf(string source, string value, int startIndex);
++        public int LastIndexOf(string source, string value, int startIndex);
+-        public virtual int LastIndexOf(string source, string value, int startIndex, CompareOptions options);
++        public int LastIndexOf(string source, string value, int startIndex, CompareOptions options);
+-        public virtual int LastIndexOf(string source, string value, int startIndex, int count);
++        public int LastIndexOf(string source, string value, int startIndex, int count);
+-        public virtual int LastIndexOf(string source, string value, int startIndex, int count, CompareOptions options);
++        public int LastIndexOf(string source, string value, int startIndex, int count, CompareOptions options);
+     }
+     public class CultureInfo : ICloneable, IFormatProvider {
++        public static CultureInfo GetCultureInfo(string name, bool predefinedOnly);
+     }
+-    public class SortKey {
++    public sealed class SortKey {
+-        public virtual byte[] KeyData { get; }
++        public byte[] KeyData { get; }
+-        public virtual string OriginalString { get; }
++        public string OriginalString { get; }
+     }
+-    public class TextInfo : ICloneable, IDeserializationCallback {
++    public sealed class TextInfo : ICloneable, IDeserializationCallback {
+-        public virtual int ANSICodePage { get; }
++        public int ANSICodePage { get; }
+-        public virtual int EBCDICCodePage { get; }
++        public int EBCDICCodePage { get; }
+-        public virtual string ListSeparator { get; set; }
++        public string ListSeparator { get; set; }
+-        public virtual int MacCodePage { get; }
++        public int MacCodePage { get; }
+-        public virtual int OEMCodePage { get; }
++        public int OEMCodePage { get; }
+-        public virtual object Clone();
++        public object Clone();
+-        public virtual char ToLower(char c);
++        public char ToLower(char c);
+-        public virtual string ToLower(string str);
++        public string ToLower(string str);
+-        public virtual char ToUpper(char c);
++        public char ToUpper(char c);
+-        public virtual string ToUpper(string str);
++        public string ToUpper(string str);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.IO.Pipes.md

@@ -0,0 +1,10 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
+     public abstract class PipeStream : Stream {
++        public override Task FlushAsync(CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.IO.md

@@ -0,0 +1,18 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public class MemoryStream : Stream {
++        public override void CopyTo(ReadOnlySpanAction<byte, object> callback, object state, int bufferSize);
++        public override Task CopyToAsync(Func<ReadOnlyMemory<byte>, object, CancellationToken, ValueTask> callback, object state, int bufferSize, CancellationToken cancellationToken);
+     }
+     public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public virtual void CopyTo(ReadOnlySpanAction<byte, object> callback, object state, int bufferSize);
++        public virtual Task CopyToAsync(Func<ReadOnlyMemory<byte>, object, CancellationToken, ValueTask> callback, object state, int bufferSize, CancellationToken cancellationToken);
+     }
+     public class UnmanagedMemoryStream : Stream {
++        public override void CopyTo(ReadOnlySpanAction<byte, object> callback, object state, int bufferSize);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Linq.md

@@ -0,0 +1,15 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public class EnumerableQuery<T> : EnumerableQuery, IEnumerable, IEnumerable<T>, IOrderedQueryable, IOrderedQueryable<T>, IQueryable, IQueryable<T>, IQueryProvider {
+-        IQueryable<S> System.Linq.IQueryProvider.CreateQuery<S>(Expression expression);
+
++        IQueryable<TElement> System.Linq.IQueryProvider.CreateQuery<TElement>(Expression expression);
+-        S System.Linq.IQueryProvider.Execute<S>(Expression expression);
+
++        TElement System.Linq.IQueryProvider.Execute<TElement>(Expression expression);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.Http.Json.md

@@ -0,0 +1,38 @@
+# System.Net.Http.Json
+
+``` diff
++namespace System.Net.Http.Json {
++    public static class HttpClientJsonExtensions {
++        public static Task<object> GetFromJsonAsync(this HttpClient client, string requestUri, Type type, JsonSerializerOptions options, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<object> GetFromJsonAsync(this HttpClient client, string requestUri, Type type, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<object> GetFromJsonAsync(this HttpClient client, Uri requestUri, Type type, JsonSerializerOptions options, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<object> GetFromJsonAsync(this HttpClient client, Uri requestUri, Type type, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, string requestUri, JsonSerializerOptions options, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, string requestUri, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, Uri requestUri, JsonSerializerOptions options, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, string requestUri, TValue value, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, string requestUri, TValue value, CancellationToken cancellationToken);
++        public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri requestUri, TValue value, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri requestUri, TValue value, CancellationToken cancellationToken);
++        public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, string requestUri, TValue value, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, string requestUri, TValue value, CancellationToken cancellationToken);
++        public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri requestUri, TValue value, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri requestUri, TValue value, CancellationToken cancellationToken);
++    }
++    public static class HttpContentJsonExtensions {
++        public static Task<object> ReadFromJsonAsync(this HttpContent content, Type type, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<T> ReadFromJsonAsync<T>(this HttpContent content, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public sealed class JsonContent : HttpContent {
++        public Type ObjectType { get; }
++        public object Value { get; }
++        public static JsonContent Create(object inputValue, Type inputType, MediaTypeHeaderValue mediaType = null, JsonSerializerOptions options = null);
++        public static JsonContent Create<T>(T inputValue, MediaTypeHeaderValue mediaType = null, JsonSerializerOptions options = null);
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context);
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
++        protected override bool TryComputeLength(out long length);
++    }
++}
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.Http.md

@@ -0,0 +1,50 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class ByteArrayContent : HttpContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class FormUrlEncodedContent : ByteArrayContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class HttpClient : HttpMessageInvoker {
++        public Task<byte[]> GetByteArrayAsync(string requestUri, CancellationToken cancellationToken);
++        public Task<byte[]> GetByteArrayAsync(Uri requestUri, CancellationToken cancellationToken);
++        public Task<Stream> GetStreamAsync(string requestUri, CancellationToken cancellationToken);
++        public Task<Stream> GetStreamAsync(Uri requestUri, CancellationToken cancellationToken);
++        public Task<string> GetStringAsync(string requestUri, CancellationToken cancellationToken);
++        public Task<string> GetStringAsync(Uri requestUri, CancellationToken cancellationToken);
+     }
+     public abstract class HttpContent : IDisposable {
++        public Task CopyToAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
++        public Task CopyToAsync(Stream stream, CancellationToken cancellationToken);
++        protected virtual Task<Stream> CreateContentReadStreamAsync(CancellationToken cancellationToken);
++        public Task<byte[]> ReadAsByteArrayAsync(CancellationToken cancellationToken);
++        public Task<Stream> ReadAsStreamAsync(CancellationToken cancellationToken);
++        public Task<string> ReadAsStringAsync(CancellationToken cancellationToken);
++        protected virtual Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class HttpRequestException : Exception {
++        public HttpRequestException(string message, Exception inner, HttpStatusCode? statusCode);
++        public HttpStatusCode? StatusCode { get; }
+     }
+     public class MultipartContent : HttpContent, IEnumerable, IEnumerable<HttpContent> {
++        protected override Task<Stream> CreateContentReadStreamAsync(CancellationToken cancellationToken);
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class MultipartFormDataContent : MultipartContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public sealed class ReadOnlyMemoryContent : HttpContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class StreamContent : HttpContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+     public class StringContent : ByteArrayContent {
++        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.Mail.md

@@ -0,0 +1,16 @@
+# System.Net.Mail
+
+``` diff
+ namespace System.Net.Mail {
+     public class MailAddress {
++        public static bool TryCreate(string address, out MailAddress result);
++        public static bool TryCreate(string address, string displayName, out MailAddress result);
++        public static bool TryCreate(string address, string displayName, Encoding displayNameEncoding, out MailAddress result);
+     }
+     public class SmtpClient : IDisposable {
++        public Task SendMailAsync(MailMessage message, CancellationToken cancellationToken);
++        public Task SendMailAsync(string from, string recipients, string subject, string body, CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.NetworkInformation.md

@@ -0,0 +1,12 @@
+# System.Net.NetworkInformation
+
+``` diff
+ namespace System.Net.NetworkInformation {
+     public class PhysicalAddress {
++        public static PhysicalAddress Parse(ReadOnlySpan<char> address);
++        public static bool TryParse(ReadOnlySpan<char> address, out PhysicalAddress value);
++        public static bool TryParse(string address, out PhysicalAddress value);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.Security.md

@@ -0,0 +1,10 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public readonly struct SslApplicationProtocol : IEquatable<SslApplicationProtocol> {
++        public static readonly SslApplicationProtocol Http3;
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.Sockets.md

@@ -0,0 +1,21 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public class NetworkStream : Stream {
+-        protected Socket Socket { get; }
++        public Socket Socket { get; }
+     }
+     public class Socket : IDisposable {
++        public Socket(SafeSocketHandle handle);
++        public static bool OSSupportsUnixDomainSockets { get; }
++        public int GetRawSocketOption(int optionLevel, int optionName, Span<byte> optionValue);
++        public void Listen();
++        public void SetRawSocketOption(int optionLevel, int optionName, ReadOnlySpan<byte> optionValue);
+     }
+     public class SocketAsyncEventArgs : EventArgs, IDisposable {
++        public SocketAsyncEventArgs(bool unsafeSuppressExecutionContextFlow);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Net.md

@@ -0,0 +1,14 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+     public class FtpWebResponse : WebResponse, IDisposable {
+-        public override string ContentType { get; }
+
+     }
+     public static class HttpVersion {
++        public static readonly Version Version30;
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Numerics.md

@@ -0,0 +1,13 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public static class Vector {
++        public static Vector<Double> Ceiling(Vector<Double> value);
++        public static Vector<Single> Ceiling(Vector<Single> value);
++        public static Vector<Double> Floor(Vector<Double> value);
++        public static Vector<Single> Floor(Vector<Single> value);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Runtime.CompilerServices.md

@@ -0,0 +1,19 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public sealed class CppInlineNamespaceAttribute : Attribute {
++        public CppInlineNamespaceAttribute(string dottedName);
++    }
+     public static class RuntimeHelpers {
++        public static IntPtr AllocateTypeAssociatedMemory(Type type, int size);
+     }
++    public sealed class SkipLocalsInitAttribute : Attribute {
++        public SkipLocalsInitAttribute();
++    }
+     public static class Unsafe {
++        public static void SkipInit<T>(out T value);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Runtime.ExceptionServices.md

@@ -0,0 +1,10 @@
+# System.Runtime.ExceptionServices
+
+``` diff
+ namespace System.Runtime.ExceptionServices {
+     public sealed class ExceptionDispatchInfo {
++        public static Exception SetCurrentStackTrace(Exception source);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Runtime.InteropServices.md

@@ -0,0 +1,59 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public enum Architecture {
++        Wasm = 4,
+     }
++    public static class CollectionsMarshal {
++        public static Span<T> AsSpan<T>(List<T> list);
++    }
++    public abstract class ComWrappers {
++        protected ComWrappers();
++        protected unsafe abstract ComWrappers.ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count);
++        protected abstract object CreateObject(IntPtr externalComObject, CreateObjectFlags flags);
++        protected static void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease);
++        public IntPtr GetOrCreateComInterfaceForObject(object instance, CreateComInterfaceFlags flags);
++        public object GetOrCreateObjectForComInstance(IntPtr externalComObject, CreateObjectFlags flags);
++        public object GetOrRegisterObjectForComInstance(IntPtr externalComObject, CreateObjectFlags flags, object wrapper);
++        public void RegisterAsGlobalInstance();
++        protected abstract void ReleaseObjects(IEnumerable objects);
++        public struct ComInterfaceDispatch {
++            public IntPtr Vtable;
++            public unsafe static T GetInstance<T>(ComWrappers.ComInterfaceDispatch* dispatchPtr) where T : class;
++        }
++        public struct ComInterfaceEntry {
++            public Guid IID;
++            public IntPtr Vtable;
++        }
++    }
++    public enum CreateComInterfaceFlags {
++        CallerDefinedIUnknown = 1,
++        None = 0,
++        TrackerSupport = 2,
++    }
++    public enum CreateObjectFlags {
++        None = 0,
++        TrackerObject = 1,
++        UniqueInstance = 2,
++    }
+     public static class MemoryMarshal {
++        public static ref T GetArrayDataReference<T>(T[] array);
+     }
++    public sealed class NativeCallableAttribute : Attribute {
++        public CallingConvention CallingConvention;
++        public string EntryPoint;
++        public NativeCallableAttribute();
++    }
+     public readonly struct OSPlatform : IEquatable<OSPlatform> {
++        public static OSPlatform Browser { get; }
+     }
+     public static class RuntimeInformation {
++        public static string RuntimeIdentifier { get; }
+     }
++    public sealed class SuppressGCTransitionAttribute : Attribute {
++        public SuppressGCTransitionAttribute();
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Runtime.Intrinsics.X86.md

@@ -0,0 +1,37 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
+ namespace System.Runtime.Intrinsics.X86 {
+     public abstract class Avx : Sse42 {
++        public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareNotEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareNotEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareNotGreaterThan(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareNotGreaterThan(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareNotGreaterThanOrEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareNotGreaterThanOrEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareNotLessThan(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareNotLessThan(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareNotLessThanOrEqual(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareNotLessThanOrEqual(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareOrdered(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareOrdered(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> CompareUnordered(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> CompareUnordered(Vector256<float> left, Vector256<float> right);
+     }
+     public abstract class Sse2 : Sse {
++        public unsafe static void StoreScalar(int* address, Vector128<int> source);
++        public unsafe static void StoreScalar(uint* address, Vector128<uint> source);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Runtime.Intrinsics.md

@@ -0,0 +1,21 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+     public static class Vector128 {
++        public static Vector128<Single> AsVector128(this Vector2 value);
++        public static Vector128<Single> AsVector128(this Vector3 value);
++        public static Vector128<Single> AsVector128(this Vector4 value);
++        public static Vector128<T> AsVector128<T>(this Vector<T> value) where T : struct;
++        public static Vector2 AsVector2(this Vector128<Single> value);
++        public static Vector3 AsVector3(this Vector128<Single> value);
++        public static Vector4 AsVector4(this Vector128<Single> value);
++        public static Vector<T> AsVector<T>(this Vector128<T> value) where T : struct;
+     }
+     public static class Vector256 {
++        public static Vector256<T> AsVector256<T>(this Vector<T> value) where T : struct;
++        public static Vector<T> AsVector<T>(this Vector256<T> value) where T : struct;
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Security.Cryptography.X509Certificates.md

@@ -0,0 +1,15 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
+ namespace System.Security.Cryptography.X509Certificates {
+     public sealed class X509ChainPolicy {
++        public X509Certificate2Collection CustomTrustStore { get; }
++        public X509ChainTrustMode TrustMode { get; set; }
+     }
++    public enum X509ChainTrustMode {
++        CustomRootTrust = 1,
++        System = 0,
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Security.Cryptography.md

@@ -0,0 +1,106 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
+     public abstract class AsymmetricAlgorithm : IDisposable {
++        public virtual void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes);
++        public virtual void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password);
++        public virtual void ImportFromPem(ReadOnlySpan<char> input);
+     }
+     public abstract class DSA : AsymmetricAlgorithm {
++        public byte[] CreateSignature(byte[] rgbHash, DSASignatureFormat signatureFormat);
++        protected virtual byte[] CreateSignatureCore(ReadOnlySpan<byte> hash, DSASignatureFormat signatureFormat);
++        public int GetMaxSignatureSize(DSASignatureFormat signatureFormat);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password);
++        public override void ImportFromPem(ReadOnlySpan<char> input);
++        public byte[] SignData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual byte[] SignDataCore(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual byte[] SignDataCore(ReadOnlySpan<byte> data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool TryCreateSignature(ReadOnlySpan<byte> hash, Span<byte> destination, DSASignatureFormat signatureFormat, out int bytesWritten);
++        protected virtual bool TryCreateSignatureCore(ReadOnlySpan<byte> hash, Span<byte> destination, DSASignatureFormat signatureFormat, out int bytesWritten);
++        public bool TrySignData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat, out int bytesWritten);
++        protected virtual bool TrySignDataCore(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat, out int bytesWritten);
++        public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifyDataCore(Stream data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifyDataCore(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifySignature(byte[] rgbHash, byte[] rgbSignature, DSASignatureFormat signatureFormat);
++        public bool VerifySignature(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifySignatureCore(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, DSASignatureFormat signatureFormat);
+     }
++    public enum DSASignatureFormat {
++        IeeeP1363FixedFieldConcatenation = 0,
++        Rfc3279DerSequence = 1,
++    }
+     public abstract class ECDiffieHellman : AsymmetricAlgorithm {
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password);
++        public override void ImportFromPem(ReadOnlySpan<char> input);
+     }
+     public abstract class ECDsa : AsymmetricAlgorithm {
++        public int GetMaxSignatureSize(DSASignatureFormat signatureFormat);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password);
++        public override void ImportFromPem(ReadOnlySpan<char> input);
++        public byte[] SignData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public byte[] SignData(byte[] data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual byte[] SignDataCore(Stream data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual byte[] SignDataCore(ReadOnlySpan<byte> data, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public byte[] SignHash(byte[] hash, DSASignatureFormat signatureFormat);
++        protected virtual byte[] SignHashCore(ReadOnlySpan<byte> hash, DSASignatureFormat signatureFormat);
++        public bool TrySignData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat, out int bytesWritten);
++        protected virtual bool TrySignDataCore(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat, out int bytesWritten);
++        public bool TrySignHash(ReadOnlySpan<byte> hash, Span<byte> destination, DSASignatureFormat signatureFormat, out int bytesWritten);
++        protected virtual bool TrySignHashCore(ReadOnlySpan<byte> hash, Span<byte> destination, DSASignatureFormat signatureFormat, out int bytesWritten);
++        public bool VerifyData(byte[] data, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(Stream data, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifyDataCore(Stream data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifyDataCore(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat);
++        public bool VerifyHash(byte[] hash, byte[] signature, DSASignatureFormat signatureFormat);
++        public bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, DSASignatureFormat signatureFormat);
++        protected virtual bool VerifyHashCore(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, DSASignatureFormat signatureFormat);
+     }
+     public abstract class HashAlgorithm : ICryptoTransform, IDisposable {
++        public Task<byte[]> ComputeHashAsync(Stream inputStream, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public readonly struct HashAlgorithmName : IEquatable<HashAlgorithmName> {
++        public static HashAlgorithmName FromOid(string oidValue);
++        public static bool TryFromOid(string oidValue, out HashAlgorithmName value);
+     }
++    public static class HKDF {
++        public static byte[] DeriveKey(HashAlgorithmName hashAlgorithmName, byte[] ikm, int outputLength, byte[] salt = null, byte[] info = null);
++        public static void DeriveKey(HashAlgorithmName hashAlgorithmName, ReadOnlySpan<byte> ikm, Span<byte> output, ReadOnlySpan<byte> salt, ReadOnlySpan<byte> info);
++        public static byte[] Expand(HashAlgorithmName hashAlgorithmName, byte[] prk, int outputLength, byte[] info = null);
++        public static void Expand(HashAlgorithmName hashAlgorithmName, ReadOnlySpan<byte> prk, Span<byte> output, ReadOnlySpan<byte> info);
++        public static byte[] Extract(HashAlgorithmName hashAlgorithmName, byte[] ikm, byte[] salt = null);
++        public static int Extract(HashAlgorithmName hashAlgorithmName, ReadOnlySpan<byte> ikm, ReadOnlySpan<byte> salt, Span<byte> prk);
++    }
++    public static class PemEncoding {
++        public static PemFields Find(ReadOnlySpan<char> pemData);
++        public static int GetEncodedSize(int labelLength, int dataLength);
++        public static bool TryFind(ReadOnlySpan<char> pemData, out PemFields fields);
++        public static bool TryWrite(ReadOnlySpan<char> label, ReadOnlySpan<byte> data, Span<char> destination, out int charsWritten);
++        public static char[] Write(ReadOnlySpan<char> label, ReadOnlySpan<byte> data);
++    }
++    public readonly struct PemFields {
++        public Range Base64Data { get; }
++        public int DecodedDataLength { get; }
++        public Range Label { get; }
++        public Range Location { get; }
++    }
+     public abstract class RSA : AsymmetricAlgorithm {
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<byte> passwordBytes);
++        public override void ImportFromEncryptedPem(ReadOnlySpan<char> input, ReadOnlySpan<char> password);
++        public override void ImportFromPem(ReadOnlySpan<char> input);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Text.Json.Serialization.md

@@ -0,0 +1,25 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
++    public sealed class JsonConstructorAttribute : JsonAttribute {
++        public JsonConstructorAttribute();
++    }
+     public sealed class JsonIgnoreAttribute : JsonAttribute {
++        public JsonIgnoreCondition Condition { get; set; }
+     }
++    public enum JsonIgnoreCondition {
++        Always = 0,
++        Never = 2,
++        WhenNull = 1,
++    }
++    public sealed class JsonIncludeAttribute : JsonAttribute {
++        public JsonIncludeAttribute();
++    }
++    public sealed class ReferenceHandling {
++        public static ReferenceHandling Default { get; }
++        public static ReferenceHandling Preserve { get; }
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Text.Json.md

@@ -0,0 +1,11 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public sealed class JsonSerializerOptions {
++        public JsonSerializerOptions(JsonSerializerOptions options);
++        public ReferenceHandling ReferenceHandling { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Text.RegularExpressions.md

@@ -0,0 +1,11 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+     public class RegexMatchTimeoutException : TimeoutException, ISerializable {
+-        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo si, StreamingContext context);
++        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo info, StreamingContext context);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Text.md

@@ -0,0 +1,21 @@
+# System.Text
+
+``` diff
+ namespace System.Text {
++    public static class EncodingExtensions {
++        public static void Convert(this Decoder decoder, in ReadOnlySequence<byte> bytes, IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed);
++        public static void Convert(this Decoder decoder, ReadOnlySpan<byte> bytes, IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed);
++        public static void Convert(this Encoder encoder, in ReadOnlySequence<char> chars, IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed);
++        public static void Convert(this Encoder encoder, ReadOnlySpan<char> chars, IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed);
++        public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars);
++        public static long GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars, IBufferWriter<byte> writer);
++        public static int GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars, Span<byte> bytes);
++        public static long GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, IBufferWriter<byte> writer);
++        public static long GetChars(this Encoding encoding, in ReadOnlySequence<byte> bytes, IBufferWriter<char> writer);
++        public static int GetChars(this Encoding encoding, in ReadOnlySequence<byte> bytes, Span<char> chars);
++        public static long GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, IBufferWriter<char> writer);
++        public static string GetString(this Encoding encoding, in ReadOnlySequence<byte> bytes);
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Threading.Channels.md

@@ -0,0 +1,11 @@
+# System.Threading.Channels
+
+``` diff
+ namespace System.Threading.Channels {
+     public abstract class ChannelReader<T> {
++        public virtual bool CanCount { get; }
++        public virtual int Count { get; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Threading.Tasks.md

@@ -0,0 +1,10 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
+     public class TaskCompletionSource<TResult> {
++        public void SetCanceled(CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.Threading.md

@@ -0,0 +1,31 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+     public class CancellationTokenSource : IDisposable {
++        public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token);
+     }
+     public static class Interlocked {
++        public static uint Add(ref uint location1, uint value);
++        public static ulong Add(ref ulong location1, ulong value);
++        public static int And(ref int location1, int value);
++        public static long And(ref long location1, long value);
++        public static uint And(ref uint location1, uint value);
++        public static ulong And(ref ulong location1, ulong value);
++        public static uint CompareExchange(ref uint location1, uint value, uint comparand);
++        public static ulong CompareExchange(ref ulong location1, ulong value, ulong comparand);
++        public static uint Decrement(ref uint location);
++        public static ulong Decrement(ref ulong location);
++        public static uint Exchange(ref uint location1, uint value);
++        public static ulong Exchange(ref ulong location1, ulong value);
++        public static uint Increment(ref uint location);
++        public static ulong Increment(ref ulong location);
++        public static int Or(ref int location1, int value);
++        public static long Or(ref long location1, long value);
++        public static uint Or(ref uint location1, uint value);
++        public static ulong Or(ref ulong location1, ulong value);
++        public static ulong Read(ref ulong location);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/5.0-preview4_System.md

@@ -0,0 +1,65 @@
+# System
+
+``` diff
+ namespace System {
+     public readonly struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable {
++        public Decimal(ReadOnlySpan<int> bits);
++        public static int GetBits(Decimal d, Span<int> destination);
++        public static bool TryGetBits(Decimal d, Span<int> destination, out int valuesWritten);
+     }
+     public static class GC {
++        public static T[] AllocateArray<T>(int length, bool pinned = false);
++        public static T[] AllocateUninitializedArray<T>(int length, bool pinned = false);
+     }
+-    public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable {
++    public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, ISerializable {
++        public static IntPtr MaxValue { get; }
++        public static IntPtr MinValue { get; }
++        public int CompareTo(IntPtr value);
++        public int CompareTo(object value);
++        public bool Equals(IntPtr other);
++        public static IntPtr Parse(string s);
++        public static IntPtr Parse(string s, NumberStyles style);
++        public static IntPtr Parse(string s, NumberStyles style, IFormatProvider provider);
++        public static IntPtr Parse(string s, IFormatProvider provider);
+-        bool System.IEquatable<System.IntPtr>.Equals(IntPtr other);
+
++        public string ToString(IFormatProvider provider);
++        public string ToString(string format, IFormatProvider provider);
++        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out IntPtr result);
++        public static bool TryParse(string s, out IntPtr result);
+     }
+     public static class MemoryExtensions {
++        public static void Sort<T, TComparer>(this Span<T> span, TComparer comparer) where TComparer : IComparer<T>;
++        public static void Sort<T>(this Span<T> span);
++        public static void Sort<T>(this Span<T> span, Comparison<T> comparison);
++        public static void Sort<TKey, TValue, TComparer>(this Span<TKey> keys, Span<TValue> items, TComparer comparer) where TComparer : IComparer<TKey>;
++        public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items);
++        public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items, Comparison<TKey> comparison);
+     }
+     public sealed class ObsoleteAttribute : Attribute {
++        public string DiagnosticId { get; set; }
++        public string UrlFormat { get; set; }
+     }
+-    public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable {
++    public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, ISerializable {
++        public static UIntPtr MaxValue { get; }
++        public static UIntPtr MinValue { get; }
++        public int CompareTo(object value);
++        public int CompareTo(UIntPtr value);
++        public bool Equals(UIntPtr other);
++        public static UIntPtr Parse(string s);
++        public static UIntPtr Parse(string s, NumberStyles style);
++        public static UIntPtr Parse(string s, NumberStyles style, IFormatProvider provider);
++        public static UIntPtr Parse(string s, IFormatProvider provider);
+-        bool System.IEquatable<System.UIntPtr>.Equals(UIntPtr other);
+
++        public string ToString(IFormatProvider provider);
++        public string ToString(string format);
++        public string ToString(string format, IFormatProvider provider);
++        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out UIntPtr result);
++        public static bool TryParse(string s, out UIntPtr result);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/standalone-packages/5.0-preview4-standalone-packages.md

@@ -0,0 +1,10 @@
+# API Difference # API Difference standalone-3.1 vs standalone-5.0-preview4.
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System.Drawing.Common](5.0-preview4-standalone-packages_System.Drawing.Common.md)
+* [System.IO.FileSystem.AccessControl](5.0-preview4-standalone-packages_System.IO.FileSystem.AccessControl.md)
+* [System.Security.Principal.Windows](5.0-preview4-standalone-packages_System.Security.Principal.Windows.md)
+* [System.Threading.AccessControl](5.0-preview4-standalone-packages_System.Threading.AccessControl.md)
+

release-notes/5.0/preview/api-diff/preview4/.Net/standalone-packages/5.0-preview4-standalone-packages_System.Drawing.Common.md

@@ -0,0 +1,29 @@
+# System.Drawing.Common
+
+``` diff
+ {
+     namespace System.Drawing.Imaging {
+         public sealed class Encoder {
++            public static readonly Encoder ColorSpace;
++            public static readonly Encoder ImageItems;
++            public static readonly Encoder SaveAsCmyk;
+         }
+         public enum EncoderParameterValueType {
++            ValueTypePointer = 9,
+         }
+     }
+     namespace System.Drawing.Printing {
+         public class PrintDocument : Component {
+-            protected virtual void OnBeginPrint(PrintEventArgs e);
++            protected internal virtual void OnBeginPrint(PrintEventArgs e);
+-            protected virtual void OnEndPrint(PrintEventArgs e);
++            protected internal virtual void OnEndPrint(PrintEventArgs e);
+-            protected virtual void OnPrintPage(PrintPageEventArgs e);
++            protected internal virtual void OnPrintPage(PrintPageEventArgs e);
+-            protected virtual void OnQueryPageSettings(QueryPageSettingsEventArgs e);
++            protected internal virtual void OnQueryPageSettings(QueryPageSettingsEventArgs e);
+         }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/standalone-packages/5.0-preview4-standalone-packages_System.IO.FileSystem.AccessControl.md

@@ -0,0 +1,12 @@
+# System.IO.FileSystem.AccessControl
+
+``` diff
+ {
+     namespace System.IO {
+         public static class FileSystemAclExtensions {
++            public static DirectoryInfo CreateDirectory(this DirectorySecurity directorySecurity, string path);
+         }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/standalone-packages/5.0-preview4-standalone-packages_System.Security.Principal.Windows.md

@@ -0,0 +1,13 @@
+# System.Security.Principal.Windows
+
+``` diff
+ {
+     namespace System.Security.Principal {
+         public class WindowsIdentity : ClaimsIdentity, IDeserializationCallback, IDisposable, ISerializable {
++            public static Task RunImpersonatedAsync(SafeAccessTokenHandle safeAccessTokenHandle, Func<Task> func);
++            public static Task<T> RunImpersonatedAsync<T>(SafeAccessTokenHandle safeAccessTokenHandle, Func<Task<T>> func);
+         }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/.Net/standalone-packages/5.0-preview4-standalone-packages_System.Threading.AccessControl.md

@@ -0,0 +1,18 @@
+# System.Threading.AccessControl
+
+``` diff
+ {
+     namespace System.Threading {
++        public static class EventWaitHandleAcl {
++            public static EventWaitHandle Create(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity);
++        }
++        public static class MutexAcl {
++            public static Mutex Create(bool initiallyOwned, string name, out bool createdNew, MutexSecurity mutexSecurity);
++        }
++        public static class SemaphoreAcl {
++            public static Semaphore Create(int initialCount, int maximumCount, string name, out bool createdNew, SemaphoreSecurity semaphoreSecurity);
++        }
+     }
+ }
+```
+

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

@@ -0,0 +1,40 @@
+# API Difference aspnetcoreapp3.1 vs aspnetcore5.0-preview2
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authentication](5.0-preview4_Microsoft.AspNetCore.Authentication.md)
+* [Microsoft.AspNetCore.Authorization.Infrastructure](5.0-preview4_Microsoft.AspNetCore.Authorization.Infrastructure.md)
+* [Microsoft.AspNetCore.Builder](5.0-preview4_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Builder.Extensions](5.0-preview4_Microsoft.AspNetCore.Builder.Extensions.md)
+* [Microsoft.AspNetCore.Components](5.0-preview4_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.Web](5.0-preview4_Microsoft.AspNetCore.Components.Web.md)
+* [Microsoft.AspNetCore.Connections](5.0-preview4_Microsoft.AspNetCore.Connections.md)
+* [Microsoft.AspNetCore.Connections.Features](5.0-preview4_Microsoft.AspNetCore.Connections.Features.md)
+* [Microsoft.AspNetCore.Http](5.0-preview4_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.Connections](5.0-preview4_Microsoft.AspNetCore.Http.Connections.md)
+* [Microsoft.AspNetCore.Http.Extensions](5.0-preview4_Microsoft.AspNetCore.Http.Extensions.md)
+* [Microsoft.AspNetCore.Identity](5.0-preview4_Microsoft.AspNetCore.Identity.md)
+* [Microsoft.AspNetCore.Mvc.Formatters](5.0-preview4_Microsoft.AspNetCore.Mvc.Formatters.md)
+* [Microsoft.AspNetCore.Mvc.Localization](5.0-preview4_Microsoft.AspNetCore.Mvc.Localization.md)
+* [Microsoft.AspNetCore.Mvc.Rendering](5.0-preview4_Microsoft.AspNetCore.Mvc.Rendering.md)
+* [Microsoft.AspNetCore.Mvc.ViewFeatures](5.0-preview4_Microsoft.AspNetCore.Mvc.ViewFeatures.md)
+* [Microsoft.AspNetCore.Rewrite](5.0-preview4_Microsoft.AspNetCore.Rewrite.md)
+* [Microsoft.AspNetCore.Server.HttpSys](5.0-preview4_Microsoft.AspNetCore.Server.HttpSys.md)
+* [Microsoft.AspNetCore.Server.IIS](5.0-preview4_Microsoft.AspNetCore.Server.IIS.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Core](5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Core.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http](5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets](5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.md)
+* [Microsoft.AspNetCore.SignalR](5.0-preview4_Microsoft.AspNetCore.SignalR.md)
+* [Microsoft.AspNetCore.StaticFiles.Infrastructure](5.0-preview4_Microsoft.AspNetCore.StaticFiles.Infrastructure.md)
+* [Microsoft.AspNetCore.WebUtilities](5.0-preview4_Microsoft.AspNetCore.WebUtilities.md)
+* [Microsoft.Extensions.Configuration](5.0-preview4_Microsoft.Extensions.Configuration.md)
+* [Microsoft.Extensions.Configuration.KeyPerFile](5.0-preview4_Microsoft.Extensions.Configuration.KeyPerFile.md)
+* [Microsoft.Extensions.DependencyInjection](5.0-preview4_Microsoft.Extensions.DependencyInjection.md)
+* [Microsoft.Extensions.Http](5.0-preview4_Microsoft.Extensions.Http.md)
+* [Microsoft.Extensions.Http.Logging](5.0-preview4_Microsoft.Extensions.Http.Logging.md)
+* [Microsoft.Extensions.Localization](5.0-preview4_Microsoft.Extensions.Localization.md)
+* [Microsoft.Extensions.Logging.Console](5.0-preview4_Microsoft.Extensions.Logging.Console.md)
+* [Microsoft.Extensions.Options](5.0-preview4_Microsoft.Extensions.Options.md)
+* [Microsoft.Net.Http.Headers](5.0-preview4_Microsoft.Net.Http.Headers.md)
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Authentication.md

@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.Authentication
+
+``` diff
+ namespace Microsoft.AspNetCore.Authentication {
+     public class AuthenticationBuilder {
++        public virtual AuthenticationBuilder AddPolicyScheme<TService>(string authenticationScheme, string displayName, Action<PolicySchemeOptions, TService> configureOptions) where TService : class;
++        public virtual AuthenticationBuilder AddRemoteScheme<TOptions, THandler, TService>(string authenticationScheme, string displayName, Action<TOptions, TService> configureOptions) where TOptions : RemoteAuthenticationOptions, new() where THandler : RemoteAuthenticationHandler<TOptions> where TService : class;
++        public virtual AuthenticationBuilder AddScheme<TOptions, THandler, TService>(string authenticationScheme, Action<TOptions, TService> configureOptions) where TOptions : AuthenticationSchemeOptions, new() where THandler : AuthenticationHandler<TOptions> where TService : class;
++        public virtual AuthenticationBuilder AddScheme<TOptions, THandler, TService>(string authenticationScheme, string displayName, Action<TOptions, TService> configureOptions) where TOptions : AuthenticationSchemeOptions, new() where THandler : AuthenticationHandler<TOptions> where TService : class;
+     }
+     public class AuthenticationSchemeProvider : IAuthenticationSchemeProvider {
++        public virtual bool TryAddScheme(AuthenticationScheme scheme);
+     }
+     public interface IAuthenticationSchemeProvider {
++        bool TryAddScheme(AuthenticationScheme scheme);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Authorization.Infrastructure.md

@@ -0,0 +1,25 @@
+# Microsoft.AspNetCore.Authorization.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Authorization.Infrastructure {
+     public class AssertionRequirement : IAuthorizationHandler, IAuthorizationRequirement {
++        public override string ToString();
+     }
+     public class ClaimsAuthorizationRequirement : AuthorizationHandler<ClaimsAuthorizationRequirement>, IAuthorizationRequirement {
++        public override string ToString();
+     }
+     public class DenyAnonymousAuthorizationRequirement : AuthorizationHandler<DenyAnonymousAuthorizationRequirement>, IAuthorizationRequirement {
++        public override string ToString();
+     }
+     public class NameAuthorizationRequirement : AuthorizationHandler<NameAuthorizationRequirement>, IAuthorizationRequirement {
++        public override string ToString();
+     }
+     public class OperationAuthorizationRequirement : IAuthorizationRequirement {
++        public override string ToString();
+     }
+     public class RolesAuthorizationRequirement : AuthorizationHandler<RolesAuthorizationRequirement>, IAuthorizationRequirement {
++        public override string ToString();
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Builder.Extensions.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Builder.Extensions
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder.Extensions {
+     public class MapOptions {
++        public bool PreserveMatchedPathSegment { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Builder.md

@@ -0,0 +1,23 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+-    public static class ConnectionsAppBuilderExtensions {
+ {
+-        public static IApplicationBuilder UseConnections(this IApplicationBuilder app, Action<ConnectionsRouteBuilder> configure);
+
+-    }
+     public static class MapExtensions {
++        public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, bool preserveMatchedPathSegment, Action<IApplicationBuilder> configuration);
+     }
+     public class RequestLocalizationOptions {
++        public bool ApplyCurrentCultureToResponseHeaders { get; set; }
+     }
+-    public static class SignalRAppBuilderExtensions {
+ {
+-        public static IApplicationBuilder UseSignalR(this IApplicationBuilder app, Action<HubRouteBuilder> configure);
+
+-    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Components.Web.md

@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Components.Web
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Web {
+     public class MouseEventArgs : EventArgs {
++        public double OffsetX { get; set; }
++        public double OffsetY { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Components.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
+     public static class BindConverter {
++        public static string FormatValue(short value, CultureInfo culture = null);
++        public static string FormatValue(short? value, CultureInfo culture = null);
++        public static bool TryConvertToNullableShort(object obj, CultureInfo culture, out short? value);
++        public static bool TryConvertToShort(object obj, CultureInfo culture, out short value);
+     }
+     public static class EventCallbackFactoryBinderExtensions {
++        public static EventCallback<ChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<short> setter, short existingValue, CultureInfo culture = null);
++        public static EventCallback<ChangeEventArgs> CreateBinder(this EventCallbackFactory factory, object receiver, Action<short?> setter, short? existingValue, CultureInfo culture = null);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Connections.Features.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Connections.Features
+
+``` diff
+ namespace Microsoft.AspNetCore.Connections.Features {
++    public interface IProtocolErrorCodeFeature {
++        long Error { get; set; }
++    }
++    public interface IStreamDirectionFeature {
++        bool CanRead { get; }
++        bool CanWrite { get; }
++    }
++    public interface IStreamIdFeature {
++        long StreamId { get; }
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Connections.md

@@ -0,0 +1,71 @@
+# Microsoft.AspNetCore.Connections
+
+``` diff
+ namespace Microsoft.AspNetCore.Connections {
++    public abstract class BaseConnectionContext : IAsyncDisposable {
++        protected BaseConnectionContext();
++        public virtual CancellationToken ConnectionClosed { get; set; }
++        public abstract string ConnectionId { get; set; }
++        public abstract IFeatureCollection Features { get; }
++        public abstract IDictionary<object, object> Items { get; set; }
++        public virtual EndPoint LocalEndPoint { get; set; }
++        public virtual EndPoint RemoteEndPoint { get; set; }
++        public abstract void Abort();
++        public abstract void Abort(ConnectionAbortedException abortReason);
++        public virtual ValueTask DisposeAsync();
++    }
+-    public abstract class ConnectionContext : IAsyncDisposable {
++    public abstract class ConnectionContext : BaseConnectionContext, IAsyncDisposable {
+-        public virtual CancellationToken ConnectionClosed { get; set; }
+
+-        public abstract string ConnectionId { get; set; }
+
+-        public abstract IFeatureCollection Features { get; }
+
+-        public abstract IDictionary<object, object> Items { get; set; }
+
+-        public virtual EndPoint LocalEndPoint { get; set; }
+
+-        public virtual EndPoint RemoteEndPoint { get; set; }
+
+-        public virtual void Abort();
++        public override void Abort();
+-        public virtual void Abort(ConnectionAbortedException abortReason);
++        public override void Abort(ConnectionAbortedException abortReason);
+-        public virtual ValueTask DisposeAsync();
+
+     }
++    public interface IMultiplexedConnectionBuilder {
++        IServiceProvider ApplicationServices { get; }
++        MultiplexedConnectionDelegate Build();
++        IMultiplexedConnectionBuilder Use(Func<MultiplexedConnectionDelegate, MultiplexedConnectionDelegate> middleware);
++    }
++    public interface IMultiplexedConnectionFactory {
++        ValueTask<MultiplexedConnectionContext> ConnectAsync(EndPoint endpoint, IFeatureCollection features = null, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public interface IMultiplexedConnectionListener : IAsyncDisposable {
++        EndPoint EndPoint { get; }
++        ValueTask<MultiplexedConnectionContext> AcceptAsync(IFeatureCollection features = null, CancellationToken cancellationToken = default(CancellationToken));
++        ValueTask UnbindAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public interface IMultiplexedConnectionListenerFactory {
++        ValueTask<IMultiplexedConnectionListener> BindAsync(EndPoint endpoint, IFeatureCollection features = null, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public class MultiplexedConnectionBuilder : IMultiplexedConnectionBuilder {
++        public MultiplexedConnectionBuilder(IServiceProvider applicationServices);
++        public IServiceProvider ApplicationServices { get; }
++        public MultiplexedConnectionDelegate Build();
++        public IMultiplexedConnectionBuilder Use(Func<MultiplexedConnectionDelegate, MultiplexedConnectionDelegate> middleware);
++    }
++    public abstract class MultiplexedConnectionContext : BaseConnectionContext, IAsyncDisposable {
++        protected MultiplexedConnectionContext();
++        public abstract ValueTask<ConnectionContext> AcceptAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public abstract ValueTask<ConnectionContext> ConnectAsync(IFeatureCollection features = null, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public delegate Task MultiplexedConnectionDelegate(MultiplexedConnectionContext connection);
+     public class UriEndPoint : EndPoint {
++        public override string ToString();
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Http.Connections.md

@@ -0,0 +1,18 @@
+# Microsoft.AspNetCore.Http.Connections
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Connections {
+-    public class ConnectionsRouteBuilder {
+ {
+-        public void MapConnectionHandler<TConnectionHandler>(PathString path) where TConnectionHandler : ConnectionHandler;
+
+-        public void MapConnectionHandler<TConnectionHandler>(PathString path, Action<HttpConnectionDispatcherOptions> configureOptions) where TConnectionHandler : ConnectionHandler;
+
+-        public void MapConnections(PathString path, HttpConnectionDispatcherOptions options, Action<IConnectionBuilder> configure);
+
+-        public void MapConnections(PathString path, Action<IConnectionBuilder> configure);
+
+-    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Http.Extensions.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Http.Extensions
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Extensions {
+     public class QueryBuilder : IEnumerable, IEnumerable<KeyValuePair<string, string>> {
++        public QueryBuilder(IEnumerable<KeyValuePair<string, StringValues>> parameters);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Http.md

@@ -0,0 +1,25 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
++    public class BadHttpRequestException : IOException {
++        public BadHttpRequestException(string message);
++        public BadHttpRequestException(string message, Exception innerException);
++        public BadHttpRequestException(string message, int statusCode);
++        public BadHttpRequestException(string message, int statusCode, Exception innerException);
++        public int StatusCode { get; }
++    }
++    public static class HttpProtocol {
++        public static readonly string Http10;
++        public static readonly string Http11;
++        public static readonly string Http2;
++        public static readonly string Http3;
++        public static string GetHttpProtocol(Version version);
++        public static bool IsHttp10(string protocol);
++        public static bool IsHttp11(string protocol);
++        public static bool IsHttp2(string protocol);
++        public static bool IsHttp3(string protocol);
++    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Identity.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Identity
+
+``` diff
+ namespace Microsoft.AspNetCore.Identity {
+     public class ClaimsIdentityOptions {
++        public string EmailClaimType { get; set; }
+     }
+     public class IdentityBuilder {
++        public virtual IdentityBuilder AddUserConfirmation<TUserConfirmation>() where TUserConfirmation : class;
+     }
+     public class UserManager<TUser> : IDisposable where TUser : class {
+-        protected static string GetChangeEmailTokenPurpose(string newEmail);
++        public static string GetChangeEmailTokenPurpose(string newEmail);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Mvc.Formatters.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Mvc.Formatters
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Formatters {
+     public class XmlSerializerInputFormatter : TextInputFormatter, IInputFormatterExceptionPolicy {
++        protected virtual XmlReader CreateXmlReader(Stream readStream, Encoding encoding, Type type);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Mvc.Localization.md

@@ -0,0 +1,23 @@
+# Microsoft.AspNetCore.Mvc.Localization
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Localization {
+     public class HtmlLocalizer : IHtmlLocalizer {
+-        public virtual IHtmlLocalizer WithCulture(CultureInfo culture);
+
+     }
+     public class HtmlLocalizer<TResource> : IHtmlLocalizer, IHtmlLocalizer<TResource> {
+-        public virtual IHtmlLocalizer WithCulture(CultureInfo culture);
+
+     }
+     public interface IHtmlLocalizer {
+-        IHtmlLocalizer WithCulture(CultureInfo culture);
+
+     }
+     public class ViewLocalizer : IHtmlLocalizer, IViewContextAware, IViewLocalizer {
+-        public IHtmlLocalizer WithCulture(CultureInfo culture);
+
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Mvc.Rendering.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.Mvc.Rendering
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Rendering {
++    public enum CheckBoxHiddenInputRenderMode {
++        EndOfForm = 2,
++        Inline = 1,
++        None = 0,
++    }
+     public class ViewContext : ActionContext {
++        public CheckBoxHiddenInputRenderMode CheckBoxHiddenInputRenderMode { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Mvc.ViewFeatures.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Mvc.ViewFeatures
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ViewFeatures {
+     public class HtmlHelperOptions {
++        public CheckBoxHiddenInputRenderMode CheckBoxHiddenInputRenderMode { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Rewrite.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.Rewrite
+
+``` diff
+ namespace Microsoft.AspNetCore.Rewrite {
+     public static class RewriteOptionsExtensions {
++        public static RewriteOptions AddRedirectToNonWww(this RewriteOptions options);
++        public static RewriteOptions AddRedirectToNonWww(this RewriteOptions options, int statusCode);
++        public static RewriteOptions AddRedirectToNonWww(this RewriteOptions options, int statusCode, params string[] domains);
++        public static RewriteOptions AddRedirectToNonWww(this RewriteOptions options, params string[] domains);
++        public static RewriteOptions AddRedirectToNonWwwPermanent(this RewriteOptions options);
++        public static RewriteOptions AddRedirectToNonWwwPermanent(this RewriteOptions options, params string[] domains);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Server.HttpSys.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Server.HttpSys
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.HttpSys {
+     public sealed class AuthenticationManager {
++        public bool AutomaticAuthentication { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Server.IIS.md

@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Server.IIS
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.IIS {
+-    public sealed class BadHttpRequestException : IOException {
++    public sealed class BadHttpRequestException : BadHttpRequestException {
+-        public int StatusCode { get; }
++        public new int StatusCode { get; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.md

@@ -0,0 +1,32 @@
+# Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http {
+-    public class HttpParser<TRequestHandler> : IHttpParser<TRequestHandler> where TRequestHandler : IHttpHeadersHandler, IHttpRequestLineHandler {
++    public class HttpParser<TRequestHandler> where TRequestHandler : IHttpHeadersHandler, IHttpRequestLineHandler {
+-        bool Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.IHttpParser<TRequestHandler>.ParseRequestLine(TRequestHandler handler, in ReadOnlySequence<byte> buffer, out SequencePosition consumed, out SequencePosition examined);
+
+     }
+     public enum HttpVersion {
++        Http3 = 3,
+     }
+     public interface IHttpHeadersHandler {
++        void OnHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value);
+-        void OnHeader(Span<byte> name, Span<byte> value);
+
+-        void OnHeadersComplete();
+
++        void OnHeadersComplete(bool endStream);
++        void OnStaticIndexedHeader(int index);
++        void OnStaticIndexedHeader(int index, ReadOnlySpan<byte> value);
+     }
+-    public interface IHttpParser<TRequestHandler> where TRequestHandler : IHttpHeadersHandler, IHttpRequestLineHandler {
+ {
+-        bool ParseHeaders(TRequestHandler handler, ref SequenceReader<byte> reader);
+
+-        bool ParseRequestLine(TRequestHandler handler, in ReadOnlySequence<byte> buffer, out SequencePosition consumed, out SequencePosition examined);
+
+-    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Core.md

@@ -0,0 +1,42 @@
+# Microsoft.AspNetCore.Server.Kestrel.Core
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.Kestrel.Core {
+-    public sealed class BadHttpRequestException : IOException {
++    public sealed class BadHttpRequestException : BadHttpRequestException {
+-        public int StatusCode { get; }
++        public new int StatusCode { get; }
+     }
++    public class Http3Limits {
++        public Http3Limits();
++        public int HeaderTableSize { get; set; }
++        public int MaxRequestHeaderFieldSize { get; set; }
++    }
+     public enum HttpProtocols {
++        Http1AndHttp2AndHttp3 = 7,
++        Http3 = 4,
+     }
+     public class KestrelServer : IDisposable, IServer {
+-        public KestrelServer(IOptions<KestrelServerOptions> options, IConnectionListenerFactory transportFactory, ILoggerFactory loggerFactory);
+
++        public KestrelServer(IOptions<KestrelServerOptions> options, IEnumerable<IConnectionListenerFactory> transportFactories, ILoggerFactory loggerFactory);
++        public KestrelServer(IOptions<KestrelServerOptions> options, IEnumerable<IConnectionListenerFactory> transportFactories, IEnumerable<IMultiplexedConnectionListenerFactory> multiplexedFactories, ILoggerFactory loggerFactory);
+     }
+     public class KestrelServerLimits {
++        public Http3Limits Http3 { get; }
+     }
+     public class KestrelServerOptions {
++        public bool AllowResponseHeaderCompression { get; set; }
++        public bool EnableAltSvc { get; set; }
++        public void Listen(EndPoint endPoint);
++        public void Listen(EndPoint endPoint, Action<ListenOptions> configure);
+     }
+-    public class ListenOptions : IConnectionBuilder {
++    public class ListenOptions : IConnectionBuilder, IMultiplexedConnectionBuilder {
++        public EndPoint EndPoint { get; }
++        MultiplexedConnectionDelegate Microsoft.AspNetCore.Connections.IMultiplexedConnectionBuilder.Build();
++        IMultiplexedConnectionBuilder Microsoft.AspNetCore.Connections.IMultiplexedConnectionBuilder.Use(Func<MultiplexedConnectionDelegate, MultiplexedConnectionDelegate> middleware);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.md

@@ -0,0 +1,16 @@
+# Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets {
++    public class SocketConnectionFactory : IAsyncDisposable, IConnectionFactory {
++        public SocketConnectionFactory(IOptions<SocketTransportOptions> options, ILoggerFactory loggerFactory);
++        public ValueTask<ConnectionContext> ConnectAsync(EndPoint endpoint, CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask DisposeAsync();
++    }
+     public class SocketTransportOptions {
++        public int Backlog { get; set; }
++        public bool WaitForDataBeforeAllocatingBuffer { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.SignalR.md

@@ -0,0 +1,27 @@
+# Microsoft.AspNetCore.SignalR
+
+``` diff
+ namespace Microsoft.AspNetCore.SignalR {
+     public static class HubClientsExtensions {
++        public static T AllExcept<T>(this IHubClients<T> hubClients, IEnumerable<string> excludedConnectionIds);
++        public static T Clients<T>(this IHubClients<T> hubClients, IEnumerable<string> connectionIds);
++        public static T GroupExcept<T>(this IHubClients<T> hubClients, string groupName, IEnumerable<string> excludedConnectionIds);
++        public static T Groups<T>(this IHubClients<T> hubClients, IEnumerable<string> groupNames);
++        public static T Users<T>(this IHubClients<T> hubClients, IEnumerable<string> userIds);
+     }
+     public class HubInvocationContext {
++        public HubInvocationContext(HubCallerContext context, Type hubType, string hubMethodName, object[] hubMethodArguments);
++        public Type HubType { get; }
+     }
+-    public class HubRouteBuilder {
+ {
+-        public HubRouteBuilder(ConnectionsRouteBuilder routes);
+
+-        public void MapHub<THub>(PathString path) where THub : Hub;
+
+-        public void MapHub<THub>(PathString path, Action<HttpConnectionDispatcherOptions> configureOptions) where THub : Hub;
+
+-    }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.StaticFiles.Infrastructure.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.StaticFiles.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.StaticFiles.Infrastructure {
+     public class SharedOptions {
++        public bool RedirectToAppendTrailingSlash { get; set; }
+     }
+     public abstract class SharedOptionsBase {
++        public bool RedirectToAppendTrailingSlash { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.AspNetCore.WebUtilities.md

@@ -0,0 +1,24 @@
+# Microsoft.AspNetCore.WebUtilities
+
+``` diff
+ namespace Microsoft.AspNetCore.WebUtilities {
+     public class HttpRequestStreamReader : TextReader {
++        public override int Read(Span<char> buffer);
++        public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override string ReadLine();
++        public override Task<string> ReadLineAsync();
++        public override Task<string> ReadToEndAsync();
+     }
+     public class HttpResponseStreamWriter : TextWriter {
++        public override void Write(ReadOnlySpan<char> value);
++        public override Task WriteAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default(CancellationToken));
++        public override void WriteLine(ReadOnlySpan<char> value);
++        public override Task WriteLineAsync(ReadOnlyMemory<char> value, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public static class QueryHelpers {
++        public static string AddQueryString(string uri, IEnumerable<KeyValuePair<string, StringValues>> queryString);
++        public static string AddQueryString(string uri, IEnumerable<KeyValuePair<string, string>> queryString);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Configuration.KeyPerFile.md

@@ -0,0 +1,15 @@
+# Microsoft.Extensions.Configuration.KeyPerFile
+
+``` diff
+ namespace Microsoft.Extensions.Configuration.KeyPerFile {
+-    public class KeyPerFileConfigurationProvider : ConfigurationProvider {
++    public class KeyPerFileConfigurationProvider : ConfigurationProvider, IDisposable {
++        public void Dispose();
+     }
+     public class KeyPerFileConfigurationSource : IConfigurationSource {
++        public int ReloadDelay { get; set; }
++        public bool ReloadOnChange { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Configuration.md

@@ -0,0 +1,11 @@
+# Microsoft.Extensions.Configuration
+
+``` diff
+ namespace Microsoft.Extensions.Configuration {
+     public static class KeyPerFileConfigurationBuilderExtensions {
++        public static IConfigurationBuilder AddKeyPerFile(this IConfigurationBuilder builder, string directoryPath);
++        public static IConfigurationBuilder AddKeyPerFile(this IConfigurationBuilder builder, string directoryPath, bool optional, bool reloadOnChange);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.DependencyInjection.md

@@ -0,0 +1,32 @@
+# Microsoft.Extensions.DependencyInjection
+
+``` diff
+ namespace Microsoft.Extensions.DependencyInjection {
+     public static class CookieExtensions {
++        public static AuthenticationBuilder AddCookie<TService>(this AuthenticationBuilder builder, Action<CookieAuthenticationOptions, TService> configureOptions) where TService : class;
++        public static AuthenticationBuilder AddCookie<TService>(this AuthenticationBuilder builder, string authenticationScheme, Action<CookieAuthenticationOptions, TService> configureOptions) where TService : class;
++        public static AuthenticationBuilder AddCookie<TService>(this AuthenticationBuilder builder, string authenticationScheme, string displayName, Action<CookieAuthenticationOptions, TService> configureOptions) where TService : class;
+     }
+     public static class HttpClientBuilderExtensions {
++        public static IHttpClientBuilder RedactLoggedHeaders(this IHttpClientBuilder builder, IEnumerable<string> redactedLoggedHeaderNames);
++        public static IHttpClientBuilder RedactLoggedHeaders(this IHttpClientBuilder builder, Func<string, bool> shouldRedactHeaderValue);
+     }
+     public static class HttpClientFactoryServiceCollectionExtensions {
++        public static IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this IServiceCollection services, Func<HttpClient, IServiceProvider, TImplementation> factory) where TClient : class where TImplementation : class, TClient;
++        public static IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this IServiceCollection services, Func<HttpClient, TImplementation> factory) where TClient : class where TImplementation : class, TClient;
++        public static IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this IServiceCollection services, string name, Func<HttpClient, IServiceProvider, TImplementation> factory) where TClient : class where TImplementation : class, TClient;
++        public static IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this IServiceCollection services, string name, Func<HttpClient, TImplementation> factory) where TClient : class where TImplementation : class, TClient;
+     }
+     public static class IdentityServiceCollectionExtensions {
++        public static IServiceCollection ConfigureApplicationCookie<TService>(this IServiceCollection services, Action<CookieAuthenticationOptions, TService> configure) where TService : class;
++        public static IServiceCollection ConfigureExternalCookie<TService>(this IServiceCollection services, Action<CookieAuthenticationOptions, TService> configure) where TService : class;
+     }
+     public static class OAuthExtensions {
++        public static AuthenticationBuilder AddOAuth<TOptions, THandler, TService>(this AuthenticationBuilder builder, string authenticationScheme, Action<TOptions, TService> configureOptions) where TOptions : OAuthOptions, new() where THandler : OAuthHandler<TOptions> where TService : class;
++        public static AuthenticationBuilder AddOAuth<TOptions, THandler, TService>(this AuthenticationBuilder builder, string authenticationScheme, string displayName, Action<TOptions, TService> configureOptions) where TOptions : OAuthOptions, new() where THandler : OAuthHandler<TOptions> where TService : class;
++        public static AuthenticationBuilder AddOAuth<TService>(this AuthenticationBuilder builder, string authenticationScheme, Action<OAuthOptions, TService> configureOptions) where TService : class;
++        public static AuthenticationBuilder AddOAuth<TService>(this AuthenticationBuilder builder, string authenticationScheme, string displayName, Action<OAuthOptions, TService> configureOptions) where TService : class;
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Http.Logging.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Http.Logging
+
+``` diff
+ namespace Microsoft.Extensions.Http.Logging {
+     public class LoggingHttpMessageHandler : DelegatingHandler {
++        public LoggingHttpMessageHandler(ILogger logger, HttpClientFactoryOptions options);
+     }
+     public class LoggingScopeHttpMessageHandler : DelegatingHandler {
++        public LoggingScopeHttpMessageHandler(ILogger logger, HttpClientFactoryOptions options);
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Http.md

@@ -0,0 +1,10 @@
+# Microsoft.Extensions.Http
+
+``` diff
+ namespace Microsoft.Extensions.Http {
+     public class HttpClientFactoryOptions {
++        public Func<string, bool> ShouldRedactHeaderValue { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Localization.md

@@ -0,0 +1,30 @@
+# Microsoft.Extensions.Localization
+
+``` diff
+ namespace Microsoft.Extensions.Localization {
+     public interface IStringLocalizer {
+-        IStringLocalizer WithCulture(CultureInfo culture);
+
+     }
+     public class ResourceManagerStringLocalizer : IStringLocalizer {
+-        public IStringLocalizer WithCulture(CultureInfo culture);
+
+     }
+-    public class ResourceManagerWithCultureStringLocalizer : ResourceManagerStringLocalizer {
+ {
+-        public ResourceManagerWithCultureStringLocalizer(ResourceManager resourceManager, Assembly resourceAssembly, string baseName, IResourceNamesCache resourceNamesCache, CultureInfo culture, ILogger logger);
+
+-        public override LocalizedString this[string name, params object[] arguments] { get; }
+
+-        public override LocalizedString this[string name] { get; }
+
+-        public override IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures);
+
+-    }
+     public class StringLocalizer<TResourceSource> : IStringLocalizer, IStringLocalizer<TResourceSource> {
+-        public virtual IStringLocalizer WithCulture(CultureInfo culture);
+
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Logging.Console.md

@@ -0,0 +1,10 @@
+# Microsoft.Extensions.Logging.Console
+
+``` diff
+ namespace Microsoft.Extensions.Logging.Console {
+     public class ConsoleLoggerOptions {
++        public bool UseUtcTimestamp { get; set; }
+     }
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Extensions.Options.md

@@ -0,0 +1,27 @@
+# Microsoft.Extensions.Options
+
+``` diff
+ namespace Microsoft.Extensions.Options {
+-    public interface IOptions<out TOptions> where TOptions : class, new()
++    public interface IOptions<out TOptions> where TOptions : class
+-    public interface IOptionsFactory<TOptions> where TOptions : class, new()
++    public interface IOptionsFactory<TOptions> where TOptions : class
+-    public interface IOptionsSnapshot<out TOptions> : IOptions<TOptions> where TOptions : class, new()
++    public interface IOptionsSnapshot<out TOptions> : IOptions<TOptions> where TOptions : class
+     public static class Options {
+-        public static IOptions<TOptions> Create<TOptions>(TOptions options) where TOptions : class, new();
++        public static IOptions<TOptions> Create<TOptions>(TOptions options) where TOptions : class;
+     }
+-    public class OptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class, new() {
++    public class OptionsFactory<TOptions> : IOptionsFactory<TOptions> where TOptions : class {
++        protected virtual TOptions CreateInstance(string name);
+     }
+-    public class OptionsManager<TOptions> : IOptions<TOptions>, IOptionsSnapshot<TOptions> where TOptions : class, new()
++    public class OptionsManager<TOptions> : IOptions<TOptions>, IOptionsSnapshot<TOptions> where TOptions : class
+-    public class OptionsMonitor<TOptions> : IDisposable, IOptionsMonitor<TOptions> where TOptions : class, new()
++    public class OptionsMonitor<TOptions> : IDisposable, IOptionsMonitor<TOptions> where TOptions : class
+-    public class OptionsWrapper<TOptions> : IOptions<TOptions> where TOptions : class, new()
++    public class OptionsWrapper<TOptions> : IOptions<TOptions> where TOptions : class
+ }
+```
+

release-notes/5.0/preview/api-diff/preview4/Asp.Net/5.0-preview4_Microsoft.Net.Http.Headers.md

@@ -0,0 +1,11 @@
+# Microsoft.Net.Http.Headers
+
+``` diff
+ namespace Microsoft.Net.Http.Headers {
+     public static class HeaderNames {
++        public static readonly string AltSvc;
++        public static readonly string XRequestedWith;
+     }
+ }
+```
+

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

@@ -0,0 +1,7 @@
+# .NET 5.0 Preview 4 API Changes
+
+The following API changes were made in .NET 5.0 Preview 4:
+
+- [.NET](./.Net/5.0-preview4.md)
+- [.NET Standalone Packages](./.Net/standalone-packages/5.0-preview4-standalone-packages.md)
+- [ASP.NET](./Asp.Net/5.0-preview4.md)