Add API diff between .NET Core 2.2 and .NET Core 3.0 preview1. (#2256)

* Add API diff between .NET Core 2.2 and .NET Core 3.0 preview1.

* Only compare ref assemblies within M.NetCore.App rather than all impl
assemblies from the repo.

* Remove Microsoft.* namespaces and update heading.

release-notes/3.0/preview/api-diff/preview1/3.0-preview1.md

@@ -0,0 +1,45 @@
+# API Difference netcoreapp2.2 vs netcoreapp3.0-preview1
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System](3.0-preview1_System.md)
+* [System.Buffers](3.0-preview1_System.Buffers.md)
+* [System.Collections.Generic](3.0-preview1_System.Collections.Generic.md)
+* [System.Collections.Immutable](3.0-preview1_System.Collections.Immutable.md)
+* [System.ComponentModel](3.0-preview1_System.ComponentModel.md)
+* [System.Diagnostics](3.0-preview1_System.Diagnostics.md)
+* [System.Globalization](3.0-preview1_System.Globalization.md)
+* [System.IO](3.0-preview1_System.IO.md)
+* [System.IO.Compression](3.0-preview1_System.IO.Compression.md)
+* [System.IO.IsolatedStorage](3.0-preview1_System.IO.IsolatedStorage.md)
+* [System.IO.Pipes](3.0-preview1_System.IO.Pipes.md)
+* [System.Linq](3.0-preview1_System.Linq.md)
+* [System.Net](3.0-preview1_System.Net.md)
+* [System.Net.Http](3.0-preview1_System.Net.Http.md)
+* [System.Net.Security](3.0-preview1_System.Net.Security.md)
+* [System.Net.Sockets](3.0-preview1_System.Net.Sockets.md)
+* [System.Net.WebSockets](3.0-preview1_System.Net.WebSockets.md)
+* [System.Numerics](3.0-preview1_System.Numerics.md)
+* [System.Reflection](3.0-preview1_System.Reflection.md)
+* [System.Reflection.Emit](3.0-preview1_System.Reflection.Emit.md)
+* [System.Runtime](3.0-preview1_System.Runtime.md)
+* [System.Runtime.CompilerServices](3.0-preview1_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](3.0-preview1_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](3.0-preview1_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.Arm.Arm64](3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md)
+* [System.Runtime.Intrinsics.X86](3.0-preview1_System.Runtime.Intrinsics.X86.md)
+* [System.Runtime.Loader](3.0-preview1_System.Runtime.Loader.md)
+* [System.Runtime.Remoting](3.0-preview1_System.Runtime.Remoting.md)
+* [System.Runtime.Serialization](3.0-preview1_System.Runtime.Serialization.md)
+* [System.Security.Authentication](3.0-preview1_System.Security.Authentication.md)
+* [System.Security.Cryptography](3.0-preview1_System.Security.Cryptography.md)
+* [System.Text](3.0-preview1_System.Text.md)
+* [System.Text.Json](3.0-preview1_System.Text.Json.md)
+* [System.Text.RegularExpressions](3.0-preview1_System.Text.RegularExpressions.md)
+* [System.Threading](3.0-preview1_System.Threading.md)
+* [System.Threading.Tasks](3.0-preview1_System.Threading.Tasks.md)
+* [System.Threading.Tasks.Sources](3.0-preview1_System.Threading.Tasks.Sources.md)
+* [System.Windows.Markup](3.0-preview1_System.Windows.Markup.md)
+* [System.Xml](3.0-preview1_System.Xml.md)
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Buffers.md

@@ -0,0 +1,48 @@
+# System.Buffers
+
+``` diff
+ namespace System.Buffers {
++    public ref struct SequenceReader<T> where T : struct, IEquatable<T> {
++        public SequenceReader(ReadOnlySequence<T> sequence);
++        public long Consumed { get; }
++        public ReadOnlySpan<T> CurrentSpan { get; }
++        public int CurrentSpanIndex { get; }
++        public bool End { get; }
++        public long Length { get; }
++        public SequencePosition Position { get; }
++        public long Remaining { get; }
++        public ReadOnlySequence<T> Sequence { get; }
++        public ReadOnlySpan<T> UnreadSpan { get; }
++        public void Advance(long count);
++        public long AdvancePast(T value);
++        public long AdvancePastAny(ReadOnlySpan<T> values);
++        public long AdvancePastAny(T value0, T value1);
++        public long AdvancePastAny(T value0, T value1, T value2);
++        public long AdvancePastAny(T value0, T value1, T value2, T value3);
++        public bool IsNext(ReadOnlySpan<T> next, bool advancePast = false);
++        public bool IsNext(T next, bool advancePast = false);
++        public void Rewind(long count);
++        public bool TryAdvanceTo(T delimiter, bool advancePastDelimiter = true);
++        public bool TryAdvanceToAny(ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryCopyTo(Span<T> destination);
++        public bool TryPeek(out T value);
++        public bool TryRead(out T value);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySpan<T> span, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++    }
++    public static class SequenceReaderExtensions {
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out long value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out long value);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Generic.md

@@ -0,0 +1,14 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
++    public interface IAsyncEnumerable<out T> {
++        IAsyncEnumerator<T> GetAsyncEnumerator();
++    }
++    public interface IAsyncEnumerator<out T> : IAsyncDisposable {
++        T Current { get; }
++        ValueTask<bool> MoveNextAsync();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Immutable.md

@@ -0,0 +1,25 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+     public static class ImmutableArray {
++        public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder);
+     }
+     public static class ImmutableDictionary {
++        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder);
+     }
+     public static class ImmutableHashSet {
++        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder);
+     }
+     public static class ImmutableList {
++        public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder);
+     }
+     public static class ImmutableSortedDictionary {
++        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder source);
+     }
+     public static class ImmutableSortedSet {
++        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.ComponentModel.md

@@ -0,0 +1,21 @@
+# System.ComponentModel
+
+``` diff
+ namespace System.ComponentModel {
+     public class BackgroundWorker : Component {
++        protected override void Dispose(bool disposing);
+     }
++    public class VersionConverter : TypeConverter {
++        public VersionConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override bool IsValid(ITypeDescriptorContext context, object value);
++    }
+     public class Win32Exception : ExternalException, ISerializable {
++        public override string ToString();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Diagnostics.md

@@ -0,0 +1,36 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public class Activity {
+-        public static Activity Current { get; private set; }
++        public static Activity Current { get; set; }
+     }
++    public class ConsoleTraceListener : TextWriterTraceListener {
++        public ConsoleTraceListener();
++        public ConsoleTraceListener(bool useErrorStream);
++        public override void Close();
++    }
+     public class DiagnosticListener : DiagnosticSource, IDisposable, IObservable<KeyValuePair<string, object>> {
++        public override string ToString();
+     }
++    public class XmlWriterTraceListener : TextWriterTraceListener {
++        public XmlWriterTraceListener(Stream stream);
++        public XmlWriterTraceListener(Stream stream, string name);
++        public XmlWriterTraceListener(TextWriter writer);
++        public XmlWriterTraceListener(TextWriter writer, string name);
++        public XmlWriterTraceListener(string filename);
++        public XmlWriterTraceListener(string filename, string name);
++        public override void Close();
++        public override void Fail(string message, string detailMessage);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args);
++        public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId);
++        public override void Write(string message);
++        public override void WriteLine(string message);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Globalization.md

@@ -0,0 +1,18 @@
+# System.Globalization
+
+``` diff
+ namespace System.Globalization {
+     public class CompareInfo : IDeserializationCallback {
++        public int GetHashCode(ReadOnlySpan<char> source, CompareOptions options);
+     }
++    public static class ISOWeek {
++        public static int GetWeekOfYear(DateTime date);
++        public static int GetWeeksInYear(int year);
++        public static int GetYear(DateTime date);
++        public static DateTime GetYearEnd(int year);
++        public static DateTime GetYearStart(int year);
++        public static DateTime ToDateTime(int year, int week, DayOfWeek dayOfWeek);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Compression.md

@@ -0,0 +1,37 @@
+# System.IO.Compression
+
+``` diff
+ namespace System.IO.Compression {
+     public sealed class BrotliStream : Stream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class DeflateStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class GZipStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.IsolatedStorage.md

@@ -0,0 +1,17 @@
+# System.IO.IsolatedStorage
+
+``` diff
+ namespace System.IO.IsolatedStorage {
+     public class IsolatedStorageFileStream : FileStream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Pipes.md

@@ -0,0 +1,13 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
+     public abstract class PipeStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.md

@@ -0,0 +1,53 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public class BinaryWriter : IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public sealed class BufferedStream : Stream {
++        public override ValueTask DisposeAsync();
+     }
+     public static class File {
++        public static void Move(string sourceFileName, string destFileName, bool overwrite);
+     }
+     public sealed class FileInfo : FileSystemInfo {
++        public void MoveTo(string destFileName, bool overwrite);
+     }
+     public class FileStream : Stream {
++        public override ValueTask DisposeAsync();
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public abstract class FileSystemInfo : MarshalByRefObject, ISerializable {
++        public override string ToString();
+     }
+     public class FileSystemWatcher : Component, ISupportInitialize {
++        public Collection<string> Filters { get; }
+     }
+     public static class Path {
++        public static string Join(string path1, string path2);
++        public static string Join(string path1, string path2, string path3);
+     }
+     public abstract class Stream : MarshalByRefObject, IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public class StreamWriter : TextWriter {
++        public override ValueTask DisposeAsync();
+     }
+     public abstract class TextWriter : MarshalByRefObject, IDisposable {
++        public virtual ValueTask DisposeAsync();
++        public virtual void Write(StringBuilder value);
++        public virtual Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual void WriteLine(StringBuilder value);
++        public virtual Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class UnmanagedMemoryStream : Stream {
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Linq.md

@@ -0,0 +1,13 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public static class Enumerable {
++        public static IEnumerable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second);
+     }
+     public static class Queryable {
++        public static IQueryable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Http.md

@@ -0,0 +1,13 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class MultipartContent : HttpContent, IEnumerable, IEnumerable<HttpContent> {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+     public sealed class ReadOnlyMemoryContent : HttpContent {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Security.md

@@ -0,0 +1,21 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public abstract class AuthenticatedStream : Stream {
++        public override ValueTask DisposeAsync();
+     }
+     public class NegotiateStream : AuthenticatedStream {
++        public override ValueTask DisposeAsync();
+     }
+     public class SslStream : AuthenticatedStream {
++        public override ValueTask DisposeAsync();
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Sockets.md

@@ -0,0 +1,27 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public class NetworkStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void WriteByte(byte value);
+     }
++    public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
++        public SafeSocketHandle(IntPtr preexistingHandle, bool ownsHandle);
++        protected override bool ReleaseHandle();
++    }
+     public class Socket : IDisposable {
++        public SafeSocketHandle SafeHandle { get; }
+     }
+     public enum SocketOptionName {
++        TcpKeepAliveInterval = 17,
++        TcpKeepAliveRetryCount = 16,
++        TcpKeepAliveTime = 3,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.WebSockets.md

@@ -0,0 +1,11 @@
+# System.Net.WebSockets
+
+``` diff
+ namespace System.Net.WebSockets {
+     public sealed class ClientWebSocket : WebSocket {
++        public override ValueTask<ValueWebSocketReceiveResult> ReceiveAsync(Memory<byte> buffer, CancellationToken cancellationToken);
++        public override ValueTask SendAsync(ReadOnlyMemory<byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.md

@@ -0,0 +1,31 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+-    public class CookieCollection : ICollection, IEnumerable {
++    public class CookieCollection : ICollection, ICollection<Cookie>, IEnumerable, IEnumerable<Cookie>, IReadOnlyCollection<Cookie> {
++        public void Clear();
++        public bool Contains(Cookie cookie);
++        public bool Remove(Cookie cookie);
++        IEnumerator<Cookie> System.Collections.Generic.IEnumerable<System.Net.Cookie>.GetEnumerator();
+     }
+     public enum DecompressionMethods {
++        All = -1,
++        Brotli = 4,
+     }
+     public class FileWebRequest : WebRequest, ISerializable {
++        public override Task<Stream> GetRequestStreamAsync();
++        public override Task<WebResponse> GetResponseAsync();
+     }
+     public class IPEndPoint : EndPoint {
++        public static IPEndPoint Parse(ReadOnlySpan<char> s);
++        public static IPEndPoint Parse(string s);
++        public static bool TryParse(ReadOnlySpan<char> s, out IPEndPoint result);
++        public static bool TryParse(string s, out IPEndPoint result);
+     }
+     public enum SecurityProtocolType {
++        Tls13 = 12288,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Numerics.md

@@ -0,0 +1,30 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public struct Complex : IEquatable<Complex>, IFormattable {
++        public static readonly Complex Infinity;
++        public static readonly Complex NaN;
++        public static Complex Add(double left, Complex right);
++        public static Complex Add(Complex left, double right);
++        public static Complex Divide(double dividend, Complex divisor);
++        public static Complex Divide(Complex dividend, double divisor);
++        public static bool IsFinite(Complex value);
++        public static bool IsInfinity(Complex value);
++        public static bool IsNaN(Complex value);
++        public static Complex Multiply(double left, Complex right);
++        public static Complex Multiply(Complex left, double right);
++        public static Complex operator +(double left, Complex right);
++        public static Complex operator +(Complex left, double right);
++        public static Complex operator /(double left, Complex right);
++        public static Complex operator /(Complex left, double right);
++        public static Complex operator *(double left, Complex right);
++        public static Complex operator *(Complex left, double right);
++        public static Complex operator -(double left, Complex right);
++        public static Complex operator -(Complex left, double right);
++        public static Complex Subtract(double left, Complex right);
++        public static Complex Subtract(Complex left, double right);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.Emit.md

@@ -0,0 +1,19 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public sealed class DynamicMethod : MethodInfo {
++        public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string parameterName);
+     }
+     public class ModuleBuilder : Module {
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
+     }
+     public sealed class TypeBuilder : Type {
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.md

@@ -0,0 +1,20 @@
+# System.Reflection
+
+``` diff
+ namespace System.Reflection {
+     public class CustomAttributeData {
+-        public Type AttributeType { get; }
++        public virtual Type AttributeType { get; }
+     }
++    public interface ICustomTypeProvider {
++        Type GetCustomType();
++    }
+     public enum MethodImplAttributes {
++        AggressiveOptimization = 512,
+     }
+     public abstract class TypeInfo : Type, IReflectableType {
++        protected TypeInfo();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.CompilerServices.md

@@ -0,0 +1,36 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public struct AsyncIteratorMethodBuilder {
++        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void Complete();
++        public static AsyncIteratorMethodBuilder Create();
++        public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
++    public sealed class CallerArgumentExpressionAttribute : Attribute {
++        public CallerArgumentExpressionAttribute(string parameterName);
++        public string ParameterName { get; }
++    }
++    public readonly struct ConfiguredAsyncEnumerable<T> {
++        public ConfiguredAsyncEnumerable<T>.Enumerator GetAsyncEnumerator();
++        public readonly struct Enumerator {
++            public T Current { get; }
++            public ConfiguredValueTaskAwaitable DisposeAsync();
++            public ConfiguredValueTaskAwaitable<bool> MoveNextAsync();
++        }
++    }
++    public sealed class IDispatchConstantAttribute : CustomConstantAttribute {
++        public IDispatchConstantAttribute();
++        public override object Value { get; }
++    }
+     public enum MethodImplOptions {
++        AggressiveOptimization = 512,
+     }
+     public static class RuntimeFeature {
++        public const string DefaultImplementationsOfInterfaces = "DefaultImplementationsOfInterfaces";
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.InteropServices.md

@@ -0,0 +1,27 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+-    public struct HandleRef
++    public readonly struct HandleRef
+     public static class Marshal {
++        public static int GetEndComSlot(Type t);
++        public static IntPtr GetExceptionPointers();
++        public static bool IsTypeVisibleFromCom(Type t);
+     }
+     public static class MemoryMarshal {
++        public static ref readonly T AsRef<T>(ReadOnlySpan<byte> span) where T : struct;
++        public static ref T AsRef<T>(Span<byte> span) where T : struct;
+     }
+     public readonly struct OSPlatform : IEquatable<OSPlatform> {
++        public static OSPlatform FreeBSD { get; }
+     }
+     public static class SequenceMarshal {
++        public static bool TryRead<T>(ref SequenceReader<byte> reader, out T value) where T : struct;
+     }
++    public class StandardOleMarshalObject : MarshalByRefObject {
++        protected StandardOleMarshalObject();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md

@@ -0,0 +1,177 @@
+# System.Runtime.Intrinsics.Arm.Arm64
+
+``` diff
++namespace System.Runtime.Intrinsics.Arm.Arm64 {
++    public static class Aes {
++        public static bool IsSupported { get; }
++        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> InverseMixColumns(Vector128<byte> value);
++        public static Vector128<byte> MixColumns(Vector128<byte> value);
++    }
++    public static class Base {
++        public static bool IsSupported { get; }
++        public static int LeadingSignCount(int value);
++        public static int LeadingSignCount(long value);
++        public static int LeadingZeroCount(int value);
++        public static int LeadingZeroCount(long value);
++        public static int LeadingZeroCount(uint value);
++        public static int LeadingZeroCount(ulong value);
++    }
++    public static class Sha1 {
++        public static bool IsSupported { get; }
++        public static uint FixedRotate(uint hash_e);
++        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11);
++        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15);
++    }
++    public static class Sha256 {
++        public static bool IsSupported { get; }
++        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk);
++        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk);
++        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7);
++        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15);
++    }
++    public static class Simd {
++        public static bool IsSupported { get; }
++        public static Vector128<double> Abs(Vector128<double> value);
++        public static Vector128<ushort> Abs(Vector128<short> value);
++        public static Vector128<uint> Abs(Vector128<int> value);
++        public static Vector128<ulong> Abs(Vector128<long> value);
++        public static Vector128<byte> Abs(Vector128<sbyte> value);
++        public static Vector128<float> Abs(Vector128<float> value);
++        public static Vector64<ushort> Abs(Vector64<short> value);
++        public static Vector64<uint> Abs(Vector64<int> value);
++        public static Vector64<byte> Abs(Vector64<sbyte> value);
++        public static Vector64<float> Abs(Vector64<float> value);
++        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> And<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> AndNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> BitwiseSelect<T>(Vector64<T> sel, Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareGreaterThan<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareGreaterThanOrEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareGreaterThanOrEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareGreaterThanZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareLessThanOrEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareLessThanZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareTest<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);
++        public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right);
++        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct;
++        public static T Extract<T>(Vector64<T> vector, byte index) where T : struct;
++        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct;
++        public static Vector64<T> Insert<T>(Vector64<T> vector, byte index, T data) where T : struct;
++        public static Vector128<short> LeadingSignCount(Vector128<short> value);
++        public static Vector128<int> LeadingSignCount(Vector128<int> value);
++        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value);
++        public static Vector64<short> LeadingSignCount(Vector64<short> value);
++        public static Vector64<int> LeadingSignCount(Vector64<int> value);
++        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value);
++        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value);
++        public static Vector128<short> LeadingZeroCount(Vector128<short> value);
++        public static Vector128<int> LeadingZeroCount(Vector128<int> value);
++        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value);
++        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value);
++        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);
++        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value);
++        public static Vector64<short> LeadingZeroCount(Vector64<short> value);
++        public static Vector64<int> LeadingZeroCount(Vector64<int> value);
++        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value);
++        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value);
++        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value);
++        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Max(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Max(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Max(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Min(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Min(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Min(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<double> Negate(Vector128<double> value);
++        public static Vector128<short> Negate(Vector128<short> value);
++        public static Vector128<int> Negate(Vector128<int> value);
++        public static Vector128<long> Negate(Vector128<long> value);
++        public static Vector128<sbyte> Negate(Vector128<sbyte> value);
++        public static Vector128<float> Negate(Vector128<float> value);
++        public static Vector64<short> Negate(Vector64<short> value);
++        public static Vector64<int> Negate(Vector64<int> value);
++        public static Vector64<sbyte> Negate(Vector64<sbyte> value);
++        public static Vector64<float> Negate(Vector64<float> value);
++        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> Not<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Or<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> OrNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<byte> PopCount(Vector128<byte> value);
++        public static Vector128<sbyte> PopCount(Vector128<sbyte> value);
++        public static Vector64<byte> PopCount(Vector64<byte> value);
++        public static Vector64<sbyte> PopCount(Vector64<sbyte> value);
++        public static Vector128<T> SetAllVector128<T>(T value) where T : struct;
++        public static Vector64<T> SetAllVector64<T>(T value) where T : struct;
++        public static Vector128<double> Sqrt(Vector128<double> value);
++        public static Vector128<float> Sqrt(Vector128<float> value);
++        public static Vector64<float> Sqrt(Vector64<float> value);
++        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Xor<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.md

@@ -0,0 +1,207 @@
+# System.Runtime.Intrinsics
+
+``` diff
++namespace System.Runtime.Intrinsics {
++    public static class Vector128 {
++        public static Vector128<Byte> Create(byte value);
++        public static Vector128<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15);
++        public static Vector128<Double> Create(double value);
++        public static Vector128<Double> Create(double e0, double e1);
++        public static Vector128<Int16> Create(short value);
++        public static Vector128<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7);
++        public static Vector128<Int32> Create(int value);
++        public static Vector128<Int32> Create(int e0, int e1, int e2, int e3);
++        public static Vector128<Int64> Create(long value);
++        public static Vector128<Int64> Create(long e0, long e1);
++        public static Vector128<Byte> Create(Vector64<byte> lower, Vector64<byte> upper);
++        public static Vector128<Double> Create(Vector64<double> lower, Vector64<double> upper);
++        public static Vector128<Int16> Create(Vector64<short> lower, Vector64<short> upper);
++        public static Vector128<Int32> Create(Vector64<int> lower, Vector64<int> upper);
++        public static Vector128<Int64> Create(Vector64<long> lower, Vector64<long> upper);
++        public static Vector128<SByte> Create(Vector64<sbyte> lower, Vector64<sbyte> upper);
++        public static Vector128<Single> Create(Vector64<float> lower, Vector64<float> upper);
++        public static Vector128<UInt16> Create(Vector64<ushort> lower, Vector64<ushort> upper);
++        public static Vector128<UInt32> Create(Vector64<uint> lower, Vector64<uint> upper);
++        public static Vector128<UInt64> Create(Vector64<ulong> lower, Vector64<ulong> upper);
++        public static Vector128<SByte> Create(sbyte value);
++        public static Vector128<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15);
++        public static Vector128<Single> Create(float value);
++        public static Vector128<Single> Create(float e0, float e1, float e2, float e3);
++        public static Vector128<UInt16> Create(ushort value);
++        public static Vector128<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7);
++        public static Vector128<UInt32> Create(uint value);
++        public static Vector128<UInt32> Create(uint e0, uint e1, uint e2, uint e3);
++        public static Vector128<UInt64> Create(ulong value);
++        public static Vector128<UInt64> Create(ulong e0, ulong e1);
++        public static Vector128<Byte> CreateScalar(byte value);
++        public static Vector128<Double> CreateScalar(double value);
++        public static Vector128<Int16> CreateScalar(short value);
++        public static Vector128<Int32> CreateScalar(int value);
++        public static Vector128<Int64> CreateScalar(long value);
++        public static Vector128<SByte> CreateScalar(sbyte value);
++        public static Vector128<Single> CreateScalar(float value);
++        public static Vector128<UInt16> CreateScalar(ushort value);
++        public static Vector128<UInt32> CreateScalar(uint value);
++        public static Vector128<UInt64> CreateScalar(ulong value);
++        public static Vector128<Byte> CreateScalarUnsafe(byte value);
++        public static Vector128<Double> CreateScalarUnsafe(double value);
++        public static Vector128<Int16> CreateScalarUnsafe(short value);
++        public static Vector128<Int32> CreateScalarUnsafe(int value);
++        public static Vector128<Int64> CreateScalarUnsafe(long value);
++        public static Vector128<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector128<Single> CreateScalarUnsafe(float value);
++        public static Vector128<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector128<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector128<UInt64> CreateScalarUnsafe(ulong value);
++    }
++    public readonly struct Vector128<T> where T : struct {
++        public static Vector128<T> Zero { get; }
++        public Vector128<U> As<U>() where U : struct;
++        public Vector128<Byte> AsByte();
++        public Vector128<Double> AsDouble();
++        public Vector128<Int16> AsInt16();
++        public Vector128<Int32> AsInt32();
++        public Vector128<Int64> AsInt64();
++        public Vector128<SByte> AsSByte();
++        public Vector128<Single> AsSingle();
++        public Vector128<UInt16> AsUInt16();
++        public Vector128<UInt32> AsUInt32();
++        public Vector128<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public Vector64<T> GetLower();
++        public Vector64<T> GetUpper();
++        public T ToScalar();
++        public Vector256<T> ToVector256();
++        public Vector256<T> ToVector256Unsafe();
++        public Vector128<T> WithElement(int index, T value);
++        public Vector128<T> WithLower(Vector64<T> value);
++        public Vector128<T> WithUpper(Vector64<T> value);
++    }
++    public static class Vector256 {
++        public static Vector256<Byte> Create(byte value);
++        public static Vector256<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31);
++        public static Vector256<Double> Create(double value);
++        public static Vector256<Double> Create(double e0, double e1, double e2, double e3);
++        public static Vector256<Int16> Create(short value);
++        public static Vector256<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15);
++        public static Vector256<Int32> Create(int value);
++        public static Vector256<Int32> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7);
++        public static Vector256<Int64> Create(long value);
++        public static Vector256<Int64> Create(long e0, long e1, long e2, long e3);
++        public static Vector256<Byte> Create(Vector128<byte> lower, Vector128<byte> upper);
++        public static Vector256<Double> Create(Vector128<double> lower, Vector128<double> upper);
++        public static Vector256<Int16> Create(Vector128<short> lower, Vector128<short> upper);
++        public static Vector256<Int32> Create(Vector128<int> lower, Vector128<int> upper);
++        public static Vector256<Int64> Create(Vector128<long> lower, Vector128<long> upper);
++        public static Vector256<SByte> Create(Vector128<sbyte> lower, Vector128<sbyte> upper);
++        public static Vector256<Single> Create(Vector128<float> lower, Vector128<float> upper);
++        public static Vector256<UInt16> Create(Vector128<ushort> lower, Vector128<ushort> upper);
++        public static Vector256<UInt32> Create(Vector128<uint> lower, Vector128<uint> upper);
++        public static Vector256<UInt64> Create(Vector128<ulong> lower, Vector128<ulong> upper);
++        public static Vector256<SByte> Create(sbyte value);
++        public static Vector256<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31);
++        public static Vector256<Single> Create(float value);
++        public static Vector256<Single> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7);
++        public static Vector256<UInt16> Create(ushort value);
++        public static Vector256<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15);
++        public static Vector256<UInt32> Create(uint value);
++        public static Vector256<UInt32> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7);
++        public static Vector256<UInt64> Create(ulong value);
++        public static Vector256<UInt64> Create(ulong e0, ulong e1, ulong e2, ulong e3);
++        public static Vector256<Byte> CreateScalar(byte value);
++        public static Vector256<Double> CreateScalar(double value);
++        public static Vector256<Int16> CreateScalar(short value);
++        public static Vector256<Int32> CreateScalar(int value);
++        public static Vector256<Int64> CreateScalar(long value);
++        public static Vector256<SByte> CreateScalar(sbyte value);
++        public static Vector256<Single> CreateScalar(float value);
++        public static Vector256<UInt16> CreateScalar(ushort value);
++        public static Vector256<UInt32> CreateScalar(uint value);
++        public static Vector256<UInt64> CreateScalar(ulong value);
++        public static Vector256<Byte> CreateScalarUnsafe(byte value);
++        public static Vector256<Double> CreateScalarUnsafe(double value);
++        public static Vector256<Int16> CreateScalarUnsafe(short value);
++        public static Vector256<Int32> CreateScalarUnsafe(int value);
++        public static Vector256<Int64> CreateScalarUnsafe(long value);
++        public static Vector256<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector256<Single> CreateScalarUnsafe(float value);
++        public static Vector256<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector256<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector256<UInt64> CreateScalarUnsafe(ulong value);
++    }
++    public readonly struct Vector256<T> where T : struct {
++        public static Vector256<T> Zero { get; }
++        public Vector256<U> As<U>() where U : struct;
++        public Vector256<Byte> AsByte();
++        public Vector256<Double> AsDouble();
++        public Vector256<Int16> AsInt16();
++        public Vector256<Int32> AsInt32();
++        public Vector256<Int64> AsInt64();
++        public Vector256<SByte> AsSByte();
++        public Vector256<Single> AsSingle();
++        public Vector256<UInt16> AsUInt16();
++        public Vector256<UInt32> AsUInt32();
++        public Vector256<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public Vector128<T> GetLower();
++        public Vector128<T> GetUpper();
++        public T ToScalar();
++        public Vector256<T> WithElement(int index, T value);
++        public Vector256<T> WithLower(Vector128<T> value);
++        public Vector256<T> WithUpper(Vector128<T> value);
++    }
++    public static class Vector64 {
++        public static Vector64<Byte> Create(byte value);
++        public static Vector64<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7);
++        public static Vector64<Double> Create(double value);
++        public static Vector64<Int16> Create(short value);
++        public static Vector64<Int16> Create(short e0, short e1, short e2, short e3);
++        public static Vector64<Int32> Create(int value);
++        public static Vector64<Int32> Create(int e0, int e1);
++        public static Vector64<Int64> Create(long value);
++        public static Vector64<SByte> Create(sbyte value);
++        public static Vector64<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7);
++        public static Vector64<Single> Create(float value);
++        public static Vector64<Single> Create(float e0, float e1);
++        public static Vector64<UInt16> Create(ushort value);
++        public static Vector64<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3);
++        public static Vector64<UInt32> Create(uint value);
++        public static Vector64<UInt32> Create(uint e0, uint e1);
++        public static Vector64<UInt64> Create(ulong value);
++        public static Vector64<Byte> CreateScalar(byte value);
++        public static Vector64<Int16> CreateScalar(short value);
++        public static Vector64<Int32> CreateScalar(int value);
++        public static Vector64<SByte> CreateScalar(sbyte value);
++        public static Vector64<Single> CreateScalar(float value);
++        public static Vector64<UInt16> CreateScalar(ushort value);
++        public static Vector64<UInt32> CreateScalar(uint value);
++        public static Vector64<Byte> CreateScalarUnsafe(byte value);
++        public static Vector64<Int16> CreateScalarUnsafe(short value);
++        public static Vector64<Int32> CreateScalarUnsafe(int value);
++        public static Vector64<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector64<Single> CreateScalarUnsafe(float value);
++        public static Vector64<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector64<UInt32> CreateScalarUnsafe(uint value);
++    }
++    public readonly struct Vector64<T> where T : struct {
++        public static Vector64<T> Zero { get; }
++        public Vector64<U> As<U>() where U : struct;
++        public Vector64<Byte> AsByte();
++        public Vector64<Double> AsDouble();
++        public Vector64<Int16> AsInt16();
++        public Vector64<Int32> AsInt32();
++        public Vector64<Int64> AsInt64();
++        public Vector64<SByte> AsSByte();
++        public Vector64<Single> AsSingle();
++        public Vector64<UInt16> AsUInt16();
++        public Vector64<UInt32> AsUInt32();
++        public Vector64<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public T ToScalar();
++        public Vector128<T> ToVector128();
++        public Vector128<T> ToVector128Unsafe();
++        public Vector64<T> WithElement(int index, T value);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Loader.md

@@ -0,0 +1,12 @@
+# System.Runtime.Loader
+
+``` diff
+ namespace System.Runtime.Loader {
+     public abstract class AssemblyLoadContext {
++        protected AssemblyLoadContext(bool isCollectible);
++        public bool IsCollectible { get; }
++        public void Unload();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Remoting.md

@@ -0,0 +1,11 @@
+# System.Runtime.Remoting
+
+``` diff
++namespace System.Runtime.Remoting {
++    public class ObjectHandle : MarshalByRefObject {
++        public ObjectHandle(object o);
++        public object Unwrap();
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Serialization.md

@@ -0,0 +1,9 @@
+# System.Runtime.Serialization
+
+``` diff
+ namespace System.Runtime.Serialization {
+-    public struct SerializationEntry
++    public readonly struct SerializationEntry
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.md

@@ -0,0 +1,11 @@
+# System.Runtime
+
+``` diff
+ namespace System.Runtime {
++    public static class ProfileOptimization {
++        public static void SetProfileRoot(string directoryPath);
++        public static void StartProfile(string profile);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Authentication.md

@@ -0,0 +1,10 @@
+# System.Security.Authentication
+
+``` diff
+ namespace System.Security.Authentication {
+     public enum SslProtocols {
++        Tls13 = 12288,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Cryptography.md

@@ -0,0 +1,116 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
++    public sealed class AesCcm : IDisposable {
++        public AesCcm(byte[] key);
++        public AesCcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
++    public sealed class AesGcm : IDisposable {
++        public AesGcm(byte[] key);
++        public AesGcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
+     public abstract class AsymmetricAlgorithm : IDisposable {
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters);
++        public virtual byte[] ExportPkcs8PrivateKey();
++        public virtual byte[] ExportSubjectPublicKeyInfo();
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public class CryptoStream : Stream, IDisposable {
++        public override ValueTask DisposeAsync();
+     }
+     public abstract class ECDiffieHellman : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
+     }
+     public abstract class ECDsa : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class MD5CryptoServiceProvider : MD5 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
++    public enum PbeEncryptionAlgorithm {
++        Aes128Cbc = 1,
++        Aes192Cbc = 2,
++        Aes256Cbc = 3,
++        TripleDes3KeyPkcs12 = 4,
++        Unknown = 0,
++    }
++    public sealed class PbeParameters {
++        public PbeParameters(PbeEncryptionAlgorithm encryptionAlgorithm, HashAlgorithmName hashAlgorithm, int iterationCount);
++        public PbeEncryptionAlgorithm EncryptionAlgorithm { get; }
++        public HashAlgorithmName HashAlgorithm { get; }
++        public int IterationCount { get; }
++    }
+     public abstract class RandomNumberGenerator : IDisposable {
++        public static int GetInt32(int toExclusive);
++        public static int GetInt32(int fromInclusive, int toExclusive);
+     }
+     public sealed class RNGCryptoServiceProvider : RandomNumberGenerator {
++        public override void GetBytes(byte[] data, int offset, int count);
++        public override void GetBytes(Span<byte> data);
++        public override void GetNonZeroBytes(Span<byte> data);
+     }
+     public abstract class RSA : AsymmetricAlgorithm {
++        public virtual byte[] ExportRSAPrivateKey();
++        public virtual byte[] ExportRSAPublicKey();
++        public virtual void ImportRSAPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportRSAPublicKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportRSAPrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportRSAPublicKey(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA1CryptoServiceProvider : SHA1 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA256CryptoServiceProvider : SHA256 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA384CryptoServiceProvider : SHA384 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA512CryptoServiceProvider : SHA512 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.Json.md

@@ -0,0 +1,62 @@
+# System.Text.Json
+
+``` diff
++namespace System.Text.Json {
++    public enum JsonCommentHandling : byte {
++        Allow = (byte)1,
++        Disallow = (byte)0,
++        Skip = (byte)2,
++    }
++    public sealed class JsonReaderException : Exception {
++        public JsonReaderException(string message, long lineNumber, long bytePositionInLine);
++        public long BytePositionInLine { get; }
++        public long LineNumber { get; }
++        public override void GetObjectData(SerializationInfo info, StreamingContext context);
++    }
++    public struct JsonReaderOptions {
++        public JsonCommentHandling CommentHandling { get; set; }
++    }
++    public struct JsonReaderState {
++        public JsonReaderState(int maxDepth = 64, JsonReaderOptions options = default(JsonReaderOptions));
++        public long BytesConsumed { get; }
++        public int MaxDepth { get; }
++        public JsonReaderOptions Options { get; }
++        public SequencePosition Position { get; }
++    }
++    public enum JsonTokenType : byte {
++        Comment = (byte)11,
++        EndArray = (byte)4,
++        EndObject = (byte)2,
++        False = (byte)9,
++        None = (byte)0,
++        Null = (byte)10,
++        Number = (byte)7,
++        PropertyName = (byte)5,
++        StartArray = (byte)3,
++        StartObject = (byte)1,
++        String = (byte)6,
++        True = (byte)8,
++    }
++    public ref struct Utf8JsonReader {
++        public Utf8JsonReader(in ReadOnlySequence<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public Utf8JsonReader(ReadOnlySpan<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public long BytesConsumed { get; }
++        public int CurrentDepth { get; }
++        public JsonReaderState CurrentState { get; }
++        public bool HasValueSequence { get; }
++        public SequencePosition Position { get; }
++        public JsonTokenType TokenType { get; }
++        public ReadOnlySequence<byte> ValueSequence { get; }
++        public ReadOnlySpan<byte> ValueSpan { get; }
++        public bool GetBooleanValue();
++        public string GetStringValue();
++        public bool Read();
++        public bool TryGetDecimalValue(out decimal value);
++        public bool TryGetDoubleValue(out double value);
++        public bool TryGetInt32Value(out int value);
++        public bool TryGetInt64Value(out long value);
++        public bool TryGetSingleValue(out float value);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.RegularExpressions.md

@@ -0,0 +1,15 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+-    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyList<Group> {
++    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IEnumerable<KeyValuePair<string, Group>>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyCollection<KeyValuePair<string, Group>>, IReadOnlyDictionary<string, Group>, IReadOnlyList<Group> {
++        public IEnumerable<string> Keys { get; }
++        public IEnumerable<Group> Values { get; }
++        public bool ContainsKey(string key);
++        IEnumerator<KeyValuePair<string, Group>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Text.RegularExpressions.Group>>.GetEnumerator();
++        public bool TryGetValue(string key, out Group value);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.md

@@ -0,0 +1,82 @@
+# System.Text
+
+``` diff
+ namespace System.Text {
++    public readonly struct Rune : IComparable<Rune>, IEquatable<Rune> {
++        public Rune(char ch);
++        public Rune(int value);
++        public Rune(uint value);
++        public bool IsAscii { get; }
++        public bool IsBmp { get; }
++        public int Plane { get; }
++        public static Rune ReplacementChar { get; }
++        public int Utf16SequenceLength { get; }
++        public int Utf8SequenceLength { get; }
++        public int Value { get; }
++        public int CompareTo(Rune other);
++        public override bool Equals(object obj);
++        public bool Equals(Rune other);
++        public override int GetHashCode();
++        public static double GetNumericValue(Rune value);
++        public static Rune GetRuneAt(string input, int index);
++        public static UnicodeCategory GetUnicodeCategory(Rune value);
++        public static bool IsControl(Rune value);
++        public static bool IsDigit(Rune value);
++        public static bool IsLetter(Rune value);
++        public static bool IsLetterOrDigit(Rune value);
++        public static bool IsLower(Rune value);
++        public static bool IsNumber(Rune value);
++        public static bool IsPunctuation(Rune value);
++        public static bool IsSeparator(Rune value);
++        public static bool IsSymbol(Rune value);
++        public static bool IsUpper(Rune value);
++        public static bool IsValid(int value);
++        public static bool IsValid(uint value);
++        public static bool IsWhiteSpace(Rune value);
++        public static bool operator ==(Rune left, Rune right);
++        public static explicit operator Rune (char ch);
++        public static explicit operator Rune (int value);
++        public static explicit operator Rune (uint value);
++        public static bool operator >(Rune left, Rune right);
++        public static bool operator >=(Rune left, Rune right);
++        public static bool operator !=(Rune left, Rune right);
++        public static bool operator <(Rune left, Rune right);
++        public static bool operator <=(Rune left, Rune right);
++        public static Rune ToLower(Rune value, CultureInfo culture);
++        public static Rune ToLowerInvariant(Rune value);
++        public override string ToString();
++        public static Rune ToUpper(Rune value, CultureInfo culture);
++        public static Rune ToUpperInvariant(Rune value);
++        public static bool TryCreate(char ch, out Rune result);
++        public static bool TryCreate(int value, out Rune result);
++        public static bool TryCreate(uint value, out Rune result);
++        public bool TryEncode(Span<char> destination, out int charsWritten);
++        public static bool TryGetRuneAt(string input, int index, out Rune value);
++    }
++    public ref struct SpanRuneEnumerator {
++        public Rune Current { get; }
++        public SpanRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++    }
+     public sealed class StringBuilder : ISerializable {
++        public StringBuilder Append(ReadOnlyMemory<char> value);
++        public StringBuilder.ChunkEnumerator GetChunks();
++        public struct ChunkEnumerator {
++            public ReadOnlyMemory<char> Current { get; }
++            public StringBuilder.ChunkEnumerator GetEnumerator();
++            public bool MoveNext();
++        }
+     }
++    public struct StringRuneEnumerator : IDisposable, IEnumerable, IEnumerable<Rune>, IEnumerator, IEnumerator<Rune> {
++        public Rune Current { get; }
++        object System.Collections.IEnumerator.Current { get; }
++        public StringRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++        IEnumerator<Rune> System.Collections.Generic.IEnumerable<System.Text.Rune>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        void System.Collections.IEnumerator.Reset();
++        void System.IDisposable.Dispose();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.Sources.md

@@ -0,0 +1,17 @@
+# System.Threading.Tasks.Sources
+
+``` diff
+ namespace System.Threading.Tasks.Sources {
++    public struct ManualResetValueTaskSourceCore<TResult> {
++        public bool RunContinuationsAsynchronously { get; set; }
++        public short Version { get; }
++        public TResult GetResult(short token);
++        public ValueTaskSourceStatus GetStatus(short token);
++        public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
++        public void Reset();
++        public void SetException(Exception error);
++        public void SetResult(TResult result);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.md

@@ -0,0 +1,10 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
+     public static class TaskExtensions {
++        public static ConfiguredAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.md

@@ -0,0 +1,28 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+-    public struct AsyncLocalValueChangedArgs<T>
++    public readonly struct AsyncLocalValueChangedArgs<T>
+     public readonly struct CancellationToken {
++        public CancellationTokenRegistration UnsafeRegister(Action<object> callback, object state);
+     }
+     public readonly struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
++        public ValueTask DisposeAsync();
++        public bool Unregister();
+     }
++    public interface IThreadPoolWorkItem {
++        void Execute();
++    }
+     public struct SpinWait {
++        public void SpinOnce(int sleep1Threshold);
+     }
+     public static class ThreadPool {
++        public static bool UnsafeQueueUserWorkItem(IThreadPoolWorkItem callBack, bool preferLocal);
+     }
+     public sealed class Timer : MarshalByRefObject, IDisposable {
++        public ValueTask DisposeAsync();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Windows.Markup.md

@@ -0,0 +1,13 @@
+# System.Windows.Markup
+
+``` diff
++namespace System.Windows.Markup {
++    public sealed class ValueSerializerAttribute : Attribute {
++        public ValueSerializerAttribute(string valueSerializerTypeName);
++        public ValueSerializerAttribute(Type valueSerializerType);
++        public Type ValueSerializerType { get; }
++        public string ValueSerializerTypeName { get; }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Xml.md

@@ -0,0 +1,24 @@
+# System.Xml
+
+``` diff
+ namespace System.Xml {
++    public class XmlDataDocument : XmlDocument {
++        public XmlDataDocument();
++        public XmlDataDocument(DataSet dataset);
++        public DataSet DataSet { get; }
++        public override XmlNode CloneNode(bool deep);
++        public override XmlElement CreateElement(string prefix, string localName, string namespaceURI);
++        public override XmlEntityReference CreateEntityReference(string name);
++        protected override XPathNavigator CreateNavigator(XmlNode node);
++        public override XmlElement GetElementById(string elemId);
++        public XmlElement GetElementFromRow(DataRow r);
++        public override XmlNodeList GetElementsByTagName(string name);
++        public DataRow GetRowFromElement(XmlElement e);
++        public override void Load(Stream inStream);
++        public override void Load(TextReader txtReader);
++        public override void Load(string filename);
++        public override void Load(XmlReader reader);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.md

@@ -0,0 +1,157 @@
+# System
+
+``` diff
+ namespace System {
+     public static class Activator {
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
+     }
+-    public class AppDomain : MarshalByRefObject {
++    public sealed class AppDomain : MarshalByRefObject {
++        public AppDomainSetup SetupInformation { get; }
++        public ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, object[] activationAttributes);
+     }
++    public sealed class AppDomainSetup {
++        public string ApplicationBase { get; }
++        public string TargetFrameworkName { get; }
++    }
++    public ref struct ArgIterator {
++        public ArgIterator(RuntimeArgumentHandle arglist);
++        public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr);
++        public void End();
++        public override bool Equals(object o);
++        public override int GetHashCode();
++        public TypedReference GetNextArg();
++        public TypedReference GetNextArg(RuntimeTypeHandle rth);
++        public RuntimeTypeHandle GetNextArgType();
++        public int GetRemainingCount();
++    }
+-    public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
++    public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
+-    public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
++    public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
+-    public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
++    public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
+-    public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
++    public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
+-    public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
++    public readonly struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
+-    public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
++    public readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
+     public class Exception : ISerializable {
+-        public int HResult { get; protected set; }
++        public int HResult { get; set; }
+     }
+     public abstract class FormattableString : IFormattable {
++        public static string CurrentCulture(FormattableString formattable);
+     }
++    public interface IAsyncDisposable {
++        ValueTask DisposeAsync();
++    }
++    public readonly struct Index : IEquatable<Index> {
++        public Index(int value, bool fromEnd);
++        public bool FromEnd { get; }
++        public int Value { get; }
++        public bool Equals(Index other);
++        public override bool Equals(object value);
++        public override int GetHashCode();
++        public static implicit operator Index (int value);
++        public override string ToString();
++    }
+-    public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
++    public readonly struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
+-    public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
++    public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
+-    public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
++    public readonly struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
+-    public struct IntPtr : IEquatable<IntPtr>, ISerializable
++    public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable
+     public static class Math {
++        public static double BitDecrement(double x);
++        public static double BitIncrement(double x);
++        public static double CopySign(double x, double y);
++        public static double FusedMultiplyAdd(double x, double y, double z);
++        public static int ILogB(double x);
++        public static double Log2(double x);
++        public static double MaxMagnitude(double x, double y);
++        public static double MinMagnitude(double x, double y);
++        public static double ScaleB(double x, int n);
+     }
+     public static class MathF {
++        public static float BitDecrement(float x);
++        public static float BitIncrement(float x);
++        public static float CopySign(float x, float y);
++        public static float FusedMultiplyAdd(float x, float y, float z);
++        public static int ILogB(float x);
++        public static float Log2(float x);
++        public static float MaxMagnitude(float x, float y);
++        public static float MinMagnitude(float x, float y);
++        public static float ScaleB(float x, int n);
+     }
+     public static class MemoryExtensions {
++        public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
++        public static bool Contains<T>(this Span<T> span, T value) where T : IEquatable<T>;
++        public static SpanRuneEnumerator EnumerateRunes(this ReadOnlySpan<char> span);
++        public static SpanRuneEnumerator EnumerateRunes(this Span<char> span);
++        public static int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+     }
++    public readonly struct Range : IEquatable<Range> {
++        public Index End { get; }
++        public Index Start { get; }
++        public static Range All();
++        public static Range Create(Index start, Index end);
++        public override bool Equals(object value);
++        public bool Equals(Range other);
++        public static Range FromStart(Index start);
++        public override int GetHashCode();
++        public static Range ToEnd(Index end);
++        public override string ToString();
++    }
+     public readonly ref struct ReadOnlySpan<T> {
++        public ref readonly T this[Index index] { get; }
++        public ReadOnlySpan<T> this[Range range] { get; }
+     }
+-    public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
++    public readonly struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
+-    public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
++    public readonly struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
+     public readonly ref struct Span<T> {
++        public ref T this[Index index] { get; }
++        public Span<T> this[Range range] { get; }
+     }
+     public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
++        public StringRuneEnumerator EnumerateRunes();
++        public static int GetHashCode(ReadOnlySpan<char> value);
++        public static int GetHashCode(ReadOnlySpan<char> value, StringComparison comparisonType);
+     }
+-    public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
++    public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
+     public abstract class Type : MemberInfo, IReflect {
++        public static Type MakeGenericSignatureType(Type genericTypeDefinition, params Type[] typeArguments);
+     }
+-    public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
++    public readonly struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
+-    public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
++    public readonly struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
+-    public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
++    public readonly struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
+-    public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
++    public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable
+ }
+```
+