dotnet · carlossanlop · May 28, 2024 · May 21, 2024 · May 21, 2024 · May 21, 2024
@@ -0,0 +1,9 @@
+# API Difference 9.0-preview3 vs 9.0-preview4
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Components](9.0-preview4_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.Routing](9.0-preview4_Microsoft.AspNetCore.Components.Routing.md)
+* [Microsoft.AspNetCore.Components.Web.Internal](9.0-preview4_Microsoft.AspNetCore.Components.Web.Internal.md)
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Components.Routing
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Routing {
++ public static class RazorComponentsEndpointHttpContextExtensions {
++ public static bool AcceptsInteractiveRouting(this HttpContext context);
++ }
+ }
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Components.Web.Internal
+
+``` diff
++namespace Microsoft.AspNetCore.Components.Web.Internal {
++ public interface IInternalWebJSInProcessRuntime {
++ string InvokeJS(string identifier, string? argsJson, JSCallResultType resultType, long targetInstanceId);
++ }
++}
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
++ public sealed class ExcludeFromInteractiveRoutingAttribute : Attribute {
++ public ExcludeFromInteractiveRoutingAttribute();
++ }
+ }
+```
+
@@ -0,0 +1,25 @@
+# API Difference 9.0-preview3 vs 9.0-preview4
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System](9.0-preview4_System.md)
+* [System.CodeDom.Compiler](9.0-preview4_System.CodeDom.Compiler.md)
+* [System.Formats.Asn1](9.0-preview4_System.Formats.Asn1.md)
+* [System.IO](9.0-preview4_System.IO.md)
+* [System.IO.Pipes](9.0-preview4_System.IO.Pipes.md)
+* [System.Numerics](9.0-preview4_System.Numerics.md)
+* [System.Reflection.Emit](9.0-preview4_System.Reflection.Emit.md)
+* [System.Runtime.CompilerServices](9.0-preview4_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](9.0-preview4_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](9.0-preview4_System.Runtime.Intrinsics.md)
+* [System.Security.Cryptography](9.0-preview4_System.Security.Cryptography.md)
+* [System.Text](9.0-preview4_System.Text.md)
+* [System.Text.Json](9.0-preview4_System.Text.Json.md)
+* [System.Text.Json.Nodes](9.0-preview4_System.Text.Json.Nodes.md)
+* [System.Text.Json.Serialization](9.0-preview4_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](9.0-preview4_System.Text.Json.Serialization.Metadata.md)
+* [System.Threading](9.0-preview4_System.Threading.md)
+* [System.Threading.Channels](9.0-preview4_System.Threading.Channels.md)
+* [System.Threading.Tasks](9.0-preview4_System.Threading.Tasks.md)
+
@@ -0,0 +1,11 @@
+# System.CodeDom.Compiler
+
+``` diff
+ namespace System.CodeDom.Compiler {
+ public class IndentedTextWriter : TextWriter {
++ public override void Write(string format, ReadOnlySpan<object?> arg);
++ public override void WriteLine(string format, ReadOnlySpan<object?> arg);
+ }
+ }
+```
+
@@ -0,0 +1,11 @@
+# System.Formats.Asn1
+
+``` diff
+ namespace System.Formats.Asn1 {
+ public static class AsnDecoder {
++ public static int? DecodeLength(ReadOnlySpan<byte> source, AsnEncodingRules ruleSet, out int bytesConsumed);
++ public static bool TryDecodeLength(ReadOnlySpan<byte> source, AsnEncodingRules ruleSet, out int? decodedLength, out int bytesConsumed);
+ }
+ }
+```
+
@@ -0,0 +1,10 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
+ public sealed class NamedPipeClientStream : PipeStream {
++ public NamedPipeClientStream(string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability);
+ }
+ }
+```
+
@@ -0,0 +1,19 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+ public static class Path {
++ public static string Combine(ReadOnlySpan<string> paths);
++ public static string Join(ReadOnlySpan<string?> paths);
+ }
+ public class StreamWriter : TextWriter {
++ public override void Write(string format, ReadOnlySpan<object?> arg);
++ public override void WriteLine(string format, ReadOnlySpan<object?> arg);
+ }
+ public abstract class TextWriter : MarshalByRefObject, IAsyncDisposable, IDisposable {
++ public virtual void Write(string format, ReadOnlySpan<object?> arg);
++ public virtual void WriteLine(string format, ReadOnlySpan<object?> arg);
+ }
+ }
+```
+
@@ -0,0 +1,17 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+ public interface IFloatingPoint<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf, bool>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf, bool>, IEquatable<TSelf>, IFloatingPointConstants<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf>, IUtf8SpanFormattable, IUtf8SpanParsable<TSelf> where TSelf : IFloatingPoint<TSelf>? {
++ TInteger ConvertToInteger<TInteger>(TSelf value);
++ TInteger ConvertToIntegerNative<TInteger>(TSelf value);
+ }
+ public static class Vector {
++ public static Vector<Int32> ConvertToInt32Native(Vector<Single> value);
++ public static Vector<Int64> ConvertToInt64Native(Vector<Double> value);
++ public static Vector<UInt32> ConvertToUInt32Native(Vector<Single> value);
++ public static Vector<UInt64> ConvertToUInt64Native(Vector<Double> value);
+ }
+ }
+```
+
@@ -0,0 +1,23 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+ public abstract class ILGenerator {
++ public void MarkSequencePoint(ISymbolDocumentWriter document, int startLine, int startColumn, int endLine, int endColumn);
++ protected virtual void MarkSequencePointCore(ISymbolDocumentWriter document, int startLine, int startColumn, int endLine, int endColumn);
+ }
+ public abstract class LocalBuilder : LocalVariableInfo {
++ public void SetLocalSymInfo(string name);
++ protected virtual void SetLocalSymInfoCore(string name);
+ }
+ public abstract class ModuleBuilder : Module {
++ public ISymbolDocumentWriter DefineDocument(string url, Guid language = default(Guid));
++ public ISymbolDocumentWriter DefineDocument(string url, Guid language, Guid languageVendor, Guid documentType);
++ protected virtual ISymbolDocumentWriter DefineDocumentCore(string url, Guid language = default(Guid));
+ }
+ public sealed class PersistedAssemblyBuilder : AssemblyBuilder {
++ public MetadataBuilder GenerateMetadata(out BlobBuilder ilStream, out BlobBuilder mappedFieldData, out MetadataBuilder pdbBuilder);
+ }
+ }
+```
+
@@ -0,0 +1,15 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
+ public static class RuntimeHelpers {
++ public static object? Box(ref byte target, RuntimeTypeHandle type);
++ public static int SizeOf(RuntimeTypeHandle type);
+ }
+ public static class Unsafe {
+- public static TTo BitCast<TFrom, TTo>(TFrom source) where TFrom : struct where TTo : struct;
++ public static TTo BitCast<TFrom, TTo>(TFrom source);
+ }
+ }
+```
+
@@ -0,0 +1,11 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+ public readonly struct NFloat : IAdditionOperators<NFloat, NFloat, NFloat>, IAdditiveIdentity<NFloat, NFloat>, IBinaryFloatingPointIeee754<NFloat>, IBinaryNumber<NFloat>, IBitwiseOperators<NFloat, NFloat, NFloat>, IComparable, IComparable<NFloat>, IComparisonOperators<NFloat, NFloat, bool>, IDecrementOperators<NFloat>, IDivisionOperators<NFloat, NFloat, NFloat>, IEqualityOperators<NFloat, NFloat, bool>, IEquatable<NFloat>, IExponentialFunctions<NFloat>, IFloatingPoint<NFloat>, IFloatingPointConstants<NFloat>, IFloatingPointIeee754<NFloat>, IFormattable, IHyperbolicFunctions<NFloat>, IIncrementOperators<NFloat>, ILogarithmicFunctions<NFloat>, IMinMaxValue<NFloat>, IModulusOperators<NFloat, NFloat, NFloat>, IMultiplicativeIdentity<NFloat, NFloat>, IMultiplyOperators<NFloat, NFloat, NFloat>, INumber<NFloat>, INumberBase<NFloat>, IParsable<NFloat>, IPowerFunctions<NFloat>, IRootFunctions<NFloat>, ISignedNumber<NFloat>, ISpanFormattable, ISpanParsable<NFloat>, ISubtractionOperators<NFloat, NFloat, NFloat>, ITrigonometricFunctions<NFloat>, IUnaryNegationOperators<NFloat, NFloat>, IUnaryPlusOperators<NFloat, NFloat>, IUtf8SpanFormattable, IUtf8SpanParsable<NFloat> {
++ static virtual TInteger ConvertToInteger<TInteger>(NFloat value);
++ static virtual TInteger ConvertToIntegerNative<TInteger>(NFloat value);
+ }
+ }
+```
+
@@ -0,0 +1,31 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+ public static class Vector128 {
++ public static Vector128<Int32> ConvertToInt32Native(Vector128<Single> vector);
++ public static Vector128<Int64> ConvertToInt64Native(Vector128<Double> vector);
++ public static Vector128<UInt32> ConvertToUInt32Native(Vector128<Single> vector);
++ public static Vector128<UInt64> ConvertToUInt64Native(Vector128<Double> vector);
+ }
+ public static class Vector256 {
++ public static Vector256<Int32> ConvertToInt32Native(Vector256<Single> vector);
++ public static Vector256<Int64> ConvertToInt64Native(Vector256<Double> vector);
++ public static Vector256<UInt32> ConvertToUInt32Native(Vector256<Single> vector);
++ public static Vector256<UInt64> ConvertToUInt64Native(Vector256<Double> vector);
+ }
+ public static class Vector512 {
++ public static Vector512<Int32> ConvertToInt32Native(Vector512<Single> vector);
++ public static Vector512<Int64> ConvertToInt64Native(Vector512<Double> vector);
++ public static Vector512<UInt32> ConvertToUInt32Native(Vector512<Single> vector);
++ public static Vector512<UInt64> ConvertToUInt64Native(Vector512<Double> vector);
+ }
+ public static class Vector64 {
++ public static Vector64<Int32> ConvertToInt32Native(Vector64<Single> vector);
++ public static Vector64<Int64> ConvertToInt64Native(Vector64<Double> vector);
++ public static Vector64<UInt32> ConvertToUInt32Native(Vector64<Single> vector);
++ public static Vector64<UInt64> ConvertToUInt64Native(Vector64<Double> vector);
+ }
+ }
+```
+
@@ -0,0 +1,19 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
+ public sealed class Shake128 : IDisposable {
++ public Shake128 Clone();
++ public byte[] Read(int outputLength);
++ public void Read(Span<byte> destination);
++ public void Reset();
+ }
+ public sealed class Shake256 : IDisposable {
++ public Shake256 Clone();
++ public byte[] Read(int outputLength);
++ public void Read(Span<byte> destination);
++ public void Reset();
+ }
+ }
+```
+
@@ -0,0 +1,11 @@
+# System.Text.Json.Nodes
+
+``` diff
+ namespace System.Text.Json.Nodes {
+ public sealed class JsonArray : JsonNode, ICollection<JsonNode?>, IEnumerable, IEnumerable<JsonNode?>, IList<JsonNode?> {
++ public JsonArray(ReadOnlySpan<JsonNode?> items);
++ public JsonArray(JsonNodeOptions options, ReadOnlySpan<JsonNode?> items);
+ }
+ }
+```
+
@@ -0,0 +1,10 @@
+# System.Text.Json.Serialization.Metadata
+
+``` diff
+ namespace System.Text.Json.Serialization.Metadata {
+ public static class JsonTypeInfoResolver {
++ public static IJsonTypeInfoResolver Combine(ReadOnlySpan<IJsonTypeInfoResolver?> resolvers);
+ }
+ }
+```
+
@@ -0,0 +1,10 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+ public sealed class JsonSourceGenerationOptionsAttribute : JsonAttribute {
++ public string NewLine { get; set; }
+ }
+ }
+```
+
@@ -0,0 +1,25 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+ public sealed class JsonSerializerOptions {
+- public JsonNamingPolicy DictionaryKeyPolicy { get; set; }
++ public JsonNamingPolicy? DictionaryKeyPolicy { get; set; }
+- public JavaScriptEncoder Encoder { get; set; }
++ public JavaScriptEncoder? Encoder { get; set; }
++ public string NewLine { get; set; }
+- public JsonNamingPolicy PropertyNamingPolicy { get; set; }
++ public JsonNamingPolicy? PropertyNamingPolicy { get; set; }
+- public ReferenceHandler ReferenceHandler { get; set; }
++ public ReferenceHandler? ReferenceHandler { get; set; }
+- public IJsonTypeInfoResolver TypeInfoResolver { get; set; }
++ public IJsonTypeInfoResolver? TypeInfoResolver { get; set; }
+ }
+ public struct JsonWriterOptions {
+- public JavaScriptEncoder Encoder { get; set; }
++ public JavaScriptEncoder? Encoder { get; set; }
++ public string NewLine { get; set; }
+ }
+ }
+```
+
@@ -0,0 +1,15 @@
+# System.Text
+
+``` diff
+ namespace System.Text {
+ public sealed class StringBuilder : ISerializable {
++ public StringBuilder AppendFormat(IFormatProvider? provider, string format, ReadOnlySpan<object?> args);
++ public StringBuilder AppendFormat(string format, ReadOnlySpan<object?> args);
++ public StringBuilder AppendJoin(char separator, ReadOnlySpan<object?> values);
++ public StringBuilder AppendJoin(char separator, ReadOnlySpan<string?> values);
++ public StringBuilder AppendJoin(string? separator, ReadOnlySpan<object?> values);
++ public StringBuilder AppendJoin(string? separator, ReadOnlySpan<string?> values);
+ }
+ }
+```
+
@@ -0,0 +1,15 @@
+# System.Threading.Channels
+
+``` diff
+ namespace System.Threading.Channels {
+ public static class Channel {
++ public static Channel<T> CreateUnboundedPrioritized<T>();
++ public static Channel<T> CreateUnboundedPrioritized<T>(UnboundedPrioritizedChannelOptions<T> options);
+ }
++ public sealed class UnboundedPrioritizedChannelOptions<T> : ChannelOptions {
++ public UnboundedPrioritizedChannelOptions();
++ public IComparer<T>? Comparer { get; set; }
++ }
+ }
+```
+
@@ -0,0 +1,21 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
+ public class Task : IAsyncResult, IDisposable {
++ public static void WaitAll(IEnumerable<Task> tasks, CancellationToken cancellationToken = default(CancellationToken));
++ public static void WaitAll(ReadOnlySpan<Task> tasks);
++ public static Task WhenAll(ReadOnlySpan<Task> tasks);
++ public static Task<TResult[]> WhenAll<TResult>(ReadOnlySpan<Task<TResult>> tasks);
++ public static Task<Task> WhenAny(ReadOnlySpan<Task> tasks);
++ public static Task<Task<TResult>> WhenAny<TResult>(ReadOnlySpan<Task<TResult>> tasks);
++ public static IAsyncEnumerable<Task> WhenEach(IEnumerable<Task> tasks);
++ public static IAsyncEnumerable<Task> WhenEach(ReadOnlySpan<Task> tasks);
++ public static IAsyncEnumerable<Task> WhenEach(params Task[] tasks);
++ public static IAsyncEnumerable<Task<TResult>> WhenEach<TResult>(IEnumerable<Task<TResult>> tasks);
++ public static IAsyncEnumerable<Task<TResult>> WhenEach<TResult>(ReadOnlySpan<Task<TResult>> tasks);
++ public static IAsyncEnumerable<Task<TResult>> WhenEach<TResult>(params Task<TResult>[] tasks);
+ }
+ }
+```
+
@@ -0,0 +1,10 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+ public class CancellationTokenSource : IDisposable {
++ public static CancellationTokenSource CreateLinkedTokenSource(ReadOnlySpan<CancellationToken> tokens);
+ }
+ }
+```
+