api diff between preview 3 and preview 4

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

@@ -0,0 +1,22 @@
+# API Difference 6.0.0-preview3 vs 6.0.0-preview4
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System](6.0-preview4_System.md)
+* [System.IO](6.0-preview4_System.IO.md)
+* [System.Linq](6.0-preview4_System.Linq.md)
+* [System.Net.Http.Json](6.0-preview4_System.Net.Http.Json.md)
+* [System.Net.Quic](6.0-preview4_System.Net.Quic.md)
+* [System.Numerics](6.0-preview4_System.Numerics.md)
+* [System.Reflection.Metadata](6.0-preview4_System.Reflection.Metadata.md)
+* [System.Runtime.CompilerServices](6.0-preview4_System.Runtime.CompilerServices.md)
+* [System.Runtime.ExceptionServices](6.0-preview4_System.Runtime.ExceptionServices.md)
+* [System.Text](6.0-preview4_System.Text.md)
+* [System.Text.Json](6.0-preview4_System.Text.Json.md)
+* [System.Text.Json.Node](6.0-preview4_System.Text.Json.Node.md)
+* [System.Text.Json.Serialization](6.0-preview4_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](6.0-preview4_System.Text.Json.Serialization.Metadata.md)
+* [System.Threading](6.0-preview4_System.Threading.md)
+* [System.Threading.Channels](6.0-preview4_System.Threading.Channels.md)
+

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

@@ -0,0 +1,10 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public class EnumerationOptions {
++        public int MaxRecursionDepth { get; set; }
+     }
+ }
+```
+

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

@@ -0,0 +1,39 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public static class Enumerable {
++        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
++        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
++        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector);
++        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
++        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector);
++        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
++        public static TSource Max<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer);
++        public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
++        public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
++        public static TSource Min<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer);
++        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
++        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
++        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector);
++        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
+     }
+     public static class Queryable {
++        public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
++        public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer);
++        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector);
++        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer);
++        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector);
++        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer);
++        public static TSource Max<TSource>(this IQueryable<TSource> source, IComparer<TSource> comparer);
++        public static TSource MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
++        public static TSource MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource> comparer);
++        public static TSource Min<TSource>(this IQueryable<TSource> source, IComparer<TSource> comparer);
++        public static TSource MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
++        public static TSource MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource> comparer);
++        public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector);
++        public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer);
+     }
+ }
+```
+

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

@@ -0,0 +1,17 @@
+# System.Net.Http.Json
+
+``` diff
+ namespace System.Net.Http.Json {
+     public static class HttpClientJsonExtensions {
++        public static Task<object> GetFromJsonAsync(this HttpClient client, string requestUri, Type type, JsonSerializerContext context, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<object> GetFromJsonAsync(this HttpClient client, Uri requestUri, Type type, JsonSerializerContext context, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, string requestUri, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<TValue> GetFromJsonAsync<TValue>(this HttpClient client, Uri requestUri, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public static class HttpContentJsonExtensions {
++        public static Task<object> ReadFromJsonAsync(this HttpContent content, Type type, JsonSerializerContext context, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task<T> ReadFromJsonAsync<T>(this HttpContent content, JsonTypeInfo<T> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

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

@@ -0,0 +1,38 @@
+# System.Net.Quic
+
+``` diff
+ namespace System.Net.Quic {
+-    public class QuicClientConnectionOptions {
++    public class QuicClientConnectionOptions : QuicOptions {
+-        public TimeSpan IdleTimeout { get; set; }
+
+-        public long MaxBidirectionalStreams { get; set; }
+
+-        public long MaxUnidirectionalStreams { get; set; }
+
+     }
+-    public class QuicListenerOptions {
++    public class QuicListenerOptions : QuicOptions {
+-        public string CertificateFilePath { get; set; }
+
+-        public TimeSpan IdleTimeout { get; set; }
+
+-        public long MaxBidirectionalStreams { get; set; }
+
+-        public long MaxUnidirectionalStreams { get; set; }
+
+-        public string PrivateKeyFilePath { get; set; }
+
+     }
++    public class QuicOptions {
++        public QuicOptions();
++        public TimeSpan IdleTimeout { get; set; }
++        public long MaxBidirectionalStreams { get; set; }
++        public long MaxUnidirectionalStreams { get; set; }
++    }
+     public sealed class QuicStream : Stream {
++        protected override void Dispose(bool disposing);
+     }
+ }
+```
+

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

@@ -0,0 +1,24 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+-    public readonly struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable
++    public readonly struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable, ISpanFormattable
+     public struct Vector2 : IEquatable<Vector2>, IFormattable {
++        public Vector2(ReadOnlySpan<float> values);
++        public void CopyTo(Span<float> destination);
++        public bool TryCopyTo(Span<float> destination);
+     }
+     public struct Vector3 : IEquatable<Vector3>, IFormattable {
++        public Vector3(ReadOnlySpan<float> values);
++        public void CopyTo(Span<float> destination);
++        public bool TryCopyTo(Span<float> destination);
+     }
+     public struct Vector4 : IEquatable<Vector4>, IFormattable {
++        public Vector4(ReadOnlySpan<float> values);
++        public void CopyTo(Span<float> destination);
++        public bool TryCopyTo(Span<float> destination);
+     }
+ }
+```
+

release-notes/6.0/preview/api-diff/preview4/.Net/6.0-preview4_System.Reflection.Metadata.md

@@ -0,0 +1,11 @@
+# System.Reflection.Metadata
+
+``` diff
+ namespace System.Reflection.Metadata {
++    public sealed class MetadataUpdateHandlerAttribute : Attribute {
++        public MetadataUpdateHandlerAttribute(Type handlerType);
++        public Type HandlerType { get; }
++    }
+ }
+```
+

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

@@ -0,0 +1,48 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public class CallConvMemberFunction {
++        public CallConvMemberFunction();
++    }
++    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 struct PoolingAsyncValueTaskMethodBuilder {
++        public ValueTask Task { get; }
++        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 static PoolingAsyncValueTaskMethodBuilder Create();
++        public void SetException(Exception exception);
++        public void SetResult();
++        public void SetStateMachine(IAsyncStateMachine stateMachine);
++        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
++    public struct PoolingAsyncValueTaskMethodBuilder<TResult> {
++        public ValueTask<TResult> Task { get; }
++        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 static PoolingAsyncValueTaskMethodBuilder<TResult> Create();
++        public void SetException(Exception exception);
++        public void SetResult(TResult result);
++        public void SetStateMachine(IAsyncStateMachine stateMachine);
++        public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
+ }
+```
+

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

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