dotnet · carlossanlop · Jul 15, 2024 · Jul 10, 2024 · Jul 10, 2024 · Jul 10, 2024
@@ -0,0 +1,16 @@
+# API Difference 9.0-preview5 vs 9.0-preview6
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authentication](9.0-preview6_Microsoft.AspNetCore.Authentication.md)
+* [Microsoft.AspNetCore.Builder](9.0-preview6_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components](9.0-preview6_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md)
+* [Microsoft.AspNetCore.Components.RenderTree](9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md)
+* [Microsoft.AspNetCore.Cors.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md)
+* [Microsoft.AspNetCore.Mvc.TagHelpers](9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md)
+* [Microsoft.AspNetCore.StaticAssets](9.0-preview6_Microsoft.AspNetCore.StaticAssets.md)
+* [Microsoft.AspNetCore.StaticAssets.Infrastructure](9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md)
+* [Microsoft.AspNetCore.WebUtilities](9.0-preview6_Microsoft.AspNetCore.WebUtilities.md)
+
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Authentication
+
+``` diff
+ namespace Microsoft.AspNetCore.Authentication {
+     public abstract class ResultContext<TOptions> : BaseContext<TOptions> where TOptions : AuthenticationSchemeOptions {
+-        public AuthenticateResult Result { get; }
++        public AuthenticateResult? Result { get; }
+     }
+ }
+```
+
@@ -0,0 +1,16 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
++    public static class ControllerActionEndpointConventionBuilderResourceCollectionExtensions {
++        public static ControllerActionEndpointConventionBuilder WithStaticAssets(this ControllerActionEndpointConventionBuilder builder, string manifestPath = null);
++    }
++    public static class PageActionEndpointConventionBuilderResourceCollectionExtensions {
++        public static PageActionEndpointConventionBuilder WithStaticAssets(this PageActionEndpointConventionBuilder builder, string? manifestPath = null);
++    }
+     public static class RazorComponentsEndpointConventionBuilderExtensions {
++        public static RazorComponentsEndpointConventionBuilder WithStaticAssets(this RazorComponentsEndpointConventionBuilder builder, string? manifestPath = null);
+     }
+ }
+```
+
@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure {
+     public class StaticHtmlRenderer : Renderer {
+-        protected internal override ComponentPlatform ComponentPlatform { get; }
+
++        protected internal override RendererInfo RendererInfo { get; }
+     }
+ }
+```
+
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Components.RenderTree
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.RenderTree {
+     public abstract class Renderer : IAsyncDisposable, IDisposable {
++        protected internal virtual ResourceAssetCollection Assets { get; }
+-        protected internal virtual ComponentPlatform ComponentPlatform { get; }
+
++        protected internal virtual RendererInfo RendererInfo { get; }
+     }
+ }
+```
+
@@ -0,0 +1,69 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
+     public abstract class ComponentBase : IComponent, IHandleAfterRender, IHandleEvent {
++        protected ResourceAssetCollection Assets { get; }
+-        protected ComponentPlatform Platform { get; }
+
++        protected RendererInfo RendererInfo { get; }
+     }
+-    public sealed class ComponentPlatform {
+ {
+-        public ComponentPlatform(string platformName, bool isInteractive);
+
+-        public bool IsInteractive { get; }
+
+-        public string Name { get; }
+
+-    }
++    public sealed class ImportMap : IComponent {
++        public ImportMap();
++        public HttpContext HttpContext { get; set; }
++        public ImportMapDefinition ImportMapDefinition { get; set; }
++        void IComponent.Attach(RenderHandle renderHandle);
++        Task IComponent.SetParametersAsync(ParameterView parameters);
++    }
++    public sealed class ImportMapDefinition {
++        public ImportMapDefinition(IReadOnlyDictionary<string, string>? imports, IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? scopes, IReadOnlyDictionary<string, string>? integrity);
++        public IReadOnlyDictionary<string, string>? Imports { get; }
++        public IReadOnlyDictionary<string, string>? Integrity { get; }
++        public IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? Scopes { get; }
++        public static ImportMapDefinition Combine(params ImportMapDefinition[] sources);
++        public static ImportMapDefinition FromResourceCollection(ResourceAssetCollection assets);
++        public override string ToString();
++    }
++    public sealed class RendererInfo {
++        public RendererInfo(string rendererName, bool isInteractive);
++        public bool IsInteractive { get; }
++        public string Name { get; }
++    }
+     public readonly struct RenderHandle {
++        public ResourceAssetCollection Assets { get; }
+-        public ComponentPlatform Platform { get; }
+
++        public RendererInfo RendererInfo { get; }
+     }
++    public sealed class ResourceAsset {
++        public ResourceAsset(string url, IReadOnlyList<ResourceAssetProperty>? properties);
++        public IReadOnlyList<ResourceAssetProperty>? Properties { get; }
++        public string Url { get; }
++    }
++    public sealed class ResourceAssetCollection : IEnumerable, IEnumerable<ResourceAsset>, IReadOnlyCollection<ResourceAsset>, IReadOnlyList<ResourceAsset> {
++        public static readonly ResourceAssetCollection Empty;
++        public ResourceAssetCollection(IReadOnlyList<ResourceAsset> resources);
++        int IReadOnlyCollection<ResourceAsset>.Count { get; }
++        ResourceAsset IReadOnlyList<ResourceAsset>.this[int index] { get; }
++        public string this[string key] { get; }
++        public bool IsContentSpecificUrl(string path);
++        IEnumerator<ResourceAsset> IEnumerable<ResourceAsset>.GetEnumerator();
++        IEnumerator IEnumerable.GetEnumerator();
++    }
++    public sealed class ResourceAssetProperty {
++        public ResourceAssetProperty(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
+ }
+```
+
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Cors.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Cors.Infrastructure {
+     public static class CorsConstants {
++        public static readonly string AnyHeader;
++        public static readonly string AnyMethod;
+     }
+ }
+```
+
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Mvc.TagHelpers
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.TagHelpers {
+     public class ScriptTagHelper : UrlResolutionTagHelper {
++        public ImportMapDefinition ImportMap { get; set; }
++        public string Type { get; set; }
+     }
+ }
+```
+
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.StaticAssets.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.StaticAssets.Infrastructure {
+     public static class StaticAssetsEndpointDataSourceHelper {
++        public static bool HasStaticAssetsDataSource(IEndpointRouteBuilder builder, string? staticAssetsManifestPath = null);
+-        public static bool IsStaticAssetsDataSource(EndpointDataSource dataSource, string? staticAssetsManifestPath = null);
+
++        public static IReadOnlyList<StaticAssetDescriptor> ResolveStaticAssetDescriptors(IEndpointRouteBuilder endpointRouteBuilder, string? manifestPath);
+     }
+ }
+```
+
@@ -0,0 +1,31 @@
+# Microsoft.AspNetCore.StaticAssets
+
+``` diff
+ namespace Microsoft.AspNetCore.StaticAssets {
++    public sealed class StaticAssetDescriptor {
++        public StaticAssetDescriptor();
++        public string AssetPath { get; set; }
++        public IReadOnlyList<StaticAssetProperty> Properties { get; set; }
++        public IReadOnlyList<StaticAssetResponseHeader> ResponseHeaders { get; set; }
++        public string Route { get; set; }
++        public IReadOnlyList<StaticAssetSelector> Selectors { get; set; }
++    }
++    public sealed class StaticAssetProperty {
++        public StaticAssetProperty(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
++    public sealed class StaticAssetResponseHeader {
++        public StaticAssetResponseHeader(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
++    public sealed class StaticAssetSelector {
++        public StaticAssetSelector(string name, string value, string quality);
++        public string Name { get; }
++        public string Quality { get; }
++        public string Value { get; }
++    }
+ }
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.WebUtilities
+
+``` diff
+ namespace Microsoft.AspNetCore.WebUtilities {
+     public static class WebEncoders {
++        public static int Base64UrlEncode(ReadOnlySpan<byte> input, Span<char> output);
+     }
+ }
+```
+
@@ -0,0 +1,33 @@
+# API Difference 9.0-preview5 vs 9.0-preview6
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System](9.0-preview6_System.md)
+* [System.Buffers.Text](9.0-preview6_System.Buffers.Text.md)
+* [System.Collections.Concurrent](9.0-preview6_System.Collections.Concurrent.md)
+* [System.Collections.Frozen](9.0-preview6_System.Collections.Frozen.md)
+* [System.Collections.Generic](9.0-preview6_System.Collections.Generic.md)
+* [System.Collections.ObjectModel](9.0-preview6_System.Collections.ObjectModel.md)
+* [System.Diagnostics](9.0-preview6_System.Diagnostics.md)
+* [System.Diagnostics.Metrics](9.0-preview6_System.Diagnostics.Metrics.md)
+* [System.IO](9.0-preview6_System.IO.md)
+* [System.Net.Http](9.0-preview6_System.Net.Http.md)
+* [System.Net.Mime](9.0-preview6_System.Net.Mime.md)
+* [System.Net.Sockets](9.0-preview6_System.Net.Sockets.md)
+* [System.Numerics](9.0-preview6_System.Numerics.md)
+* [System.Reflection.Emit](9.0-preview6_System.Reflection.Emit.md)
+* [System.Runtime.InteropServices](9.0-preview6_System.Runtime.InteropServices.md)
+* [System.Runtime.InteropServices.Marshalling](9.0-preview6_System.Runtime.InteropServices.Marshalling.md)
+* [System.Runtime.InteropServices.Swift](9.0-preview6_System.Runtime.InteropServices.Swift.md)
+* [System.Runtime.Intrinsics](9.0-preview6_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.Arm](9.0-preview6_System.Runtime.Intrinsics.Arm.md)
+* [System.Runtime.Intrinsics.X86](9.0-preview6_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography](9.0-preview6_System.Security.Cryptography.md)
+* [System.Text.Json](9.0-preview6_System.Text.Json.md)
+* [System.Text.Json.Nodes](9.0-preview6_System.Text.Json.Nodes.md)
+* [System.Text.Json.Schema](9.0-preview6_System.Text.Json.Schema.md)
+* [System.Text.Json.Serialization](9.0-preview6_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](9.0-preview6_System.Text.Json.Serialization.Metadata.md)
+* [System.Text.RegularExpressions](9.0-preview6_System.Text.RegularExpressions.md)
+
@@ -0,0 +1,34 @@
+# System.Buffers.Text
+
+``` diff
+ namespace System.Buffers.Text {
++    public static class Base64Url {
++        public static byte[] DecodeFromChars(ReadOnlySpan<char> source);
++        public static int DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination);
++        public static OperationStatus DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int charsConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static byte[] DecodeFromUtf8(ReadOnlySpan<byte> source);
++        public static int DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination);
++        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static int DecodeFromUtf8InPlace(Span<byte> buffer);
++        public static char[] EncodeToChars(ReadOnlySpan<byte> source);
++        public static int EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination);
++        public static OperationStatus EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int bytesConsumed, out int charsWritten, bool isFinalBlock = true);
++        public static string EncodeToString(ReadOnlySpan<byte> source);
++        public static byte[] EncodeToUtf8(ReadOnlySpan<byte> source);
++        public static int EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination);
++        public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static int GetEncodedLength(int bytesLength);
++        public static int GetMaxDecodedLength(int base64Length);
++        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText);
++        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText, out int decodedLength);
++        public static bool IsValid(ReadOnlySpan<char> base64UrlText);
++        public static bool IsValid(ReadOnlySpan<char> base64UrlText, out int decodedLength);
++        public static bool TryDecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryDecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryEncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten);
++        public static bool TryEncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryEncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten);
++    }
+ }
+```
+
@@ -0,0 +1,21 @@
+# System.Collections.Concurrent
+
+``` diff
+ namespace System.Collections.Concurrent {
+     public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public ConcurrentDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>();
++        public bool TryGetAlternateLookup<TAlternateKey>(out ConcurrentDictionary.AlternateLookup<TAlternateKey> lookup);
++        public readonly struct AlternateLookup<TAlternateKey> {
++            public ConcurrentDictionary<TKey, TValue> Dictionary { get; }
++            public TValue this[TAlternateKey key] { get; set; }
++            public bool ContainsKey(TAlternateKey key);
++            public bool TryAdd(TAlternateKey key, TValue value);
++            public bool TryGetValue(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryGetValue(TAlternateKey key, out TValue value);
++            public bool TryRemove(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryRemove(TAlternateKey key, out TValue value);
++        }
+     }
+ }
+```
+
@@ -0,0 +1,26 @@
+# System.Collections.Frozen
+
+``` diff
+ namespace System.Collections.Frozen {
+     public abstract class FrozenDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public FrozenDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>();
++        public bool TryGetAlternateLookup<TAlternateKey>(out FrozenDictionary.AlternateLookup<TAlternateKey> lookup);
++        public readonly struct AlternateLookup<TAlternateKey> {
++            public FrozenDictionary<TKey, TValue> Dictionary { get; }
++            public TValue this[TAlternateKey key] { get; }
++            public bool ContainsKey(TAlternateKey key);
++            public bool TryGetValue(TAlternateKey key, out TValue value);
++        }
+     }
+     public abstract class FrozenSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
++        public FrozenSet.AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>();
++        public bool TryGetAlternateLookup<TAlternate>(out FrozenSet.AlternateLookup<TAlternate> lookup);
++        public readonly struct AlternateLookup<TAlternate> {
++            public FrozenSet<T> Set { get; }
++            public bool Contains(TAlternate item);
++            public bool TryGetValue(TAlternate equalValue, out T actualValue);
++        }
+     }
+ }
+```
+