dotnet · carlossanlop · Sep 22, 2022 · Sep 15, 2022 · Sep 15, 2022 · Sep 22, 2022
@@ -0,0 +1,36 @@
+# API Difference 7.0-preview7 vs 7.0-rc1
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authorization](7.0-rc1_Microsoft.AspNetCore.Authorization.md)
+* [Microsoft.AspNetCore.Builder](7.0-rc1_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components](7.0-rc1_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.Routing](7.0-rc1_Microsoft.AspNetCore.Components.Routing.md)
+* [Microsoft.AspNetCore.Connections](7.0-rc1_Microsoft.AspNetCore.Connections.md)
+* [Microsoft.AspNetCore.Connections.Features](7.0-rc1_Microsoft.AspNetCore.Connections.Features.md)
+* [Microsoft.AspNetCore.Http](7.0-rc1_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.Features](7.0-rc1_Microsoft.AspNetCore.Http.Features.md)
+* [Microsoft.AspNetCore.Identity](7.0-rc1_Microsoft.AspNetCore.Identity.md)
+* [Microsoft.AspNetCore.Mvc.ModelBinding](7.0-rc1_Microsoft.AspNetCore.Mvc.ModelBinding.md)
+* [Microsoft.AspNetCore.Mvc.Rendering](7.0-rc1_Microsoft.AspNetCore.Mvc.Rendering.md)
+* [Microsoft.AspNetCore.Mvc.ViewFeatures](7.0-rc1_Microsoft.AspNetCore.Mvc.ViewFeatures.md)
+* [Microsoft.AspNetCore.OutputCaching](7.0-rc1_Microsoft.AspNetCore.OutputCaching.md)
+* [Microsoft.AspNetCore.RateLimiting](7.0-rc1_Microsoft.AspNetCore.RateLimiting.md)
+* [Microsoft.AspNetCore.Routing](7.0-rc1_Microsoft.AspNetCore.Routing.md)
+* [Microsoft.AspNetCore.Routing.Patterns](7.0-rc1_Microsoft.AspNetCore.Routing.Patterns.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Https](7.0-rc1_Microsoft.AspNetCore.Server.Kestrel.Https.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Transport.Quic](7.0-rc1_Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.md)
+* [Microsoft.AspNetCore.SignalR](7.0-rc1_Microsoft.AspNetCore.SignalR.md)
+* [Microsoft.Extensions.Configuration](7.0-rc1_Microsoft.Extensions.Configuration.md)
+* [Microsoft.Extensions.DependencyInjection](7.0-rc1_Microsoft.Extensions.DependencyInjection.md)
+* [Microsoft.Extensions.Hosting](7.0-rc1_Microsoft.Extensions.Hosting.md)
+* [Microsoft.Extensions.Hosting.Internal](7.0-rc1_Microsoft.Extensions.Hosting.Internal.md)
+* [Microsoft.Extensions.Logging](7.0-rc1_Microsoft.Extensions.Logging.md)
+* [Microsoft.Extensions.Logging.Configuration](7.0-rc1_Microsoft.Extensions.Logging.Configuration.md)
+* [Microsoft.Extensions.ObjectPool](7.0-rc1_Microsoft.Extensions.ObjectPool.md)
+* [Microsoft.Extensions.Options](7.0-rc1_Microsoft.Extensions.Options.md)
+* [Microsoft.JSInterop](7.0-rc1_Microsoft.JSInterop.md)
+* [System.Diagnostics.Eventing.Reader](7.0-rc1_System.Diagnostics.Eventing.Reader.md)
+* [System.Threading.RateLimiting](7.0-rc1_System.Threading.RateLimiting.md)
+
@@ -0,0 +1,18 @@
+# Microsoft.AspNetCore.Authorization
+
+``` diff
+ namespace Microsoft.AspNetCore.Authorization {
+     public class AuthorizationMiddleware {
++        public AuthorizationMiddleware(RequestDelegate next, IAuthorizationPolicyProvider policyProvider, IServiceProvider services);
+-        public Task Invoke(HttpContext context);
++        public Task Invoke(HttpContext context);
+     }
+     public class DefaultAuthorizationPolicyProvider : IAuthorizationPolicyProvider {
++        public virtual bool AllowsCachingPolicies { get; }
+     }
+     public interface IAuthorizationPolicyProvider {
++        bool AllowsCachingPolicies { get; }
+     }
+ }
+```
+
@@ -0,0 +1,43 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+     public sealed class ComponentEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
+     public sealed class ConnectionEndpointRouteBuilder : IEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
+     public sealed class ControllerActionEndpointConventionBuilder : IEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
+     public abstract class EndpointBuilder {
++        public IList<Func<EndpointFilterFactoryContext, EndpointFilterDelegate, EndpointFilterDelegate>> FilterFactories { [CompilerGeneratedAttribute] get; }
+     }
+     public sealed class HubEndpointConventionBuilder : IEndpointConventionBuilder, IHubEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
+     public interface IEndpointConventionBuilder {
++        void Finally(Action<EndpointBuilder> finallyConvention);
+     }
+     public sealed class PageActionEndpointConventionBuilder : IEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
++    public static class RateLimiterApplicationBuilderExtensions {
++        public static IApplicationBuilder UseRateLimiter(this IApplicationBuilder app);
++        public static IApplicationBuilder UseRateLimiter(this IApplicationBuilder app, RateLimiterOptions options);
++    }
++    public static class RateLimiterEndpointConventionBuilderExtensions {
++        public static TBuilder DisableRateLimiting<TBuilder>(this TBuilder builder) where TBuilder : IEndpointConventionBuilder;
++        public static TBuilder RequireRateLimiting<TBuilder, TPartitionKey>(this TBuilder builder, IRateLimiterPolicy<TPartitionKey> policy) where TBuilder : IEndpointConventionBuilder;
++        public static TBuilder RequireRateLimiting<TBuilder>(this TBuilder builder, string policyName) where TBuilder : IEndpointConventionBuilder;
++    }
++    public static class RateLimiterServiceCollectionExtensions {
++        public static IServiceCollection AddRateLimiter(this IServiceCollection services, Action<RateLimiterOptions> configureOptions);
++    }
+     public sealed class RouteHandlerBuilder : IEndpointConventionBuilder {
++        public void Finally(Action<EndpointBuilder> finalConvention);
+     }
+ }
+```
+
@@ -0,0 +1,25 @@
+# Microsoft.AspNetCore.Components.Routing
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Routing {
++    public sealed class LocationChangingContext {
++        public LocationChangingContext();
++        public CancellationToken CancellationToken { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public string? HistoryEntryState { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public bool IsNavigationIntercepted { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public required string TargetLocation { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public void PreventNavigation();
++    }
++    public sealed class NavigationLock : IAsyncDisposable, IComponent {
++        public NavigationLock();
++        [ParameterAttribute]
++        public bool ConfirmExternalNavigation { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        [ParameterAttribute]
++        public EventCallback<LocationChangingContext> OnBeforeInternalNavigation { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        void IComponent.Attach(RenderHandle renderHandle);
++        Task IComponent.SetParametersAsync(ParameterView parameters);
++        ValueTask IAsyncDisposable.DisposeAsync();
++    }
+ }
+```
+
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
+     public abstract class NavigationManager {
++        protected virtual void HandleLocationChangingHandlerException(Exception ex, LocationChangingContext context);
++        protected ValueTask<bool> NotifyLocationChangingAsync(string uri, string? state, bool isNavigationIntercepted);
++        public IDisposable RegisterLocationChangingHandler(Func<LocationChangingContext, ValueTask> locationChangingHandler);
++        protected virtual void SetNavigationLockState(bool value);
+     }
+ }
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Connections.Features
+
+``` diff
+ namespace Microsoft.AspNetCore.Connections.Features {
++    public interface IStreamClosedFeature {
++        void OnClosed(Action<object?> callback, object? state);
++    }
+ }
+```
+
@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.Connections
+
+``` diff
+ namespace Microsoft.AspNetCore.Connections {
++    public class TlsConnectionCallbackContext {
++        public TlsConnectionCallbackContext();
++        public SslClientHelloInfo ClientHelloInfo { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public BaseConnectionContext Connection { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public object? State { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++    }
++    public class TlsConnectionCallbackOptions {
++        public TlsConnectionCallbackOptions();
++        public List<SslApplicationProtocol> ApplicationProtocols { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public Func<TlsConnectionCallbackContext, CancellationToken, ValueTask<SslServerAuthenticationOptions>> OnConnection { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public object? OnConnectionState { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++    }
+ }
+```
+
@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.Http.Features
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Features {
++    [RequiresPreviewFeaturesAttribute("WebTransport is a preview feature")]
++    public interface IHttpWebTransportFeature {
++        bool IsWebTransportRequest { get; }
++        ValueTask<IWebTransportSession> AcceptAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
++    [RequiresPreviewFeaturesAttribute("WebTransport is a preview feature")]
++    public interface IWebTransportSession {
++        long SessionId { get; }
++        void Abort(int errorCode);
++        ValueTask<ConnectionContext?> AcceptStreamAsync(CancellationToken cancellationToken = default(CancellationToken));
++        ValueTask<ConnectionContext?> OpenUnidirectionalStreamAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
+ }
+```
+
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
+     public static class EndpointFilterExtensions {
+-        [RequiresUnreferencedCodeAttribute("This API may perform reflection on the supplied delegate and its parameters. These types may be trimmed if not directly referenced.")]
+-        public static TBuilder AddEndpointFilter<TBuilder>(this TBuilder builder, Func<EndpointFilterFactoryContext, EndpointFilterDelegate, EndpointFilterDelegate> filterFactory) where TBuilder : IEndpointConventionBuilder;
++        [RequiresUnreferencedCodeAttribute("This API may perform reflection on the supplied delegate and its parameters. These types may be trimmed if not directly referenced.")]
++        public static TBuilder AddEndpointFilterFactory<TBuilder>(this TBuilder builder, Func<EndpointFilterFactoryContext, EndpointFilterDelegate, EndpointFilterDelegate> filterFactory) where TBuilder : IEndpointConventionBuilder;
+     }
+ }
+```
+
@@ -0,0 +1,26 @@
+# Microsoft.AspNetCore.Identity
+
+``` diff
+ namespace Microsoft.AspNetCore.Identity {
+     public class IdentityBuilder {
+-        public IdentityBuilder(Type user, Type role, IServiceCollection services);
++        public IdentityBuilder(Type user, [DynamicallyAccessedMembersAttribute(3)] Type role, IServiceCollection services);
+-        public Type? RoleType { [CompilerGeneratedAttribute] get; }
++        [DynamicallyAccessedMembersAttribute(3)]
++        public Type? RoleType { [CompilerGeneratedAttribute] get; }
+-        public virtual IdentityBuilder AddTokenProvider(string providerName, Type provider);
++        public virtual IdentityBuilder AddTokenProvider(string providerName, [DynamicallyAccessedMembersAttribute(3)] Type provider);
+     }
+     public abstract class RoleStoreBase<TRole, TKey, TUserRole, TRoleClaim> : IDisposable, IQueryableRoleStore<TRole>, IRoleClaimStore<TRole>, IRoleStore<TRole> where TRole : IdentityRole<TKey> where TKey : IEquatable<TKey> where TUserRole : IdentityUserRole<TKey>, new() where TRoleClaim : IdentityRoleClaim<TKey>, new() {
+-        public virtual TKey? ConvertIdFromString(string? id);
++        [UnconditionalSuppressMessageAttribute("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification="TKey is annoated with RequiresUnreferencedCodeAttribute.All.")]
++        public virtual TKey? ConvertIdFromString(string? id);
+     }
+     public abstract class UserStoreBase<TUser, TKey, TUserClaim, TUserLogin, TUserToken> : IDisposable, IQueryableUserStore<TUser>, IUserAuthenticationTokenStore<TUser>, IUserAuthenticatorKeyStore<TUser>, IUserClaimStore<TUser>, IUserEmailStore<TUser>, IUserLockoutStore<TUser>, IUserLoginStore<TUser>, IUserPasswordStore<TUser>, IUserPhoneNumberStore<TUser>, IUserSecurityStampStore<TUser>, IUserStore<TUser>, IUserTwoFactorRecoveryCodeStore<TUser>, IUserTwoFactorStore<TUser> where TUser : IdentityUser<TKey> where TKey : IEquatable<TKey> where TUserClaim : IdentityUserClaim<TKey>, new() where TUserLogin : IdentityUserLogin<TKey>, new() where TUserToken : IdentityUserToken<TKey>, new() {
+-        public virtual TKey? ConvertIdFromString(string? id);
++        [UnconditionalSuppressMessageAttribute("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification="TKey is annoated with RequiresUnreferencedCodeAttribute.All.")]
++        public virtual TKey? ConvertIdFromString(string? id);
+     }
+ }
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Mvc.ModelBinding
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ModelBinding {
+     public class JQueryFormValueProvider : JQueryValueProvider {
++        public override ValueProviderResult GetValue(string key);
+     }
+ }
+```
+
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Mvc.Rendering
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.Rendering {
++    public enum FormInputRenderMode {
++        AlwaysUseCurrentCulture = 1,
++        DetectCultureFromInputType = 0,
++    }
+ }
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Mvc.ViewFeatures
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ViewFeatures {
+     public class HtmlHelperOptions {
++        public FormInputRenderMode FormInputRenderMode { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+     }
+ }
+```
+
@@ -0,0 +1,35 @@
+# Microsoft.AspNetCore.OutputCaching
+
+``` diff
+ namespace Microsoft.AspNetCore.OutputCaching {
+     public sealed class CacheVaryByRules {
++        public StringValues HeaderNames { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+-        public StringValues Headers { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public StringValues RouteValueNames { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+     }
+     [AttributeUsageAttribute(68, AllowMultiple=false, Inherited=true)]
+     public sealed class OutputCacheAttribute : Attribute {
++        public string[]? VaryByHeaderNames { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+-        public string[]? VaryByHeaders { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public string[]? VaryByRouteValueNames { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+     }
+     public sealed class OutputCacheContext {
++        public OutputCacheContext();
+-        public CacheVaryByRules CacheVaryByRules { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public CacheVaryByRules CacheVaryByRules { [CompilerGeneratedAttribute] get; }
+-        public HttpContext HttpContext { [CompilerGeneratedAttribute] get; }
++        public required HttpContext HttpContext { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+-        public DateTimeOffset? ResponseTime { [CompilerGeneratedAttribute] get; }
++        public DateTimeOffset? ResponseTime { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
+     }
+     public sealed class OutputCachePolicyBuilder {
++        public OutputCachePolicyBuilder Cache();
+-        public OutputCachePolicyBuilder VaryByHeader(params string[] headers);
++        public OutputCachePolicyBuilder VaryByHeader(params string[] headerNames);
++        public OutputCachePolicyBuilder VaryByRouteValue(params string[] routeValueNames);
+-        public OutputCachePolicyBuilder With(Func<OutputCacheContext, CancellationToken, Task<bool>> predicate);
++        public OutputCachePolicyBuilder With(Func<OutputCacheContext, CancellationToken, ValueTask<bool>> predicate);
+     }
+ }
+```
+
@@ -0,0 +1,40 @@
+# Microsoft.AspNetCore.RateLimiting
+
+``` diff
++namespace Microsoft.AspNetCore.RateLimiting {
++    [AttributeUsageAttribute(68, AllowMultiple=false, Inherited=true)]
++    public sealed class DisableRateLimitingAttribute : Attribute {
++        public DisableRateLimitingAttribute();
++    }
++    [AttributeUsageAttribute(68, AllowMultiple=false, Inherited=true)]
++    public sealed class EnableRateLimitingAttribute : Attribute {
++        public EnableRateLimitingAttribute(string policyName);
++        public string PolicyName { [CompilerGeneratedAttribute] get; }
++    }
++    public interface IRateLimiterPolicy<TPartitionKey> {
++        Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected { get; }
++        RateLimitPartition<TPartitionKey> GetPartition(HttpContext httpContext);
++    }
++    public sealed class OnRejectedContext {
++        public OnRejectedContext();
++        public required HttpContext HttpContext { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public required RateLimitLease Lease { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++    }
++    public sealed class RateLimiterOptions {
++        public RateLimiterOptions();
++        public PartitionedRateLimiter<HttpContext>? GlobalLimiter { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public int RejectionStatusCode { [CompilerGeneratedAttribute] get; [CompilerGeneratedAttribute] set; }
++        public RateLimiterOptions AddPolicy<TPartitionKey, TPolicy>(string policyName) where TPolicy : IRateLimiterPolicy<TPartitionKey>;
++        public RateLimiterOptions AddPolicy<TPartitionKey>(string policyName, IRateLimiterPolicy<TPartitionKey> policy);
++        public RateLimiterOptions AddPolicy<TPartitionKey>(string policyName, Func<HttpContext, RateLimitPartition<TPartitionKey>> partitioner);
++    }
++    public static class RateLimiterOptionsExtensions {
++        public static RateLimiterOptions AddConcurrencyLimiter(this RateLimiterOptions options, string policyName, Action<ConcurrencyLimiterOptions> configureOptions);
++        public static RateLimiterOptions AddFixedWindowLimiter(this RateLimiterOptions options, string policyName, Action<FixedWindowRateLimiterOptions> configureOptions);
++        public static RateLimiterOptions AddSlidingWindowLimiter(this RateLimiterOptions options, string policyName, Action<SlidingWindowRateLimiterOptions> configureOptions);
++        public static RateLimiterOptions AddTokenBucketLimiter(this RateLimiterOptions options, string policyName, Action<TokenBucketRateLimiterOptions> configureOptions);
++    }
++}
+```
+
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Routing.Patterns
+
+``` diff
+ namespace Microsoft.AspNetCore.Routing.Patterns {
+     public static class RoutePatternFactory {
++        public static RoutePattern Combine(RoutePattern? left, RoutePattern right);
+     }
+ }
+```
+