add api diff for preview6 (#6417)

* add api diff for preview6

* adding system.io

* adding extensions packages

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6.md

@@ -0,0 +1,20 @@
+# API Difference 6.0.0-preview5 vs 6.0.0-preview6
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System.IO](6.0-preview6_System.IO.md)
+* [System.Net](6.0-preview6_System.Net.md)
+* [System.Net.Http.Headers](6.0-preview6_System.Net.Http.Headers.md)
+* [System.Net.Quic](6.0-preview6_System.Net.Quic.md)
+* [System.Net.Security](6.0-preview6_System.Net.Security.md)
+* [System.Net.Sockets](6.0-preview6_System.Net.Sockets.md)
+* [System.Numerics](6.0-preview6_System.Numerics.md)
+* [System.Runtime.CompilerServices](6.0-preview6_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](6.0-preview6_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics.X86](6.0-preview6_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography.X509Certificates](6.0-preview6_System.Security.Cryptography.X509Certificates.md)
+* [System.Text](6.0-preview6_System.Text.md)
+* [System.Text.Json.Nodes](6.0-preview6_System.Text.Json.Nodes.md)
+* [System.Threading](6.0-preview6_System.Threading.md)
+* [System.Threading.Channels](6.0-preview6_System.Threading.Channels.md)

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.IO.md

@@ -0,0 +1,36 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public static class File {
++        public static FileStream Open(string path, FileStreamOptions options);
++        public static SafeFileHandle OpenHandle(string path, FileMode mode = FileMode.Open, FileAccess access = FileAccess.Read, FileShare share = FileShare.Read, FileOptions options = FileOptions.None, long preallocationSize = (long)0);
+     }
+     public sealed class FileInfo : FileSystemInfo {
++        public FileStream Open(FileStreamOptions options);
+     }
+     public sealed class FileStreamOptions {
++        public int BufferSize { get; set; }
+     }
++    public static class RandomAccess {
++        public static long GetLength(SafeFileHandle handle);
++        public static long Read(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset);
++        public static int Read(SafeFileHandle handle, Span<byte> buffer, long fileOffset);
++        public static ValueTask<long> ReadAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default(CancellationToken));
++        public static ValueTask<int> ReadAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default(CancellationToken));
++        public static long Write(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset);
++        public static int Write(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset);
++        public static ValueTask<long> WriteAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default(CancellationToken));
++        public static ValueTask<int> WriteAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default(CancellationToken));
++    }
+     public class StreamReader : TextReader {
++        public StreamReader(string path, FileStreamOptions options);
++        public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, FileStreamOptions options);
+     }
+     public class StreamWriter : TextWriter {
++        public StreamWriter(string path, FileStreamOptions options);
++        public StreamWriter(string path, Encoding encoding, FileStreamOptions options);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Net.Http.Headers.md

@@ -0,0 +1,44 @@
+# System.Net.Http.Headers
+
+``` diff
+ namespace System.Net.Http.Headers {
++    public readonly struct HeaderStringValues : IEnumerable, IEnumerable<string>, IReadOnlyCollection<string> {
++        public int Count { get; }
++        public HeaderStringValues.Enumerator GetEnumerator();
++        IEnumerator<string> System.Collections.Generic.IEnumerable<System.String>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        public override string ToString();
++        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<string> {
++            public string Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public void Dispose();
++            public bool MoveNext();
++            void System.Collections.IEnumerator.Reset();
++        }
++    }
+     public abstract class HttpHeaders : IEnumerable, IEnumerable<KeyValuePair<string, IEnumerable<string>>> {
++        public HttpHeadersNonValidated NonValidated { get; }
+     }
++    public readonly struct HttpHeadersNonValidated : IEnumerable, IEnumerable<KeyValuePair<string, HeaderStringValues>>, IReadOnlyCollection<KeyValuePair<string, HeaderStringValues>>, IReadOnlyDictionary<string, HeaderStringValues> {
++        public int Count { get; }
++        IEnumerable<string> System.Collections.Generic.IReadOnlyDictionary<System.String,System.Net.Http.Headers.HeaderStringValues>.Keys { get; }
++        IEnumerable<HeaderStringValues> System.Collections.Generic.IReadOnlyDictionary<System.String,System.Net.Http.Headers.HeaderStringValues>.Values { get; }
++        public HeaderStringValues this[string headerName] { get; }
++        public bool Contains(string headerName);
++        public HttpHeadersNonValidated.Enumerator GetEnumerator();
++        IEnumerator<KeyValuePair<string, HeaderStringValues>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Net.Http.Headers.HeaderStringValues>>.GetEnumerator();
++        bool System.Collections.Generic.IReadOnlyDictionary<System.String,System.Net.Http.Headers.HeaderStringValues>.ContainsKey(string key);
++        bool System.Collections.Generic.IReadOnlyDictionary<System.String,System.Net.Http.Headers.HeaderStringValues>.TryGetValue(string key, out HeaderStringValues value);
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        public bool TryGetValues(string headerName, out HeaderStringValues values);
++        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<string, HeaderStringValues>> {
++            public KeyValuePair<string, HeaderStringValues> Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public void Dispose();
++            public bool MoveNext();
++            void System.Collections.IEnumerator.Reset();
++        }
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Net.Quic.md

@@ -0,0 +1,23 @@
+# System.Net.Quic
+
+``` diff
+ namespace System.Net.Quic {
+     public sealed class QuicConnection : IDisposable {
+-        public long GetRemoteAvailableBidirectionalStreamCount();
+
++        public int GetRemoteAvailableBidirectionalStreamCount();
+-        public long GetRemoteAvailableUnidirectionalStreamCount();
+
++        public int GetRemoteAvailableUnidirectionalStreamCount();
++        public ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask WaitForAvailableUnidirectionalStreamsAsync(CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class QuicOptions {
+-        public long MaxBidirectionalStreams { get; set; }
++        public int MaxBidirectionalStreams { get; set; }
+-        public long MaxUnidirectionalStreams { get; set; }
++        public int MaxUnidirectionalStreams { get; set; }
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Net.Security.md

@@ -0,0 +1,10 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public class SslStream : AuthenticatedStream {
++        public virtual Task NegotiateClientCertificateAsync(CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Net.Sockets.md

@@ -0,0 +1,15 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public class Socket : IDisposable {
++        public ValueTask<Socket> AcceptAsync(Socket acceptSocket, CancellationToken cancellationToken);
++        public ValueTask<Socket> AcceptAsync(CancellationToken cancellationToken);
+     }
+     public class TcpListener {
++        public ValueTask<Socket> AcceptSocketAsync(CancellationToken cancellationToken);
++        public ValueTask<TcpClient> AcceptTcpClientAsync(CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Net.md

@@ -0,0 +1,10 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+     public class CookieContainer {
++        public CookieCollection GetAllCookies();
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Numerics.md

@@ -0,0 +1,14 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public static class BitOperations {
++        public static uint RoundUpToPowerOf2(uint value);
++        public static ulong RoundUpToPowerOf2(ulong value);
+     }
+     public static class Vector {
++        public static T Sum<T>(Vector<T> value) where T : struct;
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Runtime.CompilerServices.md

@@ -0,0 +1,67 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public ref struct DefaultInterpolatedStringHandler {
++        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount);
++        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider provider);
++        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider provider, Span<char> initialBuffer);
++        public void AppendFormatted(object value, int alignment = 0, string format = null);
++        public void AppendFormatted(ReadOnlySpan<char> value);
++        public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string format = null);
++        public void AppendFormatted(string value);
++        public void AppendFormatted(string value, int alignment = 0, string format = null);
++        public void AppendFormatted<T>(T value);
++        public void AppendFormatted<T>(T value, int alignment);
++        public void AppendFormatted<T>(T value, int alignment, string format);
++        public void AppendFormatted<T>(T value, string format);
++        public void AppendLiteral(string value);
++        public override string ToString();
++        public string ToStringAndClear();
++    }
+-    public ref struct InterpolatedStringBuilder {
+ {
+-        public void AppendFormatted(object value, int alignment = 0, string format = null);
+
+-        public void AppendFormatted(ReadOnlySpan<char> value);
+
+-        public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string format = null);
+
+-        public void AppendFormatted(string value);
+
+-        public void AppendFormatted(string value, int alignment = 0, string format = null);
+
+-        public void AppendFormatted<T>(T value);
+
+-        public void AppendFormatted<T>(T value, int alignment);
+
+-        public void AppendFormatted<T>(T value, int alignment, string format);
+
+-        public void AppendFormatted<T>(T value, string format);
+
+-        public void AppendLiteral(string value);
+
+-        public static InterpolatedStringBuilder Create(int literalLength, int formattedCount);
+
+-        public static InterpolatedStringBuilder Create(int literalLength, int formattedCount, IFormatProvider provider);
+
+-        public static InterpolatedStringBuilder Create(int literalLength, int formattedCount, IFormatProvider provider, Span<char> scratchBuffer);
+
+-        public static InterpolatedStringBuilder Create(int literalLength, int formattedCount, Span<char> scratchBuffer);
+
+-        public override string ToString();
+
+-        public string ToStringAndClear();
+
+-    }
++    public sealed class InterpolatedStringHandlerArgumentAttribute : Attribute {
++        public InterpolatedStringHandlerArgumentAttribute(string argument);
++        public InterpolatedStringHandlerArgumentAttribute(params string[] arguments);
++        public string[] Arguments { get; }
++    }
++    public sealed class InterpolatedStringHandlerAttribute : Attribute {
++        public InterpolatedStringHandlerAttribute();
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Runtime.InteropServices.md

@@ -0,0 +1,17 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public enum Architecture {
++        S390x = 5,
+     }
+     public static class MemoryMarshal {
++        public static ref byte GetArrayDataReference(Array array);
+     }
++    public sealed class UnmanagedCallConvAttribute : Attribute {
++        public Type[] CallConvs;
++        public UnmanagedCallConvAttribute();
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Runtime.Intrinsics.X86.md

@@ -0,0 +1,21 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
+ namespace System.Runtime.Intrinsics.X86 {
++    public abstract class AvxVnni : Avx2 {
++        public static new bool IsSupported { get; }
++        public static Vector128<int> MultiplyWideningAndAdd(Vector128<int> addend, Vector128<byte> left, Vector128<sbyte> right);
++        public static Vector128<int> MultiplyWideningAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right);
++        public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right);
++        public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right);
++        public static Vector128<int> MultiplyWideningAndAddSaturate(Vector128<int> addend, Vector128<byte> left, Vector128<sbyte> right);
++        public static Vector128<int> MultiplyWideningAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right);
++        public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right);
++        public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<short> left, Vector256<short> right);
++        public new abstract class X64 : Avx2.X64 {
++            public static new bool IsSupported { get; }
++        }
++    }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Security.Cryptography.X509Certificates.md

@@ -0,0 +1,37 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
+ namespace System.Security.Cryptography.X509Certificates {
+     public sealed class PublicKey {
++        public DSA GetDSAPublicKey();
++        public ECDiffieHellman GetECDiffieHellmanPublicKey();
++        public ECDsa GetECDsaPublicKey();
++        public RSA GetRSAPublicKey();
+     }
+-    public class X509Certificate2Collection : X509CertificateCollection {
++    public class X509Certificate2Collection : X509CertificateCollection, IEnumerable, IEnumerable<X509Certificate2> {
++        IEnumerator<X509Certificate2> System.Collections.Generic.IEnumerable<System.Security.Cryptography.X509Certificates.X509Certificate2>.GetEnumerator();
+     }
+-    public sealed class X509Certificate2Enumerator : IEnumerator {
++    public sealed class X509Certificate2Enumerator : IDisposable, IEnumerator, IEnumerator<X509Certificate2> {
++        void System.IDisposable.Dispose();
+     }
+-    public sealed class X509ChainElementCollection : ICollection, IEnumerable {
++    public sealed class X509ChainElementCollection : ICollection, IEnumerable, IEnumerable<X509ChainElement> {
++        IEnumerator<X509ChainElement> System.Collections.Generic.IEnumerable<System.Security.Cryptography.X509Certificates.X509ChainElement>.GetEnumerator();
+     }
+-    public sealed class X509ChainElementEnumerator : IEnumerator {
++    public sealed class X509ChainElementEnumerator : IDisposable, IEnumerator, IEnumerator<X509ChainElement> {
++        void System.IDisposable.Dispose();
+     }
+-    public sealed class X509ExtensionCollection : ICollection, IEnumerable {
++    public sealed class X509ExtensionCollection : ICollection, IEnumerable, IEnumerable<X509Extension> {
++        IEnumerator<X509Extension> System.Collections.Generic.IEnumerable<System.Security.Cryptography.X509Certificates.X509Extension>.GetEnumerator();
+     }
+-    public sealed class X509ExtensionEnumerator : IEnumerator {
++    public sealed class X509ExtensionEnumerator : IDisposable, IEnumerator, IEnumerator<X509Extension> {
++        void System.IDisposable.Dispose();
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview6/.Net/6.0-preview6_System.Text.Json.Nodes.md

@@ -0,0 +1,45 @@
+# System.Text.Json.Nodes
+
+``` diff
+ namespace System.Text.Json.Nodes {
+     public abstract class JsonValue : JsonNode {
++        public static JsonValue Create(bool value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(byte value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(char value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(DateTime value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(DateTimeOffset value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(decimal value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(double value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(Guid value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(short value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(int value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(long value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(bool? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(byte? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(char? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(DateTime? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(DateTimeOffset? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(decimal? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(double? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(Guid? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(short? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(int? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(long? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(sbyte? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(float? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(JsonElement? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(ushort? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(uint? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(ulong? value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(sbyte value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(float value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(string value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(JsonElement value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(ushort value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(uint value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create(ulong value, JsonNodeOptions? options = default(JsonNodeOptions?));
++        public static JsonValue Create<T>(T value, JsonTypeInfo<T> jsonTypeInfo, JsonNodeOptions? options = default(JsonNodeOptions?));
+     }
+ }
+```
+