diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3.md new file mode 100644 index 0000000000..fbba412ea2 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3.md @@ -0,0 +1,16 @@ +# API Difference 7.0-preview2 vs 7.0-preview3 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [Microsoft.AspNetCore.Http](7.0-preview3_Microsoft.AspNetCore.Http.md) +* [Microsoft.AspNetCore.Mvc](7.0-preview3_Microsoft.AspNetCore.Mvc.md) +* [Microsoft.AspNetCore.Mvc.ModelBinding.Binders](7.0-preview3_Microsoft.AspNetCore.Mvc.ModelBinding.Binders.md) +* [Microsoft.AspNetCore.Routing](7.0-preview3_Microsoft.AspNetCore.Routing.md) +* [Microsoft.Extensions.Caching.Memory](7.0-preview3_Microsoft.Extensions.Caching.Memory.md) +* [Microsoft.Extensions.Configuration](7.0-preview3_Microsoft.Extensions.Configuration.md) +* [Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts](7.0-preview3_Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts.md) +* [Microsoft.Extensions.Hosting](7.0-preview3_Microsoft.Extensions.Hosting.md) +* [Microsoft.Extensions.Logging](7.0-preview3_Microsoft.Extensions.Logging.md) +* [Microsoft.Extensions.Primitives](7.0-preview3_Microsoft.Extensions.Primitives.md) + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Http.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Http.md new file mode 100644 index 0000000000..5fb67d4e02 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Http.md @@ -0,0 +1,207 @@ +# Microsoft.AspNetCore.Http + +``` diff + namespace Microsoft.AspNetCore.Http { ++ public sealed class AcceptedAtRouteHttpResult : IResult { ++ public string RouteName { get; } ++ public RouteValueDictionary RouteValues { get; } ++ public int StatusCode { get; } ++ public object Value { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class AcceptedHttpResult : IResult { ++ public string Location { get; } ++ public int StatusCode { get; } ++ public object Value { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class BadRequestObjectHttpResult : IResult { ++ public int StatusCode { get; } ++ public object Value { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class ChallengeHttpResult : IResult { ++ public IReadOnlyList AuthenticationSchemes { get; internal set; } ++ public AuthenticationProperties? Properties { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class ConflictObjectHttpResult : IResult { ++ public int StatusCode { get; } ++ public object Value { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class ContentHttpResult : IResult { ++ public string Content { get; internal set; } ++ public string ContentType { get; internal set; } ++ public int? StatusCode { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class CreatedAtRouteHttpResult : IResult { ++ public string RouteName { get; } ++ public RouteValueDictionary RouteValues { get; } ++ public int StatusCode { get; } ++ public object Value { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class CreatedHttpResult : IResult { ++ public string Location { get; } ++ public int StatusCode { get; } ++ public object Value { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class EmptyHttpResult : IResult { ++ public static EmptyHttpResult Instance { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } + public sealed class EndpointMetadataCollection : IEnumerable, IEnumerable, IReadOnlyCollection, IReadOnlyList { ++ public T GetRequiredMetadata() where T : class; + } ++ public sealed class FileContentHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public bool EnableRangeProcessing { get; internal set; } ++ public EntityTagHeaderValue EntityTag { get; internal set; } ++ public ReadOnlyMemory FileContents { get; internal set; } ++ public string FileDownloadName { get; internal set; } ++ public long? FileLength { get; internal set; } ++ public DateTimeOffset? LastModified { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class FileStreamHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public bool EnableRangeProcessing { get; internal set; } ++ public EntityTagHeaderValue EntityTag { get; internal set; } ++ public string FileDownloadName { get; internal set; } ++ public long? FileLength { get; internal set; } ++ public Stream FileStream { get; } ++ public DateTimeOffset? LastModified { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class ForbidHttpResult : IResult { ++ public IReadOnlyList AuthenticationSchemes { get; internal set; } ++ public AuthenticationProperties? Properties { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public interface IRouteHandlerFilter { ++ ValueTask InvokeAsync(RouteHandlerInvocationContext context, RouteHandlerFilterDelegate next); ++ } ++ public sealed class JsonHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public JsonSerializerOptions JsonSerializerOptions { get; internal set; } ++ public int? StatusCode { get; } ++ public object Value { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public class NoContentHttpResult : IResult { ++ public int StatusCode { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class NotFoundObjectHttpResult : IResult { ++ public int StatusCode { get; } ++ public object Value { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class OkObjectHttpResult : IResult { ++ public int StatusCode { get; } ++ public object Value { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class PhysicalFileHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public bool EnableRangeProcessing { get; internal set; } ++ public EntityTagHeaderValue? EntityTag { get; internal set; } ++ public string? FileDownloadName { get; internal set; } ++ public long? FileLength { get; internal set; } ++ public string FileName { get; } ++ public DateTimeOffset? LastModified { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class ProblemHttpResult : IResult { ++ public string ContentType { get; } ++ public ProblemDetails ProblemDetails { get; } ++ public int? StatusCode { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class PushStreamHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public bool EnableRangeProcessing { get; internal set; } ++ public EntityTagHeaderValue EntityTag { get; internal set; } ++ public string FileDownloadName { get; internal set; } ++ public long? FileLength { get; internal set; } ++ public DateTimeOffset? LastModified { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class RedirectHttpResult : IResult { ++ public bool AcceptLocalUrlOnly { get; } ++ public bool Permanent { get; } ++ public bool PreserveMethod { get; } ++ public string Url { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class RedirectToRouteHttpResult : IResult { ++ public string Fragment { get; } ++ public bool Permanent { get; } ++ public bool PreserveMethod { get; } ++ public string RouteName { get; } ++ public RouteValueDictionary RouteValues { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } + public sealed class RequestDelegateFactoryOptions { ++ public IReadOnlyList>? RouteHandlerFilterFactories { get; set; } + } + public static class Results { ++ public static IResult Empty { get; } + } ++ public sealed class RouteHandlerContext { ++ public RouteHandlerContext(MethodInfo methodInfo, EndpointMetadataCollection endpointMetadata); ++ public EndpointMetadataCollection EndpointMetadata { get; } ++ public MethodInfo MethodInfo { get; } ++ } ++ public delegate ValueTask RouteHandlerFilterDelegate(RouteHandlerInvocationContext context); ++ public static class RouteHandlerFilterExtensions { ++ public static RouteHandlerBuilder AddFilter(this RouteHandlerBuilder builder, IRouteHandlerFilter filter); ++ public static RouteHandlerBuilder AddFilter(this RouteHandlerBuilder builder, Func filterFactory); ++ public static RouteHandlerBuilder AddFilter(this RouteHandlerBuilder builder, Func> routeHandlerFilter); ++ public static RouteHandlerBuilder AddFilter(this RouteHandlerBuilder builder) where TFilterType : IRouteHandlerFilter; ++ } ++ public sealed class RouteHandlerInvocationContext { ++ public RouteHandlerInvocationContext(HttpContext httpContext, params object[] parameters); ++ public HttpContext HttpContext { get; } ++ public IList Parameters { get; } ++ } ++ public sealed class SignInHttpResult : IResult { ++ public string AuthenticationScheme { get; internal set; } ++ public ClaimsPrincipal Principal { get; internal set; } ++ public AuthenticationProperties Properties { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class SignOutHttpResult : IResult { ++ public IReadOnlyList AuthenticationSchemes { get; internal set; } ++ public AuthenticationProperties? Properties { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class StatusCodeHttpResult : IResult { ++ public int StatusCode { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class UnauthorizedHttpResult : IResult { ++ public int StatusCode { get; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class UnprocessableEntityObjectHttpResult : IResult { ++ public int StatusCode { get; } ++ public object Value { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } ++ public sealed class VirtualFileHttpResult : IResult { ++ public string ContentType { get; internal set; } ++ public bool EnableRangeProcessing { get; internal set; } ++ public EntityTagHeaderValue? EntityTag { get; internal set; } ++ public string? FileDownloadName { get; internal set; } ++ public long? FileLength { get; internal set; } ++ public string FileName { get; internal set; } ++ public DateTimeOffset? LastModified { get; internal set; } ++ public Task ExecuteAsync(HttpContext httpContext); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.ModelBinding.Binders.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.ModelBinding.Binders.md new file mode 100644 index 0000000000..12a99e9402 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.ModelBinding.Binders.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.Mvc.ModelBinding.Binders + +``` diff + namespace Microsoft.AspNetCore.Mvc.ModelBinding.Binders { ++ public sealed class TryParseModelBinderProvider : IModelBinderProvider { ++ public TryParseModelBinderProvider(); ++ public IModelBinder? GetBinder(ModelBinderProviderContext context); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.md new file mode 100644 index 0000000000..f5a70cbfbb --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Mvc.md @@ -0,0 +1,10 @@ +# Microsoft.AspNetCore.Mvc + +``` diff + namespace Microsoft.AspNetCore.Mvc { + public abstract class ControllerBase { ++ public static EmptyResult Empty { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Routing.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Routing.md new file mode 100644 index 0000000000..0cff041d3c --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.AspNetCore.Routing.md @@ -0,0 +1,12 @@ +# Microsoft.AspNetCore.Routing + +``` diff + namespace Microsoft.AspNetCore.Routing { + public class RouteValueDictionary : ICollection>, IDictionary, IEnumerable, IEnumerable>, IReadOnlyCollection>, IReadOnlyDictionary { ++ public RouteValueDictionary(RouteValueDictionary? dictionary); ++ public RouteValueDictionary(IEnumerable>? values); ++ public RouteValueDictionary(IEnumerable>? values); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Caching.Memory.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Caching.Memory.md new file mode 100644 index 0000000000..a25e63c3a1 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Caching.Memory.md @@ -0,0 +1,11 @@ +# Microsoft.Extensions.Caching.Memory + +``` diff + namespace Microsoft.Extensions.Caching.Memory { + public static class CacheExtensions { +- public static Task GetOrCreateAsync(this IMemoryCache cache, object key, Func> factory); ++ public static Task GetOrCreateAsync(this IMemoryCache cache, object key, Func> factory); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Configuration.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Configuration.md new file mode 100644 index 0000000000..28967d7e15 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Configuration.md @@ -0,0 +1,16 @@ +# Microsoft.Extensions.Configuration + +``` diff + namespace Microsoft.Extensions.Configuration { + public static class ConfigurationBinder { +- public static object? GetValue(this IConfiguration configuration, Type type, string key, object defaultValue); ++ public static object? GetValue(this IConfiguration configuration, Type type, string key, object? defaultValue); + } + public sealed class ConfigurationManager : IConfiguration, IConfigurationBuilder, IConfigurationRoot, IDisposable { +- IList IConfigurationBuilder.Sources { get; } + ++ public IList Sources { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts.md new file mode 100644 index 0000000000..c56c59d86a --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts.md @@ -0,0 +1,14 @@ +# Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts + +``` diff + namespace Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts { +- public abstract class PatternContext : IPatternContext { ++ public abstract class PatternContext : IPatternContext where TFrame : struct { +- protected TFrame? Frame; ++ protected TFrame Frame; +- protected void PushDataFrame(TFrame? frame); ++ protected void PushDataFrame(TFrame frame); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Hosting.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Hosting.md new file mode 100644 index 0000000000..c87a912ca7 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Hosting.md @@ -0,0 +1,46 @@ +# Microsoft.Extensions.Hosting + +``` diff + namespace Microsoft.Extensions.Hosting { + public abstract class BackgroundService : IDisposable, IHostedService { +- public virtual Task ExecuteTask { get; } ++ public virtual Task? ExecuteTask { get; } + } + public static class GenericHostBuilderExtensions { ++ public static IHostBuilder ConfigureWebHostDefaults(this IHostBuilder builder, Action configure, Action configureOptions); + } + public static class Host { ++ public static HostApplicationBuilder CreateApplicationBuilder(); ++ public static HostApplicationBuilder CreateApplicationBuilder(string[] args); + } ++ public sealed class HostApplicationBuilder { ++ public HostApplicationBuilder(); ++ public HostApplicationBuilder(HostApplicationBuilderSettings settings); ++ public HostApplicationBuilder(string[] args); ++ public ConfigurationManager Configuration { get; } ++ public IHostEnvironment Environment { get; } ++ public ILoggingBuilder Logging { get; } ++ public IServiceCollection Services { get; } ++ public IHost Build(); ++ public void ConfigureContainer(IServiceProviderFactory factory, Action configure = null) where TContainerBuilder : notnull; ++ } ++ public sealed class HostApplicationBuilderSettings { ++ public HostApplicationBuilderSettings(); ++ public string ApplicationName { get; set; } ++ public string[] Args { get; set; } ++ public ConfigurationManager Configuration { get; set; } ++ public string ContentRootPath { get; set; } ++ public bool DisableDefaults { get; set; } ++ public string EnvironmentName { get; set; } ++ } + public interface IHostEnvironment { +- string ApplicationName { get; set; } ++ string? ApplicationName { get; set; } + } + public interface IHostingEnvironment { +- string ApplicationName { get; set; } ++ string? ApplicationName { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Logging.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Logging.md new file mode 100644 index 0000000000..03ab731c73 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Logging.md @@ -0,0 +1,41 @@ +# Microsoft.Extensions.Logging + +``` diff + namespace Microsoft.Extensions.Logging { + public static class FilterLoggingBuilderExtensions { +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func categoryLevelFilter); ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func categoryLevelFilter); +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func filter); ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func filter); +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string category, LogLevel level); ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string? category, LogLevel level); +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string category, Func levelFilter); ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string? category, Func levelFilter); +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func categoryLevelFilter); ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func categoryLevelFilter); +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func filter); ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func filter); +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string category, LogLevel level); ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string? category, LogLevel level); +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string category, Func levelFilter); ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string? category, Func levelFilter); +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func categoryLevelFilter) where T : ILoggerProvider; ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, Func categoryLevelFilter) where T : ILoggerProvider; +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string category, LogLevel level) where T : ILoggerProvider; ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string? category, LogLevel level) where T : ILoggerProvider; +- public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string category, Func levelFilter) where T : ILoggerProvider; ++ public static ILoggingBuilder AddFilter(this ILoggingBuilder builder, string? category, Func levelFilter) where T : ILoggerProvider; +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func categoryLevelFilter) where T : ILoggerProvider; ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, Func categoryLevelFilter) where T : ILoggerProvider; +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string category, LogLevel level) where T : ILoggerProvider; ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string? category, LogLevel level) where T : ILoggerProvider; +- public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string category, Func levelFilter) where T : ILoggerProvider; ++ public static LoggerFilterOptions AddFilter(this LoggerFilterOptions builder, string? category, Func levelFilter) where T : ILoggerProvider; + } + public class LoggerFactory : IDisposable, ILoggerFactory { +- public LoggerFactory(IEnumerable providers, IOptionsMonitor filterOption, IOptions options = null); ++ public LoggerFactory(IEnumerable providers, IOptionsMonitor filterOption, IOptions? options = null); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Primitives.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Primitives.md new file mode 100644 index 0000000000..aff27e1d15 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.AspNetCore.App/7.0-preview3_Microsoft.Extensions.Primitives.md @@ -0,0 +1,13 @@ +# Microsoft.Extensions.Primitives + +``` diff + namespace Microsoft.Extensions.Primitives { + public readonly struct StringValues : ICollection, IEnumerable, IEnumerable, IEquatable, IEquatable, IEquatable, IList, IReadOnlyCollection, IReadOnlyList { + public struct Enumerator : IDisposable, IEnumerator, IEnumerator { +- object System.Collections.IEnumerator.Current { get; } ++ object? System.Collections.IEnumerator.Current { get; } + } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3.md new file mode 100644 index 0000000000..174ed175a3 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3.md @@ -0,0 +1,13 @@ +# API Difference 7.0-preview2 vs 7.0-preview3 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [System](7.0-preview3_System.md) +* [System.Diagnostics](7.0-preview3_System.Diagnostics.md) +* [System.Net.Http](7.0-preview3_System.Net.Http.md) +* [System.Net.Http.Headers](7.0-preview3_System.Net.Http.Headers.md) +* [System.Runtime.InteropServices](7.0-preview3_System.Runtime.InteropServices.md) +* [System.Security.Cryptography.X509Certificates](7.0-preview3_System.Security.Cryptography.X509Certificates.md) +* [System.Text.RegularExpressions](7.0-preview3_System.Text.RegularExpressions.md) + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Diagnostics.md new file mode 100644 index 0000000000..dd69099f66 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Diagnostics.md @@ -0,0 +1,17 @@ +# System.Diagnostics + +``` diff + namespace System.Diagnostics { + public class Activity : IDisposable { ++ public bool HasRemoteParent { get; } + } + public readonly struct ActivityCreationOptions { ++ public string? TraceState { get; set; } + } + public class Stopwatch { ++ public static TimeSpan GetElapsedTime(long startingTimestamp); ++ public static TimeSpan GetElapsedTime(long startingTimestamp, long endingTimestamp); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.Headers.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.Headers.md new file mode 100644 index 0000000000..f5f567ec58 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.Headers.md @@ -0,0 +1,10 @@ +# System.Net.Http.Headers + +``` diff + namespace System.Net.Http.Headers { + public class MediaTypeHeaderValue : ICloneable { ++ public MediaTypeHeaderValue(string mediaType, string? charSet); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.md new file mode 100644 index 0000000000..8e41ed5b63 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Net.Http.md @@ -0,0 +1,13 @@ +# System.Net.Http + +``` diff + namespace System.Net.Http { + public class StringContent : ByteArrayContent { ++ public StringContent(string content, MediaTypeHeaderValue mediaType); ++ public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue mediaType); +- public StringContent(string content, Encoding? encoding, string? mediaType); ++ public StringContent(string content, Encoding? encoding, string mediaType); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Runtime.InteropServices.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Runtime.InteropServices.md new file mode 100644 index 0000000000..a59f4b6680 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Runtime.InteropServices.md @@ -0,0 +1,23 @@ +# System.Runtime.InteropServices + +``` diff + namespace System.Runtime.InteropServices { ++ public sealed class LibraryImportAttribute : Attribute { ++ public LibraryImportAttribute(string libraryName); ++ public string EntryPoint { get; set; } ++ public string LibraryName { get; } ++ public bool SetLastError { get; set; } ++ public StringMarshalling StringMarshalling { get; set; } ++ public Type StringMarshallingCustomType { get; set; } ++ } + public static class NativeLibrary { ++ public static IntPtr GetMainProgramHandle(); + } ++ public enum StringMarshalling { ++ Custom = 0, ++ Utf16 = 2, ++ Utf8 = 1, ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Security.Cryptography.X509Certificates.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Security.Cryptography.X509Certificates.md new file mode 100644 index 0000000000..029f61446a --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Security.Cryptography.X509Certificates.md @@ -0,0 +1,21 @@ +# System.Security.Cryptography.X509Certificates + +``` diff + namespace System.Security.Cryptography.X509Certificates { ++ public sealed class X500DistinguishedNameBuilder { ++ public X500DistinguishedNameBuilder(); ++ public void Add(Oid oid, string value, UniversalTagNumber? stringEncodingType = default(UniversalTagNumber?)); ++ public void Add(string oidValue, string value, UniversalTagNumber? stringEncodingType = default(UniversalTagNumber?)); ++ public void AddCommonName(string commonName); ++ public void AddCountryOrRegion(string twoLetterCode); ++ public void AddDomainComponent(string domainComponent); ++ public void AddEmailAddress(string emailAddress); ++ public void AddLocalityName(string localityName); ++ public void AddOrganizationalUnitName(string organizationalUnitName); ++ public void AddOrganizationName(string organizationName); ++ public void AddStateOrProvinceName(string stateOrProvinceName); ++ public X500DistinguishedName Build(); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Text.RegularExpressions.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Text.RegularExpressions.md new file mode 100644 index 0000000000..3973f333bd --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.Text.RegularExpressions.md @@ -0,0 +1,26 @@ +# System.Text.RegularExpressions + +``` diff + namespace System.Text.RegularExpressions { + public class Regex : ISerializable { ++ public int Count(ReadOnlySpan input); ++ public static int Count(ReadOnlySpan input, string pattern); ++ public static int Count(ReadOnlySpan input, string pattern, RegexOptions options); ++ public static int Count(ReadOnlySpan input, string pattern, RegexOptions options, TimeSpan matchTimeout); ++ public bool IsMatch(ReadOnlySpan input); ++ public static bool IsMatch(ReadOnlySpan input, string pattern); ++ public static bool IsMatch(ReadOnlySpan input, string pattern, RegexOptions options); ++ public static bool IsMatch(ReadOnlySpan input, string pattern, RegexOptions options, TimeSpan matchTimeout); + } + public abstract class RegexRunner { +- protected abstract bool FindFirstChar(); ++ protected virtual bool FindFirstChar(); +- protected abstract void Go(); ++ protected virtual void Go(); +- protected abstract void InitTrackCount(); ++ protected virtual void InitTrackCount(); ++ protected internal virtual void Scan(ReadOnlySpan text); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.md new file mode 100644 index 0000000000..309ba7dfd3 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.NETCore.App/7.0-preview3_System.md @@ -0,0 +1,1475 @@ +# System + +``` diff + namespace System { +- public readonly struct Byte : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Byte : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ public const byte AdditiveIdentity = (byte)0; ++ public const byte MultiplicativeIdentity = (byte)1; ++ public const byte One = (byte)1; ++ public const byte Zero = (byte)0; ++ static byte System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static byte System.IMinMaxValue.MaxValue { get; } ++ static byte System.IMinMaxValue.MinValue { get; } ++ static byte System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static byte System.INumber.One { get; } ++ static byte System.INumber.Zero { get; } ++ static Byte Abs(Byte value); ++ static Byte Clamp(Byte value, Byte min, Byte max); ++ static Byte Create(TOther value); ++ static Byte CreateSaturating(TOther value); ++ static Byte CreateTruncating(TOther value); ++ static (byte Quotient, byte Remainder) DivRem(Byte left, Byte right); ++ static bool IsPow2(Byte value); ++ static Byte LeadingZeroCount(Byte value); ++ static Byte Log2(Byte value); ++ static Byte Max(Byte x, Byte y); ++ static Byte Min(Byte x, Byte y); +- public static Byte Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Byte Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Byte Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Byte Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Byte Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Byte Parse(string s, IFormatProvider? provider); ++ static Byte Parse(string s, IFormatProvider? provider); ++ static Byte PopCount(Byte value); ++ static Byte RotateLeft(Byte value, int rotateAmount); ++ static Byte RotateRight(Byte value, int rotateAmount); ++ static Byte Sign(Byte value); ++ static Byte System.IAdditionOperators.op_Addition(Byte left, Byte right); ++ static Byte System.IBitwiseOperators.op_BitwiseAnd(Byte left, Byte right); ++ static Byte System.IBitwiseOperators.op_BitwiseOr(Byte left, Byte right); ++ static Byte System.IBitwiseOperators.op_ExclusiveOr(Byte left, Byte right); ++ static Byte System.IBitwiseOperators.op_OnesComplement(Byte value); ++ static bool System.IComparisonOperators.op_GreaterThan(Byte left, Byte right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(Byte left, Byte right); ++ static bool System.IComparisonOperators.op_LessThan(Byte left, Byte right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(Byte left, Byte right); ++ static Byte System.IDecrementOperators.op_Decrement(Byte value); ++ static Byte System.IDivisionOperators.op_Division(Byte left, Byte right); ++ static bool System.IEqualityOperators.op_Equality(Byte left, Byte right); ++ static bool System.IEqualityOperators.op_Inequality(Byte left, Byte right); ++ static Byte System.IIncrementOperators.op_Increment(Byte value); ++ static Byte System.IModulusOperators.op_Modulus(Byte left, Byte right); ++ static Byte System.IMultiplyOperators.op_Multiply(Byte left, Byte right); ++ static Byte System.IShiftOperators.op_LeftShift(Byte value, int shiftAmount); ++ static Byte System.IShiftOperators.op_RightShift(Byte value, int shiftAmount); ++ static Byte System.ISubtractionOperators.op_Subtraction(Byte left, Byte right); ++ static Byte System.IUnaryNegationOperators.op_UnaryNegation(Byte value); ++ static Byte System.IUnaryPlusOperators.op_UnaryPlus(Byte value); ++ static Byte TrailingZeroCount(Byte value); ++ static bool TryCreate(TOther value, out Byte result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Byte result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Byte result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Byte result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Byte result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Byte result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Byte result); + } +- public readonly struct Char : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Char : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ static char System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static char System.IMinMaxValue.MaxValue { get; } ++ static char System.IMinMaxValue.MinValue { get; } ++ static char System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static char System.INumber.One { get; } ++ static char System.INumber.Zero { get; } ++ static Char Abs(Char value); ++ static Char Clamp(Char value, Char min, Char max); ++ static Char Create(TOther value); ++ static Char CreateSaturating(TOther value); ++ static Char CreateTruncating(TOther value); ++ static (char Quotient, char Remainder) DivRem(Char left, Char right); ++ static bool IsPow2(Char value); ++ static Char LeadingZeroCount(Char value); ++ static Char Log2(Char value); ++ static Char Max(Char x, Char y); ++ static Char Min(Char x, Char y); ++ static Char PopCount(Char value); ++ static Char RotateLeft(Char value, int rotateAmount); ++ static Char RotateRight(Char value, int rotateAmount); ++ static Char Sign(Char value); ++ static Char System.IAdditionOperators.op_Addition(Char left, Char right); ++ static Char System.IBitwiseOperators.op_BitwiseAnd(Char left, Char right); ++ static Char System.IBitwiseOperators.op_BitwiseOr(Char left, Char right); ++ static Char System.IBitwiseOperators.op_ExclusiveOr(Char left, Char right); ++ static Char System.IBitwiseOperators.op_OnesComplement(Char value); ++ static bool System.IComparisonOperators.op_GreaterThan(Char left, Char right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(Char left, Char right); ++ static bool System.IComparisonOperators.op_LessThan(Char left, Char right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(Char left, Char right); ++ static Char System.IDecrementOperators.op_Decrement(Char value); ++ static Char System.IDivisionOperators.op_Division(Char left, Char right); ++ static bool System.IEqualityOperators.op_Equality(Char left, Char right); ++ static bool System.IEqualityOperators.op_Inequality(Char left, Char right); ++ static Char System.IIncrementOperators.op_Increment(Char value); ++ static Char System.IModulusOperators.op_Modulus(Char left, Char right); ++ static Char System.IMultiplyOperators.op_Multiply(Char left, Char right); ++ static Char System.INumber.Parse(ReadOnlySpan s, NumberStyles style, IFormatProvider provider); ++ static Char System.INumber.Parse(string s, NumberStyles style, IFormatProvider provider); ++ static bool System.INumber.TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider provider, out Char result); ++ static bool System.INumber.TryParse(string s, NumberStyles style, IFormatProvider provider, out Char result); ++ static Char System.IParseable.Parse(string s, IFormatProvider provider); ++ static bool System.IParseable.TryParse(string s, IFormatProvider provider, out Char result); ++ static Char System.IShiftOperators.op_LeftShift(Char value, int shiftAmount); ++ static Char System.IShiftOperators.op_RightShift(Char value, int shiftAmount); ++ static Char System.ISpanParseable.Parse(ReadOnlySpan s, IFormatProvider provider); ++ static bool System.ISpanParseable.TryParse(ReadOnlySpan s, IFormatProvider provider, out Char result); ++ static Char System.ISubtractionOperators.op_Subtraction(Char left, Char right); ++ static Char System.IUnaryNegationOperators.op_UnaryNegation(Char value); ++ static Char System.IUnaryPlusOperators.op_UnaryPlus(Char value); ++ static Char TrailingZeroCount(Char value); ++ static bool TryCreate(TOther value, out Char result); + } +- public readonly struct DateOnly : IComparable, IComparable, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct DateOnly : IComparable, IComparable, IComparisonOperators, IEqualityOperators, IEquatable, IFormattable, IMinMaxValue, IParseable, ISpanFormattable, ISpanParseable { +- public static DateOnly MaxValue { get; } ++ static DateOnly MaxValue { get; } +- public static DateOnly MinValue { get; } ++ static DateOnly MinValue { get; } +- public static bool operator ==(DateOnly left, DateOnly right); ++ static bool operator ==(DateOnly left, DateOnly right); +- public static bool operator >(DateOnly left, DateOnly right); ++ static bool operator >(DateOnly left, DateOnly right); +- public static bool operator >=(DateOnly left, DateOnly right); ++ static bool operator >=(DateOnly left, DateOnly right); +- public static bool operator !=(DateOnly left, DateOnly right); ++ static bool operator !=(DateOnly left, DateOnly right); +- public static bool operator <(DateOnly left, DateOnly right); ++ static bool operator <(DateOnly left, DateOnly right); +- public static bool operator <=(DateOnly left, DateOnly right); ++ static bool operator <=(DateOnly left, DateOnly right); ++ static DateOnly Parse(ReadOnlySpan s, IFormatProvider? provider); ++ static DateOnly Parse(string s, IFormatProvider? provider); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out DateOnly result); ++ static bool TryParse(string? s, IFormatProvider? provider, out DateOnly result); + } +- public readonly struct DateTime : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISerializable, ISpanFormattable { ++ public readonly struct DateTime : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IConvertible, IEqualityOperators, IEquatable, IFormattable, IMinMaxValue, IParseable, ISerializable, ISpanFormattable, ISpanParseable, ISubtractionOperators, ISubtractionOperators { ++ static TimeSpan AdditiveIdentity { get; } ++ static DateTime System.IMinMaxValue.MaxValue { get; } ++ static DateTime System.IMinMaxValue.MinValue { get; } +- public static DateTime operator +(DateTime d, TimeSpan t); ++ static DateTime operator +(DateTime d, TimeSpan t); +- public static bool operator ==(DateTime d1, DateTime d2); ++ static bool operator ==(DateTime d1, DateTime d2); +- public static bool operator >(DateTime t1, DateTime t2); ++ static bool operator >(DateTime t1, DateTime t2); +- public static bool operator >=(DateTime t1, DateTime t2); ++ static bool operator >=(DateTime t1, DateTime t2); +- public static bool operator !=(DateTime d1, DateTime d2); ++ static bool operator !=(DateTime d1, DateTime d2); +- public static bool operator <(DateTime t1, DateTime t2); ++ static bool operator <(DateTime t1, DateTime t2); +- public static bool operator <=(DateTime t1, DateTime t2); ++ static bool operator <=(DateTime t1, DateTime t2); +- public static TimeSpan operator -(DateTime d1, DateTime d2); ++ static TimeSpan operator -(DateTime d1, DateTime d2); +- public static DateTime operator -(DateTime d, TimeSpan t); ++ static DateTime operator -(DateTime d, TimeSpan t); ++ static DateTime Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static DateTime Parse(string s, IFormatProvider? provider); ++ static DateTime Parse(string s, IFormatProvider? provider); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out DateTime result); ++ static bool TryParse(string? s, IFormatProvider? provider, out DateTime result); + } +- public readonly struct DateTimeOffset : IComparable, IComparable, IDeserializationCallback, IEquatable, IFormattable, ISerializable, ISpanFormattable { ++ public readonly struct DateTimeOffset : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDeserializationCallback, IEqualityOperators, IEquatable, IFormattable, IMinMaxValue, IParseable, ISerializable, ISpanFormattable, ISpanParseable, ISubtractionOperators, ISubtractionOperators { ++ static TimeSpan AdditiveIdentity { get; } ++ static DateTimeOffset System.IMinMaxValue.MaxValue { get; } ++ static DateTimeOffset System.IMinMaxValue.MinValue { get; } +- public static DateTimeOffset operator +(DateTimeOffset dateTimeOffset, TimeSpan timeSpan); ++ static DateTimeOffset operator +(DateTimeOffset dateTimeOffset, TimeSpan timeSpan); +- public static bool operator ==(DateTimeOffset left, DateTimeOffset right); ++ static bool operator ==(DateTimeOffset left, DateTimeOffset right); +- public static bool operator >(DateTimeOffset left, DateTimeOffset right); ++ static bool operator >(DateTimeOffset left, DateTimeOffset right); +- public static bool operator >=(DateTimeOffset left, DateTimeOffset right); ++ static bool operator >=(DateTimeOffset left, DateTimeOffset right); +- public static bool operator !=(DateTimeOffset left, DateTimeOffset right); ++ static bool operator !=(DateTimeOffset left, DateTimeOffset right); +- public static bool operator <(DateTimeOffset left, DateTimeOffset right); ++ static bool operator <(DateTimeOffset left, DateTimeOffset right); +- public static bool operator <=(DateTimeOffset left, DateTimeOffset right); ++ static bool operator <=(DateTimeOffset left, DateTimeOffset right); +- public static TimeSpan operator -(DateTimeOffset left, DateTimeOffset right); ++ static TimeSpan operator -(DateTimeOffset left, DateTimeOffset right); +- public static DateTimeOffset operator -(DateTimeOffset dateTimeOffset, TimeSpan timeSpan); ++ static DateTimeOffset operator -(DateTimeOffset dateTimeOffset, TimeSpan timeSpan); ++ static DateTimeOffset Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static DateTimeOffset Parse(string input, IFormatProvider? formatProvider); ++ static DateTimeOffset Parse(string input, IFormatProvider? formatProvider); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out DateTimeOffset result); ++ static bool TryParse(string? s, IFormatProvider? provider, out DateTimeOffset result); + } +- public readonly struct Decimal : IComparable, IComparable, IConvertible, IDeserializationCallback, IEquatable, IFormattable, ISerializable, ISpanFormattable { ++ public readonly struct Decimal : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDeserializationCallback, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISerializable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public static readonly decimal AdditiveIdentity; ++ public static readonly decimal MultiplicativeIdentity; ++ public static readonly decimal NegativeOne; ++ public byte Scale { get; } ++ static decimal System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static decimal System.IMinMaxValue.MaxValue { get; } ++ static decimal System.IMinMaxValue.MinValue { get; } ++ static decimal System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static decimal System.INumber.One { get; } ++ static decimal System.INumber.Zero { get; } ++ static decimal System.ISignedNumber.NegativeOne { get; } ++ static Decimal Abs(Decimal value); ++ static Decimal Clamp(Decimal value, Decimal min, Decimal max); ++ static Decimal Create(TOther value); ++ static Decimal CreateSaturating(TOther value); ++ static Decimal CreateTruncating(TOther value); ++ static (decimal Quotient, decimal Remainder) DivRem(Decimal left, Decimal right); ++ static Decimal Max(Decimal x, Decimal y); ++ static Decimal Min(Decimal x, Decimal y); +- public static Decimal operator +(Decimal d1, Decimal d2); ++ static Decimal operator +(Decimal d1, Decimal d2); +- public static Decimal operator --(Decimal d); ++ static Decimal operator --(Decimal d); +- public static Decimal operator /(Decimal d1, Decimal d2); ++ static Decimal operator /(Decimal d1, Decimal d2); +- public static bool operator ==(Decimal d1, Decimal d2); ++ static bool operator ==(Decimal d1, Decimal d2); +- public static bool operator >(Decimal d1, Decimal d2); ++ static bool operator >(Decimal d1, Decimal d2); +- public static bool operator >=(Decimal d1, Decimal d2); ++ static bool operator >=(Decimal d1, Decimal d2); +- public static Decimal operator ++(Decimal d); ++ static Decimal operator ++(Decimal d); +- public static bool operator !=(Decimal d1, Decimal d2); ++ static bool operator !=(Decimal d1, Decimal d2); +- public static bool operator <(Decimal d1, Decimal d2); ++ static bool operator <(Decimal d1, Decimal d2); +- public static bool operator <=(Decimal d1, Decimal d2); ++ static bool operator <=(Decimal d1, Decimal d2); +- public static Decimal operator %(Decimal d1, Decimal d2); ++ static Decimal operator %(Decimal d1, Decimal d2); +- public static Decimal operator *(Decimal d1, Decimal d2); ++ static Decimal operator *(Decimal d1, Decimal d2); +- public static Decimal operator -(Decimal d1, Decimal d2); ++ static Decimal operator -(Decimal d1, Decimal d2); +- public static Decimal operator -(Decimal d); ++ static Decimal operator -(Decimal d); +- public static Decimal operator +(Decimal d); ++ static Decimal operator +(Decimal d); +- public static Decimal Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Number, IFormatProvider? provider = null); ++ static Decimal Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Number, IFormatProvider? provider = null); ++ static Decimal Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Decimal Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Decimal Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Decimal Parse(string s, IFormatProvider? provider); ++ static Decimal Parse(string s, IFormatProvider? provider); ++ static Decimal System.INumber.Sign(Decimal value); ++ static bool TryCreate(TOther value, out Decimal result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Decimal result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Decimal result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Decimal result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Decimal result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Decimal result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Decimal result); + } +- public readonly struct Double : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Double : IAdditionOperators, IAdditiveIdentity, IBinaryFloatingPoint, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFloatingPoint, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const double AdditiveIdentity = 0; ++ public const double E = 2.718281828459045; ++ public const double MultiplicativeIdentity = 1; ++ public const double NegativeOne = -1; ++ public const double NegativeZero = 0; ++ public const double One = 1; ++ public const double Pi = 3.141592653589793; ++ public const double Tau = 6.283185307179586; ++ public const double Zero = 0; ++ static double System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static double System.IFloatingPoint.E { get; } ++ static double System.IFloatingPoint.Epsilon { get; } ++ static double System.IFloatingPoint.NaN { get; } ++ static double System.IFloatingPoint.NegativeInfinity { get; } ++ static double System.IFloatingPoint.NegativeZero { get; } ++ static double System.IFloatingPoint.Pi { get; } ++ static double System.IFloatingPoint.PositiveInfinity { get; } ++ static double System.IFloatingPoint.Tau { get; } ++ static double System.IMinMaxValue.MaxValue { get; } ++ static double System.IMinMaxValue.MinValue { get; } ++ static double System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static double System.INumber.One { get; } ++ static double System.INumber.Zero { get; } ++ static double System.ISignedNumber.NegativeOne { get; } ++ static Double Abs(Double value); ++ static Double Acos(Double x); ++ static Double Acosh(Double x); ++ static Double Asin(Double x); ++ static Double Asinh(Double x); ++ static Double Atan(Double x); ++ static Double Atan2(Double y, Double x); ++ static Double Atanh(Double x); ++ static Double BitDecrement(Double x); ++ static Double BitIncrement(Double x); ++ static Double Cbrt(Double x); ++ static Double Ceiling(Double x); ++ static Double Clamp(Double value, Double min, Double max); ++ static Double CopySign(Double x, Double y); ++ static Double Cos(Double x); ++ static Double Cosh(Double x); ++ static Double Create(TOther value); ++ static Double CreateSaturating(TOther value); ++ static Double CreateTruncating(TOther value); ++ static (double Quotient, double Remainder) DivRem(Double left, Double right); ++ static Double Exp(Double x); ++ static Double Floor(Double x); ++ static Double FusedMultiplyAdd(Double left, Double right, Double addend); ++ static Double IEEERemainder(Double left, Double right); ++ static TInteger ILogB(Double x); +- public static bool IsFinite(Double d); ++ static bool IsFinite(Double d); +- public static bool IsInfinity(Double d); ++ static bool IsInfinity(Double d); +- public static bool IsNaN(Double d); ++ static bool IsNaN(Double d); +- public static bool IsNegative(Double d); ++ static bool IsNegative(Double d); +- public static bool IsNegativeInfinity(Double d); ++ static bool IsNegativeInfinity(Double d); +- public static bool IsNormal(Double d); ++ static bool IsNormal(Double d); +- public static bool IsPositiveInfinity(Double d); ++ static bool IsPositiveInfinity(Double d); ++ static bool IsPow2(Double value); +- public static bool IsSubnormal(Double d); ++ static bool IsSubnormal(Double d); ++ static Double Log(Double x); ++ static Double Log(Double x, Double newBase); ++ static Double Log10(Double x); ++ static Double Log2(Double value); ++ static Double Max(Double x, Double y); ++ static Double MaxMagnitude(Double x, Double y); ++ static Double Min(Double x, Double y); ++ static Double MinMagnitude(Double x, Double y); +- public static bool operator ==(Double left, Double right); ++ static bool operator ==(Double left, Double right); +- public static bool operator >(Double left, Double right); ++ static bool operator >(Double left, Double right); +- public static bool operator >=(Double left, Double right); ++ static bool operator >=(Double left, Double right); +- public static bool operator !=(Double left, Double right); ++ static bool operator !=(Double left, Double right); +- public static bool operator <(Double left, Double right); ++ static bool operator <(Double left, Double right); +- public static bool operator <=(Double left, Double right); ++ static bool operator <=(Double left, Double right); +- public static Double Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Double Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Double Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Double Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Double Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Double Parse(string s, IFormatProvider? provider); ++ static Double Parse(string s, IFormatProvider? provider); ++ static Double Pow(Double x, Double y); ++ static Double Round(Double x); ++ static Double Round(Double x, MidpointRounding mode); ++ static Double Round(Double x, TInteger digits); ++ static Double Round(Double x, TInteger digits, MidpointRounding mode); ++ static Double ScaleB(Double x, TInteger n); ++ static Double Sign(Double value); ++ static Double Sin(Double x); ++ static Double Sinh(Double x); ++ static Double Sqrt(Double x); ++ static Double System.IAdditionOperators.op_Addition(Double left, Double right); ++ static Double System.IBitwiseOperators.op_BitwiseAnd(Double left, Double right); ++ static Double System.IBitwiseOperators.op_BitwiseOr(Double left, Double right); ++ static Double System.IBitwiseOperators.op_ExclusiveOr(Double left, Double right); ++ static Double System.IBitwiseOperators.op_OnesComplement(Double value); ++ static Double System.IDecrementOperators.op_Decrement(Double value); ++ static Double System.IDivisionOperators.op_Division(Double left, Double right); ++ static Double System.IIncrementOperators.op_Increment(Double value); ++ static Double System.IModulusOperators.op_Modulus(Double left, Double right); ++ static Double System.IMultiplyOperators.op_Multiply(Double left, Double right); ++ static Double System.ISubtractionOperators.op_Subtraction(Double left, Double right); ++ static Double System.IUnaryNegationOperators.op_UnaryNegation(Double value); ++ static Double System.IUnaryPlusOperators.op_UnaryPlus(Double value); ++ static Double Tan(Double x); ++ static Double Tanh(Double x); ++ static Double Truncate(Double x); ++ static bool TryCreate(TOther value, out Double result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Double result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Double result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Double result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Double result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Double result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Double result); + } +- public readonly struct Guid : IComparable, IComparable, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Guid : IComparable, IComparable, IComparisonOperators, IEqualityOperators, IEquatable, IFormattable, IParseable, ISpanFormattable, ISpanParseable { +- public static bool operator ==(Guid a, Guid b); ++ static bool operator ==(Guid a, Guid b); ++ static bool operator >(Guid left, Guid right); ++ static bool operator >=(Guid left, Guid right); +- public static bool operator !=(Guid a, Guid b); ++ static bool operator !=(Guid a, Guid b); ++ static bool operator <(Guid left, Guid right); ++ static bool operator <=(Guid left, Guid right); ++ static Guid Parse(ReadOnlySpan s, IFormatProvider? provider); ++ static Guid Parse(string s, IFormatProvider? provider); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Guid result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Guid result); + } +- public readonly struct Half : IComparable, IComparable, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Half : IAdditionOperators, IAdditiveIdentity, IBinaryFloatingPoint, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFloatingPoint, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ static Half AdditiveIdentity { get; } ++ static Half E { get; } +- public static Half Epsilon { get; } ++ static Half Epsilon { get; } +- public static Half MaxValue { get; } ++ static Half MaxValue { get; } +- public static Half MinValue { get; } ++ static Half MinValue { get; } ++ static Half MultiplicativeIdentity { get; } +- public static Half NaN { get; } ++ static Half NaN { get; } +- public static Half NegativeInfinity { get; } ++ static Half NegativeInfinity { get; } ++ static Half NegativeOne { get; } ++ static Half NegativeZero { get; } ++ static Half One { get; } ++ static Half Pi { get; } +- public static Half PositiveInfinity { get; } ++ static Half PositiveInfinity { get; } ++ static Half Tau { get; } ++ static Half Zero { get; } ++ static Half Abs(Half value); ++ static Half Acos(Half x); ++ static Half Acosh(Half x); ++ static Half Asin(Half x); ++ static Half Asinh(Half x); ++ static Half Atan(Half x); ++ static Half Atan2(Half y, Half x); ++ static Half Atanh(Half x); ++ static Half BitDecrement(Half x); ++ static Half BitIncrement(Half x); ++ static Half Cbrt(Half x); ++ static Half Ceiling(Half x); ++ static Half Clamp(Half value, Half min, Half max); ++ static Half CopySign(Half x, Half y); ++ static Half Cos(Half x); ++ static Half Cosh(Half x); ++ static Half Create(TOther value); ++ static Half CreateSaturating(TOther value); ++ static Half CreateTruncating(TOther value); ++ static (Half Quotient, Half Remainder) DivRem(Half left, Half right); ++ static Half Exp(Half x); ++ static Half Floor(Half x); ++ static Half FusedMultiplyAdd(Half left, Half right, Half addend); ++ static Half IEEERemainder(Half left, Half right); ++ static TInteger ILogB(Half x); +- public static bool IsFinite(Half value); ++ static bool IsFinite(Half value); +- public static bool IsInfinity(Half value); ++ static bool IsInfinity(Half value); +- public static bool IsNaN(Half value); ++ static bool IsNaN(Half value); +- public static bool IsNegative(Half value); ++ static bool IsNegative(Half value); +- public static bool IsNegativeInfinity(Half value); ++ static bool IsNegativeInfinity(Half value); +- public static bool IsNormal(Half value); ++ static bool IsNormal(Half value); +- public static bool IsPositiveInfinity(Half value); ++ static bool IsPositiveInfinity(Half value); ++ static bool IsPow2(Half value); +- public static bool IsSubnormal(Half value); ++ static bool IsSubnormal(Half value); ++ static Half Log(Half x); ++ static Half Log(Half x, Half newBase); ++ static Half Log10(Half x); ++ static Half Log2(Half value); ++ static Half Max(Half x, Half y); ++ static Half MaxMagnitude(Half x, Half y); ++ static Half Min(Half x, Half y); ++ static Half MinMagnitude(Half x, Half y); ++ static Half operator +(Half left, Half right); ++ static Half operator --(Half value); ++ static Half operator /(Half left, Half right); +- public static bool operator ==(Half left, Half right); ++ static bool operator ==(Half left, Half right); +- public static bool operator >(Half left, Half right); ++ static bool operator >(Half left, Half right); +- public static bool operator >=(Half left, Half right); ++ static bool operator >=(Half left, Half right); ++ static Half operator ++(Half value); +- public static bool operator !=(Half left, Half right); ++ static bool operator !=(Half left, Half right); +- public static bool operator <(Half left, Half right); ++ static bool operator <(Half left, Half right); +- public static bool operator <=(Half left, Half right); ++ static bool operator <=(Half left, Half right); ++ static Half operator %(Half left, Half right); ++ static Half operator *(Half left, Half right); ++ static Half operator -(Half left, Half right); ++ static Half operator -(Half value); ++ static Half operator +(Half value); +- public static Half Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Half Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Half Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Half Parse(string s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Half Parse(string s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); +- public static Half Parse(string s, IFormatProvider? provider); ++ static Half Parse(string s, IFormatProvider? provider); ++ static Half Pow(Half x, Half y); ++ static Half Round(Half x); ++ static Half Round(Half x, MidpointRounding mode); ++ static Half Round(Half x, TInteger digits); ++ static Half Round(Half x, TInteger digits, MidpointRounding mode); ++ static Half ScaleB(Half x, TInteger n); ++ static Half Sign(Half value); ++ static Half Sin(Half x); ++ static Half Sinh(Half x); ++ static Half Sqrt(Half x); ++ static Half System.IBitwiseOperators.op_BitwiseAnd(Half left, Half right); ++ static Half System.IBitwiseOperators.op_BitwiseOr(Half left, Half right); ++ static Half System.IBitwiseOperators.op_ExclusiveOr(Half left, Half right); ++ static Half System.IBitwiseOperators.op_OnesComplement(Half value); ++ static Half Tan(Half x); ++ static Half Tanh(Half x); ++ static Half Truncate(Half x); ++ static bool TryCreate(TOther value, out Half result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Half result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Half result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Half result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Half result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Half result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Half result); + } ++ public interface IAdditionOperators where TSelf : IAdditionOperators { ++ TResult operator +(TSelf left, TOther right); ++ } ++ public interface IAdditiveIdentity where TSelf : IAdditiveIdentity { ++ TResult AdditiveIdentity { get; } ++ } ++ public interface IBinaryFloatingPoint : IAdditionOperators, IAdditiveIdentity, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFloatingPoint, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : IBinaryFloatingPoint ++ public interface IBinaryInteger : IAdditionOperators, IAdditiveIdentity, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : IBinaryInteger { ++ TSelf LeadingZeroCount(TSelf value); ++ TSelf PopCount(TSelf value); ++ TSelf RotateLeft(TSelf value, int rotateAmount); ++ TSelf RotateRight(TSelf value, int rotateAmount); ++ TSelf TrailingZeroCount(TSelf value); ++ } ++ public interface IBinaryNumber : IAdditionOperators, IAdditiveIdentity, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : IBinaryNumber { ++ bool IsPow2(TSelf value); ++ TSelf Log2(TSelf value); ++ } ++ public interface IBitwiseOperators where TSelf : IBitwiseOperators { ++ TResult operator &(TSelf left, TOther right); ++ TResult operator |(TSelf left, TOther right); ++ TResult operator ^(TSelf left, TOther right); ++ TResult operator ~(TSelf value); ++ } ++ public interface IComparisonOperators : IComparable, IComparable, IEqualityOperators, IEquatable where TSelf : IComparisonOperators { ++ bool operator >(TSelf left, TOther right); ++ bool operator >=(TSelf left, TOther right); ++ bool operator <(TSelf left, TOther right); ++ bool operator <=(TSelf left, TOther right); ++ } ++ public interface IDecrementOperators where TSelf : IDecrementOperators { ++ TSelf operator --(TSelf value); ++ } ++ public interface IDivisionOperators where TSelf : IDivisionOperators { ++ TResult operator /(TSelf left, TOther right); ++ } ++ public interface IEqualityOperators : IEquatable where TSelf : IEqualityOperators { ++ bool operator ==(TSelf left, TOther right); ++ bool operator !=(TSelf left, TOther right); ++ } ++ public interface IFloatingPoint : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : IFloatingPoint { ++ TSelf E { get; } ++ TSelf Epsilon { get; } ++ TSelf NaN { get; } ++ TSelf NegativeInfinity { get; } ++ TSelf NegativeZero { get; } ++ TSelf Pi { get; } ++ TSelf PositiveInfinity { get; } ++ TSelf Tau { get; } ++ TSelf Acos(TSelf x); ++ TSelf Acosh(TSelf x); ++ TSelf Asin(TSelf x); ++ TSelf Asinh(TSelf x); ++ TSelf Atan(TSelf x); ++ TSelf Atan2(TSelf y, TSelf x); ++ TSelf Atanh(TSelf x); ++ TSelf BitDecrement(TSelf x); ++ TSelf BitIncrement(TSelf x); ++ TSelf Cbrt(TSelf x); ++ TSelf Ceiling(TSelf x); ++ TSelf CopySign(TSelf x, TSelf y); ++ TSelf Cos(TSelf x); ++ TSelf Cosh(TSelf x); ++ TSelf Exp(TSelf x); ++ TSelf Floor(TSelf x); ++ TSelf FusedMultiplyAdd(TSelf left, TSelf right, TSelf addend); ++ TSelf IEEERemainder(TSelf left, TSelf right); ++ TInteger ILogB(TSelf x); ++ bool IsFinite(TSelf value); ++ bool IsInfinity(TSelf value); ++ bool IsNaN(TSelf value); ++ bool IsNegative(TSelf value); ++ bool IsNegativeInfinity(TSelf value); ++ bool IsNormal(TSelf value); ++ bool IsPositiveInfinity(TSelf value); ++ bool IsSubnormal(TSelf value); ++ TSelf Log(TSelf x); ++ TSelf Log(TSelf x, TSelf newBase); ++ TSelf Log10(TSelf x); ++ TSelf Log2(TSelf x); ++ TSelf MaxMagnitude(TSelf x, TSelf y); ++ TSelf MinMagnitude(TSelf x, TSelf y); ++ TSelf Pow(TSelf x, TSelf y); ++ TSelf Round(TSelf x); ++ TSelf Round(TSelf x, MidpointRounding mode); ++ TSelf Round(TSelf x, TInteger digits); ++ TSelf Round(TSelf x, TInteger digits, MidpointRounding mode); ++ TSelf ScaleB(TSelf x, TInteger n); ++ TSelf Sin(TSelf x); ++ TSelf Sinh(TSelf x); ++ TSelf Sqrt(TSelf x); ++ TSelf Tan(TSelf x); ++ TSelf Tanh(TSelf x); ++ TSelf Truncate(TSelf x); ++ } ++ public interface IIncrementOperators where TSelf : IIncrementOperators { ++ TSelf operator ++(TSelf value); ++ } ++ public interface IMinMaxValue where TSelf : IMinMaxValue { ++ TSelf MaxValue { get; } ++ TSelf MinValue { get; } ++ } ++ public interface IModulusOperators where TSelf : IModulusOperators { ++ TResult operator %(TSelf left, TOther right); ++ } ++ public interface IMultiplicativeIdentity where TSelf : IMultiplicativeIdentity { ++ TResult MultiplicativeIdentity { get; } ++ } ++ public interface IMultiplyOperators where TSelf : IMultiplyOperators { ++ TResult operator *(TSelf left, TOther right); ++ } +- public readonly struct Int16 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Int16 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const short AdditiveIdentity = (short)0; ++ public const short MultiplicativeIdentity = (short)1; ++ public const short NegativeOne = (short)-1; ++ public const short One = (short)1; ++ public const short Zero = (short)0; ++ static short System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static short System.IMinMaxValue.MaxValue { get; } ++ static short System.IMinMaxValue.MinValue { get; } ++ static short System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static short System.INumber.One { get; } ++ static short System.INumber.Zero { get; } ++ static short System.ISignedNumber.NegativeOne { get; } ++ static Int16 Abs(Int16 value); ++ static Int16 Clamp(Int16 value, Int16 min, Int16 max); ++ static Int16 Create(TOther value); ++ static Int16 CreateSaturating(TOther value); ++ static Int16 CreateTruncating(TOther value); ++ static (short Quotient, short Remainder) DivRem(Int16 left, Int16 right); ++ static bool IsPow2(Int16 value); ++ static Int16 LeadingZeroCount(Int16 value); ++ static Int16 Log2(Int16 value); ++ static Int16 Max(Int16 x, Int16 y); ++ static Int16 Min(Int16 x, Int16 y); +- public static Int16 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int16 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int16 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Int16 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Int16 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Int16 Parse(string s, IFormatProvider? provider); ++ static Int16 Parse(string s, IFormatProvider? provider); ++ static Int16 PopCount(Int16 value); ++ static Int16 RotateLeft(Int16 value, int rotateAmount); ++ static Int16 RotateRight(Int16 value, int rotateAmount); ++ static Int16 Sign(Int16 value); ++ static Int16 System.IAdditionOperators.op_Addition(Int16 left, Int16 right); ++ static Int16 System.IBitwiseOperators.op_BitwiseAnd(Int16 left, Int16 right); ++ static Int16 System.IBitwiseOperators.op_BitwiseOr(Int16 left, Int16 right); ++ static Int16 System.IBitwiseOperators.op_ExclusiveOr(Int16 left, Int16 right); ++ static Int16 System.IBitwiseOperators.op_OnesComplement(Int16 value); ++ static bool System.IComparisonOperators.op_GreaterThan(Int16 left, Int16 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(Int16 left, Int16 right); ++ static bool System.IComparisonOperators.op_LessThan(Int16 left, Int16 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(Int16 left, Int16 right); ++ static Int16 System.IDecrementOperators.op_Decrement(Int16 value); ++ static Int16 System.IDivisionOperators.op_Division(Int16 left, Int16 right); ++ static bool System.IEqualityOperators.op_Equality(Int16 left, Int16 right); ++ static bool System.IEqualityOperators.op_Inequality(Int16 left, Int16 right); ++ static Int16 System.IIncrementOperators.op_Increment(Int16 value); ++ static Int16 System.IModulusOperators.op_Modulus(Int16 left, Int16 right); ++ static Int16 System.IMultiplyOperators.op_Multiply(Int16 left, Int16 right); ++ static Int16 System.IShiftOperators.op_LeftShift(Int16 value, int shiftAmount); ++ static Int16 System.IShiftOperators.op_RightShift(Int16 value, int shiftAmount); ++ static Int16 System.ISubtractionOperators.op_Subtraction(Int16 left, Int16 right); ++ static Int16 System.IUnaryNegationOperators.op_UnaryNegation(Int16 value); ++ static Int16 System.IUnaryPlusOperators.op_UnaryPlus(Int16 value); ++ static Int16 TrailingZeroCount(Int16 value); ++ static bool TryCreate(TOther value, out Int16 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int16 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int16 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Int16 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int16 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int16 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Int16 result); + } +- public readonly struct Int32 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Int32 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const int AdditiveIdentity = 0; ++ public const int MultiplicativeIdentity = 1; ++ public const int NegativeOne = -1; ++ public const int One = 1; ++ public const int Zero = 0; ++ static int System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static int System.IMinMaxValue.MaxValue { get; } ++ static int System.IMinMaxValue.MinValue { get; } ++ static int System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static int System.INumber.One { get; } ++ static int System.INumber.Zero { get; } ++ static int System.ISignedNumber.NegativeOne { get; } ++ static Int32 Abs(Int32 value); ++ static Int32 Clamp(Int32 value, Int32 min, Int32 max); ++ static Int32 Create(TOther value); ++ static Int32 CreateSaturating(TOther value); ++ static Int32 CreateTruncating(TOther value); ++ static (int Quotient, int Remainder) DivRem(Int32 left, Int32 right); ++ static bool IsPow2(Int32 value); ++ static Int32 LeadingZeroCount(Int32 value); ++ static Int32 Log2(Int32 value); ++ static Int32 Max(Int32 x, Int32 y); ++ static Int32 Min(Int32 x, Int32 y); +- public static Int32 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int32 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int32 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Int32 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Int32 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Int32 Parse(string s, IFormatProvider? provider); ++ static Int32 Parse(string s, IFormatProvider? provider); ++ static Int32 PopCount(Int32 value); ++ static Int32 RotateLeft(Int32 value, Int32 rotateAmount); ++ static Int32 RotateRight(Int32 value, Int32 rotateAmount); ++ static Int32 Sign(Int32 value); ++ static Int32 System.IAdditionOperators.op_Addition(Int32 left, Int32 right); ++ static Int32 System.IBitwiseOperators.op_BitwiseAnd(Int32 left, Int32 right); ++ static Int32 System.IBitwiseOperators.op_BitwiseOr(Int32 left, Int32 right); ++ static Int32 System.IBitwiseOperators.op_ExclusiveOr(Int32 left, Int32 right); ++ static Int32 System.IBitwiseOperators.op_OnesComplement(Int32 value); ++ static bool System.IComparisonOperators.op_GreaterThan(Int32 left, Int32 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(Int32 left, Int32 right); ++ static bool System.IComparisonOperators.op_LessThan(Int32 left, Int32 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(Int32 left, Int32 right); ++ static Int32 System.IDecrementOperators.op_Decrement(Int32 value); ++ static Int32 System.IDivisionOperators.op_Division(Int32 left, Int32 right); ++ static bool System.IEqualityOperators.op_Equality(Int32 left, Int32 right); ++ static bool System.IEqualityOperators.op_Inequality(Int32 left, Int32 right); ++ static Int32 System.IIncrementOperators.op_Increment(Int32 value); ++ static Int32 System.IModulusOperators.op_Modulus(Int32 left, Int32 right); ++ static Int32 System.IMultiplyOperators.op_Multiply(Int32 left, Int32 right); ++ static Int32 System.IShiftOperators.op_LeftShift(Int32 value, Int32 shiftAmount); ++ static Int32 System.IShiftOperators.op_RightShift(Int32 value, Int32 shiftAmount); ++ static Int32 System.ISubtractionOperators.op_Subtraction(Int32 left, Int32 right); ++ static Int32 System.IUnaryNegationOperators.op_UnaryNegation(Int32 value); ++ static Int32 System.IUnaryPlusOperators.op_UnaryPlus(Int32 value); ++ static Int32 TrailingZeroCount(Int32 value); ++ static bool TryCreate(TOther value, out Int32 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int32 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int32 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Int32 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int32 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int32 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Int32 result); + } +- public readonly struct Int64 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Int64 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const long AdditiveIdentity = (long)0; ++ public const long MultiplicativeIdentity = (long)1; ++ public const long NegativeOne = (long)-1; ++ public const long One = (long)1; ++ public const long Zero = (long)0; ++ static long System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static long System.IMinMaxValue.MaxValue { get; } ++ static long System.IMinMaxValue.MinValue { get; } ++ static long System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static long System.INumber.One { get; } ++ static long System.INumber.Zero { get; } ++ static long System.ISignedNumber.NegativeOne { get; } ++ static Int64 Abs(Int64 value); ++ static Int64 Clamp(Int64 value, Int64 min, Int64 max); ++ static Int64 Create(TOther value); ++ static Int64 CreateSaturating(TOther value); ++ static Int64 CreateTruncating(TOther value); ++ static (long Quotient, long Remainder) DivRem(Int64 left, Int64 right); ++ static bool IsPow2(Int64 value); ++ static Int64 LeadingZeroCount(Int64 value); ++ static Int64 Log2(Int64 value); ++ static Int64 Max(Int64 x, Int64 y); ++ static Int64 Min(Int64 x, Int64 y); +- public static Int64 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int64 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static Int64 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Int64 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Int64 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Int64 Parse(string s, IFormatProvider? provider); ++ static Int64 Parse(string s, IFormatProvider? provider); ++ static Int64 PopCount(Int64 value); ++ static Int64 RotateLeft(Int64 value, int rotateAmount); ++ static Int64 RotateRight(Int64 value, int rotateAmount); ++ static Int64 Sign(Int64 value); ++ static Int64 System.IAdditionOperators.op_Addition(Int64 left, Int64 right); ++ static Int64 System.IBitwiseOperators.op_BitwiseAnd(Int64 left, Int64 right); ++ static Int64 System.IBitwiseOperators.op_BitwiseOr(Int64 left, Int64 right); ++ static Int64 System.IBitwiseOperators.op_ExclusiveOr(Int64 left, Int64 right); ++ static Int64 System.IBitwiseOperators.op_OnesComplement(Int64 value); ++ static bool System.IComparisonOperators.op_GreaterThan(Int64 left, Int64 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(Int64 left, Int64 right); ++ static bool System.IComparisonOperators.op_LessThan(Int64 left, Int64 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(Int64 left, Int64 right); ++ static Int64 System.IDecrementOperators.op_Decrement(Int64 value); ++ static Int64 System.IDivisionOperators.op_Division(Int64 left, Int64 right); ++ static bool System.IEqualityOperators.op_Equality(Int64 left, Int64 right); ++ static bool System.IEqualityOperators.op_Inequality(Int64 left, Int64 right); ++ static Int64 System.IIncrementOperators.op_Increment(Int64 value); ++ static Int64 System.IModulusOperators.op_Modulus(Int64 left, Int64 right); ++ static Int64 System.IMultiplyOperators.op_Multiply(Int64 left, Int64 right); ++ static Int64 System.IShiftOperators.op_LeftShift(Int64 value, int shiftAmount); ++ static Int64 System.IShiftOperators.op_RightShift(Int64 value, int shiftAmount); ++ static Int64 System.ISubtractionOperators.op_Subtraction(Int64 left, Int64 right); ++ static Int64 System.IUnaryNegationOperators.op_UnaryNegation(Int64 value); ++ static Int64 System.IUnaryPlusOperators.op_UnaryPlus(Int64 value); ++ static Int64 TrailingZeroCount(Int64 value); ++ static bool TryCreate(TOther value, out Int64 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int64 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Int64 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Int64 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int64 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int64 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Int64 result); + } +- public readonly struct IntPtr : IComparable, IComparable, IEquatable, IFormattable, ISerializable, ISpanFormattable { ++ public readonly struct IntPtr : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISerializable, IShiftOperators, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ static IntPtr System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static IntPtr System.IMinMaxValue.MaxValue { get; } ++ static IntPtr System.IMinMaxValue.MinValue { get; } ++ static IntPtr System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static IntPtr System.INumber.One { get; } ++ static IntPtr System.INumber.Zero { get; } ++ static IntPtr System.ISignedNumber.NegativeOne { get; } +- public static bool operator ==(IntPtr value1, IntPtr value2); ++ static bool operator ==(IntPtr value1, IntPtr value2); +- public static bool operator !=(IntPtr value1, IntPtr value2); ++ static bool operator !=(IntPtr value1, IntPtr value2); +- public static IntPtr Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static IntPtr Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static IntPtr Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static IntPtr Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static IntPtr Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static IntPtr Parse(string s, IFormatProvider? provider); ++ static IntPtr Parse(string s, IFormatProvider? provider); ++ static IntPtr System.IAdditionOperators.op_Addition(IntPtr left, IntPtr right); ++ static IntPtr System.IBinaryInteger.LeadingZeroCount(IntPtr value); ++ static IntPtr System.IBinaryInteger.PopCount(IntPtr value); ++ static IntPtr System.IBinaryInteger.RotateLeft(IntPtr value, int rotateAmount); ++ static IntPtr System.IBinaryInteger.RotateRight(IntPtr value, int rotateAmount); ++ static IntPtr System.IBinaryInteger.TrailingZeroCount(IntPtr value); ++ static bool System.IBinaryNumber.IsPow2(IntPtr value); ++ static IntPtr System.IBinaryNumber.Log2(IntPtr value); ++ static IntPtr System.IBitwiseOperators.op_BitwiseAnd(IntPtr left, IntPtr right); ++ static IntPtr System.IBitwiseOperators.op_BitwiseOr(IntPtr left, IntPtr right); ++ static IntPtr System.IBitwiseOperators.op_ExclusiveOr(IntPtr left, IntPtr right); ++ static IntPtr System.IBitwiseOperators.op_OnesComplement(IntPtr value); ++ static bool System.IComparisonOperators.op_GreaterThan(IntPtr left, IntPtr right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(IntPtr left, IntPtr right); ++ static bool System.IComparisonOperators.op_LessThan(IntPtr left, IntPtr right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(IntPtr left, IntPtr right); ++ static IntPtr System.IDecrementOperators.op_Decrement(IntPtr value); ++ static IntPtr System.IDivisionOperators.op_Division(IntPtr left, IntPtr right); ++ static IntPtr System.IIncrementOperators.op_Increment(IntPtr value); ++ static IntPtr System.IModulusOperators.op_Modulus(IntPtr left, IntPtr right); ++ static IntPtr System.IMultiplyOperators.op_Multiply(IntPtr left, IntPtr right); ++ static IntPtr System.INumber.Abs(IntPtr value); ++ static IntPtr System.INumber.Clamp(IntPtr value, IntPtr min, IntPtr max); ++ static IntPtr System.INumber.Create(TOther value); ++ static IntPtr System.INumber.CreateSaturating(TOther value); ++ static IntPtr System.INumber.CreateTruncating(TOther value); ++ static (IntPtr Quotient, IntPtr Remainder) System.INumber.DivRem(IntPtr left, IntPtr right); ++ static IntPtr System.INumber.Max(IntPtr x, IntPtr y); ++ static IntPtr System.INumber.Min(IntPtr x, IntPtr y); ++ static IntPtr System.INumber.Sign(IntPtr value); ++ static bool System.INumber.TryCreate(TOther value, out IntPtr result); ++ static IntPtr System.IShiftOperators.op_LeftShift(IntPtr value, int shiftAmount); ++ static IntPtr System.IShiftOperators.op_RightShift(IntPtr value, int shiftAmount); ++ static IntPtr System.ISubtractionOperators.op_Subtraction(IntPtr left, IntPtr right); ++ static IntPtr System.IUnaryNegationOperators.op_UnaryNegation(IntPtr value); ++ static IntPtr System.IUnaryPlusOperators.op_UnaryPlus(IntPtr value); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out IntPtr result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out IntPtr result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out IntPtr result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out IntPtr result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out IntPtr result); ++ static bool TryParse(string? s, IFormatProvider? provider, out IntPtr result); + } ++ public interface INumber : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : INumber { ++ TSelf One { get; } ++ TSelf Zero { get; } ++ TSelf Abs(TSelf value); ++ TSelf Clamp(TSelf value, TSelf min, TSelf max); ++ TSelf Create(TOther value); ++ TSelf CreateSaturating(TOther value); ++ TSelf CreateTruncating(TOther value); ++ (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right); ++ TSelf Max(TSelf x, TSelf y); ++ TSelf Min(TSelf x, TSelf y); ++ TSelf Parse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider); ++ TSelf Parse(string s, NumberStyles style, IFormatProvider? provider); ++ TSelf Sign(TSelf value); ++ bool TryCreate(TOther value, out TSelf result); ++ bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out TSelf result); ++ bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result); ++ } ++ public interface IParseable where TSelf : IParseable { ++ TSelf Parse(string s, IFormatProvider? provider); ++ bool TryParse(string? s, IFormatProvider? provider, out TSelf result); ++ } ++ public interface IShiftOperators where TSelf : IShiftOperators { ++ TResult operator <<(TSelf value, int shiftAmount); ++ TResult operator >>(TSelf value, int shiftAmount); ++ } ++ public interface ISignedNumber : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : ISignedNumber { ++ TSelf NegativeOne { get; } ++ } ++ public interface ISpanParseable : IParseable where TSelf : ISpanParseable { ++ TSelf Parse(ReadOnlySpan s, IFormatProvider? provider); ++ bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out TSelf result); ++ } ++ public interface ISubtractionOperators where TSelf : ISubtractionOperators { ++ TResult operator -(TSelf left, TOther right); ++ } ++ public interface IUnaryNegationOperators where TSelf : IUnaryNegationOperators { ++ TResult operator -(TSelf value); ++ } ++ public interface IUnaryPlusOperators where TSelf : IUnaryPlusOperators { ++ TResult operator +(TSelf value); ++ } ++ public interface IUnsignedNumber : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators where TSelf : IUnsignedNumber + public static class Nullable { ++ public static ref readonly T GetValueRefOrDefaultRef(in T? nullable) where T : struct; + } +- public readonly struct SByte : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct SByte : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const sbyte AdditiveIdentity = (sbyte)0; ++ public const sbyte MultiplicativeIdentity = (sbyte)1; ++ public const sbyte NegativeOne = (sbyte)-1; ++ public const sbyte One = (sbyte)1; ++ public const sbyte Zero = (sbyte)0; ++ static sbyte System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static sbyte System.IMinMaxValue.MaxValue { get; } ++ static sbyte System.IMinMaxValue.MinValue { get; } ++ static sbyte System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static sbyte System.INumber.One { get; } ++ static sbyte System.INumber.Zero { get; } ++ static sbyte System.ISignedNumber.NegativeOne { get; } ++ static SByte Abs(SByte value); ++ static SByte Clamp(SByte value, SByte min, SByte max); ++ static SByte Create(TOther value); ++ static SByte CreateSaturating(TOther value); ++ static SByte CreateTruncating(TOther value); ++ static (sbyte Quotient, sbyte Remainder) DivRem(SByte left, SByte right); ++ static bool IsPow2(SByte value); ++ static SByte LeadingZeroCount(SByte value); ++ static SByte Log2(SByte value); ++ static SByte Max(SByte x, SByte y); ++ static SByte Min(SByte x, SByte y); +- public static SByte Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static SByte Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static SByte Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static SByte Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static SByte Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static SByte Parse(string s, IFormatProvider? provider); ++ static SByte Parse(string s, IFormatProvider? provider); ++ static SByte PopCount(SByte value); ++ static SByte RotateLeft(SByte value, int rotateAmount); ++ static SByte RotateRight(SByte value, int rotateAmount); ++ static SByte Sign(SByte value); ++ static SByte System.IAdditionOperators.op_Addition(SByte left, SByte right); ++ static SByte System.IBitwiseOperators.op_BitwiseAnd(SByte left, SByte right); ++ static SByte System.IBitwiseOperators.op_BitwiseOr(SByte left, SByte right); ++ static SByte System.IBitwiseOperators.op_ExclusiveOr(SByte left, SByte right); ++ static SByte System.IBitwiseOperators.op_OnesComplement(SByte value); ++ static bool System.IComparisonOperators.op_GreaterThan(SByte left, SByte right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(SByte left, SByte right); ++ static bool System.IComparisonOperators.op_LessThan(SByte left, SByte right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(SByte left, SByte right); ++ static SByte System.IDecrementOperators.op_Decrement(SByte value); ++ static SByte System.IDivisionOperators.op_Division(SByte left, SByte right); ++ static bool System.IEqualityOperators.op_Equality(SByte left, SByte right); ++ static bool System.IEqualityOperators.op_Inequality(SByte left, SByte right); ++ static SByte System.IIncrementOperators.op_Increment(SByte value); ++ static SByte System.IModulusOperators.op_Modulus(SByte left, SByte right); ++ static SByte System.IMultiplyOperators.op_Multiply(SByte left, SByte right); ++ static SByte System.IShiftOperators.op_LeftShift(SByte value, int shiftAmount); ++ static SByte System.IShiftOperators.op_RightShift(SByte value, int shiftAmount); ++ static SByte System.ISubtractionOperators.op_Subtraction(SByte left, SByte right); ++ static SByte System.IUnaryNegationOperators.op_UnaryNegation(SByte value); ++ static SByte System.IUnaryPlusOperators.op_UnaryPlus(SByte value); ++ static SByte TrailingZeroCount(SByte value); ++ static bool TryCreate(TOther value, out SByte result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out SByte result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out SByte result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out SByte result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out SByte result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out SByte result); ++ static bool TryParse(string? s, IFormatProvider? provider, out SByte result); + } +- public readonly struct Single : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct Single : IAdditionOperators, IAdditiveIdentity, IBinaryFloatingPoint, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFloatingPoint, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISignedNumber, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ public const float AdditiveIdentity = 0f; ++ public const float E = 2.7182817f; ++ public const float MultiplicativeIdentity = 1f; ++ public const float NegativeOne = -1f; ++ public const float NegativeZero = -0f; ++ public const float One = 1f; ++ public const float Pi = 3.1415927f; ++ public const float Tau = 6.2831855f; ++ public const float Zero = 0f; ++ static float System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static float System.IFloatingPoint.E { get; } ++ static float System.IFloatingPoint.Epsilon { get; } ++ static float System.IFloatingPoint.NaN { get; } ++ static float System.IFloatingPoint.NegativeInfinity { get; } ++ static float System.IFloatingPoint.NegativeZero { get; } ++ static float System.IFloatingPoint.Pi { get; } ++ static float System.IFloatingPoint.PositiveInfinity { get; } ++ static float System.IFloatingPoint.Tau { get; } ++ static float System.IMinMaxValue.MaxValue { get; } ++ static float System.IMinMaxValue.MinValue { get; } ++ static float System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static float System.INumber.One { get; } ++ static float System.INumber.Zero { get; } ++ static float System.ISignedNumber.NegativeOne { get; } ++ static Single Abs(Single value); ++ static Single Acos(Single x); ++ static Single Acosh(Single x); ++ static Single Asin(Single x); ++ static Single Asinh(Single x); ++ static Single Atan(Single x); ++ static Single Atan2(Single y, Single x); ++ static Single Atanh(Single x); ++ static Single BitDecrement(Single x); ++ static Single BitIncrement(Single x); ++ static Single Cbrt(Single x); ++ static Single Ceiling(Single x); ++ static Single Clamp(Single value, Single min, Single max); ++ static Single CopySign(Single x, Single y); ++ static Single Cos(Single x); ++ static Single Cosh(Single x); ++ static Single Create(TOther value); ++ static Single CreateSaturating(TOther value); ++ static Single CreateTruncating(TOther value); ++ static (float Quotient, float Remainder) DivRem(Single left, Single right); ++ static Single Exp(Single x); ++ static Single Floor(Single x); ++ static Single FusedMultiplyAdd(Single left, Single right, Single addend); ++ static Single IEEERemainder(Single left, Single right); ++ static TInteger ILogB(Single x); +- public static bool IsFinite(Single f); ++ static bool IsFinite(Single f); +- public static bool IsInfinity(Single f); ++ static bool IsInfinity(Single f); +- public static bool IsNaN(Single f); ++ static bool IsNaN(Single f); +- public static bool IsNegative(Single f); ++ static bool IsNegative(Single f); +- public static bool IsNegativeInfinity(Single f); ++ static bool IsNegativeInfinity(Single f); +- public static bool IsNormal(Single f); ++ static bool IsNormal(Single f); +- public static bool IsPositiveInfinity(Single f); ++ static bool IsPositiveInfinity(Single f); ++ static bool IsPow2(Single value); +- public static bool IsSubnormal(Single f); ++ static bool IsSubnormal(Single f); ++ static Single Log(Single x); ++ static Single Log(Single x, Single newBase); ++ static Single Log10(Single x); ++ static Single Log2(Single value); ++ static Single Max(Single x, Single y); ++ static Single MaxMagnitude(Single x, Single y); ++ static Single Min(Single x, Single y); ++ static Single MinMagnitude(Single x, Single y); +- public static bool operator ==(Single left, Single right); ++ static bool operator ==(Single left, Single right); +- public static bool operator >(Single left, Single right); ++ static bool operator >(Single left, Single right); +- public static bool operator >=(Single left, Single right); ++ static bool operator >=(Single left, Single right); +- public static bool operator !=(Single left, Single right); ++ static bool operator !=(Single left, Single right); +- public static bool operator <(Single left, Single right); ++ static bool operator <(Single left, Single right); +- public static bool operator <=(Single left, Single right); ++ static bool operator <=(Single left, Single right); +- public static Single Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Single Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowThousands | NumberStyles.AllowTrailingWhite, IFormatProvider? provider = null); ++ static Single Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static Single Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static Single Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static Single Parse(string s, IFormatProvider? provider); ++ static Single Parse(string s, IFormatProvider? provider); ++ static Single Pow(Single x, Single y); ++ static Single Round(Single x); ++ static Single Round(Single x, MidpointRounding mode); ++ static Single Round(Single x, TInteger digits); ++ static Single Round(Single x, TInteger digits, MidpointRounding mode); ++ static Single ScaleB(Single x, TInteger n); ++ static Single Sign(Single value); ++ static Single Sin(Single x); ++ static Single Sinh(Single x); ++ static Single Sqrt(Single x); ++ static Single System.IAdditionOperators.op_Addition(Single left, Single right); ++ static Single System.IBitwiseOperators.op_BitwiseAnd(Single left, Single right); ++ static Single System.IBitwiseOperators.op_BitwiseOr(Single left, Single right); ++ static Single System.IBitwiseOperators.op_ExclusiveOr(Single left, Single right); ++ static Single System.IBitwiseOperators.op_OnesComplement(Single value); ++ static Single System.IDecrementOperators.op_Decrement(Single value); ++ static Single System.IDivisionOperators.op_Division(Single left, Single right); ++ static Single System.IIncrementOperators.op_Increment(Single value); ++ static Single System.IModulusOperators.op_Modulus(Single left, Single right); ++ static Single System.IMultiplyOperators.op_Multiply(Single left, Single right); ++ static Single System.ISubtractionOperators.op_Subtraction(Single left, Single right); ++ static Single System.IUnaryNegationOperators.op_UnaryNegation(Single value); ++ static Single System.IUnaryPlusOperators.op_UnaryPlus(Single value); ++ static Single Tan(Single x); ++ static Single Tanh(Single x); ++ static Single Truncate(Single x); ++ static bool TryCreate(TOther value, out Single result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Single result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out Single result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out Single result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Single result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Single result); ++ static bool TryParse(string? s, IFormatProvider? provider, out Single result); + } +- public readonly struct TimeOnly : IComparable, IComparable, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct TimeOnly : IComparable, IComparable, IComparisonOperators, IEqualityOperators, IEquatable, IFormattable, IMinMaxValue, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators { ++ static TimeOnly System.IMinMaxValue.MaxValue { get; } ++ static TimeOnly System.IMinMaxValue.MinValue { get; } +- public static bool operator ==(TimeOnly left, TimeOnly right); ++ static bool operator ==(TimeOnly left, TimeOnly right); +- public static bool operator >(TimeOnly left, TimeOnly right); ++ static bool operator >(TimeOnly left, TimeOnly right); +- public static bool operator >=(TimeOnly left, TimeOnly right); ++ static bool operator >=(TimeOnly left, TimeOnly right); +- public static bool operator !=(TimeOnly left, TimeOnly right); ++ static bool operator !=(TimeOnly left, TimeOnly right); +- public static bool operator <(TimeOnly left, TimeOnly right); ++ static bool operator <(TimeOnly left, TimeOnly right); +- public static bool operator <=(TimeOnly left, TimeOnly right); ++ static bool operator <=(TimeOnly left, TimeOnly right); +- public static TimeSpan operator -(TimeOnly t1, TimeOnly t2); ++ static TimeSpan operator -(TimeOnly t1, TimeOnly t2); ++ static TimeOnly Parse(ReadOnlySpan s, IFormatProvider? provider); ++ static TimeOnly Parse(string s, IFormatProvider? provider); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out TimeOnly result); ++ static bool TryParse(string? s, IFormatProvider? provider, out TimeOnly result); + } +- public readonly struct TimeSpan : IComparable, IComparable, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct TimeSpan : IAdditionOperators, IAdditiveIdentity, IComparable, IComparable, IComparisonOperators, IDivisionOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IMinMaxValue, IMultiplicativeIdentity, IMultiplyOperators, IParseable, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators { ++ static TimeSpan AdditiveIdentity { get; } ++ static double MultiplicativeIdentity { get; } ++ static TimeSpan System.IMinMaxValue.MaxValue { get; } ++ static TimeSpan System.IMinMaxValue.MinValue { get; } +- public static TimeSpan operator +(TimeSpan t1, TimeSpan t2); ++ static TimeSpan operator +(TimeSpan t1, TimeSpan t2); +- public static TimeSpan operator /(TimeSpan timeSpan, double divisor); ++ static TimeSpan operator /(TimeSpan timeSpan, double divisor); +- public static double operator /(TimeSpan t1, TimeSpan t2); ++ static double operator /(TimeSpan t1, TimeSpan t2); +- public static bool operator ==(TimeSpan t1, TimeSpan t2); ++ static bool operator ==(TimeSpan t1, TimeSpan t2); +- public static bool operator >(TimeSpan t1, TimeSpan t2); ++ static bool operator >(TimeSpan t1, TimeSpan t2); +- public static bool operator >=(TimeSpan t1, TimeSpan t2); ++ static bool operator >=(TimeSpan t1, TimeSpan t2); +- public static bool operator !=(TimeSpan t1, TimeSpan t2); ++ static bool operator !=(TimeSpan t1, TimeSpan t2); +- public static bool operator <(TimeSpan t1, TimeSpan t2); ++ static bool operator <(TimeSpan t1, TimeSpan t2); +- public static bool operator <=(TimeSpan t1, TimeSpan t2); ++ static bool operator <=(TimeSpan t1, TimeSpan t2); +- public static TimeSpan operator *(TimeSpan timeSpan, double factor); ++ static TimeSpan operator *(TimeSpan timeSpan, double factor); +- public static TimeSpan operator -(TimeSpan t1, TimeSpan t2); ++ static TimeSpan operator -(TimeSpan t1, TimeSpan t2); +- public static TimeSpan operator -(TimeSpan t); ++ static TimeSpan operator -(TimeSpan t); +- public static TimeSpan operator +(TimeSpan t); ++ static TimeSpan operator +(TimeSpan t); +- public static TimeSpan Parse(ReadOnlySpan input, IFormatProvider? formatProvider = null); ++ static TimeSpan Parse(ReadOnlySpan input, IFormatProvider? formatProvider = null); +- public static TimeSpan Parse(string input, IFormatProvider? formatProvider); ++ static TimeSpan Parse(string input, IFormatProvider? formatProvider); +- public static bool TryParse(ReadOnlySpan input, IFormatProvider? formatProvider, out TimeSpan result); ++ static bool TryParse(ReadOnlySpan input, IFormatProvider? formatProvider, out TimeSpan result); +- public static bool TryParse(string? input, IFormatProvider? formatProvider, out TimeSpan result); ++ static bool TryParse(string? input, IFormatProvider? formatProvider, out TimeSpan result); + } +- public readonly struct UInt16 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct UInt16 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ public const ushort AdditiveIdentity = (ushort)0; ++ public const ushort MultiplicativeIdentity = (ushort)1; ++ public const ushort One = (ushort)1; ++ public const ushort Zero = (ushort)0; ++ static ushort System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static ushort System.IMinMaxValue.MaxValue { get; } ++ static ushort System.IMinMaxValue.MinValue { get; } ++ static ushort System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static ushort System.INumber.One { get; } ++ static ushort System.INumber.Zero { get; } ++ static UInt16 Abs(UInt16 value); ++ static UInt16 Clamp(UInt16 value, UInt16 min, UInt16 max); ++ static UInt16 Create(TOther value); ++ static UInt16 CreateSaturating(TOther value); ++ static UInt16 CreateTruncating(TOther value); ++ static (ushort Quotient, ushort Remainder) DivRem(UInt16 left, UInt16 right); ++ static bool IsPow2(UInt16 value); ++ static UInt16 LeadingZeroCount(UInt16 value); ++ static UInt16 Log2(UInt16 value); ++ static UInt16 Max(UInt16 x, UInt16 y); ++ static UInt16 Min(UInt16 x, UInt16 y); +- public static UInt16 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt16 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt16 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static UInt16 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static UInt16 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static UInt16 Parse(string s, IFormatProvider? provider); ++ static UInt16 Parse(string s, IFormatProvider? provider); ++ static UInt16 PopCount(UInt16 value); ++ static UInt16 RotateLeft(UInt16 value, int rotateAmount); ++ static UInt16 RotateRight(UInt16 value, int rotateAmount); ++ static UInt16 Sign(UInt16 value); ++ static UInt16 System.IAdditionOperators.op_Addition(UInt16 left, UInt16 right); ++ static UInt16 System.IBitwiseOperators.op_BitwiseAnd(UInt16 left, UInt16 right); ++ static UInt16 System.IBitwiseOperators.op_BitwiseOr(UInt16 left, UInt16 right); ++ static UInt16 System.IBitwiseOperators.op_ExclusiveOr(UInt16 left, UInt16 right); ++ static UInt16 System.IBitwiseOperators.op_OnesComplement(UInt16 value); ++ static bool System.IComparisonOperators.op_GreaterThan(UInt16 left, UInt16 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(UInt16 left, UInt16 right); ++ static bool System.IComparisonOperators.op_LessThan(UInt16 left, UInt16 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(UInt16 left, UInt16 right); ++ static UInt16 System.IDecrementOperators.op_Decrement(UInt16 value); ++ static UInt16 System.IDivisionOperators.op_Division(UInt16 left, UInt16 right); ++ static bool System.IEqualityOperators.op_Equality(UInt16 left, UInt16 right); ++ static bool System.IEqualityOperators.op_Inequality(UInt16 left, UInt16 right); ++ static UInt16 System.IIncrementOperators.op_Increment(UInt16 value); ++ static UInt16 System.IModulusOperators.op_Modulus(UInt16 left, UInt16 right); ++ static UInt16 System.IMultiplyOperators.op_Multiply(UInt16 left, UInt16 right); ++ static UInt16 System.IShiftOperators.op_LeftShift(UInt16 value, int shiftAmount); ++ static UInt16 System.IShiftOperators.op_RightShift(UInt16 value, int shiftAmount); ++ static UInt16 System.ISubtractionOperators.op_Subtraction(UInt16 left, UInt16 right); ++ static UInt16 System.IUnaryNegationOperators.op_UnaryNegation(UInt16 value); ++ static UInt16 System.IUnaryPlusOperators.op_UnaryPlus(UInt16 value); ++ static UInt16 TrailingZeroCount(UInt16 value); ++ static bool TryCreate(TOther value, out UInt16 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt16 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt16 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out UInt16 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt16 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt16 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out UInt16 result); + } +- public readonly struct UInt32 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct UInt32 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ public const uint AdditiveIdentity = (uint)0; ++ public const uint MultiplicativeIdentity = (uint)1; ++ public const uint One = (uint)1; ++ public const uint Zero = (uint)0; ++ static uint System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static uint System.IMinMaxValue.MaxValue { get; } ++ static uint System.IMinMaxValue.MinValue { get; } ++ static uint System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static uint System.INumber.One { get; } ++ static uint System.INumber.Zero { get; } ++ static UInt32 Abs(UInt32 value); ++ static UInt32 Clamp(UInt32 value, UInt32 min, UInt32 max); ++ static UInt32 Create(TOther value); ++ static UInt32 CreateSaturating(TOther value); ++ static UInt32 CreateTruncating(TOther value); ++ static (uint Quotient, uint Remainder) DivRem(UInt32 left, UInt32 right); ++ static bool IsPow2(UInt32 value); ++ static UInt32 LeadingZeroCount(UInt32 value); ++ static UInt32 Log2(UInt32 value); ++ static UInt32 Max(UInt32 x, UInt32 y); ++ static UInt32 Min(UInt32 x, UInt32 y); +- public static UInt32 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt32 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt32 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static UInt32 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static UInt32 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static UInt32 Parse(string s, IFormatProvider? provider); ++ static UInt32 Parse(string s, IFormatProvider? provider); ++ static UInt32 PopCount(UInt32 value); ++ static UInt32 RotateLeft(UInt32 value, int rotateAmount); ++ static UInt32 RotateRight(UInt32 value, int rotateAmount); ++ static UInt32 Sign(UInt32 value); ++ static UInt32 System.IAdditionOperators.op_Addition(UInt32 left, UInt32 right); ++ static UInt32 System.IBitwiseOperators.op_BitwiseAnd(UInt32 left, UInt32 right); ++ static UInt32 System.IBitwiseOperators.op_BitwiseOr(UInt32 left, UInt32 right); ++ static UInt32 System.IBitwiseOperators.op_ExclusiveOr(UInt32 left, UInt32 right); ++ static UInt32 System.IBitwiseOperators.op_OnesComplement(UInt32 value); ++ static bool System.IComparisonOperators.op_GreaterThan(UInt32 left, UInt32 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(UInt32 left, UInt32 right); ++ static bool System.IComparisonOperators.op_LessThan(UInt32 left, UInt32 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(UInt32 left, UInt32 right); ++ static UInt32 System.IDecrementOperators.op_Decrement(UInt32 value); ++ static UInt32 System.IDivisionOperators.op_Division(UInt32 left, UInt32 right); ++ static bool System.IEqualityOperators.op_Equality(UInt32 left, UInt32 right); ++ static bool System.IEqualityOperators.op_Inequality(UInt32 left, UInt32 right); ++ static UInt32 System.IIncrementOperators.op_Increment(UInt32 value); ++ static UInt32 System.IModulusOperators.op_Modulus(UInt32 left, UInt32 right); ++ static UInt32 System.IMultiplyOperators.op_Multiply(UInt32 left, UInt32 right); ++ static UInt32 System.IShiftOperators.op_LeftShift(UInt32 value, int shiftAmount); ++ static UInt32 System.IShiftOperators.op_RightShift(UInt32 value, int shiftAmount); ++ static UInt32 System.ISubtractionOperators.op_Subtraction(UInt32 left, UInt32 right); ++ static UInt32 System.IUnaryNegationOperators.op_UnaryNegation(UInt32 value); ++ static UInt32 System.IUnaryPlusOperators.op_UnaryPlus(UInt32 value); ++ static UInt32 TrailingZeroCount(UInt32 value); ++ static bool TryCreate(TOther value, out UInt32 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt32 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt32 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out UInt32 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt32 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt32 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out UInt32 result); + } +- public readonly struct UInt64 : IComparable, IComparable, IConvertible, IEquatable, IFormattable, ISpanFormattable { ++ public readonly struct UInt64 : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IConvertible, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ public const ulong AdditiveIdentity = (ulong)0; ++ public const ulong MultiplicativeIdentity = (ulong)1; ++ public const ulong One = (ulong)1; ++ public const ulong Zero = (ulong)0; ++ static ulong System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static ulong System.IMinMaxValue.MaxValue { get; } ++ static ulong System.IMinMaxValue.MinValue { get; } ++ static ulong System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static ulong System.INumber.One { get; } ++ static ulong System.INumber.Zero { get; } ++ static UInt64 Abs(UInt64 value); ++ static UInt64 Clamp(UInt64 value, UInt64 min, UInt64 max); ++ static UInt64 Create(TOther value); ++ static UInt64 CreateSaturating(TOther value); ++ static UInt64 CreateTruncating(TOther value); ++ static (ulong Quotient, ulong Remainder) DivRem(UInt64 left, UInt64 right); ++ static bool IsPow2(UInt64 value); ++ static UInt64 LeadingZeroCount(UInt64 value); ++ static UInt64 Log2(UInt64 value); ++ static UInt64 Max(UInt64 x, UInt64 y); ++ static UInt64 Min(UInt64 x, UInt64 y); +- public static UInt64 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt64 Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UInt64 Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static UInt64 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static UInt64 Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static UInt64 Parse(string s, IFormatProvider? provider); ++ static UInt64 Parse(string s, IFormatProvider? provider); ++ static UInt64 PopCount(UInt64 value); ++ static UInt64 RotateLeft(UInt64 value, int rotateAmount); ++ static UInt64 RotateRight(UInt64 value, int rotateAmount); ++ static UInt64 Sign(UInt64 value); ++ static UInt64 System.IAdditionOperators.op_Addition(UInt64 left, UInt64 right); ++ static UInt64 System.IBitwiseOperators.op_BitwiseAnd(UInt64 left, UInt64 right); ++ static UInt64 System.IBitwiseOperators.op_BitwiseOr(UInt64 left, UInt64 right); ++ static UInt64 System.IBitwiseOperators.op_ExclusiveOr(UInt64 left, UInt64 right); ++ static UInt64 System.IBitwiseOperators.op_OnesComplement(UInt64 value); ++ static bool System.IComparisonOperators.op_GreaterThan(UInt64 left, UInt64 right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(UInt64 left, UInt64 right); ++ static bool System.IComparisonOperators.op_LessThan(UInt64 left, UInt64 right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(UInt64 left, UInt64 right); ++ static UInt64 System.IDecrementOperators.op_Decrement(UInt64 value); ++ static UInt64 System.IDivisionOperators.op_Division(UInt64 left, UInt64 right); ++ static bool System.IEqualityOperators.op_Equality(UInt64 left, UInt64 right); ++ static bool System.IEqualityOperators.op_Inequality(UInt64 left, UInt64 right); ++ static UInt64 System.IIncrementOperators.op_Increment(UInt64 value); ++ static UInt64 System.IModulusOperators.op_Modulus(UInt64 left, UInt64 right); ++ static UInt64 System.IMultiplyOperators.op_Multiply(UInt64 left, UInt64 right); ++ static UInt64 System.IShiftOperators.op_LeftShift(UInt64 value, int shiftAmount); ++ static UInt64 System.IShiftOperators.op_RightShift(UInt64 value, int shiftAmount); ++ static UInt64 System.ISubtractionOperators.op_Subtraction(UInt64 left, UInt64 right); ++ static UInt64 System.IUnaryNegationOperators.op_UnaryNegation(UInt64 value); ++ static UInt64 System.IUnaryPlusOperators.op_UnaryPlus(UInt64 value); ++ static UInt64 TrailingZeroCount(UInt64 value); ++ static bool TryCreate(TOther value, out UInt64 result); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt64 result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UInt64 result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out UInt64 result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt64 result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt64 result); ++ static bool TryParse(string? s, IFormatProvider? provider, out UInt64 result); + } +- public readonly struct UIntPtr : IComparable, IComparable, IEquatable, IFormattable, ISerializable, ISpanFormattable { ++ public readonly struct UIntPtr : IAdditionOperators, IAdditiveIdentity, IBinaryInteger, IBinaryNumber, IBitwiseOperators, IComparable, IComparable, IComparisonOperators, IDecrementOperators, IDivisionOperators, IEqualityOperators, IEquatable, IFormattable, IIncrementOperators, IMinMaxValue, IModulusOperators, IMultiplicativeIdentity, IMultiplyOperators, INumber, IParseable, ISerializable, IShiftOperators, ISpanFormattable, ISpanParseable, ISubtractionOperators, IUnaryNegationOperators, IUnaryPlusOperators, IUnsignedNumber { ++ static UIntPtr System.IAdditiveIdentity.AdditiveIdentity { get; } ++ static UIntPtr System.IMinMaxValue.MaxValue { get; } ++ static UIntPtr System.IMinMaxValue.MinValue { get; } ++ static UIntPtr System.IMultiplicativeIdentity.MultiplicativeIdentity { get; } ++ static UIntPtr System.INumber.One { get; } ++ static UIntPtr System.INumber.Zero { get; } +- public static bool operator ==(UIntPtr value1, UIntPtr value2); ++ static bool operator ==(UIntPtr value1, UIntPtr value2); +- public static bool operator !=(UIntPtr value1, UIntPtr value2); ++ static bool operator !=(UIntPtr value1, UIntPtr value2); +- public static UIntPtr Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UIntPtr Parse(ReadOnlySpan s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ static UIntPtr Parse(ReadOnlySpan s, IFormatProvider? provider); +- public static UIntPtr Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static UIntPtr Parse(string s, NumberStyles style, IFormatProvider? provider); +- public static UIntPtr Parse(string s, IFormatProvider? provider); ++ static UIntPtr Parse(string s, IFormatProvider? provider); ++ static UIntPtr System.IAdditionOperators.op_Addition(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IBinaryInteger.LeadingZeroCount(UIntPtr value); ++ static UIntPtr System.IBinaryInteger.PopCount(UIntPtr value); ++ static UIntPtr System.IBinaryInteger.RotateLeft(UIntPtr value, int rotateAmount); ++ static UIntPtr System.IBinaryInteger.RotateRight(UIntPtr value, int rotateAmount); ++ static UIntPtr System.IBinaryInteger.TrailingZeroCount(UIntPtr value); ++ static bool System.IBinaryNumber.IsPow2(UIntPtr value); ++ static UIntPtr System.IBinaryNumber.Log2(UIntPtr value); ++ static UIntPtr System.IBitwiseOperators.op_BitwiseAnd(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IBitwiseOperators.op_BitwiseOr(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IBitwiseOperators.op_ExclusiveOr(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IBitwiseOperators.op_OnesComplement(UIntPtr value); ++ static bool System.IComparisonOperators.op_GreaterThan(UIntPtr left, UIntPtr right); ++ static bool System.IComparisonOperators.op_GreaterThanOrEqual(UIntPtr left, UIntPtr right); ++ static bool System.IComparisonOperators.op_LessThan(UIntPtr left, UIntPtr right); ++ static bool System.IComparisonOperators.op_LessThanOrEqual(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IDecrementOperators.op_Decrement(UIntPtr value); ++ static UIntPtr System.IDivisionOperators.op_Division(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IIncrementOperators.op_Increment(UIntPtr value); ++ static UIntPtr System.IModulusOperators.op_Modulus(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IMultiplyOperators.op_Multiply(UIntPtr left, UIntPtr right); ++ static UIntPtr System.INumber.Abs(UIntPtr value); ++ static UIntPtr System.INumber.Clamp(UIntPtr value, UIntPtr min, UIntPtr max); ++ static UIntPtr System.INumber.Create(TOther value); ++ static UIntPtr System.INumber.CreateSaturating(TOther value); ++ static UIntPtr System.INumber.CreateTruncating(TOther value); ++ static (UIntPtr Quotient, UIntPtr Remainder) System.INumber.DivRem(UIntPtr left, UIntPtr right); ++ static UIntPtr System.INumber.Max(UIntPtr x, UIntPtr y); ++ static UIntPtr System.INumber.Min(UIntPtr x, UIntPtr y); ++ static UIntPtr System.INumber.Sign(UIntPtr value); ++ static bool System.INumber.TryCreate(TOther value, out UIntPtr result); ++ static UIntPtr System.IShiftOperators.op_LeftShift(UIntPtr value, int shiftAmount); ++ static UIntPtr System.IShiftOperators.op_RightShift(UIntPtr value, int shiftAmount); ++ static UIntPtr System.ISubtractionOperators.op_Subtraction(UIntPtr left, UIntPtr right); ++ static UIntPtr System.IUnaryNegationOperators.op_UnaryNegation(UIntPtr value); ++ static UIntPtr System.IUnaryPlusOperators.op_UnaryPlus(UIntPtr value); +- public static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UIntPtr result); ++ static bool TryParse(ReadOnlySpan s, NumberStyles style, IFormatProvider? provider, out UIntPtr result); ++ static bool TryParse(ReadOnlySpan s, IFormatProvider? provider, out UIntPtr result); +- public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UIntPtr result); ++ static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UIntPtr result); ++ static bool TryParse(string? s, IFormatProvider? provider, out UIntPtr result); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3.md new file mode 100644 index 0000000000..76d8f0d00a --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3.md @@ -0,0 +1,10 @@ +# API Difference 7.0-preview2 vs 7.0-preview3 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [System.Drawing](7.0-preview3_System.Drawing.md) +* [System.Windows.Forms](7.0-preview3_System.Windows.Forms.md) +* [System.Windows.Forms.Design](7.0-preview3_System.Windows.Forms.Design.md) +* [System.Windows.Forms.PropertyGridInternal](7.0-preview3_System.Windows.Forms.PropertyGridInternal.md) + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Drawing.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Drawing.md new file mode 100644 index 0000000000..0e1df6aac9 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Drawing.md @@ -0,0 +1,11 @@ +# System.Drawing + +``` diff + namespace System.Drawing { + public sealed class ImageAnimator { +- public static void UpdateFrames(Image image); ++ public static void UpdateFrames(Image? image); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.Design.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.Design.md new file mode 100644 index 0000000000..8a40c24103 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.Design.md @@ -0,0 +1,15 @@ +# System.Windows.Forms.Design + +``` diff + namespace System.Windows.Forms.Design { + public abstract class PropertyTab : IExtenderProvider { +- public virtual PropertyDescriptorCollection GetProperties(ITypeDescriptorContext? context, object component, Attribute[]? attributes); ++ public virtual PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object component, Attribute[]? attributes); +- public virtual PropertyDescriptorCollection GetProperties(object component); ++ public virtual PropertyDescriptorCollection? GetProperties(object component); +- public abstract PropertyDescriptorCollection GetProperties(object component, Attribute[]? attributes); ++ public abstract PropertyDescriptorCollection? GetProperties(object component, Attribute[]? attributes); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.PropertyGridInternal.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.PropertyGridInternal.md new file mode 100644 index 0000000000..f9c6889ef7 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.PropertyGridInternal.md @@ -0,0 +1,15 @@ +# System.Windows.Forms.PropertyGridInternal + +``` diff + namespace System.Windows.Forms.PropertyGridInternal { + public class PropertiesTab : PropertyTab { +- public override PropertyDescriptor GetDefaultProperty(object obj); ++ public override PropertyDescriptor? GetDefaultProperty(object obj); +- public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object component, Attribute[] attributes); ++ public override PropertyDescriptorCollection? GetProperties(ITypeDescriptorContext? context, object component, Attribute[]? attributes); +- public override PropertyDescriptorCollection GetProperties(object component, Attribute[] attributes); ++ public override PropertyDescriptorCollection? GetProperties(object component, Attribute[]? attributes); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.md b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.md new file mode 100644 index 0000000000..7b3df3b8e3 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/Microsoft.WindowsDesktop.App/7.0-preview3_System.Windows.Forms.md @@ -0,0 +1,218 @@ +# System.Windows.Forms + +``` diff + namespace System.Windows.Forms { + public class CheckBox : ButtonBase { +- public event EventHandler AppearanceChanged; ++ public event EventHandler? AppearanceChanged; +- public event EventHandler CheckedChanged; ++ public event EventHandler? CheckedChanged; +- public event EventHandler CheckStateChanged; ++ public event EventHandler? CheckStateChanged; +- public new event EventHandler DoubleClick; ++ public new event EventHandler? DoubleClick; +- public new event MouseEventHandler MouseDoubleClick; ++ public new event MouseEventHandler? MouseDoubleClick; + } + public sealed class Cursor : IDisposable, IHandle, ISerializable { +- public static Cursor? Current { get; set; } ++ public static Cursor Current { get; set; } +- public object? Tag { get; set; } ++ public object Tag { get; set; } +- public override bool Equals(object? obj); ++ public override bool Equals(object obj); + } + public class CursorConverter : TypeConverter { +- public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType); ++ public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType); +- public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context); ++ public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context); + } + public class DateTimePicker : Control { ++ protected override void OnGotFocus(EventArgs e); + public class DateTimePickerAccessibleObject : Control.ControlAccessibleObject { ++ public override string DefaultAction { get; } +- public override string KeyboardShortcut { get; } ++ public override string? KeyboardShortcut { get; } ++ public override string Name { get; } ++ public override void DoDefaultAction(); + } + } + public class DomainUpDown : UpDownBase { +- public object SelectedItem { get; set; } ++ public object? SelectedItem { get; set; } +- public new event EventHandler PaddingChanged; ++ public new event EventHandler? PaddingChanged; +- public event EventHandler SelectedItemChanged; ++ public event EventHandler? SelectedItemChanged; +- protected override void OnChanged(object source, EventArgs e); ++ protected override void OnChanged(object? source, EventArgs e); +- protected void OnSelectedItemChanged(object source, EventArgs e); ++ protected void OnSelectedItemChanged(object? source, EventArgs e); +- protected override void OnTextBoxKeyPress(object source, KeyPressEventArgs e); ++ protected override void OnTextBoxKeyPress(object? source, KeyPressEventArgs e); + } + public sealed class FolderBrowserDialog : CommonDialog { +- public new event EventHandler HelpRequest; ++ public new event EventHandler? HelpRequest; + } + public class Form : ContainerControl { + public new class ControlCollection : Control.ControlCollection { +- public override void Add(Control value); ++ public override void Add(Control? value); +- public override void Remove(Control value); ++ public override void Remove(Control? value); + } + } + public class FormCollection : ReadOnlyCollectionBase { +- public virtual Form this[int index] { get; } ++ public virtual Form? this[int index] { get; } +- public virtual Form this[string name] { get; } ++ public virtual Form? this[string? name] { get; } + } + public sealed class ImageList : Component, IHandle { +- public ImageListStreamer ImageStream { get; set; } ++ public ImageListStreamer? ImageStream { get; set; } +- public object Tag { get; set; } ++ public object? Tag { get; set; } +- public event EventHandler RecreateHandle; ++ public event EventHandler? RecreateHandle; + public sealed class ImageCollection : ICollection, IEnumerable, IList { +- bool System.Collections.ICollection.IsSynchronized { get; } ++ bool ICollection.IsSynchronized { get; } +- object System.Collections.ICollection.SyncRoot { get; } ++ object ICollection.SyncRoot { get; } +- bool System.Collections.IList.IsFixedSize { get; } ++ bool IList.IsFixedSize { get; } +- object System.Collections.IList.this[int index] { get; set; } ++ object? IList.this[int index] { get; set; } +- public Image this[string key] { get; } ++ public Image? this[string key] { get; } +- int System.Collections.IList.Add(object value); ++ int System.Collections.IList.Add(object? value); +- bool System.Collections.IList.Contains(object value); ++ bool System.Collections.IList.Contains(object? value); +- int System.Collections.IList.IndexOf(object value); ++ int System.Collections.IList.IndexOf(object? value); +- void System.Collections.IList.Insert(int index, object value); ++ void System.Collections.IList.Insert(int index, object? value); +- void System.Collections.IList.Remove(object value); ++ void System.Collections.IList.Remove(object? value); + } + } + public class KeysConverter : TypeConverter, IComparer { +- public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType); ++ public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType); +- public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context); ++ public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context); + } + public class ListBox : ListControl { +- public override Image BackgroundImage { get; set; } ++ public override Image? BackgroundImage { get; set; } +- public object SelectedItem { get; set; } ++ public object? SelectedItem { get; set; } +- public override string Text { get; set; } ++ public override string? Text { get; set; } +- public new event EventHandler BackgroundImageChanged; ++ public new event EventHandler? BackgroundImageChanged; +- public new event EventHandler BackgroundImageLayoutChanged; ++ public new event EventHandler? BackgroundImageLayoutChanged; +- public new event EventHandler Click; ++ public new event EventHandler? Click; +- public event DrawItemEventHandler DrawItem; ++ public event DrawItemEventHandler? DrawItem; +- public event MeasureItemEventHandler MeasureItem; ++ public event MeasureItemEventHandler? MeasureItem; +- public new event MouseEventHandler MouseClick; ++ public new event MouseEventHandler? MouseClick; +- public new event EventHandler PaddingChanged; ++ public new event EventHandler? PaddingChanged; +- public new event PaintEventHandler Paint; ++ public new event PaintEventHandler? Paint; +- public event EventHandler SelectedIndexChanged; ++ public event EventHandler? SelectedIndexChanged; +- public new event EventHandler TextChanged; ++ public new event EventHandler? TextChanged; + } + public class ListView : Control { +- public event EventHandler GroupCollapsedStateChanged; ++ public event EventHandler? GroupCollapsedStateChanged; +- public event EventHandler GroupTaskLinkClick; ++ public event EventHandler? GroupTaskLinkClick; +- public ListViewItem FindItemWithText(string text); ++ public ListViewItem? FindItemWithText(string text); +- public ListViewItem FindItemWithText(string text, bool includeSubItemsInSearch, int startIndex); ++ public ListViewItem? FindItemWithText(string text, bool includeSubItemsInSearch, int startIndex); +- public ListViewItem FindItemWithText(string text, bool includeSubItemsInSearch, int startIndex, bool isPrefixSearch); ++ public ListViewItem? FindItemWithText(string text, bool includeSubItemsInSearch, int startIndex, bool isPrefixSearch); + } + public class ListViewItem : ICloneable, IKeyboardToolTip, ISerializable { + public class ListViewSubItem { +- public ListViewSubItem(ListViewItem owner, string text); ++ public ListViewSubItem(ListViewItem owner, string? text); +- public ListViewSubItem(ListViewItem owner, string text, Color foreColor, Color backColor, Font font); ++ public ListViewSubItem(ListViewItem owner, string? text, Color foreColor, Color backColor, Font font); +- public object Tag { get; set; } ++ public object? Tag { get; set; } + } + public class ListViewSubItemCollection : ICollection, IEnumerable, IList { +- bool System.Collections.ICollection.IsSynchronized { get; } ++ bool ICollection.IsSynchronized { get; } +- object System.Collections.ICollection.SyncRoot { get; } ++ object ICollection.SyncRoot { get; } +- bool System.Collections.IList.IsFixedSize { get; } ++ bool IList.IsFixedSize { get; } +- object System.Collections.IList.this[int index] { get; set; } ++ object? IList.this[int index] { get; set; } +- public virtual ListViewItem.ListViewSubItem this[string key] { get; } ++ public virtual ListViewItem.ListViewSubItem? this[string key] { get; } +- public ListViewItem.ListViewSubItem Add(string text); ++ public ListViewItem.ListViewSubItem Add(string? text); +- public ListViewItem.ListViewSubItem Add(string text, Color foreColor, Color backColor, Font font); ++ public ListViewItem.ListViewSubItem Add(string? text, Color foreColor, Color backColor, Font font); +- public bool Contains(ListViewItem.ListViewSubItem subItem); ++ public bool Contains(ListViewItem.ListViewSubItem? subItem); +- public virtual bool ContainsKey(string key); ++ public virtual bool ContainsKey(string? key); +- public int IndexOf(ListViewItem.ListViewSubItem subItem); ++ public int IndexOf(ListViewItem.ListViewSubItem? subItem); +- public virtual int IndexOfKey(string key); ++ public virtual int IndexOfKey(string? key); +- public void Remove(ListViewItem.ListViewSubItem item); ++ public void Remove(ListViewItem.ListViewSubItem? item); +- public virtual void RemoveByKey(string key); ++ public virtual void RemoveByKey(string? key); +- int System.Collections.IList.Add(object item); ++ int System.Collections.IList.Add(object? item); +- bool System.Collections.IList.Contains(object item); ++ bool System.Collections.IList.Contains(object? item); +- int System.Collections.IList.IndexOf(object subItem); ++ int System.Collections.IList.IndexOf(object? subItem); +- void System.Collections.IList.Insert(int index, object item); ++ void System.Collections.IList.Insert(int index, object? item); +- void System.Collections.IList.Remove(object item); ++ void System.Collections.IList.Remove(object? item); + } + } + public class PrintControllerWithStatusDialog : PrintController { +- public override Graphics OnStartPage(PrintDocument document, PrintPageEventArgs e); ++ public override Graphics? OnStartPage(PrintDocument document, PrintPageEventArgs e); + } + public class PrintPreviewControl : Control { +- public PrintDocument Document { get; set; } ++ public PrintDocument? Document { get; set; } +- public event EventHandler StartPageChanged; ++ public event EventHandler? StartPageChanged; +- public new event EventHandler TextChanged; ++ public new event EventHandler? TextChanged; ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + public class SplitContainer : ContainerControl, ISupportInitialize { ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + public class TreeView : Control { ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview3/README.md b/release-notes/7.0/preview/api-diff/preview3/README.md new file mode 100644 index 0000000000..b458d9b642 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview3/README.md @@ -0,0 +1,7 @@ +# .NET 7.0 Preview 3 API Changes + +The following API changes were made in .NET 7.0 Preview 3: + +- [Microsoft.NETCore.App](./Microsoft.NETCore.App/7.0-preview3.md) +- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/7.0-preview3.md) +- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/7.0-preview3.md)