diff options
author | Carlos Sanchez <1175054+carlossanlop@users.noreply.github.com> | 2022-07-12 00:48:09 +0300 |
---|---|---|
committer | GitHub <noreply@github.com> | 2022-07-12 00:48:09 +0300 |
commit | 8c81085305ef9820f6bb67ff5ac29ad935b2c1fc (patch) | |
tree | c96cbc24866a53544774229c4e4f5141b66e154e | |
parent | 05f9819cd60ed4bcd2887ed8b5e7fe4485a57acd (diff) |
API-diff between 7.0-preview4 and 7.0-preview5 (#7587)
* API-diff between 7.0-preview4 and 7.0-preview5
* Apply suggestions from code review
Co-authored-by: Brennan <brecon@microsoft.com>
Co-authored-by: Tanner Gooding <tagoo@outlook.com>
Co-authored-by: carlossanlop <carlossanlop@users.noreply.github.com>
Co-authored-by: Brennan <brecon@microsoft.com>
Co-authored-by: Tanner Gooding <tagoo@outlook.com>
52 files changed, 2774 insertions, 0 deletions
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md new file mode 100644 index 00000000..015e5407 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md @@ -0,0 +1,22 @@ +# API Difference 7.0-preview4 vs 7.0-preview5 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [Microsoft.AspNetCore.Authentication](7.0-preview5_Microsoft.AspNetCore.Authentication.md) +* [Microsoft.AspNetCore.Authorization.Infrastructure](7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md) +* [Microsoft.AspNetCore.Builder](7.0-preview5_Microsoft.AspNetCore.Builder.md) +* [Microsoft.AspNetCore.DataProtection](7.0-preview5_Microsoft.AspNetCore.DataProtection.md) +* [Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel](7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md) +* [Microsoft.AspNetCore.DataProtection.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md) +* [Microsoft.AspNetCore.DataProtection.KeyManagement](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md) +* [Microsoft.AspNetCore.DataProtection.KeyManagement.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md) +* [Microsoft.AspNetCore.Http](7.0-preview5_Microsoft.AspNetCore.Http.md) +* [Microsoft.AspNetCore.Http.HttpResults](7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md) +* [Microsoft.AspNetCore.Mvc](7.0-preview5_Microsoft.AspNetCore.Mvc.md) +* [Microsoft.AspNetCore.ResponseCompression](7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md) +* [Microsoft.AspNetCore.SignalR](7.0-preview5_Microsoft.AspNetCore.SignalR.md) +* [Microsoft.AspNetCore.WebUtilities](7.0-preview5_Microsoft.AspNetCore.WebUtilities.md) +* [Microsoft.Extensions.Logging](7.0-preview5_Microsoft.Extensions.Logging.md) +* [Microsoft.JSInterop.Infrastructure](7.0-preview5_Microsoft.JSInterop.Infrastructure.md) + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md new file mode 100644 index 00000000..bf591034 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md @@ -0,0 +1,10 @@ +# Microsoft.AspNetCore.Authentication + +``` diff + namespace Microsoft.AspNetCore.Authentication { ++ public interface IAuthenticationConfigurationProvider { ++ IConfiguration GetAuthenticationSchemeConfiguration(string authenticationScheme); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md new file mode 100644 index 00000000..1629ecc0 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.Authorization.Infrastructure + +``` diff + namespace Microsoft.AspNetCore.Authorization.Infrastructure { + public class PassThroughAuthorizationHandler : IAuthorizationHandler { ++ public PassThroughAuthorizationHandler(IOptions<AuthorizationOptions> options); + public Task HandleAsync(AuthorizationHandlerContext context); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md new file mode 100644 index 00000000..686039f8 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md @@ -0,0 +1,10 @@ +# Microsoft.AspNetCore.Builder + +``` diff + namespace Microsoft.AspNetCore.Builder { + public sealed class WebApplicationBuilder { ++ public AuthenticationBuilder Authentication { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md new file mode 100644 index 00000000..2a2ddb5d --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md @@ -0,0 +1,27 @@ +# Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel + +``` diff + namespace Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public sealed class AuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer { + public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element); + } + public sealed class CngCbcAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element); + } + public sealed class CngGcmAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element); + } + public interface IAuthenticatedEncryptorDescriptorDeserializer { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element); + } + public sealed class ManagedAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md new file mode 100644 index 00000000..75be7596 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md @@ -0,0 +1,12 @@ +# Microsoft.AspNetCore.DataProtection.Internal + +``` diff + namespace Microsoft.AspNetCore.DataProtection.Internal { + public interface IActivator { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] +- object CreateInstance(Type expectedBaseType, string implementationTypeName); ++ object CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type expectedBaseType, string implementationTypeName); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md new file mode 100644 index 00000000..21d38681 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md @@ -0,0 +1,19 @@ +# Microsoft.AspNetCore.DataProtection.KeyManagement.Internal + +``` diff + namespace Microsoft.AspNetCore.DataProtection.KeyManagement.Internal { + public interface ICacheableKeyRingProvider { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + CacheableKeyRing GetCacheableKeyRing(DateTimeOffset now); + } + public interface IInternalXmlKeyManager { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + IAuthenticatedEncryptorDescriptor DeserializeDescriptorFromKeyElement(XElement keyElement); + } + public interface IKeyRingProvider { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + IKeyRing GetCurrentKeyRing(); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md new file mode 100644 index 00000000..6d7a711b --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md @@ -0,0 +1,17 @@ +# Microsoft.AspNetCore.DataProtection.KeyManagement + +``` diff + namespace Microsoft.AspNetCore.DataProtection.KeyManagement { + public interface IKeyManager { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + IReadOnlyCollection<IKey> GetAllKeys(); + } + public sealed class XmlKeyManager : IInternalXmlKeyManager, IKeyManager { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public IReadOnlyCollection<IKey> GetAllKeys(); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + IAuthenticatedEncryptorDescriptor IInternalXmlKeyManager.DeserializeDescriptorFromKeyElement(XElement keyElement); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md new file mode 100644 index 00000000..203479c2 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md @@ -0,0 +1,39 @@ +# Microsoft.AspNetCore.DataProtection + +``` diff + namespace Microsoft.AspNetCore.DataProtection { + public static class DataProtectionAdvancedExtensions { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static byte[] Protect(this ITimeLimitedDataProtector protector, byte[] plaintext, TimeSpan lifetime); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, DateTimeOffset expiration); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, TimeSpan lifetime); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static string Unprotect(this ITimeLimitedDataProtector protector, string protectedData, out DateTimeOffset expiration); + } + public static class DataProtectionCommonExtensions { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static string Protect(this IDataProtector protector, string plaintext); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + public static string Unprotect(this IDataProtector protector, string protectedData); + } + public interface IDataProtector : IDataProtectionProvider { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + byte[] Protect(byte[] plaintext); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + byte[] Unprotect(byte[] protectedData); + } + public interface IPersistedDataProtector : IDataProtectionProvider, IDataProtector { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + byte[] DangerousUnprotect(byte[] protectedData, bool ignoreRevocationErrors, out bool requiresMigration, out bool wasRevoked); + } + public interface ITimeLimitedDataProtector : IDataProtectionProvider, IDataProtector { +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + byte[] Protect(byte[] plaintext, DateTimeOffset expiration); +- [RequiresUnreferencedCode(TrimmerWarning.Message)] + byte[] Unprotect(byte[] protectedData, out DateTimeOffset expiration); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md new file mode 100644 index 00000000..4dc03c2f --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md @@ -0,0 +1,17 @@ +# Microsoft.AspNetCore.Http.HttpResults + +``` diff +- namespace Microsoft.AspNetCore.Http { ++ namespace Microsoft.AspNetCore.Http.HttpResults { + public sealed class ChallengeHttpResult : IResult { + public Task ExecuteAsync(HttpContext httpContext); + } + public sealed class ForbidHttpResult : IResult { + public Task ExecuteAsync(HttpContext httpContext); + } + public sealed class SignOutHttpResult : IResult { + public Task ExecuteAsync(HttpContext httpContext); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md new file mode 100644 index 00000000..164dcd07 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md @@ -0,0 +1,92 @@ +# Microsoft.AspNetCore.Http + +``` diff + namespace Microsoft.AspNetCore.Http { ++ public sealed class AsParametersAttribute : Attribute { ++ public AsParametersAttribute(); ++ } ++ public sealed class DefaultRouteHandlerInvocationContext : RouteHandlerInvocationContext { ++ public DefaultRouteHandlerInvocationContext(HttpContext httpContext, params object[] arguments); ++ public override IList<object?> Arguments { get; } ++ public override HttpContext HttpContext { get; } ++ public override T GetArgument<T>(int index); ++ } + public static class Results { +- public static IResult Content(string content, MediaTypeHeaderValue contentType); ++ public static IResult Content(string? content, MediaTypeHeaderValue contentType); +- public static IResult Content(string content, string? contentType = null, Encoding? contentEncoding = null); ++ public static IResult Content(string? content, string? contentType, Encoding? contentEncoding); ++ public static IResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?)); +- public static IResult Text(string content, string? contentType = null, Encoding? contentEncoding = null); ++ public static IResult Text(string? content, string? contentType, Encoding? contentEncoding); ++ public static IResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?)); + } +- public sealed class RouteHandlerInvocationContext { ++ public abstract class RouteHandlerInvocationContext { ++ protected RouteHandlerInvocationContext(); +- public RouteHandlerInvocationContext(HttpContext httpContext, params object[] parameters); ++ public abstract IList<object?> Arguments { get; } +- public HttpContext HttpContext { get; } ++ public abstract HttpContext HttpContext { get; } +- public IList<object?> Parameters { get; } ++ public abstract T GetArgument<T>(int index); + } + public static class TypedResults { +- public static Accepted<TValue> Accepted<TValue>(string? uri, TValue? value); ++ public static Accepted<TValue> Accepted<TValue>(string uri, TValue value); +- public static AcceptedAtRoute AcceptedAtRoute(string? routeName = null, object? routeValues = null); ++ public static AcceptedAtRoute AcceptedAtRoute(string routeName = null, object routeValues = null); +- public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null); ++ public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null); +- public static BadRequest<TValue> BadRequest<TValue>(TValue? error); ++ public static BadRequest<TValue> BadRequest<TValue>(TValue error); +- public static FileContentHttpResult Bytes(byte[] contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null); ++ public static FileContentHttpResult Bytes(byte[] contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null); +- public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null); ++ public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null); +- public static Conflict<TValue> Conflict<TValue>(TValue? error); ++ public static Conflict<TValue> Conflict<TValue>(TValue error); +- public static ContentHttpResult Content(string content, MediaTypeHeaderValue contentType); ++ public static ContentHttpResult Content(string? content, MediaTypeHeaderValue contentType); +- public static ContentHttpResult Content(string content, string? contentType = null, Encoding? contentEncoding = null); ++ public static ContentHttpResult Content(string content, string contentType, Encoding contentEncoding); ++ public static ContentHttpResult Content(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?)); +- public static CreatedAtRoute CreatedAtRoute(string? routeName = null, object? routeValues = null); ++ public static CreatedAtRoute CreatedAtRoute(string routeName = null, object routeValues = null); +- public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null); ++ public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null); +- public static FileContentHttpResult File(byte[] fileContents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null); ++ public static FileContentHttpResult File(byte[] fileContents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null); +- public static FileStreamHttpResult File(Stream fileStream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false); ++ public static FileStreamHttpResult File(Stream fileStream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false); +- public static JsonHttpResult<TValue> Json<TValue>(TValue? data, JsonSerializerOptions? options = null, string? contentType = null, int? statusCode = default(int?)); ++ public static JsonHttpResult<TValue> Json<TValue>(TValue data, JsonSerializerOptions options = null, string contentType = null, int? statusCode = default(int?)); +- public static NotFound<TValue> NotFound<TValue>(TValue? value); ++ public static NotFound<TValue> NotFound<TValue>(TValue value); +- public static Ok<TValue> Ok<TValue>(TValue? value); ++ public static Ok<TValue> Ok<TValue>(TValue value); +- public static PhysicalFileHttpResult PhysicalFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false); ++ public static PhysicalFileHttpResult PhysicalFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false); +- public static ProblemHttpResult Problem(string? detail = null, string? instance = null, int? statusCode = default(int?), string? title = null, string? type = null, IDictionary<string, object?>? extensions = null); ++ public static ProblemHttpResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IDictionary<string, object?>? extensions = null); +- public static RedirectToRouteHttpResult RedirectToRoute(string? routeName = null, object? routeValues = null, bool permanent = false, bool preserveMethod = false, string? fragment = null); ++ public static RedirectToRouteHttpResult RedirectToRoute(string routeName = null, object routeValues = null, bool permanent = false, bool preserveMethod = false, string fragment = null); +- public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null); ++ public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null); +- public static FileStreamHttpResult Stream(PipeReader pipeReader, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false); ++ public static FileStreamHttpResult Stream(PipeReader pipeReader, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false); +- public static FileStreamHttpResult Stream(Stream stream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false); ++ public static FileStreamHttpResult Stream(Stream stream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false); +- public static ContentHttpResult Text(string content, string? contentType = null, Encoding? contentEncoding = null); ++ public static ContentHttpResult Text(string content, string contentType, Encoding contentEncoding); ++ public static ContentHttpResult Text(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?)); +- public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue? error); ++ public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue error); +- public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string? detail = null, string? instance = null, string? title = null, string? type = null, IDictionary<string, object?>? extensions = null); ++ public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string detail = null, string instance = null, string title = null, string type = null, IDictionary<string, object?>? extensions = null); +- public static VirtualFileHttpResult VirtualFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false); ++ public static VirtualFileHttpResult VirtualFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md new file mode 100644 index 00000000..d7e1ebbf --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md @@ -0,0 +1,8 @@ +# Microsoft.AspNetCore.Mvc + +``` diff + namespace Microsoft.AspNetCore.Mvc { + public class FromServicesAttribute : Attribute, IBindingSourceMetadata, IFromServiceMetadata + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md new file mode 100644 index 00000000..1f058d5e --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md @@ -0,0 +1,11 @@ +# Microsoft.AspNetCore.ResponseCompression + +``` diff + namespace Microsoft.AspNetCore.ResponseCompression { + public class CompressionProviderCollection : Collection<ICompressionProvider> { +- public void Add(Type providerType); ++ public void Add([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type providerType); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md new file mode 100644 index 00000000..8f5c5a29 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md @@ -0,0 +1,10 @@ +# Microsoft.AspNetCore.SignalR + +``` diff + namespace Microsoft.AspNetCore.SignalR { + public interface IInvocationBinder { ++ string? GetTarget(ReadOnlySpan<byte> utf8Bytes); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md new file mode 100644 index 00000000..4c703123 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md @@ -0,0 +1,14 @@ +# Microsoft.AspNetCore.WebUtilities + +``` diff + namespace Microsoft.AspNetCore.WebUtilities { + public class FormMultipartSection { ++ public ValueTask<string> GetValueAsync(CancellationToken cancellationToken); + } + public static class MultipartSectionStreamExtensions { + public static Task<string> ReadAsStringAsync(this MultipartSection section); ++ public static ValueTask<string> ReadAsStringAsync(this MultipartSection section, CancellationToken cancellationToken); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md new file mode 100644 index 00000000..21297253 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md @@ -0,0 +1,12 @@ +# Microsoft.Extensions.Logging + +``` diff + namespace Microsoft.Extensions.Logging { + public class LoggerFactory : IDisposable, ILoggerFactory { +- public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null); ++ public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options); ++ public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null, IExternalScopeProvider? scopeProvider = null); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md new file mode 100644 index 00000000..59d2a397 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md @@ -0,0 +1,14 @@ +# Microsoft.JSInterop.Infrastructure + +``` diff + namespace Microsoft.JSInterop.Infrastructure { + public static class DotNetDispatcher + { ++ [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")] + public static string? Invoke(Microsoft.JSInterop.JSRuntime jsRuntime, in Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson); ++ [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")] + public static void BeginInvokeDotNet(Microsoft.JSInterop.JSRuntime jsRuntime, Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md new file mode 100644 index 00000000..106f6383 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md @@ -0,0 +1,33 @@ +# API Difference 7.0-preview4 vs 7.0-preview5 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [Microsoft.VisualBasic.FileIO](7.0-preview5_Microsoft.VisualBasic.FileIO.md) +* [System](7.0-preview5_System.md) +* [System.Collections.Immutable](7.0-preview5_System.Collections.Immutable.md) +* [System.ComponentModel](7.0-preview5_System.ComponentModel.md) +* [System.Data](7.0-preview5_System.Data.md) +* [System.Diagnostics](7.0-preview5_System.Diagnostics.md) +* [System.IO](7.0-preview5_System.IO.md) +* [System.Net](7.0-preview5_System.Net.md) +* [System.Net.Http](7.0-preview5_System.Net.Http.md) +* [System.Net.NetworkInformation](7.0-preview5_System.Net.NetworkInformation.md) +* [System.Net.Security](7.0-preview5_System.Net.Security.md) +* [System.Net.Sockets](7.0-preview5_System.Net.Sockets.md) +* [System.Numerics](7.0-preview5_System.Numerics.md) +* [System.Reflection.Emit](7.0-preview5_System.Reflection.Emit.md) +* [System.Reflection.Metadata.Ecma335](7.0-preview5_System.Reflection.Metadata.Ecma335.md) +* [System.Runtime.CompilerServices](7.0-preview5_System.Runtime.CompilerServices.md) +* [System.Runtime.InteropServices](7.0-preview5_System.Runtime.InteropServices.md) +* [System.Runtime.InteropServices.Marshalling](7.0-preview5_System.Runtime.InteropServices.Marshalling.md) +* [System.Runtime.Intrinsics](7.0-preview5_System.Runtime.Intrinsics.md) +* [System.Runtime.Intrinsics.X86](7.0-preview5_System.Runtime.Intrinsics.X86.md) +* [System.Security.Cryptography](7.0-preview5_System.Security.Cryptography.md) +* [System.Security.Cryptography.X509Certificates](7.0-preview5_System.Security.Cryptography.X509Certificates.md) +* [System.Text.Json](7.0-preview5_System.Text.Json.md) +* [System.Text.Json.Nodes](7.0-preview5_System.Text.Json.Nodes.md) +* [System.Text.Json.Serialization](7.0-preview5_System.Text.Json.Serialization.md) +* [System.Text.Json.Serialization.Metadata](7.0-preview5_System.Text.Json.Serialization.Metadata.md) +* [System.Threading](7.0-preview5_System.Threading.md) + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md new file mode 100644 index 00000000..6481ee6c --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md @@ -0,0 +1,10 @@ +# Microsoft.VisualBasic.FileIO + +``` diff + namespace Microsoft.VisualBasic.FileIO { + public class TextFieldParser : IDisposable { + public string[]? CommentTokens { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md new file mode 100644 index 00000000..728b66b0 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md @@ -0,0 +1,42 @@ +# System.Collections.Immutable + +``` diff + namespace System.Collections.Immutable { + public readonly struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable { ++ public ImmutableArray<T> AddRange(ImmutableArray<T> items, int length); ++ public ImmutableArray<T> AddRange(T[] items, int length); ++ public ImmutableArray<T> AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T; ++ public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T; + public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> { ++ public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length); ++ public void CopyTo(T[] destination); ++ public int IndexOf(T item, int startIndex, IEqualityComparer<T>? equalityComparer); ++ public void InsertRange(int index, IEnumerable<T> items); ++ public void InsertRange(int index, ImmutableArray<T> items); ++ public bool Remove(T element, IEqualityComparer<T>? equalityComparer); ++ public void RemoveAll(Predicate<T> match); ++ public void RemoveRange(IEnumerable<T> items); ++ public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer); ++ public void RemoveRange(int index, int length); ++ public void Replace(T oldValue, T newValue); ++ public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer); + } + } + public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> { + public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> { ++ public bool Remove(T item, IEqualityComparer<T>? equalityComparer); ++ public void RemoveRange(IEnumerable<T> items); ++ public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer); ++ public void RemoveRange(int index, int count); ++ public void Replace(T oldValue, T newValue); ++ public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer); + } + } + public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> { + public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> { ++ public int IndexOf(T item); + } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md new file mode 100644 index 00000000..67b6a2b5 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md @@ -0,0 +1,13 @@ +# System.ComponentModel + +``` diff + namespace System.ComponentModel { + public sealed class TypeDescriptor { ++ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static Type ComObjectType { get; } ++ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static Type InterfaceType { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md new file mode 100644 index 00000000..5a554bc6 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md @@ -0,0 +1,13 @@ +# System.Data + +``` diff + namespace System.Data { + public class DataColumn : MarshalByValueComponent { + public Type DataType { get; set; } + } + public enum SerializationFormat { + Binary = 1, + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md new file mode 100644 index 00000000..1fefc80e --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md @@ -0,0 +1,17 @@ +# System.Diagnostics + +``` diff + namespace System.Diagnostics { + public readonly struct ActivityEvent { ++ public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects(); + } + public readonly struct ActivityLink : IEquatable<ActivityLink> { ++ public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects(); + } + public class Process : Component, IDisposable { + public TimeSpan PrivilegedProcessorTime { get; } + public DateTime StartTime { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md new file mode 100644 index 00000000..f177f46c --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md @@ -0,0 +1,23 @@ +# System.IO + +``` diff + namespace System.IO { + public static class File { ++ public static IAsyncEnumerable<string> ReadLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)); ++ public static IAsyncEnumerable<string> ReadLinesAsync(string path, CancellationToken cancellationToken = default(CancellationToken)); + } + public class FileStream : Stream { + public virtual void Lock(long position, long length); + public virtual void Unlock(long position, long length); + } + public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable { ++ public int ReadAtLeast(Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true); ++ public ValueTask<int> ReadAtLeastAsync(Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken)); ++ public void ReadExactly(byte[] buffer, int offset, int count); ++ public void ReadExactly(Span<byte> buffer); ++ public ValueTask ReadExactlyAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default(CancellationToken)); ++ public ValueTask ReadExactlyAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken)); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md new file mode 100644 index 00000000..8aedea8d --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md @@ -0,0 +1,10 @@ +# System.Net.Http + +``` diff + namespace System.Net.Http { + public class HttpClientHandler : HttpMessageHandler { + public IWebProxy Proxy { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md new file mode 100644 index 00000000..329d97dc --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md @@ -0,0 +1,21 @@ +# System.Net.NetworkInformation + +``` diff + namespace System.Net.NetworkInformation { + public abstract class IPInterfaceStatistics { + public abstract long OutgoingPacketsDiscarded { get; } + } + public abstract class IPv4InterfaceStatistics { + public abstract long OutgoingPacketsDiscarded { get; } + } + public class NetworkChange { + public static event NetworkAddressChangedEventHandler NetworkAddressChanged; + public static event NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged; + } + public abstract class NetworkInterface { + public static int IPv6LoopbackInterfaceIndex { get; } + public static int LoopbackInterfaceIndex { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md new file mode 100644 index 00000000..0e2ee3c9 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md @@ -0,0 +1,13 @@ +# System.Net.Security + +``` diff + namespace System.Net.Security { + public readonly struct SslClientHelloInfo { + public string ServerName { get; } + public SslProtocols SslProtocols { get; } + } +- public sealed class SslStreamCertificateContext ++ public class SslStreamCertificateContext + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md new file mode 100644 index 00000000..2c06f78f --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md @@ -0,0 +1,16 @@ +# System.Net.Sockets + +``` diff + namespace System.Net.Sockets { + public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid { ++ public override bool IsInvalid { get; } + } + public sealed class UnixDomainSocketEndPoint : EndPoint { ++ public override AddressFamily AddressFamily { get; } ++ public override EndPoint Create(SocketAddress socketAddress); ++ public override SocketAddress Serialize(); ++ public override string ToString(); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md new file mode 100644 index 00000000..e0466298 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md @@ -0,0 +1,10 @@ +# System.Net + +``` diff + namespace System.Net { + public class IPAddress { + public long Address { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md new file mode 100644 index 00000000..1ef7bf18 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md @@ -0,0 +1,239 @@ +# System.Numerics + +``` diff + namespace System.Numerics { +- public readonly struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable, ISpanFormattable { ++ public readonly struct BigInteger : IAdditionOperators<BigInteger, BigInteger, BigInteger>, IAdditiveIdentity<BigInteger, BigInteger>, IBinaryInteger<BigInteger>, IBinaryNumber<BigInteger>, IBitwiseOperators<BigInteger, BigInteger, BigInteger>, IComparable, IComparable<BigInteger>, IComparisonOperators<BigInteger, BigInteger>, IDecrementOperators<BigInteger>, IDivisionOperators<BigInteger, BigInteger, BigInteger>, IEqualityOperators<BigInteger, BigInteger>, IEquatable<BigInteger>, IFormattable, IIncrementOperators<BigInteger>, IModulusOperators<BigInteger, BigInteger, BigInteger>, IMultiplicativeIdentity<BigInteger, BigInteger>, IMultiplyOperators<BigInteger, BigInteger, BigInteger>, INumber<BigInteger>, INumberBase<BigInteger>, IParsable<BigInteger>, IShiftOperators<BigInteger, BigInteger>, ISignedNumber<BigInteger>, ISpanFormattable, ISpanParsable<BigInteger>, ISubtractionOperators<BigInteger, BigInteger, BigInteger>, IUnaryNegationOperators<BigInteger, BigInteger>, IUnaryPlusOperators<BigInteger, BigInteger> { ++ static BigInteger System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.AdditiveIdentity { get; } ++ static BigInteger System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.MultiplicativeIdentity { get; } ++ static int System.Numerics.INumberBase<System.Numerics.BigInteger>.Radix { get; } ++ static BigInteger System.Numerics.ISignedNumber<System.Numerics.BigInteger>.NegativeOne { get; } ++ public static BigInteger Clamp(BigInteger value, BigInteger min, BigInteger max); ++ public static BigInteger CopySign(BigInteger value, BigInteger sign); ++ public static (BigInteger Quotient, BigInteger Remainder) DivRem(BigInteger left, BigInteger right); ++ public static bool IsEvenInteger(BigInteger value); ++ public static bool IsNegative(BigInteger value); ++ public static bool IsOddInteger(BigInteger value); ++ public static bool IsPositive(BigInteger value); ++ public static bool IsPow2(BigInteger value); ++ public static BigInteger LeadingZeroCount(BigInteger value); ++ public static BigInteger Log2(BigInteger value); ++ public static BigInteger MaxMagnitude(BigInteger x, BigInteger y); ++ public static BigInteger MinMagnitude(BigInteger x, BigInteger y); ++ public static explicit operator BigInteger (Half value); ++ public static explicit operator char (BigInteger value); ++ public static explicit operator Half (BigInteger value); ++ public static explicit operator Int128 (BigInteger value); ++ public static explicit operator nint (BigInteger value); ++ public static explicit operator UInt128 (BigInteger value); ++ public static explicit operator nuint (BigInteger value); ++ public static explicit operator BigInteger (Complex value); ++ public static implicit operator BigInteger (char value); ++ public static implicit operator BigInteger (Int128 value); ++ public static implicit operator BigInteger (IntPtr value); ++ public static implicit operator BigInteger (UInt128 value); ++ public static implicit operator BigInteger (UIntPtr value); ++ public static BigInteger operator >>>(BigInteger value, int shiftAmount); ++ public static BigInteger Parse(ReadOnlySpan<char> s, IFormatProvider? provider); ++ public static BigInteger PopCount(BigInteger value); ++ public static BigInteger RotateLeft(BigInteger value, int rotateAmount); ++ public static BigInteger RotateRight(BigInteger value, int rotateAmount); ++ static BigInteger IAdditionOperators<BigInteger, BigInteger, BigInteger>.operator checked +(BigInteger left, BigInteger right); ++ int IBinaryInteger<BigInteger>.GetByteCount(); ++ int IBinaryInteger<BigInteger>.GetShortestBitLength(); ++ bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten); ++ static BigInteger IDecrementOperators<BigInteger>.operator checked --(BigInteger value); ++ static BigInteger IDivisionOperators<BigInteger, BigInteger, BigInteger>.operator checked /(BigInteger left, BigInteger right); ++ static BigInteger IIncrementOperators<BigInteger>.operator checked ++(BigInteger value); ++ static BigInteger IMultiplyOperators<BigInteger, BigInteger, BigInteger>.operator checked *(BigInteger left, BigInteger right); ++ static BigInteger INumber<BigInteger>.MaxNumber(BigInteger x, BigInteger y); ++ static BigInteger INumber<BigInteger>.MinNumber(BigInteger x, BigInteger y); ++ static int INumber<BigInteger>.Sign(BigInteger value); ++ static bool INumberBase<BigInteger>.IsCanonical(BigInteger value); ++ static bool INumberBase<BigInteger>.IsComplexNumber(BigInteger value); ++ static bool INumberBase<BigInteger>.IsFinite(BigInteger value); ++ static bool INumberBase<BigInteger>.IsImaginaryNumber(BigInteger value); ++ static bool INumberBase<BigInteger>.IsInfinity(BigInteger value); ++ static bool INumberBase<BigInteger>.IsInteger(BigInteger value); ++ static bool INumberBase<BigInteger>.IsNaN(BigInteger value); ++ static bool INumberBase<BigInteger>.IsNegativeInfinity(BigInteger value); ++ static bool INumberBase<BigInteger>.IsNormal(BigInteger value); ++ static bool INumberBase<BigInteger>.IsPositiveInfinity(BigInteger value); ++ static bool INumberBase<BigInteger>.IsRealNumber(BigInteger value); ++ static bool INumberBase<BigInteger>.IsSubnormal(BigInteger value); ++ static bool INumberBase<BigInteger>.IsZero(BigInteger value); ++ static BigInteger INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger x, BigInteger y); ++ static BigInteger INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger x, BigInteger y); ++ static bool INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther value, out BigInteger result); ++ static bool INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther value, out BigInteger result); ++ static bool INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther value, out BigInteger result); ++ static bool INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger value, out TOther result); ++ static bool INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger value, out TOther result); ++ static bool INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger value, out TOther result); ++ static BigInteger ISubtractionOperators<BigInteger, BigInteger, BigInteger>.operator checked -(BigInteger left, BigInteger right); ++ static BigInteger IUnaryNegationOperators<BigInteger, BigInteger>.operator checked -(BigInteger value); ++ public static BigInteger TrailingZeroCount(BigInteger value); ++ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out BigInteger result); ++ public static bool TryParse(string? s, IFormatProvider? provider, out BigInteger result); + } +- public readonly struct Complex : IEquatable<Complex>, IFormattable { ++ public readonly struct Complex : IAdditionOperators<Complex, Complex, Complex>, IAdditiveIdentity<Complex, Complex>, IDecrementOperators<Complex>, IDivisionOperators<Complex, Complex, Complex>, IEqualityOperators<Complex, Complex>, IEquatable<Complex>, IFormattable, IIncrementOperators<Complex>, IMultiplicativeIdentity<Complex, Complex>, IMultiplyOperators<Complex, Complex, Complex>, INumberBase<Complex>, IParsable<Complex>, ISignedNumber<Complex>, ISpanFormattable, ISpanParsable<Complex>, ISubtractionOperators<Complex, Complex, Complex>, IUnaryNegationOperators<Complex, Complex>, IUnaryPlusOperators<Complex, Complex> { ++ static Complex System.Numerics.IAdditiveIdentity<System.Numerics.Complex,System.Numerics.Complex>.AdditiveIdentity { get; } ++ static Complex System.Numerics.IMultiplicativeIdentity<System.Numerics.Complex,System.Numerics.Complex>.MultiplicativeIdentity { get; } ++ static Complex System.Numerics.INumberBase<System.Numerics.Complex>.One { get; } ++ static int System.Numerics.INumberBase<System.Numerics.Complex>.Radix { get; } ++ static Complex System.Numerics.INumberBase<System.Numerics.Complex>.Zero { get; } ++ static Complex System.Numerics.ISignedNumber<System.Numerics.Complex>.NegativeOne { get; } ++ public static bool IsComplexNumber(Complex value); ++ public static bool IsEvenInteger(Complex value); ++ public static bool IsImaginaryNumber(Complex value); ++ public static bool IsInteger(Complex value); ++ public static bool IsNegative(Complex value); ++ public static bool IsNegativeInfinity(Complex value); ++ public static bool IsNormal(Complex value); ++ public static bool IsOddInteger(Complex value); ++ public static bool IsPositive(Complex value); ++ public static bool IsPositiveInfinity(Complex value); ++ public static bool IsRealNumber(Complex value); ++ public static bool IsSubnormal(Complex value); ++ public static Complex MaxMagnitude(Complex x, Complex y); ++ public static Complex MinMagnitude(Complex x, Complex y); ++ public static Complex operator --(Complex value); ++ public static explicit operator Complex (Int128 value); ++ public static explicit operator Complex (UInt128 value); ++ public static implicit operator Complex (char value); ++ public static implicit operator Complex (Half value); ++ public static implicit operator Complex (IntPtr value); ++ public static implicit operator Complex (UIntPtr value); ++ public static Complex operator ++(Complex value); ++ public static Complex operator +(Complex value); ++ public static Complex Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider); ++ public static Complex Parse(ReadOnlySpan<char> s, IFormatProvider? provider); ++ public static Complex Parse(string s, NumberStyles style, IFormatProvider? provider); ++ public static Complex Parse(string s, IFormatProvider? provider); ++ static Complex IAdditionOperators<Complex, Complex, Complex>.operator checked +(Complex left, Complex right); ++ static Complex IDecrementOperators<Complex>.operator checked --(Complex value); ++ static Complex IDivisionOperators<Complex, Complex, Complex>.operator checked /(Complex left, Complex right); ++ static Complex IIncrementOperators<Complex>.operator checked ++(Complex value); ++ static Complex IMultiplyOperators<Complex, Complex, Complex>.operator checked *(Complex left, Complex right); ++ static Complex INumberBase<Complex>.Abs(Complex value); ++ static bool INumberBase<Complex>.IsCanonical(Complex value); ++ static bool INumberBase<Complex>.IsZero(Complex value); ++ static Complex INumberBase<Complex>.MaxMagnitudeNumber(Complex x, Complex y); ++ static Complex INumberBase<Complex>.MinMagnitudeNumber(Complex x, Complex y); ++ static bool INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther value, out Complex result); ++ static bool INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther value, out Complex result); ++ static bool INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther value, out Complex result); ++ static bool INumberBase<Complex>.TryConvertToChecked<TOther>(Complex value, out TOther result); ++ static bool INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex value, out TOther result); ++ static bool INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex value, out TOther result); ++ static Complex ISubtractionOperators<Complex, Complex, Complex>.operator checked -(Complex left, Complex right); ++ static Complex IUnaryNegationOperators<Complex, Complex>.operator checked -(Complex value); ++ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider); ++ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Complex result); ++ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Complex result); ++ public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Complex result); ++ public static bool TryParse(string? s, IFormatProvider? provider, out Complex result); + } + public interface IBinaryInteger<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IBinaryNumber<TSelf>, IBitwiseOperators<TSelf, TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IShiftOperators<TSelf, TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IBinaryInteger<TSelf> { +- long GetShortestBitLength(); ++ int GetShortestBitLength(); ++ bool TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ int WriteBigEndian(byte[] destination); ++ int WriteBigEndian(byte[] destination, int startIndex); ++ int WriteBigEndian(Span<byte> destination); + } + public interface IExponentialFunctions<TSelf> where TSelf : IExponentialFunctions<TSelf> { ++ static abstract TSelf Exp10(TSelf x); ++ static abstract TSelf Exp10M1(TSelf x); ++ static abstract TSelf Exp2(TSelf x); ++ static abstract TSelf Exp2M1(TSelf x); ++ static abstract TSelf ExpM1(TSelf x); + } + public interface IFloatingPoint<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPoint<TSelf> { +- long GetExponentShortestBitLength(); ++ int GetExponentShortestBitLength(); +- long GetSignificandBitLength(); ++ int GetSignificandBitLength(); ++ bool TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ int WriteExponentBigEndian(byte[] destination); ++ int WriteExponentBigEndian(byte[] destination, int startIndex); ++ int WriteExponentBigEndian(Span<byte> destination); ++ int WriteSignificandBigEndian(byte[] destination); ++ int WriteSignificandBigEndian(byte[] destination, int startIndex); ++ int WriteSignificandBigEndian(Span<byte> destination); + } + public interface IFloatingPointIeee754<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IExponentialFunctions<TSelf>, IFloatingPoint<TSelf>, IFormattable, IHyperbolicFunctions<TSelf>, IIncrementOperators<TSelf>, ILogarithmicFunctions<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IPowerFunctions<TSelf>, IRootFunctions<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, ITrigonometricFunctions<TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPointIeee754<TSelf> { +- static abstract bool IsFinite(TSelf value); +- static abstract bool IsInfinity(TSelf value); +- static abstract bool IsNaN(TSelf value); +- static abstract bool IsNegativeInfinity(TSelf value); +- static abstract bool IsNormal(TSelf value); +- static abstract bool IsPositiveInfinity(TSelf value); +- static abstract bool IsSubnormal(TSelf value); + } + public interface ILogarithmicFunctions<TSelf> where TSelf : ILogarithmicFunctions<TSelf> { ++ static abstract TSelf Log10P1(TSelf x); ++ static abstract TSelf Log2P1(TSelf x); ++ static abstract TSelf LogP1(TSelf x); + } + public interface INumber<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumber<TSelf> { +- static abstract TSelf Abs(TSelf value); +- static abstract TSelf CreateChecked<TOther>(TOther value); +- static abstract TSelf CreateSaturating<TOther>(TOther value); +- static abstract TSelf CreateTruncating<TOther>(TOther value); +- static abstract bool IsNegative(TSelf value); +- static abstract TSelf MaxMagnitude(TSelf x, TSelf y); ++ static abstract TSelf MaxNumber(TSelf x, TSelf y); +- static abstract TSelf MinMagnitude(TSelf x, TSelf y); ++ static abstract TSelf MinNumber(TSelf x, TSelf y); +- static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider); +- static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider); +- static abstract bool TryCreate<TOther>(TOther value, out TSelf result); +- static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result); +- static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result); + } +- public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> { ++ public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> { ++ static abstract int Radix { get; } ++ static abstract TSelf Abs(TSelf value); ++ static TSelf CreateChecked<TOther>(TOther value); ++ static TSelf CreateSaturating<TOther>(TOther value); ++ static TSelf CreateTruncating<TOther>(TOther value); ++ static abstract bool IsCanonical(TSelf value); ++ static abstract bool IsComplexNumber(TSelf value); ++ static abstract bool IsEvenInteger(TSelf value); ++ static abstract bool IsFinite(TSelf value); ++ static abstract bool IsImaginaryNumber(TSelf value); ++ static abstract bool IsInfinity(TSelf value); ++ static abstract bool IsInteger(TSelf value); ++ static abstract bool IsNaN(TSelf value); ++ static abstract bool IsNegative(TSelf value); ++ static abstract bool IsNegativeInfinity(TSelf value); ++ static abstract bool IsNormal(TSelf value); ++ static abstract bool IsOddInteger(TSelf value); ++ static abstract bool IsPositive(TSelf value); ++ static abstract bool IsPositiveInfinity(TSelf value); ++ static abstract bool IsRealNumber(TSelf value); ++ static abstract bool IsSubnormal(TSelf value); ++ static abstract bool IsZero(TSelf value); ++ static abstract TSelf MaxMagnitude(TSelf x, TSelf y); ++ static abstract TSelf MaxMagnitudeNumber(TSelf x, TSelf y); ++ static abstract TSelf MinMagnitude(TSelf x, TSelf y); ++ static abstract TSelf MinMagnitudeNumber(TSelf x, TSelf y); ++ static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider); ++ static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider); ++ static abstract bool TryConvertFromChecked<TOther>(TOther value, out TSelf? result); ++ static abstract bool TryConvertFromSaturating<TOther>(TOther value, out TSelf? result); ++ static abstract bool TryConvertFromTruncating<TOther>(TOther value, out TSelf? result); ++ static abstract bool TryConvertToChecked<TOther>(TSelf value, out TOther? result); ++ static abstract bool TryConvertToSaturating<TOther>(TSelf value, out TOther? result); ++ static abstract bool TryConvertToTruncating<TOther>(TSelf value, out TOther? result); ++ static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result); ++ static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md new file mode 100644 index 00000000..7ae5d108 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md @@ -0,0 +1,14 @@ +# System.Reflection.Emit + +``` diff + namespace System.Reflection.Emit { + public sealed class AssemblyBuilder : Assembly { + public override string? CodeBase { get; } + } + public class ModuleBuilder : Module { + public override string FullyQualifiedName { get; } + public override string Name { get; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md new file mode 100644 index 00000000..12659e0c --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md @@ -0,0 +1,17 @@ +# System.Reflection.Metadata.Ecma335 + +``` diff + namespace System.Reflection.Metadata.Ecma335 { + public readonly struct BlobEncoder { ++ public FieldTypeEncoder Field(); + } ++ public readonly struct FieldTypeEncoder { ++ public FieldTypeEncoder(BlobBuilder builder); ++ public BlobBuilder Builder { get; } ++ public CustomModifiersEncoder CustomModifiers(); ++ public SignatureTypeEncoder Type(bool isByRef = false); ++ public void TypedReference(); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md new file mode 100644 index 00000000..b0524c1f --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md @@ -0,0 +1,10 @@ +# System.Runtime.CompilerServices + +``` diff + namespace System.Runtime.CompilerServices { + public static class RuntimeFeature { ++ public const string NumericIntPtr = "NumericIntPtr"; + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md new file mode 100644 index 00000000..49642ce1 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md @@ -0,0 +1,104 @@ +# System.Runtime.InteropServices.Marshalling + +``` diff ++namespace System.Runtime.InteropServices.Marshalling { ++ public ref struct AnsiStringMarshaller { ++ public AnsiStringMarshaller(string? str); ++ public AnsiStringMarshaller(string? str, Span<byte> buffer); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(byte* value); ++ public string? ToManaged(); ++ public unsafe byte* ToNativeValue(); ++ } ++ public ref struct ArrayMarshaller<T> { ++ public ArrayMarshaller(int sizeOfNativeElement); ++ public ArrayMarshaller(T[]? array, int sizeOfNativeElement); ++ public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(byte* value); ++ public Span<T> GetManagedValuesDestination(int length); ++ public ReadOnlySpan<T> GetManagedValuesSource(); ++ public Span<byte> GetNativeValuesDestination(); ++ public ReadOnlySpan<byte> GetNativeValuesSource(int length); ++ public ref byte GetPinnableReference(); ++ public T[]? ToManaged(); ++ public unsafe byte* ToNativeValue(); ++ } ++ public ref struct BStrStringMarshaller { ++ public BStrStringMarshaller(string? str); ++ public BStrStringMarshaller(string? str, Span<ushort> buffer); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(void* value); ++ public string? ToManaged(); ++ public unsafe void* ToNativeValue(); ++ } ++ public sealed class CustomTypeMarshallerAttribute : Attribute { ++ public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value); ++ public int BufferSize { get; set; } ++ public CustomTypeMarshallerDirection Direction { get; set; } ++ public CustomTypeMarshallerFeatures Features { get; set; } ++ public Type ManagedType { get; } ++ public CustomTypeMarshallerKind MarshallerKind { get; } ++ public struct GenericPlaceholder ++ } ++ public enum CustomTypeMarshallerDirection { ++ In = 1, ++ None = 0, ++ Out = 2, ++ Ref = 3, ++ } ++ public enum CustomTypeMarshallerFeatures { ++ CallerAllocatedBuffer = 2, ++ None = 0, ++ TwoStageMarshalling = 4, ++ UnmanagedResources = 1, ++ } ++ public enum CustomTypeMarshallerKind { ++ LinearCollection = 1, ++ Value = 0, ++ } ++ public sealed class MarshalUsingAttribute : Attribute { ++ public const string ReturnsCountValue = "return-value"; ++ public MarshalUsingAttribute(); ++ public MarshalUsingAttribute(Type nativeType); ++ public int ConstantElementCount { get; set; } ++ public string CountElementName { get; set; } ++ public int ElementIndirectionDepth { get; set; } ++ public Type? NativeType { get; } ++ } ++ public sealed class NativeMarshallingAttribute : Attribute { ++ public NativeMarshallingAttribute(Type nativeType); ++ public Type NativeType { get; } ++ } ++ public ref struct PointerArrayMarshaller<T> where T : struct { ++ public PointerArrayMarshaller(int sizeOfNativeElement); ++ public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement); ++ public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(byte* value); ++ public Span<IntPtr> GetManagedValuesDestination(int length); ++ public ReadOnlySpan<IntPtr> GetManagedValuesSource(); ++ public Span<byte> GetNativeValuesDestination(); ++ public ReadOnlySpan<byte> GetNativeValuesSource(int length); ++ public ref byte GetPinnableReference(); ++ public T*[]? ToManaged(); ++ public unsafe byte* ToNativeValue(); ++ } ++ public ref struct Utf16StringMarshaller { ++ public Utf16StringMarshaller(string? str); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(void* value); ++ public string? ToManaged(); ++ public unsafe void* ToNativeValue(); ++ } ++ public ref struct Utf8StringMarshaller { ++ public Utf8StringMarshaller(string? str); ++ public Utf8StringMarshaller(string? str, Span<byte> buffer); ++ public void FreeNative(); ++ public unsafe void FromNativeValue(byte* value); ++ public string? ToManaged(); ++ public unsafe byte* ToNativeValue(); ++ } ++} +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md new file mode 100644 index 00000000..203cb608 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md @@ -0,0 +1,160 @@ +# System.Runtime.InteropServices + +``` diff + namespace System.Runtime.InteropServices { +- public ref struct AnsiStringMarshaller { +- public AnsiStringMarshaller(string? str); +- public AnsiStringMarshaller(string? str, Span<byte> buffer); +- public void FreeNative(); +- public unsafe void FromNativeValue(byte* value); +- public string? ToManaged(); +- public unsafe byte* ToNativeValue(); +- } +- public ref struct ArrayMarshaller<T> { +- public ArrayMarshaller(int sizeOfNativeElement); +- public ArrayMarshaller(T[]? array, int sizeOfNativeElement); +- public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement); +- public void FreeNative(); +- public unsafe void FromNativeValue(byte* value); +- public Span<T> GetManagedValuesDestination(int length); +- public ReadOnlySpan<T> GetManagedValuesSource(); +- public Span<byte> GetNativeValuesDestination(); +- public ReadOnlySpan<byte> GetNativeValuesSource(int length); +- public ref byte GetPinnableReference(); +- public T[]? ToManaged(); +- public unsafe byte* ToNativeValue(); +- } +- public sealed class CustomTypeMarshallerAttribute : Attribute { +- public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value); +- public int BufferSize { get; set; } +- public CustomTypeMarshallerDirection Direction { get; set; } +- public CustomTypeMarshallerFeatures Features { get; set; } +- public Type ManagedType { get; } +- public CustomTypeMarshallerKind MarshallerKind { get; } +- public struct GenericPlaceholder +- } +- public enum CustomTypeMarshallerDirection { +- In = 1, +- None = 0, +- Out = 2, +- Ref = 3, +- } +- public enum CustomTypeMarshallerFeatures { +- CallerAllocatedBuffer = 2, +- None = 0, +- TwoStageMarshalling = 4, +- UnmanagedResources = 1, +- } +- public enum CustomTypeMarshallerKind { +- LinearCollection = 1, +- Value = 0, +- } +- public sealed class MarshalUsingAttribute : Attribute { +- public const string ReturnsCountValue = "return-value"; +- public MarshalUsingAttribute(); +- public MarshalUsingAttribute(Type nativeType); +- public int ConstantElementCount { get; set; } +- public string CountElementName { get; set; } +- public int ElementIndirectionDepth { get; set; } +- public Type? NativeType { get; } +- } +- public sealed class NativeMarshallingAttribute : Attribute { +- public NativeMarshallingAttribute(Type nativeType); +- public Type NativeType { get; } +- } + public static class NativeMemory { ++ public unsafe static void ZeroMemory(void* ptr, UIntPtr byteCount); + } + public readonly struct NFloat : IAdditionOperators<NFloat, NFloat, NFloat>, IAdditiveIdentity<NFloat, NFloat>, IBinaryFloatingPointIeee754<NFloat>, IBinaryNumber<NFloat>, IBitwiseOperators<NFloat, NFloat, NFloat>, IComparable, IComparable<NFloat>, IComparisonOperators<NFloat, NFloat>, IDecrementOperators<NFloat>, IDivisionOperators<NFloat, NFloat, NFloat>, IEqualityOperators<NFloat, NFloat>, IEquatable<NFloat>, IExponentialFunctions<NFloat>, IFloatingPoint<NFloat>, IFloatingPointIeee754<NFloat>, IFormattable, IHyperbolicFunctions<NFloat>, IIncrementOperators<NFloat>, ILogarithmicFunctions<NFloat>, IMinMaxValue<NFloat>, IModulusOperators<NFloat, NFloat, NFloat>, IMultiplicativeIdentity<NFloat, NFloat>, IMultiplyOperators<NFloat, NFloat, NFloat>, INumber<NFloat>, INumberBase<NFloat>, IParsable<NFloat>, IPowerFunctions<NFloat>, IRootFunctions<NFloat>, ISignedNumber<NFloat>, ISpanFormattable, ISpanParsable<NFloat>, ISubtractionOperators<NFloat, NFloat, NFloat>, ITrigonometricFunctions<NFloat>, IUnaryNegationOperators<NFloat, NFloat>, IUnaryPlusOperators<NFloat, NFloat> { ++ static int System.Numerics.INumberBase<System.Runtime.InteropServices.NFloat>.Radix { get; } +- public static NFloat CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static NFloat CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static NFloat CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static NFloat Exp10(NFloat x); ++ public static NFloat Exp10M1(NFloat x); ++ public static NFloat Exp2(NFloat x); ++ public static NFloat Exp2M1(NFloat x); ++ public static NFloat ExpM1(NFloat x); ++ public static bool IsEvenInteger(NFloat value); ++ public static bool IsInteger(NFloat value); ++ public static bool IsOddInteger(NFloat value); ++ public static bool IsPositive(NFloat value); ++ public static bool IsRealNumber(NFloat value); ++ public static NFloat Log10P1(NFloat x); ++ public static NFloat Log2P1(NFloat x); ++ public static NFloat LogP1(NFloat x); ++ public static NFloat MaxMagnitudeNumber(NFloat x, NFloat y); ++ public static NFloat MaxNumber(NFloat x, NFloat y); ++ public static NFloat MinMagnitudeNumber(NFloat x, NFloat y); ++ public static NFloat MinNumber(NFloat x, NFloat y); ++ public static explicit operator checked byte (NFloat value); ++ public static explicit operator checked char (NFloat value); ++ public static explicit operator checked short (NFloat value); ++ public static explicit operator checked int (NFloat value); ++ public static explicit operator checked long (NFloat value); ++ public static explicit operator checked Int128 (NFloat value); ++ public static explicit operator checked IntPtr (NFloat value); ++ public static explicit operator checked sbyte (NFloat value); ++ public static explicit operator checked ushort (NFloat value); ++ public static explicit operator checked uint (NFloat value); ++ public static explicit operator checked ulong (NFloat value); ++ public static explicit operator checked UInt128 (NFloat value); ++ public static explicit operator checked UIntPtr (NFloat value); ++ public static explicit operator NFloat (Int128 value); ++ public static explicit operator Half (NFloat value); ++ public static explicit operator Int128 (NFloat value); ++ public static explicit operator UInt128 (NFloat value); ++ public static explicit operator NFloat (UInt128 value); ++ public static implicit operator NFloat (Half value); +- long IFloatingPoint<NFloat>.GetExponentShortestBitLength(); ++ int IFloatingPoint<NFloat>.GetExponentShortestBitLength(); +- long IFloatingPoint<NFloat>.GetSignificandBitLength(); ++ int IFloatingPoint<NFloat>.GetSignificandBitLength(); ++ bool IFloatingPoint<NFloat>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IFloatingPoint<NFloat>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ static bool INumberBase<NFloat>.IsCanonical(NFloat value); ++ static bool INumberBase<NFloat>.IsComplexNumber(NFloat value); ++ static bool INumberBase<NFloat>.IsImaginaryNumber(NFloat value); ++ static bool INumberBase<NFloat>.IsZero(NFloat value); ++ static bool INumberBase<NFloat>.TryConvertFromChecked<TOther>(TOther value, out NFloat result); ++ static bool INumberBase<NFloat>.TryConvertFromSaturating<TOther>(TOther value, out NFloat result); ++ static bool INumberBase<NFloat>.TryConvertFromTruncating<TOther>(TOther value, out NFloat result); ++ static bool INumberBase<NFloat>.TryConvertToChecked<TOther>(NFloat value, out TOther result); ++ static bool INumberBase<NFloat>.TryConvertToSaturating<TOther>(NFloat value, out TOther result); ++ static bool INumberBase<NFloat>.TryConvertToTruncating<TOther>(NFloat value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out NFloat result) where TOther : INumber<TOther>; + } +- public ref struct PointerArrayMarshaller<T> where T : struct { +- public PointerArrayMarshaller(int sizeOfNativeElement); +- public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement); +- public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement); +- public void FreeNative(); +- public unsafe void FromNativeValue(byte* value); +- public Span<IntPtr> GetManagedValuesDestination(int length); +- public ReadOnlySpan<IntPtr> GetManagedValuesSource(); +- public Span<byte> GetNativeValuesDestination(); +- public ReadOnlySpan<byte> GetNativeValuesSource(int length); +- public ref byte GetPinnableReference(); +- public T*[]? ToManaged(); +- public unsafe byte* ToNativeValue(); +- } +- public ref struct Utf16StringMarshaller { +- public Utf16StringMarshaller(string? str); +- public Utf16StringMarshaller(string? str, Span<ushort> buffer); +- public void FreeNative(); +- public unsafe void FromNativeValue(ushort* value); +- public ref ushort GetPinnableReference(); +- public string? ToManaged(); +- public unsafe ushort* ToNativeValue(); +- } +- public ref struct Utf8StringMarshaller { +- public Utf8StringMarshaller(string? str); +- public Utf8StringMarshaller(string? str, Span<byte> buffer); +- public void FreeNative(); +- public unsafe void FromNativeValue(byte* value); +- public string? ToManaged(); +- public unsafe byte* ToNativeValue(); +- } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md new file mode 100644 index 00000000..23a3cf0d --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md @@ -0,0 +1,14 @@ +# System.Runtime.Intrinsics.X86 + +``` diff + namespace System.Runtime.Intrinsics.X86 { ++ public abstract class X86Serialize : X86Base { ++ public static new bool IsSupported { get; } ++ public static void Serialize(); ++ public new abstract class X64 : X86Base.X64 { ++ public static new bool IsSupported { get; } ++ } ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md new file mode 100644 index 00000000..33b6ee81 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md @@ -0,0 +1,40 @@ +# System.Runtime.Intrinsics + +``` diff + namespace System.Runtime.Intrinsics { + public static class Vector128 { ++ public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices); ++ public static Vector128<double> Shuffle(Vector128<double> vector, Vector128<long> indices); ++ public static Vector128<short> Shuffle(Vector128<short> vector, Vector128<short> indices); ++ public static Vector128<int> Shuffle(Vector128<int> vector, Vector128<int> indices); ++ public static Vector128<long> Shuffle(Vector128<long> vector, Vector128<long> indices); ++ public static Vector128<sbyte> Shuffle(Vector128<sbyte> vector, Vector128<sbyte> indices); ++ public static Vector128<float> Shuffle(Vector128<float> vector, Vector128<int> indices); ++ public static Vector128<ushort> Shuffle(Vector128<ushort> vector, Vector128<ushort> indices); ++ public static Vector128<uint> Shuffle(Vector128<uint> vector, Vector128<uint> indices); ++ public static Vector128<ulong> Shuffle(Vector128<ulong> vector, Vector128<ulong> indices); + } + public static class Vector256 { ++ public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices); ++ public static Vector256<double> Shuffle(Vector256<double> vector, Vector256<long> indices); ++ public static Vector256<short> Shuffle(Vector256<short> vector, Vector256<short> indices); ++ public static Vector256<int> Shuffle(Vector256<int> vector, Vector256<int> indices); ++ public static Vector256<long> Shuffle(Vector256<long> vector, Vector256<long> indices); ++ public static Vector256<sbyte> Shuffle(Vector256<sbyte> vector, Vector256<sbyte> indices); ++ public static Vector256<float> Shuffle(Vector256<float> vector, Vector256<int> indices); ++ public static Vector256<ushort> Shuffle(Vector256<ushort> vector, Vector256<ushort> indices); ++ public static Vector256<uint> Shuffle(Vector256<uint> vector, Vector256<uint> indices); ++ public static Vector256<ulong> Shuffle(Vector256<ulong> vector, Vector256<ulong> indices); + } + public static class Vector64 { ++ public static Vector64<byte> Shuffle(Vector64<byte> vector, Vector64<byte> indices); ++ public static Vector64<short> Shuffle(Vector64<short> vector, Vector64<short> indices); ++ public static Vector64<int> Shuffle(Vector64<int> vector, Vector64<int> indices); ++ public static Vector64<sbyte> Shuffle(Vector64<sbyte> vector, Vector64<sbyte> indices); ++ public static Vector64<float> Shuffle(Vector64<float> vector, Vector64<int> indices); ++ public static Vector64<ushort> Shuffle(Vector64<ushort> vector, Vector64<ushort> indices); ++ public static Vector64<uint> Shuffle(Vector64<uint> vector, Vector64<uint> indices); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md new file mode 100644 index 00000000..568c1008 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md @@ -0,0 +1,18 @@ +# System.Security.Cryptography.X509Certificates + +``` diff + namespace System.Security.Cryptography.X509Certificates { ++ public sealed class X509AuthorityInformationAccessExtension : X509Extension { ++ public X509AuthorityInformationAccessExtension(); ++ public X509AuthorityInformationAccessExtension(byte[] rawData, bool critical = false); ++ public X509AuthorityInformationAccessExtension(IEnumerable<string>? ocspUris, IEnumerable<string>? caIssuersUris, bool critical = false); ++ public X509AuthorityInformationAccessExtension(ReadOnlySpan<byte> rawData, bool critical = false); ++ public override void CopyFrom(AsnEncodedData asnEncodedData); ++ public IEnumerable<string> EnumerateCAIssuersUris(); ++ public IEnumerable<string> EnumerateOcspUris(); ++ public IEnumerable<string> EnumerateUris(Oid accessMethodOid); ++ public IEnumerable<string> EnumerateUris(string accessMethodOid); ++ } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md new file mode 100644 index 00000000..41feda09 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md @@ -0,0 +1,26 @@ +# System.Security.Cryptography + +``` diff + namespace System.Security.Cryptography { + public sealed class DSACng : DSA { +- protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm); +- protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm); +- protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten); + } + public sealed class ECDsaCng : ECDsa { +- protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm); +- protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm); +- protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten); + } + public sealed class RSACng : RSA { +- protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm); +- protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm); +- protected override bool TryHashData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten); + } + public sealed class RSACryptoServiceProvider : RSA, ICspAsymmetricAlgorithm { +- protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm); +- protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md new file mode 100644 index 00000000..7951d35e --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md @@ -0,0 +1,13 @@ +# System.Text.Json.Nodes + +``` diff + namespace System.Text.Json.Nodes { + public sealed class JsonArray : JsonNode, ICollection<JsonNode?>, IEnumerable, IEnumerable<JsonNode?>, IList<JsonNode?> { + public void Add<T>(T value); + } + public abstract class JsonValue : JsonNode { + public static JsonValue Create<T>(T value, JsonNodeOptions? options = default(JsonNodeOptions?)); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md new file mode 100644 index 00000000..82147c0f --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md @@ -0,0 +1,13 @@ +# System.Text.Json.Serialization.Metadata + +``` diff + namespace System.Text.Json.Serialization.Metadata { + public static class JsonMetadataServices { ++ public static JsonConverter<DateOnly> DateOnlyConverter { get; } ++ public static JsonConverter<JsonDocument> JsonDocumentConverter { get; } ++ public static JsonConverter<TimeOnly> TimeOnlyConverter { get; } ++ public static JsonTypeInfo<TCollection> CreateIAsyncEnumerableInfo<TCollection, TElement>(JsonSerializerOptions options, JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : IAsyncEnumerable<TElement>; + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md new file mode 100644 index 00000000..eec8017d --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md @@ -0,0 +1,56 @@ +# System.Text.Json.Serialization + +``` diff + namespace System.Text.Json.Serialization { + public class JsonDerivedTypeAttribute : JsonAttribute { ++ public JsonDerivedTypeAttribute(Type derivedType, int typeDiscriminator); +- public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminatorId); ++ public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminator); ++ public object? TypeDiscriminator { get; } +- public string? TypeDiscriminatorId { get; } + } + public sealed class JsonPolymorphicAttribute : JsonAttribute { +- public string CustomTypeDiscriminatorPropertyName { get; set; } ++ public string TypeDiscriminatorPropertyName { get; set; } + } +- public class JsonPolymorphicTypeConfiguration : ICollection<(Type, string?)>, IEnumerable, IEnumerable<(Type, string?)> { ++ public class JsonPolymorphicTypeConfiguration : ICollection<(Type, object?)>, IEnumerable, IEnumerable<(Type, object?)> { +- public string? CustomTypeDiscriminatorPropertyName { get; set; } ++ int ICollection<(Type, object?)>.Count { get; } ++ bool ICollection<(Type, object?)>.IsReadOnly { get; } +- int ICollection<(Type, string?)>.Count { get; } +- bool ICollection<(Type, string?)>.IsReadOnly { get; } ++ public string? TypeDiscriminatorPropertyName { get; set; } ++ void ICollection<(Type, object?)>.Add((Type DerivedType, object TypeDiscriminator) item); ++ void ICollection<(Type, object?)>.Clear(); ++ bool ICollection<(Type, object?)>.Contains((Type DerivedType, object TypeDiscriminator) item); ++ void ICollection<(Type, object?)>.CopyTo((Type DerivedType, object TypeDiscriminator)[] array, int arrayIndex); ++ bool ICollection<(Type, object?)>.Remove((Type DerivedType, object TypeDiscriminator) item); +- void ICollection<(Type, string?)>.Add((Type DerivedType, string TypeDiscriminatorId) item); +- void ICollection<(Type, string?)>.Clear(); +- bool ICollection<(Type, string?)>.Contains((Type DerivedType, string TypeDiscriminatorId) item); +- void ICollection<(Type, string?)>.CopyTo((Type DerivedType, string TypeDiscriminatorId)[] array, int arrayIndex); +- bool ICollection<(Type, string?)>.Remove((Type DerivedType, string TypeDiscriminatorId) item); ++ IEnumerator<(Type DerivedType, object TypeDiscriminator)> IEnumerable<(Type, object?)>.GetEnumerator(); +- IEnumerator<(Type DerivedType, string TypeDiscriminatorId)> IEnumerable<(Type, string?)>.GetEnumerator(); ++ public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType); ++ public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, int typeDiscriminator); +- public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string? typeDiscriminatorId = null); ++ public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string typeDiscriminator); + } + public class JsonPolymorphicTypeConfiguration<TBaseType> : JsonPolymorphicTypeConfiguration where TBaseType : class { ++ public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>() where TDerivedType : TBaseType; ++ public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(int typeDiscriminator) where TDerivedType : TBaseType; +- public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string? typeDiscriminatorId = null) where TDerivedType : TBaseType; ++ public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string typeDiscriminator) where TDerivedType : TBaseType; + } + public class JsonStringEnumConverter : JsonConverterFactory + public enum JsonUnknownDerivedTypeHandling { +- FallbackToBaseType = 1, ++ FallBackToBaseType = 1, +- FallbackToNearestAncestor = 2, ++ FallBackToNearestAncestor = 2, + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md new file mode 100644 index 00000000..d210642e --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md @@ -0,0 +1,53 @@ +# System.Text.Json + +``` diff + namespace System.Text.Json { + public static class JsonSerializer { + public static object? Deserialize(Stream utf8Json, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(ReadOnlySpan<byte> utf8Json, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(ReadOnlySpan<char> json, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(string json, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(this JsonDocument document, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(this JsonElement element, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(this JsonNode? node, Type returnType, JsonSerializerOptions? options = null); + public static object? Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(Stream utf8Json, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(ReadOnlySpan<byte> utf8Json, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(ReadOnlySpan<char> json, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(string json, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(this JsonDocument document, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(this JsonElement element, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(this JsonNode? node, JsonSerializerOptions? options = null); + public static TValue? Deserialize<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions? options = null); + public static ValueTask<object?> DeserializeAsync(Stream utf8Json, Type returnType, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken)); + public static ValueTask<TValue?> DeserializeAsync<TValue>(Stream utf8Json, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken)); + public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken)); ++ public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken)); + public static void Serialize(Stream utf8Json, object? value, Type inputType, JsonSerializerOptions? options = null); + public static string Serialize(object? value, Type inputType, JsonSerializerOptions? options = null); + public static void Serialize(Utf8JsonWriter writer, object? value, Type inputType, JsonSerializerOptions? options = null); + public static void Serialize<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions? options = null); + public static void Serialize<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions? options = null); + public static string Serialize<TValue>(TValue value, JsonSerializerOptions? options = null); + public static Task SerializeAsync(Stream utf8Json, object? value, Type inputType, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken)); + public static Task SerializeAsync<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken)); + public static JsonDocument SerializeToDocument(object? value, Type inputType, JsonSerializerOptions? options = null); + public static JsonDocument SerializeToDocument<TValue>(TValue value, JsonSerializerOptions? options = null); + public static JsonElement SerializeToElement(object? value, Type inputType, JsonSerializerOptions? options = null); + public static JsonElement SerializeToElement<TValue>(TValue value, JsonSerializerOptions? options = null); + public static JsonNode? SerializeToNode(object? value, Type inputType, JsonSerializerOptions? options = null); + public static JsonNode? SerializeToNode<TValue>(TValue value, JsonSerializerOptions? options = null); + public static byte[] SerializeToUtf8Bytes(object? value, Type inputType, JsonSerializerOptions? options = null); + public static byte[] SerializeToUtf8Bytes<TValue>(TValue value, JsonSerializerOptions? options = null); + } + public sealed class JsonSerializerOptions { + public JsonConverter GetConverter(Type typeToConvert); + } + public ref struct Utf8JsonReader { ++ public bool ValueIsEscaped { get; } ++ public int CopyString(Span<byte> utf8Destination); ++ public int CopyString(Span<char> destination); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md new file mode 100644 index 00000000..bfbb8116 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md @@ -0,0 +1,11 @@ +# System.Threading + +``` diff + namespace System.Threading { + public static class Interlocked { ++ public static UIntPtr CompareExchange(ref UIntPtr location1, UIntPtr value, UIntPtr comparand); ++ public static UIntPtr Exchange(ref UIntPtr location1, UIntPtr value); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md new file mode 100644 index 00000000..be7ad90d --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md @@ -0,0 +1,1118 @@ +# System + +``` diff + namespace System { + public readonly struct Byte : IAdditionOperators<byte, byte, byte>, IAdditiveIdentity<byte, byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte, byte, byte>, IComparable, IComparable<byte>, IComparisonOperators<byte, byte>, IConvertible, IDecrementOperators<byte>, IDivisionOperators<byte, byte, byte>, IEqualityOperators<byte, byte>, IEquatable<byte>, IFormattable, IIncrementOperators<byte>, IMinMaxValue<byte>, IModulusOperators<byte, byte, byte>, IMultiplicativeIdentity<byte, byte>, IMultiplyOperators<byte, byte, byte>, INumber<byte>, INumberBase<byte>, IParsable<byte>, IShiftOperators<byte, byte>, ISpanFormattable, ISpanParsable<byte>, ISubtractionOperators<byte, byte, byte>, IUnaryNegationOperators<byte, byte>, IUnaryPlusOperators<byte, byte>, IUnsignedNumber<byte> { ++ static int System.Numerics.INumberBase<System.Byte>.Radix { get; } +- public static byte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static byte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static byte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(byte value); ++ public static bool IsOddInteger(byte value); +- long IBinaryInteger<byte>.GetShortestBitLength(); ++ int IBinaryInteger<byte>.GetShortestBitLength(); ++ bool IBinaryInteger<byte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static byte INumber<byte>.Abs(byte value); +- static bool INumber<byte>.IsNegative(byte value); +- static byte INumber<byte>.MaxMagnitude(byte x, byte y); ++ static byte INumber<byte>.MaxNumber(byte x, byte y); +- static byte INumber<byte>.MinMagnitude(byte x, byte y); ++ static byte INumber<byte>.MinNumber(byte x, byte y); ++ static byte INumberBase<byte>.Abs(byte value); ++ static bool INumberBase<byte>.IsCanonical(byte value); ++ static bool INumberBase<byte>.IsComplexNumber(byte value); ++ static bool INumberBase<byte>.IsFinite(byte value); ++ static bool INumberBase<byte>.IsImaginaryNumber(byte value); ++ static bool INumberBase<byte>.IsInfinity(byte value); ++ static bool INumberBase<byte>.IsInteger(byte value); ++ static bool INumberBase<byte>.IsNaN(byte value); ++ static bool INumberBase<byte>.IsNegative(byte value); ++ static bool INumberBase<byte>.IsNegativeInfinity(byte value); ++ static bool INumberBase<byte>.IsNormal(byte value); ++ static bool INumberBase<byte>.IsPositive(byte value); ++ static bool INumberBase<byte>.IsPositiveInfinity(byte value); ++ static bool INumberBase<byte>.IsRealNumber(byte value); ++ static bool INumberBase<byte>.IsSubnormal(byte value); ++ static bool INumberBase<byte>.IsZero(byte value); ++ static byte INumberBase<byte>.MaxMagnitude(byte x, byte y); ++ static byte INumberBase<byte>.MaxMagnitudeNumber(byte x, byte y); ++ static byte INumberBase<byte>.MinMagnitude(byte x, byte y); ++ static byte INumberBase<byte>.MinMagnitudeNumber(byte x, byte y); ++ static bool INumberBase<byte>.TryConvertFromChecked<TOther>(TOther value, out byte result); ++ static bool INumberBase<byte>.TryConvertFromSaturating<TOther>(TOther value, out byte result); ++ static bool INumberBase<byte>.TryConvertFromTruncating<TOther>(TOther value, out byte result); ++ static bool INumberBase<byte>.TryConvertToChecked<TOther>(byte value, out TOther result); ++ static bool INumberBase<byte>.TryConvertToSaturating<TOther>(byte value, out TOther result); ++ static bool INumberBase<byte>.TryConvertToTruncating<TOther>(byte value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out byte result) where TOther : INumber<TOther>; + } + public readonly struct Char : IAdditionOperators<char, char, char>, IAdditiveIdentity<char, char>, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char, char, char>, IComparable, IComparable<char>, IComparisonOperators<char, char>, IConvertible, IDecrementOperators<char>, IDivisionOperators<char, char, char>, IEqualityOperators<char, char>, IEquatable<char>, IFormattable, IIncrementOperators<char>, IMinMaxValue<char>, IModulusOperators<char, char, char>, IMultiplicativeIdentity<char, char>, IMultiplyOperators<char, char, char>, INumber<char>, INumberBase<char>, IParsable<char>, IShiftOperators<char, char>, ISpanFormattable, ISpanParsable<char>, ISubtractionOperators<char, char, char>, IUnaryNegationOperators<char, char>, IUnaryPlusOperators<char, char>, IUnsignedNumber<char> { ++ static int System.Numerics.INumberBase<System.Char>.Radix { get; } +- public static char Clamp(char value, char min, char max); +- public static char CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static char CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static char CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static (char Quotient, char Remainder) DivRem(char left, char right); ++ public static bool IsAsciiDigit(char c); ++ public static bool IsAsciiHexDigit(char c); ++ public static bool IsAsciiHexDigitLower(char c); ++ public static bool IsAsciiHexDigitUpper(char c); ++ public static bool IsAsciiLetter(char c); ++ public static bool IsAsciiLetterLower(char c); ++ public static bool IsAsciiLetterOrDigit(char c); ++ public static bool IsAsciiLetterUpper(char c); ++ public static bool IsBetween(char c, char minInclusive, char maxInclusive); +- public static bool IsPow2(char value); +- public static char LeadingZeroCount(char value); +- public static char Log2(char value); +- public static char Max(char x, char y); +- public static char Min(char x, char y); +- public static char PopCount(char value); +- public static char RotateLeft(char value, int rotateAmount); +- public static char RotateRight(char value, int rotateAmount); +- public static int Sign(char value); ++ static (char Quotient, char Remainder) IBinaryInteger<char>.DivRem(char left, char right); +- long IBinaryInteger<char>.GetShortestBitLength(); ++ int IBinaryInteger<char>.GetShortestBitLength(); ++ static char IBinaryInteger<char>.LeadingZeroCount(char value); ++ static char IBinaryInteger<char>.PopCount(char value); ++ static char IBinaryInteger<char>.RotateLeft(char value, int rotateAmount); ++ static char IBinaryInteger<char>.RotateRight(char value, int rotateAmount); ++ static char IBinaryInteger<char>.TrailingZeroCount(char value); ++ bool IBinaryInteger<char>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ static bool IBinaryNumber<char>.IsPow2(char value); ++ static char IBinaryNumber<char>.Log2(char value); +- static char INumber<char>.Abs(char value); ++ static char INumber<char>.Clamp(char value, char min, char max); +- static bool INumber<char>.IsNegative(char value); ++ static char INumber<char>.Max(char x, char y); +- static char INumber<char>.MaxMagnitude(char x, char y); ++ static char INumber<char>.MaxNumber(char x, char y); ++ static char INumber<char>.Min(char x, char y); +- static char INumber<char>.MinMagnitude(char x, char y); ++ static char INumber<char>.MinNumber(char x, char y); +- static char INumber<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider); +- static char INumber<char>.Parse(string s, NumberStyles style, IFormatProvider provider); ++ static int INumber<char>.Sign(char value); +- static bool INumber<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result); +- static bool INumber<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result); ++ static char INumberBase<char>.Abs(char value); ++ static bool INumberBase<char>.IsCanonical(char value); ++ static bool INumberBase<char>.IsComplexNumber(char value); ++ static bool INumberBase<char>.IsEvenInteger(char value); ++ static bool INumberBase<char>.IsFinite(char value); ++ static bool INumberBase<char>.IsImaginaryNumber(char value); ++ static bool INumberBase<char>.IsInfinity(char value); ++ static bool INumberBase<char>.IsInteger(char value); ++ static bool INumberBase<char>.IsNaN(char value); ++ static bool INumberBase<char>.IsNegative(char value); ++ static bool INumberBase<char>.IsNegativeInfinity(char value); ++ static bool INumberBase<char>.IsNormal(char value); ++ static bool INumberBase<char>.IsOddInteger(char value); ++ static bool INumberBase<char>.IsPositive(char value); ++ static bool INumberBase<char>.IsPositiveInfinity(char value); ++ static bool INumberBase<char>.IsRealNumber(char value); ++ static bool INumberBase<char>.IsSubnormal(char value); ++ static bool INumberBase<char>.IsZero(char value); ++ static char INumberBase<char>.MaxMagnitude(char x, char y); ++ static char INumberBase<char>.MaxMagnitudeNumber(char x, char y); ++ static char INumberBase<char>.MinMagnitude(char x, char y); ++ static char INumberBase<char>.MinMagnitudeNumber(char x, char y); ++ static char INumberBase<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider); ++ static char INumberBase<char>.Parse(string s, NumberStyles style, IFormatProvider provider); ++ static bool INumberBase<char>.TryConvertFromChecked<TOther>(TOther value, out char result); ++ static bool INumberBase<char>.TryConvertFromSaturating<TOther>(TOther value, out char result); ++ static bool INumberBase<char>.TryConvertFromTruncating<TOther>(TOther value, out char result); ++ static bool INumberBase<char>.TryConvertToChecked<TOther>(char value, out TOther result); ++ static bool INumberBase<char>.TryConvertToSaturating<TOther>(char value, out TOther result); ++ static bool INumberBase<char>.TryConvertToTruncating<TOther>(char value, out TOther result); ++ static bool INumberBase<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result); ++ static bool INumberBase<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result); +- public static char TrailingZeroCount(char value); +- public static bool TryCreate<TOther>(TOther value, out char result) where TOther : INumber<TOther>; + } +- public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IComparisonOperators<DateOnly, DateOnly>, IEqualityOperators<DateOnly, DateOnly>, IEquatable<DateOnly>, IFormattable, IMinMaxValue<DateOnly>, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly> ++ public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IEquatable<DateOnly>, IFormattable, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly> +- public readonly struct DateTime : IAdditionOperators<DateTime, TimeSpan, DateTime>, IAdditiveIdentity<DateTime, TimeSpan>, IComparable, IComparable<DateTime>, IComparisonOperators<DateTime, DateTime>, IConvertible, IEqualityOperators<DateTime, DateTime>, IEquatable<DateTime>, IFormattable, IMinMaxValue<DateTime>, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime>, ISubtractionOperators<DateTime, DateTime, TimeSpan>, ISubtractionOperators<DateTime, TimeSpan, DateTime> { ++ public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime> { +- static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTime,System.TimeSpan>.AdditiveIdentity { get; } +- static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MaxValue { get; } +- static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MinValue { get; } +- static DateTime IAdditionOperators<DateTime, TimeSpan, DateTime>.operator checked +(DateTime left, TimeSpan right); +- static TimeSpan ISubtractionOperators<DateTime, DateTime, TimeSpan>.operator checked -(DateTime left, DateTime right); +- static DateTime ISubtractionOperators<DateTime, TimeSpan, DateTime>.operator checked -(DateTime left, TimeSpan right); + } +- public readonly struct DateTimeOffset : IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>, IAdditiveIdentity<DateTimeOffset, TimeSpan>, IComparable, IComparable<DateTimeOffset>, IComparisonOperators<DateTimeOffset, DateTimeOffset>, IDeserializationCallback, IEqualityOperators<DateTimeOffset, DateTimeOffset>, IEquatable<DateTimeOffset>, IFormattable, IMinMaxValue<DateTimeOffset>, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset>, ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>, ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset> { ++ public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset> { +- static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTimeOffset,System.TimeSpan>.AdditiveIdentity { get; } +- static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MaxValue { get; } +- static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MinValue { get; } +- static DateTimeOffset IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked +(DateTimeOffset left, TimeSpan right); +- static TimeSpan ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>.operator checked -(DateTimeOffset left, DateTimeOffset right); +- static DateTimeOffset ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked -(DateTimeOffset left, TimeSpan right); + } + public readonly struct Decimal : IAdditionOperators<decimal, decimal, decimal>, IAdditiveIdentity<decimal, decimal>, IComparable, IComparable<decimal>, IComparisonOperators<decimal, decimal>, IConvertible, IDecrementOperators<decimal>, IDeserializationCallback, IDivisionOperators<decimal, decimal, decimal>, IEqualityOperators<decimal, decimal>, IEquatable<decimal>, IFloatingPoint<decimal>, IFormattable, IIncrementOperators<decimal>, IMinMaxValue<decimal>, IModulusOperators<decimal, decimal, decimal>, IMultiplicativeIdentity<decimal, decimal>, IMultiplyOperators<decimal, decimal, decimal>, INumber<decimal>, INumberBase<decimal>, IParsable<decimal>, ISerializable, ISignedNumber<decimal>, ISpanFormattable, ISpanParsable<decimal>, ISubtractionOperators<decimal, decimal, decimal>, IUnaryNegationOperators<decimal, decimal>, IUnaryPlusOperators<decimal, decimal> { ++ static int System.Numerics.INumberBase<System.Decimal>.Radix { get; } +- public static decimal CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static decimal CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static decimal CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsCanonical(decimal value); ++ public static bool IsEvenInteger(decimal value); ++ public static bool IsInteger(decimal value); ++ public static bool IsOddInteger(decimal value); ++ public static bool IsPositive(decimal value); +- long IFloatingPoint<decimal>.GetExponentShortestBitLength(); ++ int IFloatingPoint<decimal>.GetExponentShortestBitLength(); +- long IFloatingPoint<decimal>.GetSignificandBitLength(); ++ int IFloatingPoint<decimal>.GetSignificandBitLength(); ++ bool IFloatingPoint<decimal>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IFloatingPoint<decimal>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ static decimal INumber<decimal>.MaxNumber(decimal x, decimal y); ++ static decimal INumber<decimal>.MinNumber(decimal x, decimal y); ++ static bool INumberBase<decimal>.IsComplexNumber(decimal value); ++ static bool INumberBase<decimal>.IsFinite(decimal value); ++ static bool INumberBase<decimal>.IsImaginaryNumber(decimal value); ++ static bool INumberBase<decimal>.IsInfinity(decimal value); ++ static bool INumberBase<decimal>.IsNaN(decimal value); ++ static bool INumberBase<decimal>.IsNegativeInfinity(decimal value); ++ static bool INumberBase<decimal>.IsNormal(decimal value); ++ static bool INumberBase<decimal>.IsPositiveInfinity(decimal value); ++ static bool INumberBase<decimal>.IsRealNumber(decimal value); ++ static bool INumberBase<decimal>.IsSubnormal(decimal value); ++ static bool INumberBase<decimal>.IsZero(decimal value); ++ static decimal INumberBase<decimal>.MaxMagnitudeNumber(decimal x, decimal y); ++ static decimal INumberBase<decimal>.MinMagnitudeNumber(decimal x, decimal y); ++ static bool INumberBase<decimal>.TryConvertFromChecked<TOther>(TOther value, out decimal result); ++ static bool INumberBase<decimal>.TryConvertFromSaturating<TOther>(TOther value, out decimal result); ++ static bool INumberBase<decimal>.TryConvertFromTruncating<TOther>(TOther value, out decimal result); ++ static bool INumberBase<decimal>.TryConvertToChecked<TOther>(decimal value, out TOther result); ++ static bool INumberBase<decimal>.TryConvertToSaturating<TOther>(decimal value, out TOther result); ++ static bool INumberBase<decimal>.TryConvertToTruncating<TOther>(decimal value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out decimal result) where TOther : INumber<TOther>; + } + public readonly struct Double : IAdditionOperators<double, double, double>, IAdditiveIdentity<double, double>, IBinaryFloatingPointIeee754<double>, IBinaryNumber<double>, IBitwiseOperators<double, double, double>, IComparable, IComparable<double>, IComparisonOperators<double, double>, IConvertible, IDecrementOperators<double>, IDivisionOperators<double, double, double>, IEqualityOperators<double, double>, IEquatable<double>, IExponentialFunctions<double>, IFloatingPoint<double>, IFloatingPointIeee754<double>, IFormattable, IHyperbolicFunctions<double>, IIncrementOperators<double>, ILogarithmicFunctions<double>, IMinMaxValue<double>, IModulusOperators<double, double, double>, IMultiplicativeIdentity<double, double>, IMultiplyOperators<double, double, double>, INumber<double>, INumberBase<double>, IParsable<double>, IPowerFunctions<double>, IRootFunctions<double>, ISignedNumber<double>, ISpanFormattable, ISpanParsable<double>, ISubtractionOperators<double, double, double>, ITrigonometricFunctions<double>, IUnaryNegationOperators<double, double>, IUnaryPlusOperators<double, double> { ++ static int System.Numerics.INumberBase<System.Double>.Radix { get; } +- public static double CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static double CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static double CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static double Exp10(double x); ++ public static double Exp10M1(double x); ++ public static double Exp2(double x); ++ public static double Exp2M1(double x); ++ public static double ExpM1(double x); ++ public static bool IsEvenInteger(double value); ++ public static bool IsInteger(double value); ++ public static bool IsOddInteger(double value); ++ public static bool IsPositive(double value); ++ public static bool IsRealNumber(double value); ++ public static double Log10P1(double x); ++ public static double Log2P1(double x); ++ public static double LogP1(double x); ++ public static double MaxMagnitudeNumber(double x, double y); ++ public static double MaxNumber(double x, double y); ++ public static double MinMagnitudeNumber(double x, double y); ++ public static double MinNumber(double x, double y); +- long IFloatingPoint<double>.GetExponentShortestBitLength(); ++ int IFloatingPoint<double>.GetExponentShortestBitLength(); +- long IFloatingPoint<double>.GetSignificandBitLength(); ++ int IFloatingPoint<double>.GetSignificandBitLength(); ++ bool IFloatingPoint<double>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IFloatingPoint<double>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ static bool INumberBase<double>.IsCanonical(double value); ++ static bool INumberBase<double>.IsComplexNumber(double value); ++ static bool INumberBase<double>.IsImaginaryNumber(double value); ++ static bool INumberBase<double>.IsZero(double value); ++ static bool INumberBase<double>.TryConvertFromChecked<TOther>(TOther value, out double result); ++ static bool INumberBase<double>.TryConvertFromSaturating<TOther>(TOther value, out double result); ++ static bool INumberBase<double>.TryConvertFromTruncating<TOther>(TOther value, out double result); ++ static bool INumberBase<double>.TryConvertToChecked<TOther>(double value, out TOther result); ++ static bool INumberBase<double>.TryConvertToSaturating<TOther>(double value, out TOther result); ++ static bool INumberBase<double>.TryConvertToTruncating<TOther>(double value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out double result) where TOther : INumber<TOther>; + } + public static class GC { ++ public static TimeSpan GetTotalPauseDuration(); + } +- public readonly struct Guid : IComparable, IComparable<Guid>, IComparisonOperators<Guid, Guid>, IEqualityOperators<Guid, Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid> ++ public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid> + public readonly struct Half : IAdditionOperators<Half, Half, Half>, IAdditiveIdentity<Half, Half>, IBinaryFloatingPointIeee754<Half>, IBinaryNumber<Half>, IBitwiseOperators<Half, Half, Half>, IComparable, IComparable<Half>, IComparisonOperators<Half, Half>, IDecrementOperators<Half>, IDivisionOperators<Half, Half, Half>, IEqualityOperators<Half, Half>, IEquatable<Half>, IExponentialFunctions<Half>, IFloatingPoint<Half>, IFloatingPointIeee754<Half>, IFormattable, IHyperbolicFunctions<Half>, IIncrementOperators<Half>, ILogarithmicFunctions<Half>, IMinMaxValue<Half>, IModulusOperators<Half, Half, Half>, IMultiplicativeIdentity<Half, Half>, IMultiplyOperators<Half, Half, Half>, INumber<Half>, INumberBase<Half>, IParsable<Half>, IPowerFunctions<Half>, IRootFunctions<Half>, ISignedNumber<Half>, ISpanFormattable, ISpanParsable<Half>, ISubtractionOperators<Half, Half, Half>, ITrigonometricFunctions<Half>, IUnaryNegationOperators<Half, Half>, IUnaryPlusOperators<Half, Half> { ++ public static Half NegativeOne { get; } ++ public static Half One { get; } +- static Half System.Numerics.INumberBase<System.Half>.One { get; } ++ static int System.Numerics.INumberBase<System.Half>.Radix { get; } +- static Half System.Numerics.INumberBase<System.Half>.Zero { get; } +- static Half System.Numerics.ISignedNumber<System.Half>.NegativeOne { get; } ++ public static Half Zero { get; } +- public static Half CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static Half CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static Half CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static Half Exp10(Half x); ++ public static Half Exp10M1(Half x); ++ public static Half Exp2(Half x); ++ public static Half Exp2M1(Half x); ++ public static Half ExpM1(Half x); ++ public static bool IsEvenInteger(Half value); ++ public static bool IsInteger(Half value); ++ public static bool IsOddInteger(Half value); ++ public static bool IsPositive(Half value); ++ public static bool IsRealNumber(Half value); ++ public static Half Log10P1(Half x); ++ public static Half Log2P1(Half x); ++ public static Half LogP1(Half x); ++ public static Half MaxMagnitudeNumber(Half x, Half y); ++ public static Half MaxNumber(Half x, Half y); ++ public static Half MinMagnitudeNumber(Half x, Half y); ++ public static Half MinNumber(Half x, Half y); ++ public static explicit operator checked byte (Half value); ++ public static explicit operator checked char (Half value); ++ public static explicit operator checked short (Half value); ++ public static explicit operator checked int (Half value); ++ public static explicit operator checked long (Half value); ++ public static explicit operator checked Int128 (Half value); ++ public static explicit operator checked IntPtr (Half value); ++ public static explicit operator checked sbyte (Half value); ++ public static explicit operator checked ushort (Half value); ++ public static explicit operator checked uint (Half value); ++ public static explicit operator checked ulong (Half value); ++ public static explicit operator checked UInt128 (Half value); ++ public static explicit operator checked UIntPtr (Half value); ++ public static explicit operator Half (char value); ++ public static explicit operator Half (decimal value); ++ public static explicit operator byte (Half value); ++ public static explicit operator char (Half value); ++ public static explicit operator decimal (Half value); ++ public static explicit operator Int128 (Half value); ++ public static explicit operator short (Half value); ++ public static explicit operator int (Half value); ++ public static explicit operator long (Half value); ++ public static explicit operator IntPtr (Half value); ++ public static explicit operator sbyte (Half value); ++ public static explicit operator UInt128 (Half value); ++ public static explicit operator ushort (Half value); ++ public static explicit operator uint (Half value); ++ public static explicit operator ulong (Half value); ++ public static explicit operator UIntPtr (Half value); ++ public static explicit operator Half (short value); ++ public static explicit operator Half (int value); ++ public static explicit operator Half (long value); ++ public static explicit operator Half (IntPtr value); ++ public static explicit operator Half (ushort value); ++ public static explicit operator Half (uint value); ++ public static explicit operator Half (ulong value); ++ public static explicit operator Half (UIntPtr value); ++ public static implicit operator Half (byte value); ++ public static implicit operator Half (sbyte value); +- long IFloatingPoint<Half>.GetExponentShortestBitLength(); ++ int IFloatingPoint<Half>.GetExponentShortestBitLength(); +- long IFloatingPoint<Half>.GetSignificandBitLength(); ++ int IFloatingPoint<Half>.GetSignificandBitLength(); ++ bool IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ static bool INumberBase<Half>.IsCanonical(Half value); ++ static bool INumberBase<Half>.IsComplexNumber(Half value); ++ static bool INumberBase<Half>.IsImaginaryNumber(Half value); ++ static bool INumberBase<Half>.IsZero(Half value); ++ static bool INumberBase<Half>.TryConvertFromChecked<TOther>(TOther value, out Half result); ++ static bool INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther value, out Half result); ++ static bool INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther value, out Half result); ++ static bool INumberBase<Half>.TryConvertToChecked<TOther>(Half value, out TOther result); ++ static bool INumberBase<Half>.TryConvertToSaturating<TOther>(Half value, out TOther result); ++ static bool INumberBase<Half>.TryConvertToTruncating<TOther>(Half value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out Half result) where TOther : INumber<TOther>; + } ++ public readonly struct Int128 : IAdditionOperators<Int128, Int128, Int128>, IAdditiveIdentity<Int128, Int128>, IBinaryInteger<Int128>, IBinaryNumber<Int128>, IBitwiseOperators<Int128, Int128, Int128>, IComparable, IComparable<Int128>, IComparisonOperators<Int128, Int128>, IDecrementOperators<Int128>, IDivisionOperators<Int128, Int128, Int128>, IEqualityOperators<Int128, Int128>, IEquatable<Int128>, IFormattable, IIncrementOperators<Int128>, IMinMaxValue<Int128>, IModulusOperators<Int128, Int128, Int128>, IMultiplicativeIdentity<Int128, Int128>, IMultiplyOperators<Int128, Int128, Int128>, INumber<Int128>, INumberBase<Int128>, IParsable<Int128>, IShiftOperators<Int128, Int128>, ISignedNumber<Int128>, ISpanFormattable, ISpanParsable<Int128>, ISubtractionOperators<Int128, Int128, Int128>, IUnaryNegationOperators<Int128, Int128>, IUnaryPlusOperators<Int128, Int128> { ++ public Int128(ulong upper, ulong lower); ++ public static Int128 MaxValue { get; } ++ public static Int128 MinValue { get; } ++ public static Int128 NegativeOne { get; } ++ public static Int128 One { get; } ++ static Int128 System.Numerics.IAdditiveIdentity<System.Int128,System.Int128>.AdditiveIdentity { get; } ++ static Int128 System.Numerics.IMultiplicativeIdentity<System.Int128,System.Int128>.MultiplicativeIdentity { get; } ++ static int System.Numerics.INumberBase<System.Int128>.Radix { get; } ++ public static Int128 Zero { get; } ++ public static Int128 Abs(Int128 value); ++ public static Int128 Clamp(Int128 value, Int128 min, Int128 max); ++ public int CompareTo(Int128 value); ++ public int CompareTo(object? value); ++ public static Int128 CopySign(Int128 value, Int128 sign); ++ public static (Int128 Quotient, Int128 Remainder) DivRem(Int128 left, Int128 right); ++ public bool Equals(Int128 other); ++ public override bool Equals(object? obj); ++ public override int GetHashCode(); ++ public static bool IsEvenInteger(Int128 value); ++ public static bool IsNegative(Int128 value); ++ public static bool IsOddInteger(Int128 value); ++ public static bool IsPositive(Int128 value); ++ public static bool IsPow2(Int128 value); ++ public static Int128 LeadingZeroCount(Int128 value); ++ public static Int128 Log2(Int128 value); ++ public static Int128 Max(Int128 x, Int128 y); ++ public static Int128 MaxMagnitude(Int128 x, Int128 y); ++ public static Int128 Min(Int128 x, Int128 y); ++ public static Int128 MinMagnitude(Int128 x, Int128 y); ++ public static Int128 operator +(Int128 left, Int128 right); ++ public static Int128 operator &(Int128 left, Int128 right); ++ public static Int128 operator |(Int128 left, Int128 right); ++ public static Int128 operator checked +(Int128 left, Int128 right); ++ public static Int128 operator checked --(Int128 value); ++ public static Int128 operator checked /(Int128 left, Int128 right); ++ public static explicit operator checked Int128 (double value); ++ public static explicit operator checked byte (Int128 value); ++ public static explicit operator checked char (Int128 value); ++ public static explicit operator checked short (Int128 value); ++ public static explicit operator checked int (Int128 value); ++ public static explicit operator checked long (Int128 value); ++ public static explicit operator checked nint (Int128 value); ++ public static explicit operator checked sbyte (Int128 value); ++ public static explicit operator checked ushort (Int128 value); ++ public static explicit operator checked uint (Int128 value); ++ public static explicit operator checked ulong (Int128 value); ++ public static explicit operator checked UInt128 (Int128 value); ++ public static explicit operator checked nuint (Int128 value); ++ public static explicit operator checked Int128 (float value); ++ public static Int128 operator checked ++(Int128 value); ++ public static Int128 operator checked *(Int128 left, Int128 right); ++ public static Int128 operator checked -(Int128 left, Int128 right); ++ public static Int128 operator checked -(Int128 value); ++ public static Int128 operator --(Int128 value); ++ public static Int128 operator /(Int128 left, Int128 right); ++ public static bool operator ==(Int128 left, Int128 right); ++ public static Int128 operator ^(Int128 left, Int128 right); ++ public static explicit operator Int128 (decimal value); ++ public static explicit operator Int128 (double value); ++ public static explicit operator byte (Int128 value); ++ public static explicit operator char (Int128 value); ++ public static explicit operator decimal (Int128 value); ++ public static explicit operator double (Int128 value); ++ public static explicit operator Half (Int128 value); ++ public static explicit operator short (Int128 value); ++ public static explicit operator int (Int128 value); ++ public static explicit operator long (Int128 value); ++ public static explicit operator nint (Int128 value); ++ public static explicit operator sbyte (Int128 value); ++ public static explicit operator float (Int128 value); ++ public static explicit operator UInt128 (Int128 value); ++ public static explicit operator ushort (Int128 value); ++ public static explicit operator uint (Int128 value); ++ public static explicit operator ulong (Int128 value); ++ public static explicit operator nuint (Int128 value); ++ public static explicit operator Int128 (float value); ++ public static bool operator >(Int128 left, Int128 right); ++ public static bool operator >=(Int128 left, Int128 right); ++ public static implicit operator Int128 (byte value); ++ public static implicit operator Int128 (char value); ++ public static implicit operator Int128 (short value); ++ public static implicit operator Int128 (int value); ++ public static implicit operator Int128 (long value); ++ public static implicit operator Int128 (nint value); ++ public static implicit operator Int128 (sbyte value); ++ public static implicit operator Int128 (ushort value); ++ public static implicit operator Int128 (uint value); ++ public static implicit operator Int128 (ulong value); ++ public static implicit operator Int128 (nuint value); ++ public static Int128 operator ++(Int128 value); ++ public static bool operator !=(Int128 left, Int128 right); ++ public static Int128 operator <<(Int128 value, int shiftAmount); ++ public static bool operator <(Int128 left, Int128 right); ++ public static bool operator <=(Int128 left, Int128 right); ++ public static Int128 operator %(Int128 left, Int128 right); ++ public static Int128 operator *(Int128 left, Int128 right); ++ public static Int128 operator ~(Int128 value); ++ public static Int128 operator >>(Int128 value, int shiftAmount); ++ public static Int128 operator -(Int128 left, Int128 right); ++ public static Int128 operator -(Int128 value); ++ public static Int128 operator +(Int128 value); ++ public static Int128 operator >>>(Int128 value, int shiftAmount); ++ public static Int128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ public static Int128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider); ++ public static Int128 Parse(string s); ++ public static Int128 Parse(string s, NumberStyles style); ++ public static Int128 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ public static Int128 Parse(string s, IFormatProvider? provider); ++ public static Int128 PopCount(Int128 value); ++ public static Int128 RotateLeft(Int128 value, int rotateAmount); ++ public static Int128 RotateRight(Int128 value, int rotateAmount); ++ public static int Sign(Int128 value); ++ int IBinaryInteger<Int128>.GetByteCount(); ++ int IBinaryInteger<Int128>.GetShortestBitLength(); ++ bool IBinaryInteger<Int128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IBinaryInteger<Int128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten); ++ static Int128 INumber<Int128>.MaxNumber(Int128 x, Int128 y); ++ static Int128 INumber<Int128>.MinNumber(Int128 x, Int128 y); ++ static bool INumberBase<Int128>.IsCanonical(Int128 value); ++ static bool INumberBase<Int128>.IsComplexNumber(Int128 value); ++ static bool INumberBase<Int128>.IsFinite(Int128 value); ++ static bool INumberBase<Int128>.IsImaginaryNumber(Int128 value); ++ static bool INumberBase<Int128>.IsInfinity(Int128 value); ++ static bool INumberBase<Int128>.IsInteger(Int128 value); ++ static bool INumberBase<Int128>.IsNaN(Int128 value); ++ static bool INumberBase<Int128>.IsNegativeInfinity(Int128 value); ++ static bool INumberBase<Int128>.IsNormal(Int128 value); ++ static bool INumberBase<Int128>.IsPositiveInfinity(Int128 value); ++ static bool INumberBase<Int128>.IsRealNumber(Int128 value); ++ static bool INumberBase<Int128>.IsSubnormal(Int128 value); ++ static bool INumberBase<Int128>.IsZero(Int128 value); ++ static Int128 INumberBase<Int128>.MaxMagnitudeNumber(Int128 x, Int128 y); ++ static Int128 INumberBase<Int128>.MinMagnitudeNumber(Int128 x, Int128 y); ++ static bool INumberBase<Int128>.TryConvertFromChecked<TOther>(TOther value, out Int128 result); ++ static bool INumberBase<Int128>.TryConvertFromSaturating<TOther>(TOther value, out Int128 result); ++ static bool INumberBase<Int128>.TryConvertFromTruncating<TOther>(TOther value, out Int128 result); ++ static bool INumberBase<Int128>.TryConvertToChecked<TOther>(Int128 value, out TOther result); ++ static bool INumberBase<Int128>.TryConvertToSaturating<TOther>(Int128 value, out TOther result); ++ static bool INumberBase<Int128>.TryConvertToTruncating<TOther>(Int128 value, out TOther result); ++ public override string ToString(); ++ public string ToString(IFormatProvider? provider); ++ public string ToString(string? format); ++ public string ToString(string? format, IFormatProvider? provider); ++ public static Int128 TrailingZeroCount(Int128 value); ++ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null); ++ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Int128 result); ++ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Int128 result); ++ public static bool TryParse(ReadOnlySpan<char> s, out Int128 result); ++ public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int128 result); ++ public static bool TryParse(string? s, IFormatProvider? provider, out Int128 result); ++ public static bool TryParse(string? s, out Int128 result); ++ } + public readonly struct Int16 : IAdditionOperators<short, short, short>, IAdditiveIdentity<short, short>, IBinaryInteger<short>, IBinaryNumber<short>, IBitwiseOperators<short, short, short>, IComparable, IComparable<short>, IComparisonOperators<short, short>, IConvertible, IDecrementOperators<short>, IDivisionOperators<short, short, short>, IEqualityOperators<short, short>, IEquatable<short>, IFormattable, IIncrementOperators<short>, IMinMaxValue<short>, IModulusOperators<short, short, short>, IMultiplicativeIdentity<short, short>, IMultiplyOperators<short, short, short>, INumber<short>, INumberBase<short>, IParsable<short>, IShiftOperators<short, short>, ISignedNumber<short>, ISpanFormattable, ISpanParsable<short>, ISubtractionOperators<short, short, short>, IUnaryNegationOperators<short, short>, IUnaryPlusOperators<short, short> { ++ static int System.Numerics.INumberBase<System.Int16>.Radix { get; } +- public static short CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static short CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static short CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(short value); ++ public static bool IsOddInteger(short value); ++ public static bool IsPositive(short value); +- long IBinaryInteger<short>.GetShortestBitLength(); ++ int IBinaryInteger<short>.GetShortestBitLength(); ++ bool IBinaryInteger<short>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ static short INumber<short>.MaxNumber(short x, short y); ++ static short INumber<short>.MinNumber(short x, short y); ++ static bool INumberBase<short>.IsCanonical(short value); ++ static bool INumberBase<short>.IsComplexNumber(short value); ++ static bool INumberBase<short>.IsFinite(short value); ++ static bool INumberBase<short>.IsImaginaryNumber(short value); ++ static bool INumberBase<short>.IsInfinity(short value); ++ static bool INumberBase<short>.IsInteger(short value); ++ static bool INumberBase<short>.IsNaN(short value); ++ static bool INumberBase<short>.IsNegativeInfinity(short value); ++ static bool INumberBase<short>.IsNormal(short value); ++ static bool INumberBase<short>.IsPositiveInfinity(short value); ++ static bool INumberBase<short>.IsRealNumber(short value); ++ static bool INumberBase<short>.IsSubnormal(short value); ++ static bool INumberBase<short>.IsZero(short value); ++ static short INumberBase<short>.MaxMagnitudeNumber(short x, short y); ++ static short INumberBase<short>.MinMagnitudeNumber(short x, short y); ++ static bool INumberBase<short>.TryConvertFromChecked<TOther>(TOther value, out short result); ++ static bool INumberBase<short>.TryConvertFromSaturating<TOther>(TOther value, out short result); ++ static bool INumberBase<short>.TryConvertFromTruncating<TOther>(TOther value, out short result); ++ static bool INumberBase<short>.TryConvertToChecked<TOther>(short value, out TOther result); ++ static bool INumberBase<short>.TryConvertToSaturating<TOther>(short value, out TOther result); ++ static bool INumberBase<short>.TryConvertToTruncating<TOther>(short value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out short result) where TOther : INumber<TOther>; + } + public readonly struct Int32 : IAdditionOperators<int, int, int>, IAdditiveIdentity<int, int>, IBinaryInteger<int>, IBinaryNumber<int>, IBitwiseOperators<int, int, int>, IComparable, IComparable<int>, IComparisonOperators<int, int>, IConvertible, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IEqualityOperators<int, int>, IEquatable<int>, IFormattable, IIncrementOperators<int>, IMinMaxValue<int>, IModulusOperators<int, int, int>, IMultiplicativeIdentity<int, int>, IMultiplyOperators<int, int, int>, INumber<int>, INumberBase<int>, IParsable<int>, IShiftOperators<int, int>, ISignedNumber<int>, ISpanFormattable, ISpanParsable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int> { ++ static int System.Numerics.INumberBase<System.Int32>.Radix { get; } +- public static int CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static int CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static int CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(int value); ++ public static bool IsOddInteger(int value); ++ public static bool IsPositive(int value); +- long IBinaryInteger<int>.GetShortestBitLength(); ++ int IBinaryInteger<int>.GetShortestBitLength(); ++ bool IBinaryInteger<int>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ static int INumber<int>.MaxNumber(int x, int y); ++ static int INumber<int>.MinNumber(int x, int y); ++ static bool INumberBase<int>.IsCanonical(int value); ++ static bool INumberBase<int>.IsComplexNumber(int value); ++ static bool INumberBase<int>.IsFinite(int value); ++ static bool INumberBase<int>.IsImaginaryNumber(int value); ++ static bool INumberBase<int>.IsInfinity(int value); ++ static bool INumberBase<int>.IsInteger(int value); ++ static bool INumberBase<int>.IsNaN(int value); ++ static bool INumberBase<int>.IsNegativeInfinity(int value); ++ static bool INumberBase<int>.IsNormal(int value); ++ static bool INumberBase<int>.IsPositiveInfinity(int value); ++ static bool INumberBase<int>.IsRealNumber(int value); ++ static bool INumberBase<int>.IsSubnormal(int value); ++ static bool INumberBase<int>.IsZero(int value); ++ static int INumberBase<int>.MaxMagnitudeNumber(int x, int y); ++ static int INumberBase<int>.MinMagnitudeNumber(int x, int y); ++ static bool INumberBase<int>.TryConvertFromChecked<TOther>(TOther value, out int result); ++ static bool INumberBase<int>.TryConvertFromSaturating<TOther>(TOther value, out int result); ++ static bool INumberBase<int>.TryConvertFromTruncating<TOther>(TOther value, out int result); ++ static bool INumberBase<int>.TryConvertToChecked<TOther>(int value, out TOther result); ++ static bool INumberBase<int>.TryConvertToSaturating<TOther>(int value, out TOther result); ++ static bool INumberBase<int>.TryConvertToTruncating<TOther>(int value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out int result) where TOther : INumber<TOther>; + } + public readonly struct Int64 : IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, IComparable, IComparable<long>, IComparisonOperators<long, long>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long>, IEquatable<long>, IFormattable, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, INumber<long>, INumberBase<long>, IParsable<long>, IShiftOperators<long, long>, ISignedNumber<long>, ISpanFormattable, ISpanParsable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long> { ++ static int System.Numerics.INumberBase<System.Int64>.Radix { get; } +- public static long CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static long CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static long CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(long value); ++ public static bool IsOddInteger(long value); ++ public static bool IsPositive(long value); +- long IBinaryInteger<long>.GetShortestBitLength(); ++ int IBinaryInteger<long>.GetShortestBitLength(); ++ bool IBinaryInteger<long>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ static long INumber<long>.MaxNumber(long x, long y); ++ static long INumber<long>.MinNumber(long x, long y); ++ static bool INumberBase<long>.IsCanonical(long value); ++ static bool INumberBase<long>.IsComplexNumber(long value); ++ static bool INumberBase<long>.IsFinite(long value); ++ static bool INumberBase<long>.IsImaginaryNumber(long value); ++ static bool INumberBase<long>.IsInfinity(long value); ++ static bool INumberBase<long>.IsInteger(long value); ++ static bool INumberBase<long>.IsNaN(long value); ++ static bool INumberBase<long>.IsNegativeInfinity(long value); ++ static bool INumberBase<long>.IsNormal(long value); ++ static bool INumberBase<long>.IsPositiveInfinity(long value); ++ static bool INumberBase<long>.IsRealNumber(long value); ++ static bool INumberBase<long>.IsSubnormal(long value); ++ static bool INumberBase<long>.IsZero(long value); ++ static long INumberBase<long>.MaxMagnitudeNumber(long x, long y); ++ static long INumberBase<long>.MinMagnitudeNumber(long x, long y); ++ static bool INumberBase<long>.TryConvertFromChecked<TOther>(TOther value, out long result); ++ static bool INumberBase<long>.TryConvertFromSaturating<TOther>(TOther value, out long result); ++ static bool INumberBase<long>.TryConvertFromTruncating<TOther>(TOther value, out long result); ++ static bool INumberBase<long>.TryConvertToChecked<TOther>(long value, out TOther result); ++ static bool INumberBase<long>.TryConvertToSaturating<TOther>(long value, out TOther result); ++ static bool INumberBase<long>.TryConvertToTruncating<TOther>(long value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out long result) where TOther : INumber<TOther>; + } + public readonly struct IntPtr : IAdditionOperators<IntPtr, IntPtr, IntPtr>, IAdditiveIdentity<IntPtr, IntPtr>, IBinaryInteger<IntPtr>, IBinaryNumber<IntPtr>, IBitwiseOperators<IntPtr, IntPtr, IntPtr>, IComparable, IComparable<IntPtr>, IComparisonOperators<IntPtr, IntPtr>, IDecrementOperators<IntPtr>, IDivisionOperators<IntPtr, IntPtr, IntPtr>, IEqualityOperators<IntPtr, IntPtr>, IEquatable<IntPtr>, IFormattable, IIncrementOperators<IntPtr>, IMinMaxValue<IntPtr>, IModulusOperators<IntPtr, IntPtr, IntPtr>, IMultiplicativeIdentity<IntPtr, IntPtr>, IMultiplyOperators<IntPtr, IntPtr, IntPtr>, INumber<IntPtr>, INumberBase<IntPtr>, IParsable<IntPtr>, ISerializable, IShiftOperators<IntPtr, IntPtr>, ISignedNumber<IntPtr>, ISpanFormattable, ISpanParsable<IntPtr>, ISubtractionOperators<IntPtr, IntPtr, IntPtr>, IUnaryNegationOperators<IntPtr, IntPtr>, IUnaryPlusOperators<IntPtr, IntPtr> { ++ static int System.Numerics.INumberBase<nint>.Radix { get; } ++ public static IntPtr Abs(IntPtr value); ++ public static IntPtr Clamp(IntPtr value, IntPtr min, IntPtr max); ++ public static IntPtr CopySign(IntPtr value, IntPtr sign); ++ public static (IntPtr Quotient, IntPtr Remainder) DivRem(IntPtr left, IntPtr right); ++ public static bool IsEvenInteger(IntPtr value); ++ public static bool IsNegative(IntPtr value); ++ public static bool IsOddInteger(IntPtr value); ++ public static bool IsPositive(IntPtr value); ++ public static bool IsPow2(IntPtr value); ++ public static IntPtr LeadingZeroCount(IntPtr value); ++ public static IntPtr Log2(IntPtr value); ++ public static IntPtr Max(IntPtr x, IntPtr y); ++ public static IntPtr MaxMagnitude(IntPtr x, IntPtr y); ++ public static IntPtr Min(IntPtr x, IntPtr y); ++ public static IntPtr MinMagnitude(IntPtr x, IntPtr y); ++ public static IntPtr PopCount(IntPtr value); ++ public static IntPtr RotateLeft(IntPtr value, int rotateAmount); ++ public static IntPtr RotateRight(IntPtr value, int rotateAmount); ++ public static int Sign(IntPtr value); +- static (IntPtr Quotient, IntPtr Remainder) IBinaryInteger<IntPtr>.DivRem(IntPtr left, IntPtr right); +- long IBinaryInteger<IntPtr>.GetShortestBitLength(); ++ int IBinaryInteger<IntPtr>.GetShortestBitLength(); +- static IntPtr IBinaryInteger<IntPtr>.LeadingZeroCount(IntPtr value); +- static IntPtr IBinaryInteger<IntPtr>.PopCount(IntPtr value); +- static IntPtr IBinaryInteger<IntPtr>.RotateLeft(IntPtr value, int rotateAmount); +- static IntPtr IBinaryInteger<IntPtr>.RotateRight(IntPtr value, int rotateAmount); +- static IntPtr IBinaryInteger<IntPtr>.TrailingZeroCount(IntPtr value); ++ bool IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static bool IBinaryNumber<IntPtr>.IsPow2(IntPtr value); +- static IntPtr IBinaryNumber<IntPtr>.Log2(IntPtr value); +- static IntPtr INumber<IntPtr>.Abs(IntPtr value); +- static IntPtr INumber<IntPtr>.Clamp(IntPtr value, IntPtr min, IntPtr max); +- static IntPtr INumber<IntPtr>.CopySign(IntPtr value, IntPtr sign); +- static IntPtr INumber<IntPtr>.CreateChecked<TOther>(TOther value); +- static IntPtr INumber<IntPtr>.CreateSaturating<TOther>(TOther value); +- static IntPtr INumber<IntPtr>.CreateTruncating<TOther>(TOther value); +- static bool INumber<IntPtr>.IsNegative(IntPtr value); +- static IntPtr INumber<IntPtr>.Max(IntPtr x, IntPtr y); +- static IntPtr INumber<IntPtr>.MaxMagnitude(IntPtr x, IntPtr y); ++ static IntPtr INumber<IntPtr>.MaxNumber(IntPtr x, IntPtr y); +- static IntPtr INumber<IntPtr>.Min(IntPtr x, IntPtr y); +- static IntPtr INumber<IntPtr>.MinMagnitude(IntPtr x, IntPtr y); ++ static IntPtr INumber<IntPtr>.MinNumber(IntPtr x, IntPtr y); +- static int INumber<IntPtr>.Sign(IntPtr value); +- static bool INumber<IntPtr>.TryCreate<TOther>(TOther value, out IntPtr result); ++ static bool INumberBase<IntPtr>.IsCanonical(IntPtr value); ++ static bool INumberBase<IntPtr>.IsComplexNumber(IntPtr value); ++ static bool INumberBase<IntPtr>.IsFinite(IntPtr value); ++ static bool INumberBase<IntPtr>.IsImaginaryNumber(IntPtr value); ++ static bool INumberBase<IntPtr>.IsInfinity(IntPtr value); ++ static bool INumberBase<IntPtr>.IsInteger(IntPtr value); ++ static bool INumberBase<IntPtr>.IsNaN(IntPtr value); ++ static bool INumberBase<IntPtr>.IsNegativeInfinity(IntPtr value); ++ static bool INumberBase<IntPtr>.IsNormal(IntPtr value); ++ static bool INumberBase<IntPtr>.IsPositiveInfinity(IntPtr value); ++ static bool INumberBase<IntPtr>.IsRealNumber(IntPtr value); ++ static bool INumberBase<IntPtr>.IsSubnormal(IntPtr value); ++ static bool INumberBase<IntPtr>.IsZero(IntPtr value); ++ static IntPtr INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr x, IntPtr y); ++ static IntPtr INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr x, IntPtr y); ++ static bool INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther value, out IntPtr result); ++ static bool INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther value, out IntPtr result); ++ static bool INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther value, out IntPtr result); ++ static bool INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr value, out TOther result); ++ static bool INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr value, out TOther result); ++ static bool INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr value, out TOther result); ++ public static IntPtr TrailingZeroCount(IntPtr value); + } + public struct RuntimeFieldHandle : IEquatable<RuntimeFieldHandle>, ISerializable { ++ public static RuntimeFieldHandle FromIntPtr(IntPtr value); ++ public static IntPtr ToIntPtr(RuntimeFieldHandle value); + } + public struct RuntimeMethodHandle : IEquatable<RuntimeMethodHandle>, ISerializable { ++ public static RuntimeMethodHandle FromIntPtr(IntPtr value); ++ public static IntPtr ToIntPtr(RuntimeMethodHandle value); + } + public struct RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, ISerializable { ++ public static RuntimeTypeHandle FromIntPtr(IntPtr value); ++ public static IntPtr ToIntPtr(RuntimeTypeHandle value); + } + public readonly struct SByte : IAdditionOperators<sbyte, sbyte, sbyte>, IAdditiveIdentity<sbyte, sbyte>, IBinaryInteger<sbyte>, IBinaryNumber<sbyte>, IBitwiseOperators<sbyte, sbyte, sbyte>, IComparable, IComparable<sbyte>, IComparisonOperators<sbyte, sbyte>, IConvertible, IDecrementOperators<sbyte>, IDivisionOperators<sbyte, sbyte, sbyte>, IEqualityOperators<sbyte, sbyte>, IEquatable<sbyte>, IFormattable, IIncrementOperators<sbyte>, IMinMaxValue<sbyte>, IModulusOperators<sbyte, sbyte, sbyte>, IMultiplicativeIdentity<sbyte, sbyte>, IMultiplyOperators<sbyte, sbyte, sbyte>, INumber<sbyte>, INumberBase<sbyte>, IParsable<sbyte>, IShiftOperators<sbyte, sbyte>, ISignedNumber<sbyte>, ISpanFormattable, ISpanParsable<sbyte>, ISubtractionOperators<sbyte, sbyte, sbyte>, IUnaryNegationOperators<sbyte, sbyte>, IUnaryPlusOperators<sbyte, sbyte> { ++ static int System.Numerics.INumberBase<System.SByte>.Radix { get; } +- public static sbyte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static sbyte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static sbyte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(sbyte value); ++ public static bool IsOddInteger(sbyte value); ++ public static bool IsPositive(sbyte value); +- long IBinaryInteger<sbyte>.GetShortestBitLength(); ++ int IBinaryInteger<sbyte>.GetShortestBitLength(); ++ bool IBinaryInteger<sbyte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ static sbyte INumber<sbyte>.MaxNumber(sbyte x, sbyte y); ++ static sbyte INumber<sbyte>.MinNumber(sbyte x, sbyte y); ++ static bool INumberBase<sbyte>.IsCanonical(sbyte value); ++ static bool INumberBase<sbyte>.IsComplexNumber(sbyte value); ++ static bool INumberBase<sbyte>.IsFinite(sbyte value); ++ static bool INumberBase<sbyte>.IsImaginaryNumber(sbyte value); ++ static bool INumberBase<sbyte>.IsInfinity(sbyte value); ++ static bool INumberBase<sbyte>.IsInteger(sbyte value); ++ static bool INumberBase<sbyte>.IsNaN(sbyte value); ++ static bool INumberBase<sbyte>.IsNegativeInfinity(sbyte value); ++ static bool INumberBase<sbyte>.IsNormal(sbyte value); ++ static bool INumberBase<sbyte>.IsPositiveInfinity(sbyte value); ++ static bool INumberBase<sbyte>.IsRealNumber(sbyte value); ++ static bool INumberBase<sbyte>.IsSubnormal(sbyte value); ++ static bool INumberBase<sbyte>.IsZero(sbyte value); ++ static sbyte INumberBase<sbyte>.MaxMagnitudeNumber(sbyte x, sbyte y); ++ static sbyte INumberBase<sbyte>.MinMagnitudeNumber(sbyte x, sbyte y); ++ static bool INumberBase<sbyte>.TryConvertFromChecked<TOther>(TOther value, out sbyte result); ++ static bool INumberBase<sbyte>.TryConvertFromSaturating<TOther>(TOther value, out sbyte result); ++ static bool INumberBase<sbyte>.TryConvertFromTruncating<TOther>(TOther value, out sbyte result); ++ static bool INumberBase<sbyte>.TryConvertToChecked<TOther>(sbyte value, out TOther result); ++ static bool INumberBase<sbyte>.TryConvertToSaturating<TOther>(sbyte value, out TOther result); ++ static bool INumberBase<sbyte>.TryConvertToTruncating<TOther>(sbyte value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out sbyte result) where TOther : INumber<TOther>; + } + public readonly struct Single : IAdditionOperators<float, float, float>, IAdditiveIdentity<float, float>, IBinaryFloatingPointIeee754<float>, IBinaryNumber<float>, IBitwiseOperators<float, float, float>, IComparable, IComparable<float>, IComparisonOperators<float, float>, IConvertible, IDecrementOperators<float>, IDivisionOperators<float, float, float>, IEqualityOperators<float, float>, IEquatable<float>, IExponentialFunctions<float>, IFloatingPoint<float>, IFloatingPointIeee754<float>, IFormattable, IHyperbolicFunctions<float>, IIncrementOperators<float>, ILogarithmicFunctions<float>, IMinMaxValue<float>, IModulusOperators<float, float, float>, IMultiplicativeIdentity<float, float>, IMultiplyOperators<float, float, float>, INumber<float>, INumberBase<float>, IParsable<float>, IPowerFunctions<float>, IRootFunctions<float>, ISignedNumber<float>, ISpanFormattable, ISpanParsable<float>, ISubtractionOperators<float, float, float>, ITrigonometricFunctions<float>, IUnaryNegationOperators<float, float>, IUnaryPlusOperators<float, float> { ++ static int System.Numerics.INumberBase<System.Single>.Radix { get; } +- public static float CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static float CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static float CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static float Exp10(float x); ++ public static float Exp10M1(float x); ++ public static float Exp2(float x); ++ public static float Exp2M1(float x); ++ public static float ExpM1(float x); ++ public static bool IsEvenInteger(float value); ++ public static bool IsInteger(float value); ++ public static bool IsOddInteger(float value); ++ public static bool IsPositive(float value); ++ public static bool IsRealNumber(float value); ++ public static float Log10P1(float x); ++ public static float Log2P1(float x); ++ public static float LogP1(float x); ++ public static float MaxMagnitudeNumber(float x, float y); ++ public static float MaxNumber(float x, float y); ++ public static float MinMagnitudeNumber(float x, float y); ++ public static float MinNumber(float x, float y); +- long IFloatingPoint<float>.GetExponentShortestBitLength(); ++ int IFloatingPoint<float>.GetExponentShortestBitLength(); +- long IFloatingPoint<float>.GetSignificandBitLength(); ++ int IFloatingPoint<float>.GetSignificandBitLength(); ++ bool IFloatingPoint<float>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IFloatingPoint<float>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten); ++ static bool INumberBase<float>.IsCanonical(float value); ++ static bool INumberBase<float>.IsComplexNumber(float value); ++ static bool INumberBase<float>.IsImaginaryNumber(float value); ++ static bool INumberBase<float>.IsZero(float value); ++ static bool INumberBase<float>.TryConvertFromChecked<TOther>(TOther value, out float result); ++ static bool INumberBase<float>.TryConvertFromSaturating<TOther>(TOther value, out float result); ++ static bool INumberBase<float>.TryConvertFromTruncating<TOther>(TOther value, out float result); ++ static bool INumberBase<float>.TryConvertToChecked<TOther>(float value, out TOther result); ++ static bool INumberBase<float>.TryConvertToSaturating<TOther>(float value, out TOther result); ++ static bool INumberBase<float>.TryConvertToTruncating<TOther>(float value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out float result) where TOther : INumber<TOther>; + } +- public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IComparisonOperators<TimeOnly, TimeOnly>, IEqualityOperators<TimeOnly, TimeOnly>, IEquatable<TimeOnly>, IFormattable, IMinMaxValue<TimeOnly>, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly>, ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan> { ++ public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IEquatable<TimeOnly>, IFormattable, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly> { +- static TimeSpan ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>.operator checked -(TimeOnly left, TimeOnly right); + } +- public readonly struct TimeSpan : IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparable, IComparable<TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IEqualityOperators<TimeSpan, TimeSpan>, IEquatable<TimeSpan>, IFormattable, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, TimeSpan> { ++ public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan> { +- static TimeSpan System.Numerics.IAdditiveIdentity<System.TimeSpan,System.TimeSpan>.AdditiveIdentity { get; } +- static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MaxValue { get; } +- static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MinValue { get; } +- static double System.Numerics.IMultiplicativeIdentity<System.TimeSpan,System.Double>.MultiplicativeIdentity { get; } +- static TimeSpan IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked +(TimeSpan left, TimeSpan right); +- static TimeSpan IDivisionOperators<TimeSpan, double, TimeSpan>.operator checked /(TimeSpan left, double right); +- static double IDivisionOperators<TimeSpan, TimeSpan, double>.operator checked /(TimeSpan left, TimeSpan right); +- static TimeSpan IMultiplyOperators<TimeSpan, double, TimeSpan>.operator checked *(TimeSpan left, double right); +- static TimeSpan ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked -(TimeSpan left, TimeSpan right); +- static TimeSpan IUnaryNegationOperators<TimeSpan, TimeSpan>.operator checked -(TimeSpan value); + } ++ public readonly struct UInt128 : IAdditionOperators<UInt128, UInt128, UInt128>, IAdditiveIdentity<UInt128, UInt128>, IBinaryInteger<UInt128>, IBinaryNumber<UInt128>, IBitwiseOperators<UInt128, UInt128, UInt128>, IComparable, IComparable<UInt128>, IComparisonOperators<UInt128, UInt128>, IDecrementOperators<UInt128>, IDivisionOperators<UInt128, UInt128, UInt128>, IEqualityOperators<UInt128, UInt128>, IEquatable<UInt128>, IFormattable, IIncrementOperators<UInt128>, IMinMaxValue<UInt128>, IModulusOperators<UInt128, UInt128, UInt128>, IMultiplicativeIdentity<UInt128, UInt128>, IMultiplyOperators<UInt128, UInt128, UInt128>, INumber<UInt128>, INumberBase<UInt128>, IParsable<UInt128>, IShiftOperators<UInt128, UInt128>, ISpanFormattable, ISpanParsable<UInt128>, ISubtractionOperators<UInt128, UInt128, UInt128>, IUnaryNegationOperators<UInt128, UInt128>, IUnaryPlusOperators<UInt128, UInt128>, IUnsignedNumber<UInt128> { ++ public UInt128(ulong upper, ulong lower); ++ public static UInt128 MaxValue { get; } ++ public static UInt128 MinValue { get; } ++ public static UInt128 One { get; } ++ static UInt128 System.Numerics.IAdditiveIdentity<System.UInt128,System.UInt128>.AdditiveIdentity { get; } ++ static UInt128 System.Numerics.IMultiplicativeIdentity<System.UInt128,System.UInt128>.MultiplicativeIdentity { get; } ++ static int System.Numerics.INumberBase<System.UInt128>.Radix { get; } ++ public static UInt128 Zero { get; } ++ public static UInt128 Clamp(UInt128 value, UInt128 min, UInt128 max); ++ public int CompareTo(object? value); ++ public int CompareTo(UInt128 value); ++ public static (UInt128 Quotient, UInt128 Remainder) DivRem(UInt128 left, UInt128 right); ++ public override bool Equals(object? obj); ++ public bool Equals(UInt128 other); ++ public override int GetHashCode(); ++ public static bool IsEvenInteger(UInt128 value); ++ public static bool IsOddInteger(UInt128 value); ++ public static bool IsPow2(UInt128 value); ++ public static UInt128 LeadingZeroCount(UInt128 value); ++ public static UInt128 Log2(UInt128 value); ++ public static UInt128 Max(UInt128 x, UInt128 y); ++ public static UInt128 Min(UInt128 x, UInt128 y); ++ public static UInt128 operator +(UInt128 left, UInt128 right); ++ public static UInt128 operator &(UInt128 left, UInt128 right); ++ public static UInt128 operator |(UInt128 left, UInt128 right); ++ public static UInt128 operator checked +(UInt128 left, UInt128 right); ++ public static UInt128 operator checked --(UInt128 value); ++ public static UInt128 operator checked /(UInt128 left, UInt128 right); ++ public static explicit operator checked UInt128 (double value); ++ public static explicit operator checked UInt128 (short value); ++ public static explicit operator checked UInt128 (int value); ++ public static explicit operator checked UInt128 (long value); ++ public static explicit operator checked UInt128 (nint value); ++ public static explicit operator checked UInt128 (sbyte value); ++ public static explicit operator checked UInt128 (float value); ++ public static explicit operator checked byte (UInt128 value); ++ public static explicit operator checked char (UInt128 value); ++ public static explicit operator checked short (UInt128 value); ++ public static explicit operator checked int (UInt128 value); ++ public static explicit operator checked long (UInt128 value); ++ public static explicit operator checked Int128 (UInt128 value); ++ public static explicit operator checked nint (UInt128 value); ++ public static explicit operator checked sbyte (UInt128 value); ++ public static explicit operator checked ushort (UInt128 value); ++ public static explicit operator checked uint (UInt128 value); ++ public static explicit operator checked ulong (UInt128 value); ++ public static explicit operator checked nuint (UInt128 value); ++ public static UInt128 operator checked ++(UInt128 value); ++ public static UInt128 operator checked *(UInt128 left, UInt128 right); ++ public static UInt128 operator checked -(UInt128 left, UInt128 right); ++ public static UInt128 operator checked -(UInt128 value); ++ public static UInt128 operator --(UInt128 value); ++ public static UInt128 operator /(UInt128 left, UInt128 right); ++ public static bool operator ==(UInt128 left, UInt128 right); ++ public static UInt128 operator ^(UInt128 left, UInt128 right); ++ public static explicit operator UInt128 (decimal value); ++ public static explicit operator UInt128 (double value); ++ public static explicit operator UInt128 (short value); ++ public static explicit operator UInt128 (int value); ++ public static explicit operator UInt128 (long value); ++ public static explicit operator UInt128 (nint value); ++ public static explicit operator UInt128 (sbyte value); ++ public static explicit operator UInt128 (float value); ++ public static explicit operator byte (UInt128 value); ++ public static explicit operator char (UInt128 value); ++ public static explicit operator decimal (UInt128 value); ++ public static explicit operator double (UInt128 value); ++ public static explicit operator Half (UInt128 value); ++ public static explicit operator Int128 (UInt128 value); ++ public static explicit operator short (UInt128 value); ++ public static explicit operator int (UInt128 value); ++ public static explicit operator long (UInt128 value); ++ public static explicit operator nint (UInt128 value); ++ public static explicit operator sbyte (UInt128 value); ++ public static explicit operator float (UInt128 value); ++ public static explicit operator ushort (UInt128 value); ++ public static explicit operator uint (UInt128 value); ++ public static explicit operator ulong (UInt128 value); ++ public static explicit operator nuint (UInt128 value); ++ public static bool operator >(UInt128 left, UInt128 right); ++ public static bool operator >=(UInt128 left, UInt128 right); ++ public static implicit operator UInt128 (byte value); ++ public static implicit operator UInt128 (char value); ++ public static implicit operator UInt128 (ushort value); ++ public static implicit operator UInt128 (uint value); ++ public static implicit operator UInt128 (ulong value); ++ public static implicit operator UInt128 (nuint value); ++ public static UInt128 operator ++(UInt128 value); ++ public static bool operator !=(UInt128 left, UInt128 right); ++ public static UInt128 operator <<(UInt128 value, int shiftAmount); ++ public static bool operator <(UInt128 left, UInt128 right); ++ public static bool operator <=(UInt128 left, UInt128 right); ++ public static UInt128 operator %(UInt128 left, UInt128 right); ++ public static UInt128 operator *(UInt128 left, UInt128 right); ++ public static UInt128 operator ~(UInt128 value); ++ public static UInt128 operator >>(UInt128 value, int shiftAmount); ++ public static UInt128 operator -(UInt128 left, UInt128 right); ++ public static UInt128 operator -(UInt128 value); ++ public static UInt128 operator +(UInt128 value); ++ public static UInt128 operator >>>(UInt128 value, int shiftAmount); ++ public static UInt128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null); ++ public static UInt128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider); ++ public static UInt128 Parse(string s); ++ public static UInt128 Parse(string s, NumberStyles style); ++ public static UInt128 Parse(string s, NumberStyles style, IFormatProvider? provider); ++ public static UInt128 Parse(string s, IFormatProvider? provider); ++ public static UInt128 PopCount(UInt128 value); ++ public static UInt128 RotateLeft(UInt128 value, int rotateAmount); ++ public static UInt128 RotateRight(UInt128 value, int rotateAmount); ++ public static int Sign(UInt128 value); ++ int IBinaryInteger<UInt128>.GetByteCount(); ++ int IBinaryInteger<UInt128>.GetShortestBitLength(); ++ bool IBinaryInteger<UInt128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); ++ bool IBinaryInteger<UInt128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten); ++ static UInt128 INumber<UInt128>.CopySign(UInt128 value, UInt128 sign); ++ static UInt128 INumber<UInt128>.MaxNumber(UInt128 x, UInt128 y); ++ static UInt128 INumber<UInt128>.MinNumber(UInt128 x, UInt128 y); ++ static UInt128 INumberBase<UInt128>.Abs(UInt128 value); ++ static bool INumberBase<UInt128>.IsCanonical(UInt128 value); ++ static bool INumberBase<UInt128>.IsComplexNumber(UInt128 value); ++ static bool INumberBase<UInt128>.IsFinite(UInt128 value); ++ static bool INumberBase<UInt128>.IsImaginaryNumber(UInt128 value); ++ static bool INumberBase<UInt128>.IsInfinity(UInt128 value); ++ static bool INumberBase<UInt128>.IsInteger(UInt128 value); ++ static bool INumberBase<UInt128>.IsNaN(UInt128 value); ++ static bool INumberBase<UInt128>.IsNegative(UInt128 value); ++ static bool INumberBase<UInt128>.IsNegativeInfinity(UInt128 value); ++ static bool INumberBase<UInt128>.IsNormal(UInt128 value); ++ static bool INumberBase<UInt128>.IsPositive(UInt128 value); ++ static bool INumberBase<UInt128>.IsPositiveInfinity(UInt128 value); ++ static bool INumberBase<UInt128>.IsRealNumber(UInt128 value); ++ static bool INumberBase<UInt128>.IsSubnormal(UInt128 value); ++ static bool INumberBase<UInt128>.IsZero(UInt128 value); ++ static UInt128 INumberBase<UInt128>.MaxMagnitude(UInt128 x, UInt128 y); ++ static UInt128 INumberBase<UInt128>.MaxMagnitudeNumber(UInt128 x, UInt128 y); ++ static UInt128 INumberBase<UInt128>.MinMagnitude(UInt128 x, UInt128 y); ++ static UInt128 INumberBase<UInt128>.MinMagnitudeNumber(UInt128 x, UInt128 y); ++ static bool INumberBase<UInt128>.TryConvertFromChecked<TOther>(TOther value, out UInt128 result); ++ static bool INumberBase<UInt128>.TryConvertFromSaturating<TOther>(TOther value, out UInt128 result); ++ static bool INumberBase<UInt128>.TryConvertFromTruncating<TOther>(TOther value, out UInt128 result); ++ static bool INumberBase<UInt128>.TryConvertToChecked<TOther>(UInt128 value, out TOther result); ++ static bool INumberBase<UInt128>.TryConvertToSaturating<TOther>(UInt128 value, out TOther result); ++ static bool INumberBase<UInt128>.TryConvertToTruncating<TOther>(UInt128 value, out TOther result); ++ public override string ToString(); ++ public string ToString(IFormatProvider? provider); ++ public string ToString(string? format); ++ public string ToString(string? format, IFormatProvider? provider); ++ public static UInt128 TrailingZeroCount(UInt128 value); ++ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null); ++ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out UInt128 result); ++ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out UInt128 result); ++ public static bool TryParse(ReadOnlySpan<char> s, out UInt128 result); ++ public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt128 result); ++ public static bool TryParse(string? s, IFormatProvider? provider, out UInt128 result); ++ public static bool TryParse(string? s, out UInt128 result); ++ } + public readonly struct UInt16 : IAdditionOperators<ushort, ushort, ushort>, IAdditiveIdentity<ushort, ushort>, IBinaryInteger<ushort>, IBinaryNumber<ushort>, IBitwiseOperators<ushort, ushort, ushort>, IComparable, IComparable<ushort>, IComparisonOperators<ushort, ushort>, IConvertible, IDecrementOperators<ushort>, IDivisionOperators<ushort, ushort, ushort>, IEqualityOperators<ushort, ushort>, IEquatable<ushort>, IFormattable, IIncrementOperators<ushort>, IMinMaxValue<ushort>, IModulusOperators<ushort, ushort, ushort>, IMultiplicativeIdentity<ushort, ushort>, IMultiplyOperators<ushort, ushort, ushort>, INumber<ushort>, INumberBase<ushort>, IParsable<ushort>, IShiftOperators<ushort, ushort>, ISpanFormattable, ISpanParsable<ushort>, ISubtractionOperators<ushort, ushort, ushort>, IUnaryNegationOperators<ushort, ushort>, IUnaryPlusOperators<ushort, ushort>, IUnsignedNumber<ushort> { ++ static int System.Numerics.INumberBase<System.UInt16>.Radix { get; } +- public static ushort CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static ushort CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static ushort CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(ushort value); ++ public static bool IsOddInteger(ushort value); +- long IBinaryInteger<ushort>.GetShortestBitLength(); ++ int IBinaryInteger<ushort>.GetShortestBitLength(); ++ bool IBinaryInteger<ushort>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static ushort INumber<ushort>.Abs(ushort value); +- static bool INumber<ushort>.IsNegative(ushort value); +- static ushort INumber<ushort>.MaxMagnitude(ushort x, ushort y); ++ static ushort INumber<ushort>.MaxNumber(ushort x, ushort y); +- static ushort INumber<ushort>.MinMagnitude(ushort x, ushort y); ++ static ushort INumber<ushort>.MinNumber(ushort x, ushort y); ++ static ushort INumberBase<ushort>.Abs(ushort value); ++ static bool INumberBase<ushort>.IsCanonical(ushort value); ++ static bool INumberBase<ushort>.IsComplexNumber(ushort value); ++ static bool INumberBase<ushort>.IsFinite(ushort value); ++ static bool INumberBase<ushort>.IsImaginaryNumber(ushort value); ++ static bool INumberBase<ushort>.IsInfinity(ushort value); ++ static bool INumberBase<ushort>.IsInteger(ushort value); ++ static bool INumberBase<ushort>.IsNaN(ushort value); ++ static bool INumberBase<ushort>.IsNegative(ushort value); ++ static bool INumberBase<ushort>.IsNegativeInfinity(ushort value); ++ static bool INumberBase<ushort>.IsNormal(ushort value); ++ static bool INumberBase<ushort>.IsPositive(ushort value); ++ static bool INumberBase<ushort>.IsPositiveInfinity(ushort value); ++ static bool INumberBase<ushort>.IsRealNumber(ushort value); ++ static bool INumberBase<ushort>.IsSubnormal(ushort value); ++ static bool INumberBase<ushort>.IsZero(ushort value); ++ static ushort INumberBase<ushort>.MaxMagnitude(ushort x, ushort y); ++ static ushort INumberBase<ushort>.MaxMagnitudeNumber(ushort x, ushort y); ++ static ushort INumberBase<ushort>.MinMagnitude(ushort x, ushort y); ++ static ushort INumberBase<ushort>.MinMagnitudeNumber(ushort x, ushort y); ++ static bool INumberBase<ushort>.TryConvertFromChecked<TOther>(TOther value, out ushort result); ++ static bool INumberBase<ushort>.TryConvertFromSaturating<TOther>(TOther value, out ushort result); ++ static bool INumberBase<ushort>.TryConvertFromTruncating<TOther>(TOther value, out ushort result); ++ static bool INumberBase<ushort>.TryConvertToChecked<TOther>(ushort value, out TOther result); ++ static bool INumberBase<ushort>.TryConvertToSaturating<TOther>(ushort value, out TOther result); ++ static bool INumberBase<ushort>.TryConvertToTruncating<TOther>(ushort value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out ushort result) where TOther : INumber<TOther>; + } + public readonly struct UInt32 : IAdditionOperators<uint, uint, uint>, IAdditiveIdentity<uint, uint>, IBinaryInteger<uint>, IBinaryNumber<uint>, IBitwiseOperators<uint, uint, uint>, IComparable, IComparable<uint>, IComparisonOperators<uint, uint>, IConvertible, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IEqualityOperators<uint, uint>, IEquatable<uint>, IFormattable, IIncrementOperators<uint>, IMinMaxValue<uint>, IModulusOperators<uint, uint, uint>, IMultiplicativeIdentity<uint, uint>, IMultiplyOperators<uint, uint, uint>, INumber<uint>, INumberBase<uint>, IParsable<uint>, IShiftOperators<uint, uint>, ISpanFormattable, ISpanParsable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IUnsignedNumber<uint> { ++ static int System.Numerics.INumberBase<System.UInt32>.Radix { get; } +- public static uint CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static uint CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static uint CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(uint value); ++ public static bool IsOddInteger(uint value); +- long IBinaryInteger<uint>.GetShortestBitLength(); ++ int IBinaryInteger<uint>.GetShortestBitLength(); ++ bool IBinaryInteger<uint>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static uint INumber<uint>.Abs(uint value); +- static bool INumber<uint>.IsNegative(uint value); +- static uint INumber<uint>.MaxMagnitude(uint x, uint y); ++ static uint INumber<uint>.MaxNumber(uint x, uint y); +- static uint INumber<uint>.MinMagnitude(uint x, uint y); ++ static uint INumber<uint>.MinNumber(uint x, uint y); ++ static uint INumberBase<uint>.Abs(uint value); ++ static bool INumberBase<uint>.IsCanonical(uint value); ++ static bool INumberBase<uint>.IsComplexNumber(uint value); ++ static bool INumberBase<uint>.IsFinite(uint value); ++ static bool INumberBase<uint>.IsImaginaryNumber(uint value); ++ static bool INumberBase<uint>.IsInfinity(uint value); ++ static bool INumberBase<uint>.IsInteger(uint value); ++ static bool INumberBase<uint>.IsNaN(uint value); ++ static bool INumberBase<uint>.IsNegative(uint value); ++ static bool INumberBase<uint>.IsNegativeInfinity(uint value); ++ static bool INumberBase<uint>.IsNormal(uint value); ++ static bool INumberBase<uint>.IsPositive(uint value); ++ static bool INumberBase<uint>.IsPositiveInfinity(uint value); ++ static bool INumberBase<uint>.IsRealNumber(uint value); ++ static bool INumberBase<uint>.IsSubnormal(uint value); ++ static bool INumberBase<uint>.IsZero(uint value); ++ static uint INumberBase<uint>.MaxMagnitude(uint x, uint y); ++ static uint INumberBase<uint>.MaxMagnitudeNumber(uint x, uint y); ++ static uint INumberBase<uint>.MinMagnitude(uint x, uint y); ++ static uint INumberBase<uint>.MinMagnitudeNumber(uint x, uint y); ++ static bool INumberBase<uint>.TryConvertFromChecked<TOther>(TOther value, out uint result); ++ static bool INumberBase<uint>.TryConvertFromSaturating<TOther>(TOther value, out uint result); ++ static bool INumberBase<uint>.TryConvertFromTruncating<TOther>(TOther value, out uint result); ++ static bool INumberBase<uint>.TryConvertToChecked<TOther>(uint value, out TOther result); ++ static bool INumberBase<uint>.TryConvertToSaturating<TOther>(uint value, out TOther result); ++ static bool INumberBase<uint>.TryConvertToTruncating<TOther>(uint value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out uint result) where TOther : INumber<TOther>; + } + public readonly struct UInt64 : IAdditionOperators<ulong, ulong, ulong>, IAdditiveIdentity<ulong, ulong>, IBinaryInteger<ulong>, IBinaryNumber<ulong>, IBitwiseOperators<ulong, ulong, ulong>, IComparable, IComparable<ulong>, IComparisonOperators<ulong, ulong>, IConvertible, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IEqualityOperators<ulong, ulong>, IEquatable<ulong>, IFormattable, IIncrementOperators<ulong>, IMinMaxValue<ulong>, IModulusOperators<ulong, ulong, ulong>, IMultiplicativeIdentity<ulong, ulong>, IMultiplyOperators<ulong, ulong, ulong>, INumber<ulong>, INumberBase<ulong>, IParsable<ulong>, IShiftOperators<ulong, ulong>, ISpanFormattable, ISpanParsable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IUnsignedNumber<ulong> { ++ static int System.Numerics.INumberBase<System.UInt64>.Radix { get; } +- public static ulong CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>; +- public static ulong CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>; +- public static ulong CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>; ++ public static bool IsEvenInteger(ulong value); ++ public static bool IsOddInteger(ulong value); +- long IBinaryInteger<ulong>.GetShortestBitLength(); ++ int IBinaryInteger<ulong>.GetShortestBitLength(); ++ bool IBinaryInteger<ulong>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static ulong INumber<ulong>.Abs(ulong value); +- static bool INumber<ulong>.IsNegative(ulong value); +- static ulong INumber<ulong>.MaxMagnitude(ulong x, ulong y); ++ static ulong INumber<ulong>.MaxNumber(ulong x, ulong y); +- static ulong INumber<ulong>.MinMagnitude(ulong x, ulong y); ++ static ulong INumber<ulong>.MinNumber(ulong x, ulong y); ++ static ulong INumberBase<ulong>.Abs(ulong value); ++ static bool INumberBase<ulong>.IsCanonical(ulong value); ++ static bool INumberBase<ulong>.IsComplexNumber(ulong value); ++ static bool INumberBase<ulong>.IsFinite(ulong value); ++ static bool INumberBase<ulong>.IsImaginaryNumber(ulong value); ++ static bool INumberBase<ulong>.IsInfinity(ulong value); ++ static bool INumberBase<ulong>.IsInteger(ulong value); ++ static bool INumberBase<ulong>.IsNaN(ulong value); ++ static bool INumberBase<ulong>.IsNegative(ulong value); ++ static bool INumberBase<ulong>.IsNegativeInfinity(ulong value); ++ static bool INumberBase<ulong>.IsNormal(ulong value); ++ static bool INumberBase<ulong>.IsPositive(ulong value); ++ static bool INumberBase<ulong>.IsPositiveInfinity(ulong value); ++ static bool INumberBase<ulong>.IsRealNumber(ulong value); ++ static bool INumberBase<ulong>.IsSubnormal(ulong value); ++ static bool INumberBase<ulong>.IsZero(ulong value); ++ static ulong INumberBase<ulong>.MaxMagnitude(ulong x, ulong y); ++ static ulong INumberBase<ulong>.MaxMagnitudeNumber(ulong x, ulong y); ++ static ulong INumberBase<ulong>.MinMagnitude(ulong x, ulong y); ++ static ulong INumberBase<ulong>.MinMagnitudeNumber(ulong x, ulong y); ++ static bool INumberBase<ulong>.TryConvertFromChecked<TOther>(TOther value, out ulong result); ++ static bool INumberBase<ulong>.TryConvertFromSaturating<TOther>(TOther value, out ulong result); ++ static bool INumberBase<ulong>.TryConvertFromTruncating<TOther>(TOther value, out ulong result); ++ static bool INumberBase<ulong>.TryConvertToChecked<TOther>(ulong value, out TOther result); ++ static bool INumberBase<ulong>.TryConvertToSaturating<TOther>(ulong value, out TOther result); ++ static bool INumberBase<ulong>.TryConvertToTruncating<TOther>(ulong value, out TOther result); +- public static bool TryCreate<TOther>(TOther value, out ulong result) where TOther : INumber<TOther>; + } + public readonly struct UIntPtr : IAdditionOperators<UIntPtr, UIntPtr, UIntPtr>, IAdditiveIdentity<UIntPtr, UIntPtr>, IBinaryInteger<UIntPtr>, IBinaryNumber<UIntPtr>, IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>, IComparable, IComparable<UIntPtr>, IComparisonOperators<UIntPtr, UIntPtr>, IDecrementOperators<UIntPtr>, IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>, IEqualityOperators<UIntPtr, UIntPtr>, IEquatable<UIntPtr>, IFormattable, IIncrementOperators<UIntPtr>, IMinMaxValue<UIntPtr>, IModulusOperators<UIntPtr, UIntPtr, UIntPtr>, IMultiplicativeIdentity<UIntPtr, UIntPtr>, IMultiplyOperators<UIntPtr, UIntPtr, UIntPtr>, INumber<UIntPtr>, INumberBase<UIntPtr>, IParsable<UIntPtr>, ISerializable, IShiftOperators<UIntPtr, UIntPtr>, ISpanFormattable, ISpanParsable<UIntPtr>, ISubtractionOperators<UIntPtr, UIntPtr, UIntPtr>, IUnaryNegationOperators<UIntPtr, UIntPtr>, IUnaryPlusOperators<UIntPtr, UIntPtr>, IUnsignedNumber<UIntPtr> { ++ static int System.Numerics.INumberBase<nuint>.Radix { get; } ++ public static UIntPtr Clamp(UIntPtr value, UIntPtr min, UIntPtr max); ++ public static (UIntPtr Quotient, UIntPtr Remainder) DivRem(UIntPtr left, UIntPtr right); ++ public static bool IsEvenInteger(UIntPtr value); ++ public static bool IsOddInteger(UIntPtr value); ++ public static bool IsPow2(UIntPtr value); ++ public static UIntPtr LeadingZeroCount(UIntPtr value); ++ public static UIntPtr Log2(UIntPtr value); ++ public static UIntPtr Max(UIntPtr x, UIntPtr y); ++ public static UIntPtr Min(UIntPtr x, UIntPtr y); ++ public static UIntPtr PopCount(UIntPtr value); ++ public static UIntPtr RotateLeft(UIntPtr value, int rotateAmount); ++ public static UIntPtr RotateRight(UIntPtr value, int rotateAmount); ++ public static int Sign(UIntPtr value); +- static (UIntPtr Quotient, UIntPtr Remainder) IBinaryInteger<UIntPtr>.DivRem(UIntPtr left, UIntPtr right); +- long IBinaryInteger<UIntPtr>.GetShortestBitLength(); ++ int IBinaryInteger<UIntPtr>.GetShortestBitLength(); +- static UIntPtr IBinaryInteger<UIntPtr>.LeadingZeroCount(UIntPtr value); +- static UIntPtr IBinaryInteger<UIntPtr>.PopCount(UIntPtr value); +- static UIntPtr IBinaryInteger<UIntPtr>.RotateLeft(UIntPtr value, int rotateAmount); +- static UIntPtr IBinaryInteger<UIntPtr>.RotateRight(UIntPtr value, int rotateAmount); +- static UIntPtr IBinaryInteger<UIntPtr>.TrailingZeroCount(UIntPtr value); ++ bool IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten); +- static bool IBinaryNumber<UIntPtr>.IsPow2(UIntPtr value); +- static UIntPtr IBinaryNumber<UIntPtr>.Log2(UIntPtr value); +- static UIntPtr INumber<UIntPtr>.Abs(UIntPtr value); +- static UIntPtr INumber<UIntPtr>.Clamp(UIntPtr value, UIntPtr min, UIntPtr max); +- static UIntPtr INumber<UIntPtr>.CreateChecked<TOther>(TOther value); +- static UIntPtr INumber<UIntPtr>.CreateSaturating<TOther>(TOther value); +- static UIntPtr INumber<UIntPtr>.CreateTruncating<TOther>(TOther value); +- static bool INumber<UIntPtr>.IsNegative(UIntPtr value); +- static UIntPtr INumber<UIntPtr>.Max(UIntPtr x, UIntPtr y); +- static UIntPtr INumber<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y); ++ static UIntPtr INumber<UIntPtr>.MaxNumber(UIntPtr x, UIntPtr y); +- static UIntPtr INumber<UIntPtr>.Min(UIntPtr x, UIntPtr y); +- static UIntPtr INumber<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y); ++ static UIntPtr INumber<UIntPtr>.MinNumber(UIntPtr x, UIntPtr y); +- static int INumber<UIntPtr>.Sign(UIntPtr value); +- static bool INumber<UIntPtr>.TryCreate<TOther>(TOther value, out UIntPtr result); ++ static UIntPtr INumberBase<UIntPtr>.Abs(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsCanonical(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsComplexNumber(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsFinite(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsInfinity(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsInteger(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsNaN(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsNegative(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsNormal(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsPositive(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsRealNumber(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsSubnormal(UIntPtr value); ++ static bool INumberBase<UIntPtr>.IsZero(UIntPtr value); ++ static UIntPtr INumberBase<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y); ++ static UIntPtr INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr x, UIntPtr y); ++ static UIntPtr INumberBase<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y); ++ static UIntPtr INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr x, UIntPtr y); ++ static bool INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther value, out UIntPtr result); ++ static bool INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther value, out UIntPtr result); ++ static bool INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther value, out UIntPtr result); ++ static bool INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr value, out TOther result); ++ static bool INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr value, out TOther result); ++ static bool INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr value, out TOther result); ++ public static UIntPtr TrailingZeroCount(UIntPtr value); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md new file mode 100644 index 00000000..bc1b4c61 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md @@ -0,0 +1,11 @@ +# API Difference 7.0-preview4 vs 7.0-preview5 + +API listing follows standard diff formatting. +Lines preceded by a '+' are additions and a '-' indicates removal. + +* [System.Diagnostics](7.0-preview5_System.Diagnostics.md) +* [System.Security.Permissions](7.0-preview5_System.Security.Permissions.md) +* [System.Windows.Forms](7.0-preview5_System.Windows.Forms.md) +* [System.Windows.Forms.Design](7.0-preview5_System.Windows.Forms.Design.md) +* [System.Windows.Forms.Layout](7.0-preview5_System.Windows.Forms.Layout.md) + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md new file mode 100644 index 00000000..68f7bc77 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md @@ -0,0 +1,10 @@ +# System.Diagnostics + +``` diff + namespace System.Diagnostics { + public sealed class PerformanceCounter : Component, ISupportInitialize { + public static int DefaultFileMappingSize; + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md new file mode 100644 index 00000000..d2590ff5 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md @@ -0,0 +1,19 @@ +# System.Security.Permissions + +``` diff + namespace System.Security.Permissions { + public sealed class ReflectionPermissionAttribute : CodeAccessSecurityAttribute { + public bool ReflectionEmit { get; set; } + public bool TypeInformation { get; set; } + } + public enum ReflectionPermissionFlag { + AllFlags = 7, + ReflectionEmit = 4, + TypeInformation = 1, + } + public sealed class RegistryPermissionAttribute : CodeAccessSecurityAttribute { + public string All { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md new file mode 100644 index 00000000..23bf2411 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md @@ -0,0 +1,11 @@ +# System.Windows.Forms.Design + +``` diff + namespace System.Windows.Forms.Design { + public sealed class ToolStripItemDesignerAvailabilityAttribute : Attribute { +- public override bool Equals(object obj); ++ public override bool Equals(object? obj); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md new file mode 100644 index 00000000..ac317ca9 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md @@ -0,0 +1,17 @@ +# System.Windows.Forms.Layout + +``` diff + namespace System.Windows.Forms.Layout { + public class TableLayoutSettingsTypeConverter : TypeConverter { +- public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType); ++ public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType); +- public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType); ++ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType); +- public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value); ++ public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value); +- public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType); ++ public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType); + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md new file mode 100644 index 00000000..79757bdf --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md @@ -0,0 +1,227 @@ +# System.Windows.Forms + +``` diff + namespace System.Windows.Forms { + public abstract class AxHost : Control, ICustomTypeDescriptor, ISupportInitialize { + public class State : ISerializable { +- public State(Stream ms, int storageType, bool manualUpdate, string licKey); ++ public State(Stream ms, int storageType, bool manualUpdate, string? licKey); + } + } +- public struct BindingMemberInfo { ++ public struct BindingMemberInfo : IEquatable<BindingMemberInfo> { ++ public bool Equals(BindingMemberInfo other); + } + public class ContextMenuStrip : ToolStripDropDownMenu { +- public Control SourceControl { get; } ++ public Control? SourceControl { get; } + } + public class Control : Component, IArrangedElement, IBindableComponent, IComponent, IDisposable, IDropTarget, IHandle, IKeyboardToolTip, Interop.Ole32.IOleControl, Interop.Ole32.IOleInPlaceActiveObject, Interop.Ole32.IOleInPlaceObject, Interop.Ole32.IOleObject, Interop.Ole32.IOleWindow, Interop.Ole32.IPersist, Interop.Ole32.IPersistStorage, Interop.Ole32.IPersistStreamInit, Interop.Ole32.IQuickActivate, Interop.Ole32.IViewObject, Interop.Ole32.IViewObject2, Interop.Oleaut32.IPersistPropertyBag, ISupportOleDropSource, ISynchronizeInvoke, IWin32Window { +- public Control(string text); ++ public Control(string? text); +- public Control(string text, int left, int top, int width, int height); ++ public Control(string? text, int left, int top, int width, int height); +- public Control(Control parent, string text); ++ public Control(Control? parent, string? text); +- public Control(Control parent, string text, int left, int top, int width, int height); ++ public Control(Control? parent, string? text, int left, int top, int width, int height); +- public string AccessibleDefaultActionDescription { get; set; } ++ public string? AccessibleDefaultActionDescription { get; set; } +- public string AccessibleDescription { get; set; } ++ public string? AccessibleDescription { get; set; } +- public string AccessibleName { get; set; } ++ public string? AccessibleName { get; set; } +- public virtual Image BackgroundImage { get; set; } ++ public virtual Image? BackgroundImage { get; set; } +- public virtual BindingContext BindingContext { get; set; } ++ public virtual BindingContext? BindingContext { get; set; } +- public virtual ContextMenuStrip ContextMenuStrip { get; set; } ++ public virtual ContextMenuStrip? ContextMenuStrip { get; set; } + public virtual Cursor Cursor { get; set; } + public virtual Font Font { get; set; } +- public event EventHandler AutoSizeChanged; ++ public event EventHandler? AutoSizeChanged; +- public event EventHandler BackColorChanged; ++ public event EventHandler? BackColorChanged; +- public event EventHandler BackgroundImageChanged; ++ public event EventHandler? BackgroundImageChanged; +- public event EventHandler BackgroundImageLayoutChanged; ++ public event EventHandler? BackgroundImageLayoutChanged; +- public event EventHandler BindingContextChanged; ++ public event EventHandler? BindingContextChanged; +- public event EventHandler CausesValidationChanged; ++ public event EventHandler? CausesValidationChanged; +- public event EventHandler ClientSizeChanged; ++ public event EventHandler? ClientSizeChanged; +- public event EventHandler ContextMenuStripChanged; ++ public event EventHandler? ContextMenuStripChanged; +- public event EventHandler CursorChanged; ++ public event EventHandler? CursorChanged; +- public event EventHandler DockChanged; ++ public event EventHandler? DockChanged; +- public event EventHandler EnabledChanged; ++ public event EventHandler? EnabledChanged; +- public event EventHandler FontChanged; ++ public event EventHandler? FontChanged; +- public event EventHandler ForeColorChanged; ++ public event EventHandler? ForeColorChanged; +- protected virtual AccessibleObject GetAccessibilityObjectById(int objectId); ++ protected virtual AccessibleObject? GetAccessibilityObjectById(int objectId); +- public bool SelectNextControl(Control ctl, bool forward, bool tabStopOnly, bool nested, bool wrap); ++ public bool SelectNextControl(Control? ctl, bool forward, bool tabStopOnly, bool nested, bool wrap); + } + public sealed class DataGridViewAdvancedBorderStyle : ICloneable { +- public override bool Equals(object other); ++ public override bool Equals(object? other); + } + public class Form : ContainerControl { ++ protected override void OnGotFocus(EventArgs e); + } + public class Label : Control, IAutomationLiveRegion { + public override string Text { get; set; } + } +- public struct LinkArea { ++ public struct LinkArea : IEquatable<LinkArea> { +- public override bool Equals(object o); ++ public override bool Equals(object? o); ++ public bool Equals(LinkArea other); + public class LinkAreaConverter : TypeConverter { +- public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType); ++ public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType); +- public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues); ++ public override object CreateInstance(ITypeDescriptorContext? context, IDictionary propertyValues); +- public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes); ++ public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext? context, object value, Attribute[]? attributes); + } + } + public class ListBox : ListControl { + public override Font Font { get; set; } + } + public class ListView : Control { + public class CheckedListViewItemCollection : 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 class SelectedListViewItemCollection : 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 class ListViewHitTestInfo { + public ListViewItem Item { get; } + public ListViewHitTestLocations Location { get; } + public ListViewItem.ListViewSubItem SubItem { get; } + } +- public struct Message { ++ public struct Message : IEquatable<Message> { ++ public bool Equals(Message other); + } + public sealed class NotifyIcon : Component { + public string Text { get; set; } + } +- public struct Padding { ++ public struct Padding : IEquatable<Padding> { ++ public bool Equals(Padding other); + } + public class PrintPreviewDialog : Form { + public override Cursor Cursor { get; set; } + public override Font Font { get; set; } + } + public class ProgressBar : Control { + public override Font Font { get; set; } + } + public abstract class ScrollBar : Control { + public override Font Font { get; set; } + } + public class Splitter : Control { + public override Font Font { get; set; } + } + public class TabControl : Control { + public class TabPageCollection : 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 struct TableLayoutPanelCellPosition { ++ public struct TableLayoutPanelCellPosition : IEquatable<TableLayoutPanelCellPosition> { ++ public bool Equals(TableLayoutPanelCellPosition other); + } + public class TabPage : Panel { + public string ImageKey { get; set; } + public override string Text { get; set; } + public string ToolTipText { get; set; } + } + public class ToolStripContentPanel : Panel { + public new string Name { get; set; } + } + public class ToolStripDropDownMenu : ToolStripDropDown { ++ protected override AccessibleObject CreateAccessibilityInstance(); + } + public class TrackBar : Control, ISupportInitialize { + public override Font Font { get; set; } + } + public class TreeViewImageIndexConverter : ImageIndexConverter { +- public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context); ++ public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context); + } + public class TreeViewImageKeyConverter : ImageKeyConverter { +- public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType); ++ public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType); + } + public abstract class UpDownBase : ContainerControl { +- public override Image BackgroundImage { get; set; } ++ public override Image? BackgroundImage { get; set; } +- public override ContextMenuStrip ContextMenuStrip { get; set; } ++ public override ContextMenuStrip? ContextMenuStrip { get; set; } + public override string Text { get; set; } +- public new event EventHandler AutoSizeChanged; ++ public new event EventHandler? AutoSizeChanged; +- public new event EventHandler BackgroundImageChanged; ++ public new event EventHandler? BackgroundImageChanged; +- public new event EventHandler BackgroundImageLayoutChanged; ++ public new event EventHandler? BackgroundImageLayoutChanged; +- public new event EventHandler MouseEnter; ++ public new event EventHandler? MouseEnter; +- public new event EventHandler MouseHover; ++ public new event EventHandler? MouseHover; +- public new event EventHandler MouseLeave; ++ public new event EventHandler? MouseLeave; +- public new event MouseEventHandler MouseMove; ++ public new event MouseEventHandler? MouseMove; +- protected virtual void OnChanged(object source, EventArgs e); ++ protected virtual void OnChanged(object? source, EventArgs e); +- protected virtual void OnTextBoxKeyDown(object source, KeyEventArgs e); ++ protected virtual void OnTextBoxKeyDown(object? source, KeyEventArgs e); +- protected virtual void OnTextBoxKeyPress(object source, KeyPressEventArgs e); ++ protected virtual void OnTextBoxKeyPress(object? source, KeyPressEventArgs e); +- protected virtual void OnTextBoxLostFocus(object source, EventArgs e); ++ protected virtual void OnTextBoxLostFocus(object? source, EventArgs e); +- protected virtual void OnTextBoxResize(object source, EventArgs e); ++ protected virtual void OnTextBoxResize(object? source, EventArgs e); +- protected virtual void OnTextBoxTextChanged(object source, EventArgs e); ++ protected virtual void OnTextBoxTextChanged(object? source, EventArgs e); + } + public class UserControl : ContainerControl { + public override string Text { get; set; } + } + } +``` + diff --git a/release-notes/7.0/preview/api-diff/preview5/README.md b/release-notes/7.0/preview/api-diff/preview5/README.md new file mode 100644 index 00000000..e2087f33 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/preview5/README.md @@ -0,0 +1,7 @@ +# .NET 7.0 Preview 5 API Changes + +The following API changes were made in .NET 7.0 Preview 5: + +- [Microsoft.NETCore.App](./Microsoft.NETCore.App/7.0-preview5.md) +- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/7.0-preview5.md) +- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/7.0-preview5.md) |