+
+
+
+
+
+""", "text/html"));
+
+app.Run();
+
+[JsonSerializable(typeof(string))]
+internal partial class AppJsonSerializerContext : JsonSerializerContext { }
+
+public class ChatHub : Hub
+{
+ public async Task SendMessage(string user, string message)
+ {
+ await Clients.All.SendAsync("ReceiveMessage", user, message);
+ }
+}
+```
+
+Publishing this app produces a native Windows executable of `10 MB` and a Linux executable of `10.9 MB`.
+
+### Limitations
+
+- Only the JSON protocol is currently supported
+ - As shown in the preceding code, apps that use JSON serialization and Native AOT must use the `System.Text.Json` Source Generator. This follows the same approach as minimal APIs.
+- On the SignalR server, Hub method parameters of type `IAsyncEnumerable` and `ChannelReader` where `T` is a ValueType (i.e. `struct`) aren't supported. Using these types results in a runtime exception at startup in development and in the published app. See https://github.com/dotnet/aspnetcore/issues/56179 for more information.
+* [Strongly-typed hubs](https://learn.microsoft.com/aspnet/core/signalr/hubs#strongly-typed-hubs) aren't supported with Native AOT (`PublishAot`). Using strongly-typed hubs with Native AOT will result in warnings during build and publish, and a runtime exception. Using strongly-typed hubs with trimming (`PublishedTrimmed`) is supported.
+
+- Only `Task`, `Task`, `ValueTask`, or `ValueTask` are supported for async return types.
+
+## Microsoft.AspNetCore.OpenApi supports trimming and Native AOT
+
+The new built-in OpenAPI support in ASP.NET Core now also supports trimming and Native AOT.
+
+### Get started
+
+Create a new ASP.NET Core Web API (native AOT) project.
+
+```console
+dotnet new webapiaot
+```
+
+Add the Microsoft.AspNetCore.OpenAPI package.
+
+```console
+dotnet add package Microsoft.AspNetCore.OpenApi --prerelease
+```
+
+For this prerelease, you also need to add the latest Microsoft.OpenAPI package to avoid trimming warnings.
+
+```console
+dotnet add package Microsoft.OpenApi
+```
+
+Update *Program.cs* to enable generating OpenAPI documents.
+
+```diff
++ builder.Services.AddOpenApi();
+
+var app = builder.Build();
+
++ app.MapOpenApi();
+```
+
+Publish the app.
+
+```console
+dotnet publish
+```
+
+The app should publish cleanly using Native AOT without warnings.
+
+## Improvements to transformer registration APIs in Microsoft.AspNetCore.OpenApi
+
+OpenAPI transformers support modifying the OpenAPI document, operations within the document, or schemas associated with types in the API. In this preview, the APIs for registering transformers on an OpenAPI document provide a variety of options for registering transformers.
+
+
+Previously, the following APIs where available for registering transformers:
+
+```csharp
+OpenApiOptions UseTransformer(Func transformer)
+OpenApiOptions UseTransformer(IOpenApiDocumentTransformer transformer)
+OpenApiOptions UseTransformer()
+OpenApiOptions UseSchemaTransformer(Func)
+OpenApiOptions UseOperationTransformer(Func)
+```
+
+The new API set is as follows:
+
+```csharp
+OpenApiOptions AddDocumentTransformer(Func transformer)
+OpenApiOptions AddDocumentTransformer(IOpenApiDocumentTransformer transformer)
+OpenApiOptions AddDocumentTransformer()
+
+OpenApiOptions AddSchemaTransformer(Func transformer)
+OpenApiOptions AddSchemaTransformer(IOpenApiSchemaTransformer transformer)
+OpenApiOptions AddSchemaTransformer()
+
+OpenApiOptions AddOperationTransformer(Func transformer)
+OpenApiOptions AddOperationTransformer(IOpenApiOperationTransformer transformer)
+OpenApiOptions AddOperationTransformer()
+```
+
+Thanks to [@martincostello](https://github.com/martincostello) for this contribution!
+
+## Call `ProducesProblem` and `ProducesValidationProblem` on route groups
+
+The `ProducesProblem` and `ProducesValidationProblem` extension methods have been updated to support application on route groups. These methods can be used to indicate that all endpoints in a route group can return `ProblemDetails` or `ValidationProblemDetails` responses for the purposes of OpenAPI metadata.
+
+```csharp
+var app = WebApplication.Create();
+
+var todos = app.MapGroup("/todos")
+ .ProducesProblem();
+
+todos.MapGet("/", () => new Todo(1, "Create sample app", false));
+todos.MapPost("/", (Todo todo) => Results.Ok(todo));
+
+app.Run();
+
+record Todo(int Id, string Title, boolean IsCompleted);
+```
+
+## Construct `Problem` and `ValidationProblem` result types with `IEnumerable>` values
+
+Prior to this preview, constructing `Problem` and `ValidationProblem` result types in minimal APIs required `errors` and `extensions` parameters of type `IDictionary`. In this release, these construction APIs support overloads that consume `IEnumerable>`.
+
+```csharp
+using Microsoft.AspNetCore.Http;
+
+var app = WebApplication.Create();
+
+app.MapGet("/", () =>
+{
+ var extensions = new List> { new("test", "value") };
+ return TypedResults.Problem("This is an error with extensions", extensions: extensions);
+});
+```
+
+Thank you [@joegoldman2](https://github.com/joegoldman2) for this contribution!
+
+## `OpenIdConnectHandler` support for Pushed Authorization Requests (PAR)
+
+We'd like to thank @josephdecock from @DuendeSoftware for adding Pushed Authorization Requests (PAR) to ASP.NET Core's `OpenIdConnectHandler`. Joe described the background and motivation for enabling PAR in [his API proposal](https://github.com/dotnet/aspnetcore/issues/51686) as follows:
+
+> Pushed Authorization Requests (PAR) is a relatively new [OAuth standard](https://datatracker.ietf.org/doc/html/rfc9126) that improves the security of OAuth and OIDC flows by moving authorization parameters from the front channel to the back channel (that is, from redirect URLs in the browser to direct machine to machine http calls on the back end).
+>
+> This prevents an attacker in the browser from:
+>
+> - Seeing authorization parameters (which could leak PII) and from
+> - Tampering with those parameters (e.g., the attacker could change the scope of access being requested).
+>
+> Pushing the authorization parameters also keeps request URLs short. Authorize parameters might get very long when using more complex OAuth and OIDC features such as Rich Authorization Requests, and URLs that are long cause issues in many browsers and networking infrastructure.
+>
+> The use of PAR is encouraged by the [FAPI working group](https://openid.net/wg/fapi/) within the OpenID Foundation. For example, [the FAPI2.0 Security Profile](https://openid.bitbucket.io/fapi/fapi-2_0-security-profile.html) requires the use of PAR. This security profile is used by many of the groups working on open banking (primarily in Europe), in health care, and in other industries with high security requirements.
+>
+> PAR is supported by a number of identity providers, including
+>
+> - Duende IdentityServer
+> - Curity
+> - Keycloak
+> - Authlete
+
+PAR is now enabled by default if the identity provider's discovery document advertises support for it. The identity provider's discovery document is usually found at `.well-known/openid-configuration`. This change should provide enhanced security for providers that support PAR. If this causes problems, disable PAR via `OpenIdConnectOptions.PushedAuthorizationBehavior` as follows:
+
+
+```csharp
+builder.Services
+ .AddAuthentication(options =>
+ {
+ options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
+ options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
+ })
+ .AddCookie()
+ .AddOpenIdConnect(oidcOptions =>
+ {
+ // Other provider-specific configuration goes here.
+
+ // The default value is PushedAuthorizationBehavior.UseIfAvailable.
+ oidcOptions.PushedAuthorizationBehavior = PushedAuthorizationBehavior.Disable;
+ });
+```
+
+To ensure that authentication only succeeds if PAR is used, use `PushedAuthorizationBehavior.Require`.
+
+This change also introduces a new `OnPushAuthorization` event to `OpenIdConnectEvents` which can be used to customize the pushed authorization request or handle it manually. Refer to the [API proposal](https://github.com/dotnet/aspnetcore/issues/51686) for more details.
+
+
+## Data Protection support for deleting keys
+
+Historically, it has been intentionally impossible to delete data protection keys because doing so makes it impossible to decrypt any data protected with them (i.e. causing data loss). Fortunately, keys are quite small, so the impact of accumulating many of them is minor. However, in order to support _very_ long running services, we've added the ability to explicitly delete (typically, very old) keys. Only delete keys when you can accept the risk of data loss in exchange for storage savings. Our guidance remains that data protection keys shouldn't be deleted.
+
+
+```csharp
+var keyManager = services.GetService();
+if (keyManager is IDeletableKeyManager deletableKeyManager)
+{
+ var utcNow = DateTimeOffset.UtcNow;
+ var yearGo = utcNow.AddYears(-1);
+ if (!deletableKeyManager.DeleteKeys(key => key.ExpirationDate < yearGo))
+ {
+ throw new InvalidOperationException("Failed to delete keys.");
+ }
+}
+```
+
+## Customize Kestrel named pipe endpoints
+
+Kestrel's named pipe support has been improved with advanced customization options. The new `CreateNamedPipeServerStream` method on the named pipe options allows pipes to be customized per-endpoint.
+
+An example of where this is useful is a Kestrel app that requires two pipe endpoints with different [access security](https://learn.microsoft.com/windows/win32/ipc/named-pipe-security-and-access-rights). The `CreateNamedPipeServerStream` option can be used to create pipes with custom security settings, depending on the pipe name.
+
+
+```csharp
+var builder = WebApplication.CreateBuilder();
+
+builder.WebHost.ConfigureKestrel(options =>
+{
+ options.ListenNamedPipe("pipe1");
+ options.ListenNamedPipe("pipe2");
+});
+
+builder.WebHost.UseNamedPipes(options =>
+{
+ options.CreateNamedPipeServerStream = (context) =>
+ {
+ var pipeSecurity = CreatePipeSecurity(context.NamedPipeEndpoint.PipeName);
+
+ return NamedPipeServerStreamAcl.Create(context.NamedPipeEndPoint.PipeName, PipeDirection.InOut,
+ NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte,
+ context.PipeOptions, inBufferSize: 0, outBufferSize: 0, pipeSecurity);
+ };
+});
+```
+
+## Improved Kestrel connection metrics
+
+We've made a significant improvement to Kestrel's connection metrics by including metadata about why a connection failed. The [`kestrel.connection.duration`](https://learn.microsoft.com/dotnet/core/diagnostics/built-in-metrics-aspnetcore#metric-kestrelconnectionduration) metric now includes the connection close reason in the `error.type` attribute.
+
+Here is a small sample of the `error.type` values:
+
+- `tls_handshake_failed` - The connection requires TLS, and the TLS handshake failed.
+- `connection_reset` - The connection was unexpectedly closed by the client while requests were in progress.
+- `request_headers_timeout` - Kestrel closed the connection because it didn't receive request headers in time.
+- `max_request_body_size_exceeded` - Kestrel closed the connection because uploaded data exceeded max size.
+
+Previously, diagnosing Kestrel connection issues required a server to record detailed, low-level logging. However, logs can be expensive to generate and store, and it can be difficult to find the right information amongst the noise.
+
+Metrics are a much cheaper alternative that can be left on in a production environment with minimal impact. Collected metrics can [drive dashboards and alerts](https://learn.microsoft.com/aspnet/core/log-mon/metrics/metrics#show-metrics-on-a-grafana-dashboard). Once a problem is identified at a high-level with metrics, further investigation using logging and other tooling can begin.
+
+We expect improved connection metrics to be useful in many scenarios:
+
+- Investigating performance issues caused by short connection lifetimes.
+- Observing ongoing external attacks on Kestrel that impact performance and stability.
+- Recording attempted external attacks on Kestrel that Kestrel's built-in security hardening prevented.
+
+For more information, see [ASP.NET Core metrics](https://learn.microsoft.com/aspnet/core/log-mon/metrics/metrics).
+
+## Opt-out of HTTP metrics on certain endpoints and requests
+
+.NET 9 adds the ability to opt-out of HTTP metrics and not record a value for certain endpoints and requests. It's common for apps to have endpoints that are frequently called by automated systems, such as a health checks endpoint. Recording information about those requests isn't useful.
+
+Endpoint can be excluded from metrics by adding metadata using either of the following approaches:
+
+* Add the `[DisableHttpMetrics]` attribute to your Web API controller, SignalR Hub, or gRPC service
+* Call `DisableHttpMetrics()` when mapping endpoints in app startup:
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddHealthChecks();
+
+var app = builder.Build();
+app.MapHealthChecks("/healthz").DisableHttpMetrics();
+app.Run();
+```
+
+In more advanced scenarios where a request doesn't map to an endpoint, or you want to opt-out HTTP requests dynamically, use the new `MetricsDisabled` property on `IHttpMetricsTagsFeature`. Set `MetricsDisabled` to true during a HTTP request to opt-out.
+
+```csharp
+// Middleware that conditionally opts-out HTTP requests.
+app.Use(async (context, next) =>
+{
+ if (context.Request.Headers.ContainsKey("x-disable-metrics"))
+ {
+ context.Features.Get()?.MetricsDisabled = true;
+ }
+
+ await next(context);
+});
+```
+
+## `ExceptionHandlerMiddleware` option to choose the status code based on the exception
+
+A new option when configuring the `ExceptionHandlerMiddleware` allows app developers to choose what status code to return when an exception occurs during application request handling. The new option changes the status code being set in the `ProblemDetails` response from the `ExceptionHandlerMiddleware`.
+
+```csharp
+app.UseExceptionHandler(new ExceptionHandlerOptions
+{
+ StatusCodeSelector = ex => ex is TimeoutException
+ ? StatusCodes.Status503ServiceUnavailable
+ : StatusCodes.Status500InternalServerError,
+});
+```
+
+Thanks to [@latonz](https://github.com/latonz) for contributing this new option!
+
+## Community contributors
+
+Thank you contributors! ❤️
+
+- [@SimonCropp](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3ASimonCropp)
+- [@andrewjsaid](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Aandrewjsaid)
+- [@dnperfors](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Adnperfors)
+- [@gitslav](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Agitslav)
+- [@joegoldman2](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Ajoegoldman2)
+- [@josephdecock](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Ajosephdecock)
+- [@ladeak](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Aladeak)
+- [@latonz](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Alatonz)
+- [@martincostello](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Amartincostello)
+- [@paulomorgado](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Apaulomorgado)
+- [@shoboske](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Ashoboske)
+- [@xiaozhao018](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Axiaozhao018)
+- [@yepeekai](https://github.com/dotnet/aspnetcore/pulls?q=is%3Apr+is%3Amerged+milestone%3A9.0-preview7+author%3Ayepeekai)
diff --git a/release-notes/9.0/preview/preview7/csharp.md b/release-notes/9.0/preview/preview7/csharp.md
new file mode 100644
index 0000000000..444d0fa99a
--- /dev/null
+++ b/release-notes/9.0/preview/preview7/csharp.md
@@ -0,0 +1,25 @@
+# C# updates in .NET 9 Preview 7
+
+Summary of what's new in C# in this release:
+
+- [Prioritize better overloads with `OverloadResolutionPriority` attribute](#prioritize-better-overloads-with-overloadresolutionpriority-attribute)
+
+What's new in C# for .NET 9:
+
+* [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/csharp.md)
+* [What's new in C# 13](https://learn.microsoft.com/dotnet/csharp/whats-new/csharp-13) documentation.
+* [Breaking changes in C# 13](https://learn.microsoft.com/dotnet/csharp/whats-new/breaking-changes/compiler%20breaking%20changes%20-%20dotnet%209) documentation.
+
+.NET 9 Preview 7:
+
+* [Discussion](https://aka.ms/dotnet/9/preview7)
+* [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/README.md)
+
+## Prioritize better overloads with `OverloadResolutionPriority` attribute
+
+C# introduces a new attribute, `System.Runtime.CompilerServices.OverloadResolutionPriority`, that can be used by API authors to adjust the relative priority of overloads within a single type as a means of steering API consumers to use specific APIs, even if those APIs would normally be considered ambiguous or otherwise not be chosen by C#'s overload resolution rules. This helps framework and library authors guide API usage as they APIs as they develop new and better patterns.
+
+The `OverloadResolutionPriorityAttribute` can be used in conjunction with the [`ObsoleteAttribute`](https://learn.microsoft.com/dotnet/api/system.obsoleteattribute). A library author may mark properties, methods, types and other programming elements as obsolete, while leaving them in place for backwards compatibility. Using programming elements marked with the `ObsoleteAttribute` will result in compiler warnings or errors. However, the type or member is still visible to overload resolution and may be selected over a better overload or cause an ambiguity failure. The `OverloadResolutionPriorityAttribute` lets library authors fix these problems by lowering the priority of obsolete members when there are better alternatives.
+
+We've already started using this attribute in the .NET libraries, with [Debug.Assert](https://github.com/dotnet/runtime/blob/019d7580a27db97f1fbdcf0d26f7ae3fa54fc2d1/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Debug.cs#L81). This particular change is discussed in more detail in the [Libraries release notes](./libraries.md#debugassert-now-reports-assert-condition-by-default).
+
diff --git a/release-notes/9.0/preview/preview7/dotnetmaui.md b/release-notes/9.0/preview/preview7/dotnetmaui.md
new file mode 100644
index 0000000000..6f51561b59
--- /dev/null
+++ b/release-notes/9.0/preview/preview7/dotnetmaui.md
@@ -0,0 +1,489 @@
+# .NET MAUI updates in .NET 9 Preview 7
+
+Here's a summary of what's new in .NET MAUI in this preview release:
+
+* [Introduction of `HybridWebview`](introduction-of-hybridwebview)
+* [New `TitleBar` Control and `Window.TitleBar` for Windows](#new-titlebar-control-and-windowtitlebar-for-windows)
+* [`CollectionView` & `CarouselView` improvements with a new opt-in handler for iOS and Mac Catalyst](#collectionview--carouselview-improvements-with-a-new-opt-in-handler-for-ios-and-mac-catalyst)
+* [Ability to bring a `Window` to the foregrond with `ActivateWindow`](#activatewindow-added-to-bring-a-window-to-foreground)
+* [`BackButtonBehavior` `OneWay` binding mode](#backbuttonbehavior-oneway-binding-mode)
+* [`BlazorWebView` backward compatibility host address](#blazorwebview-backward-compatibility-host-address)
+* [Native Embedding improvements](#native-embedding-improvements)
+* [`MainPage` is Obsolete](#mainpage-is-obsolete)
+* [New Handler Disconnect Policy](#new-handler-disconnect-policy)
+* [New `ProcessTerminated` event on `WebView` Control](#new-processterminated-event-on-webview-control)
+* [New lifecycle methods for remote notifications on iOS & Mac Catalyst](#new-lifecycle-methods-for-remote-notifications-on-ios--mac-catalyst)
+* [Xcode Sync for CLI and Visual Studio Code](#xcode-sync-for-cli-and-visual-studio-code)
+
+.NET MAUI updates in .NET 9 Preview 7:
+* [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/dotnetmaui.md)
+* [What's new in .NET MAUI in .NET 9](https://learn.microsoft.com/dotnet/maui/whats-new/dotnet-9) documentation.
+* [GitHub Release](https://aka.ms/maui9p7)
+
+.NET 9 Preview 7:
+* [Discussion](https://aka.ms/dotnet/9/preview7)
+* [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/README.md)
+
+## Introduction of `HybridWebView`
+
+`HybridWebView` enables hosting arbitrary HTML/JS/CSS content in a WebView, and enables communication between the code in the WebView (JavaScript) and the code that hosts the WebView (C#/.NET). For example, if you have an existing React JS application, you could host it in a cross-platform .NET MAUI native application, and build the back-end of the application using C# and .NET.
+
+To build a .NET MAUI app with `HybridWebView` you need a few pieces:
+
+1. The web content of the app, which consists of static HTML, JavaScript, CSS, images, and other files.
+2. Using the `HybridWebView` control as part of the app's UI, such as by referencing it in the app's XAML.
+3. Adding code to the "web" portion and the C#/.NET portion of the app to use the `HybridWebView`'s APIs to send messages between them, thus making it a hybrid application.
+
+The entire app, including the web content, is packaged and then runs locally on the device, and can be published to applicable app stores. The web content is hosted within a native web view control and runs within the context of the app. Any part of the app can access external web services, but it is not required. Let's take a look at how to use the new `HybridWebView` in a new .NET MAUI application.
+
+1. **Create a new project**
+
+ Open up your existing .NET MAUI project or create a new **.NET MAUI Application** project in Visual Studio, Visual Studio Code, or using command line tools.
+
+1. **Adding web content to the app**
+
+ Your app's web content is included as part of the .NET MAUI project as "raw assets." A raw asset is any file in the app's `Resources\Raw` folder, including sub-folders.
+
+ For `HybridWebView` the default location is to place files in the `Resources\Raw\wwwroot` folder, with the main file named `index.html`.
+
+ A simple application might have the following files and contents:
+
+ `Resources\Raw\wwwroot\index.html` with content for the main UI:
+
+ ```html
+
+
+
+
+
+
+
+
+
+
+
+
HybridWebView app!
+
+
+
+
+ Messages from C#:
+
+
+
+ ```
+
+ `Resources\Raw\wwwroot\scripts\HybridWebView.js` with the standard HybridWebView JavaScript library:
+
+ ```js
+ function HybridWebViewInit() {
+
+ function DispatchHybridWebViewMessage(message) {
+ const event = new CustomEvent("HybridWebViewMessageReceived", { detail: { message: message } });
+ window.dispatchEvent(event);
+ }
+
+ if (window.chrome && window.chrome.webview) {
+ // Windows WebView2
+ window.chrome.webview.addEventListener('message', arg => {
+ DispatchHybridWebViewMessage(arg.data);
+ });
+ }
+ else if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.webwindowinterop) {
+ // iOS and MacCatalyst WKWebView
+ window.external = {
+ "receiveMessage": message => {
+ DispatchHybridWebViewMessage(message);
+ }
+ };
+ }
+ else {
+ // Android WebView
+ window.addEventListener('message', arg => {
+ DispatchHybridWebViewMessage(arg.data);
+ });
+ }
+ }
+
+ window.HybridWebView = {
+ "SendRawMessage": function (message) {
+
+ if (window.chrome && window.chrome.webview) {
+ // Windows WebView2
+ window.chrome.webview.postMessage(message);
+ }
+ else if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.webwindowinterop) {
+ // iOS and MacCatalyst WKWebView
+ window.webkit.messageHandlers.webwindowinterop.postMessage(message);
+ }
+ else {
+ // Android WebView
+ hybridWebViewHost.sendRawMessage(message);
+ }
+ }
+ }
+
+ HybridWebViewInit();
+ ```
+
+ And you can then add any other files for CSS, images, additional HTML files, and so on.
+
+ > [!TIP] In some cases the IDE or code editor might add entries to the project's `.csproj` file that are incorrect. When using the default locations for the raw assets there should be no entries for any of these files or folders in the `.csproj` file. You might need to look at source control diffs to undo any such changes.
+
+
+1. **Adding the HybridWebView control**
+
+ In the app's `MainPage.xaml` file replace the default code within the `` tag with this XAML that has a grid layout, a button, and the `HybridWebView` control:
+
+
+ ```xml
+
+
+
+
+
+ ```
+
+1. **Use HybridWebView APIs to send messages between the JavaScript and C# code**
+
+ The sample HTML code above already include JavaScript code to send messages to the C# code.
+
+ Edit the `MainPage.xaml.cs` file and replace the default counter code with the following code to send and receive messages:
+
+ ```c#
+ private void OnSendMessageButtonClicked(object sender, EventArgs e)
+ {
+ hybridWebView.SendRawMessage($"Hello from C#!");
+ }
+
+ private async void OnHybridWebViewRawMessageReceived(object sender, HybridWebViewRawMessageReceivedEventArgs e)
+ {
+ await DisplayAlert("Raw Message Received", e.Message, "OK");
+ }
+ ```
+
+ The message are "raw" because no additional processing is performed. You can encode data within the message to perform more advanced messaging.
+
+
+## New `TitleBar` Control and `Window.TitleBar` for Windows
+
+
+The new `TitleBar` control enables developers the ability to create custom title bars in their applications. There are two parts to this new control, first is the control itself which inherits from `ContentView` and can be placed anywhere in an application. Second, is a new `Window.TitleBar` property on `Window` that enables developers to set a `TitleBar` control that users will see at the top of their application. `Window.TitleBar` is available in Windows projects today and will come to Mac Catalyst in a future release. Thanks to Mike Corsaro ([@Foda](https://github.com/Foda)) for the contribution.
+
+
+
+
+
+The `TitleBar` control can now be set for the `Window.TitleBar` property for any `Window`.
+
+```xml
+
+
+
+
+
+
+
+```
+
+It can also be set in C# code:
+
+```cs
+protected override void OnAppearing()
+{
+ base.OnAppearing();
+
+ Window.TitleBar = new TitleBar
+ {
+ Title = "MAUI App",
+ Icon = "appicon.png",
+ LeadingContent = new AvatarButton()
+ };
+}
+```
+
+The `TitleBar.Content` and `TitleBar.LeadingContent` are extremely customizable as seen in this sample:
+
+
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+Here is an overview of different settings in action:
+
+
+
+## `ActivateWindow` Added to bring a `Window` to foreground
+
+A specific window can be brought to the front on Mac Catalyst and Windows with the `Application.Current.ActivateWindow` method:
+
+```csharp
+Application.Current?.ActivateWindow(secondWindow);
+```
+
+## `BackButtonBehavior` OneWay binding mode
+
+The binding mode for `IsVisible` and `IsEnabled` on the `BackButtonBehavior` is now `BindingMode.OneWay` instead of `BindingMode.OneTime`. This allows you to more easily control the behavior of the back button at runtime using data bindings.
+
+```xml
+
+
+
+
+ ...
+
+```
+
+## `BlazorWebView` backward compatibility host address
+
+.NET 9 Preview 7 changes the default behavior for hosting content to be `localhost` on iOS and Mac Catalyst 18 and newer. Starting with iOS and Mac Catalyst 18 the internal `0.0.0.0` address used to host the `BlazorWebView`'s content no longer works and causes the `BlazorWebView` to not load and render as an empty rectangle.
+
+
+In order to continue using `0.0.0.0`, activate this behavior using a switch in `MauiProgram.cs`:
+
+```c#
+// Set this switch to use the LEGACY behavior of always using 0.0.0.0 to host BlazorWebView
+AppContext.SetSwitch("BlazorWebView.AppHostAddressAlways0000", true);
+```
+
+## `MainPage` is Obsolete
+
+Instead of setting a `MainPage` property on the `Application`, developers should now set the `Page` on the `Window` to which it belongs. This is what actually happens when you set `MainPage` today in a .NET MAUI application, so the behavior is the same and the usage is now more clear. `MainPage` has been retained for .NET 9 in order to facilitate upgrading projects from Xamarin.Forms, but will be completely removed in a future release.
+
+
+New projects now see the recommended pattern in the .NET MAUI template:
+
+```csharp
+public partial class App : Application
+{
+ public App()
+ {
+ InitializeComponent();
+ }
+
+ protected override Window CreateWindow(IActivationState? activationState)
+ {
+ return new Window(new AppShell());
+ }
+}
+```
+
+## CollectionView & CarouselView improvements with a new opt-in handler for iOS and Mac Catalyst
+
+This release introduces two new handlers for developers to try that bring sweeping performance and stability improvements for both `CollectionView` and `CarouselView`. These new implementations are based on newer `UICollectionView` APIs. Opt-in by adding the following into your `Program.cs`:
+
+```csharp
+#if IOS || MACCATALYST
+appBuilder.ConfigureMauiHandlers(handlers =>
+{
+ handlers.AddHandler();
+ handlers.AddHandler();
+});
+#endif
+```
+
+## Native Embedding improvements
+
+[Native Embedding](https://learn.microsoft.com/dotnet/maui/platform-integration/native-embedding) enables you to bring .NET MAUI controls into .NET for Android/iOS/MacCatalyst or WinUI applications, rather than an entire .NET MAUI application. Now in .NET 9 Preview 7 this no longer requires the compatibility package. To start using embedding you only need:
+
+```csharp
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+
+ builder
+ .UseMauiEmbeddedApp();
+
+ return builder.Build();
+ }
+}
+```
+
+### Creating a `MauiContext` and getting a native view
+
+Before instantiating the view, you need a `MauiContext`.
+
+```csharp
+var mauiApp = MauiProgram.CreateMauiApp();
+
+#if ANDROID
+var mauiContext = new MauiContext(mauiApp.Services, window);
+#else
+var mauiContext = new MauiContext(mauiApp.Services);
+#endif
+
+var mauiView = new MyMauiContent();
+var nativeView = mauiView.ToPlatform(mauiContext);
+```
+
+Alternatively, you can use the `ToPlatformEmbedded` method passing in the window for the platform on which the app is running.
+
+```csharp
+var mauiApp = MauiProgram.CreateMauiApp();
+var mauiView = new MyMauiContent();
+var nativeView = mauiView.ToPlatformEmbedded(mauiApp, window);
+```
+
+In both cases, `nativeView` is the platform-specific view described by the `mauiView`.
+
+## New Handler disconnect policy
+
+There have been improvements to how a handler disconnect including new automatic disconnection, which is enabled in this release by default. Take the following user interface:
+
+```xml
+
+
+
+
+
+```
+
+When you navigate away from this page, previously the `ButtonHandler.DisconnectHandler();` was not called. Now with automatic handler disconnect, it will be called automatically as soon as possible.
+
+In rare scenarios you may not want automatic handler disconnection and want the old behavior and need to perform this operation manually. By changing the policy to `Manual` you can keep views around until you are done with them, for example when navigating between many pages in a `FlyoutPage`.
+
+Example with a `VerticalStackLayout`:
+
+```csharp
+var layout2 = new VerticalStackLayout()
+{
+ new Button(),
+ new Button()
+};
+
+HandlerProperties.SetDisconnectPolicy(layout2, HandlerDisconnectPolicy.Manual);
+```
+
+To clean up the native views, call the `DisconnectHandler` method.
+
+```csharp
+layout2.DisconnectHandler();
+```
+
+When disconnecting, the action will continue down the tree until it completes or arrives at a control that has set a manual policy.
+
+## New `ProcessTerminated` event on `WebView` Control
+
+`WebView` adds a `ProcessTerminated` event that's raised when a `WebView` process ends unexpectedly. The `WebViewProcessTerminatedEventArgs` object that accompanies this event defines platform-specific properties that indicate why the process failed.
+
+
+## New lifecycle methods for remote notifications on iOS & Mac Catalyst
+
+
+When working with remote notifications it is now easier to get insight into when a user registers or receives remove notifications.
+
+* `ReceivedRemoteNotifications` - Invoked when a remote notification is received.
+* `RegisteredForRemoteNotifications` - Invoked when the app has successfully registered for remote notifications.
+
+```csharp
+using Microsoft.Maui.LifecycleEvents;
+
+namespace PlatformLifecycleDemo;
+
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+ builder
+ .UseMauiApp()
+ .ConfigureLifecycleEvents(events =>
+ {
+#if IOS || MACCATALYST
+ events.AddiOS(ios => ios
+ .ReceivedRemoteNotifications((app, dictionary) => LogEvent(nameof(iOSLifecycle.OnReceivedRemoteNotifications)))
+ .RegisteredForRemoteNotifications((app, data) => LogEvent(nameof(iOSLifecycle.OnRegisteredForRemoteNotifications)));
+#endif
+ static bool LogEvent(string eventName, string type = null)
+ {
+ System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
+ return true;
+ }
+ });
+
+ return builder.Build();
+ }
+}
+```
+
+For more information see the [App Lifecycle documentation](https://learn.microsoft.com/dotnet/maui/fundamentals/app-lifecycle)
+
+## Xcode Sync for CLI and Visual Studio Code
+
+Xcode sync (xcsync) is a tool that enables developers to leverage Xcode for managing Apple specific files with .NET projects including asset catalogs, plist, storyboard, and xib files. The tool has two main commandes to generates a temporary Xcode project from a .NET project and to synchronize changes to the Xcode files back to the .NET project for iOS, tvOS, macOS, or Mac Catalyst.
+
+To generate or sync these files you can use the `dotnet build` command with `xcsync-generate` or `xcsync-sync` and passing in a project file and additional parameters for the project TFM in a multi-targeted project, Xcode location, and verbosity.
+
+```bash
+dotnet build /t:xcsync-generate
+ /p:xcSyncProjectFile=
+ /p:xcSyncXcodeFolder=
+ /p:xcSyncTargetFrameworkMoniker=
+ /p:xcSyncVerbosity=
+```
+
+For more information browse the [Xcode sync documentation](https://learn.microsoft.com/dotnet/maui/macios/xcsync).
+
+
+## .NET for Android
+
+This release was focused on quality improvements.
+
+- [GitHub Release](https://github.com/xamarin/xamarin-android/releases/)
+
+## .NET for iOS
+
+This release was focused on quality improvements. Using this release requires the use of Xcode 15.4 for building apps.
+
+- [GitHub Release](https://github.com/xamarin/xamarin-macios/releases/)
+- [Known issues](https://github.com/xamarin/xamarin-macios/wiki/Known-issues-in-.NET9)
+
+## Community Contributions
+
+Thank you to community contributors [@albyrock87](https://github.com/albyrock87), [@symbiogenesis](https://github.com/symbiogenesis), [@BurningLights](https://github.com/BurningLights), [@Takym](https://github.com/Takym), [@pictos](https://github.com/pictos), [@kubaflo](https://github.com/kubaflo), and [@rs-lkroneman](https://github.com/rs-lkroneman).
diff --git a/release-notes/9.0/preview/preview7/libraries.md b/release-notes/9.0/preview/preview7/libraries.md
new file mode 100644
index 0000000000..8df496a07d
--- /dev/null
+++ b/release-notes/9.0/preview/preview7/libraries.md
@@ -0,0 +1,285 @@
+# Libraries updates in .NET 9 Preview 7
+
+New in .NET Libraries with this release:
+
+- [Removal of `BinaryFormatter` is complete](#removal-of-binaryformatter-is-complete)
+- [Enumerate over `ReadOnlySpan.Split()` segments](#enumerate-over-readonlyspancharsplit-segments)
+- [`Debug.Assert` now reports assert condition, by default.](#debugassert-now-reports-assert-condition-by-default)
+- [Compression APIs now use `zlib-ng`](#compression-apis-now-use-zlib-ng)
+- [`Guid.CreateVersion7` enables creating GUIDs with a natural sort order](#guidcreateversion7-enables-creating-guids-with-a-natural-sort-order)
+- [`Interlocked.CompareExchange` for more types](#interlockedcompareexchange-for-more-types)
+- [AES-GCM and ChaChaPoly1305 algorithms enabled for iOS/tvOS/MacCatalyst](#aes-gcm-and-chachapoly1305-algorithms-enabled-for-iostvosmaccatalyst)
+- [Changes to X.509 Certificate Loading](#changes-to-x509-certificate-loading)
+- [Support for XPS documents from XPS virtual printer](#support-for-xps-documents-from-xps-virtual-printer)
+- [Marking `Tensor` as `Experimental`](#marking-tensort-as-experimental)
+
+Libraries updates in .NET 9 Preview 7:
+
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/libraries.md)
+- [What's new in .NET 9](https://learn.microsoft.com/dotnet/core/whats-new/dotnet-9/overview) documentation
+
+.NET 9 Preview 7:
+
+- [Discussion](https://aka.ms/dotnet/9/preview7)
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/README.md)
+- [Runtime release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/runtime.md)
+- [SDK release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/sdk.md)
+
+## Removal of `BinaryFormatter` is complete
+
+As [announced earlier](https://github.com/dotnet/announcements/issues/293), starting with .NET 9, we no longer include an implementation of `BinaryFormatter` in the runtime (.NET Framework remains unchanged). The APIs are still present, but their implementation always throws an exception, regardless of project type. Hence, setting the existing backwards compatibility flag is no longer sufficient to use `BinaryFormatter`.
+
+* We published the [BinaryFormatter migration guide][migration-guide]. We'd appreciate if could give it a read and give us feedback by filling issues in the [dotnet/docs][dotnet/docs] repo.
+* If you experience issues related to BinaryFormatter's removal not addressed in this migration guide, please file an issue in the [dotnet/runtime][dotnet/runtime] repo and indicate that the issue is related to the removal of `BinaryFormatter`.
+
+### Why was `BinaryFormatter` removed?
+
+The primary reason is that `BinaryFormatter` is unsafe. Any deserializer, binary or text, that allows its input to carry information about the objects to be created is a security problem waiting to happen. There is a common weakness enumeration (CWE) that describes the issue: [CWE-502 "Deserialization of Untrusted Data"][CWE502]. `BinaryFormatter` is such a deserializer but this isn't specific to .NET; this applies to any deserializer. Another example is using `eval` in JavaScript to load JSON.
+
+We also cover this in the [BinaryFormatter security guide][security-guide].
+
+### What are my options to move forward?
+
+You have two options to address the removal of `BinaryFormatter`'s implementation:
+
+1. **Migrate away from BinaryFormatter**. We strongly recommend you to investigate options to stop using `BinaryFormatter` due to the associated security risks. The [BinaryFormatter migration guide][migration-guide] lists several options.
+
+2. **Keep using BinaryFormatter**. If you need to continue using `BinaryFormatter` in .NET 9, you need to depend on the unsupported [System.Runtime.Serialization.Formatters][compat-pack] NuGet package, which restores the unsafe legacy functionality and replaces the throwing implementation.
+
+[compat-pack]: https://learn.microsoft.com/dotnet/standard/serialization/binaryformatter-migration-guide/compatibility-package
+[migration-guide]: https://learn.microsoft.com/dotnet/standard/serialization/binaryformatter-migration-guide/
+[security-guide]: https://learn.microsoft.com/dotnet/standard/serialization/binaryformatter-security-guide
+[CWE502]: https://cwe.mitre.org/data/definitions/502.html
+[dotnet/docs]: https://github.com/dotnet/docs/issues/new?assignees=&labels=&projects=&template=01-general-issue.yml
+[dotnet/runtime]: https://github.com/dotnet/runtime/issues/new
+
+## Enumerate over `ReadOnlySpan.Split()` segments
+
+`string.Split` is a very popular and convenient method for quickly partitioning a string with one or more supplied separators. For code focused on performance, however, the allocation profile of `string.Split` can be prohibitive, allocating a `string` for each parsed component and a `string[]` to store them all. It also doesn't work with spans, so if you have a `ReadOnlySpan` and want to use `string.Split` with it, you're forced to allocate yet another string, converting the `ReadOnlySpan` to a `string` to be able to call the method on it.
+
+In .NET 8, a set of `Split` and `SplitAny` methods were introduced for `ReadOnlySpan`. Rather than returning a new `string[]`, these methods instead accept a destination `Span` into which to write the bounding indices for each component. This makes the operation fully allocation-free, as no new `string` object is required (each result is represented just as a `Range` within the original span) and no `string[]` needs to be allocated (the results can be written into the supplied destination buffer). This is great when the number of ranges is both known and small, yielding an API that's both efficient and almost as convenient as `string.Split`.
+
+New overloads of `Split` and `SplitAny` have been added to allow incrementally parsing a `ReadOnlySpan` with an a priori unknown number of segments. The new methods enable enumerating through each segment, which is similarly represented as a `Range` that can be used to slice into the original span.
+
+```C#
+public static bool ListContainsItem(ReadOnlySpan span, string item)
+{
+ foreach (Range segment in span.Split(','))
+ {
+ if (span[segment].SequenceEquals(item))
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+```
+
+## `Debug.Assert` now reports assert condition, by default.
+
+`Debug.Assert` is commonly-used to help validate conditions that are expected to always be true, where failure typically indicates a bug in the code.
+
+There are many overloads of `Debug.Assert`, the simplest of which just accepts a condition:
+
+```C#
+Debug.Assert(a > 0 && b > 0);
+```
+
+The assert fails if the condition is false. Historically, however, such asserts were void of any information about what condition failed. Now in .NET 9, if no message is explicitly provided by the user, the assert will contain the textual representation of the condition.
+
+For example, for the above assert, rather than getting a message like:
+
+```bash
+Process terminated. Assertion failed.
+ at Program.SomeMethod(Int32 a, Int32 b)
+```
+
+The message will now be like:
+
+```bash
+Process terminated. Assertion failed.
+a > 0 && b > 0
+ at Program.SomeMethod(Int32 a, Int32 b)
+```
+
+## Compression APIs now use `zlib-ng`
+
+`System.IO.Compression` features like `ZipArchive`, `DeflateStream`, `GZipStream`, and `ZLibStream` are all based primarily on the zlib library. Now in .NET 9, these features instead all use [zlib-ng](https://github.com/zlib-ng/zlib-ng), yielding more consistent and efficient processing across a wider array of operating systems and hardware.
+
+## `Guid.CreateVersion7` enables creating GUIDs with a natural sort order
+
+`Guid.NewGuid()` creates a `Guid` filled mostly with cryptographically-secure random data, following the [UUID Version 4 specification](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)) in RFC 9562. That same RFC also defines other versions, including [Version 7](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_7_(timestamp_and_random)), which "features a time-ordered value field derived from the widely implemented and well-known Unix Epoch timestamp source". In other words, much of the data is still random, but some of it is reserved for data based on a timestamp, enabling these values to have a natural sort order. In .NET 9, a `Guid` can be created according to Version 7 via the new `Guid.CreateVersion7()` and `Guid.CreateVersion7(DateTimeOffset timestamp)` methods. A `Guid`'s version field can also be retrieved with the new `Version` property.
+
+## `Interlocked.CompareExchange` for more types
+
+In previous versions of .NET, `Interlocked.Exchange` and [`Interlocked.CompareExchange`](https://learn.microsoft.com/dotnet/api/system.threading.interlocked.compareexchange) had overloads for working with `int`, `uint`, `long`, `ulong`, `nint`, `nuint`, `float`, `double`, and `object`, as well as a generic overload for working with any reference type `T`. Now in .NET 9, thanks to several contributions from [@MichalPetryka](https://github.com/MichalPetryka), there are now also overloads for atomically working with `byte`, `sbyte`, `short`, and `ushort`. Moreover, the generic constraint on the generic `Interlocked.Exchange` and `Interlocked.CompareExchange` overloads has been removed, so those methods are no longer constrained to only work with reference types. In addition, they can now work with any primitive type, which includes all of the aforementioned types as well as `bool` and `char`, as well as any enum type.
+
+## AES-GCM and ChaChaPoly1305 algorithms enabled for iOS/tvOS/MacCatalyst
+
+`AesGcm.IsSupported` and `ChaChaPoly1305.IsSupported` now return `true` when running on iOS 13+, tvOS 13+ or Mac Catalyst.
+
+As with macOS, AesGcm on these environments only supports 16-byte (128-bit) tag values.
+
+## Changes to X.509 Certificate Loading
+
+Since .NET Framework 2.0 (way back in 2005) the way to load a certificate has been `new X509Certificate2(bytes)`. There have also been other patterns, such as: `new X509Certificate2(bytes, password, flags)`, `new X509Certificate2(path)`, `new X509Certificate2(path, password, flags)`, and `X509Certificate2Collection.Import(bytes, password, flags)` (and its overloads).
+
+Those methods all used content-sniffing to figure out if the input was something it could handle, and then loaded it if it could. For some callers this was the epitome of convenience, for others it was frustration that not every file format worked on every OS. For some it was a protocol deviation, and for a few it was a source of security issues.
+
+.NET 9 introduces a new `X509CertificateLoader` class, which has a "one method, one purpose" design. In its initial version, it only supports two of the five formats that the X509Certificate2 constructor supported, but they are the only two formats that worked on all OSes.
+
+The following snippets highlight the new API as a sort of exhaustive textbook example:
+
+```csharp
+private static X509Certificate2 LoadSingleCertificate(
+ byte[] data,
+ X509ContentType format,
+ string pfxPassword,
+ X509KeyStorageFlags pfxFlags)
+{
+ switch (format)
+ {
+ case X509ContentType.Cert:
+ return X509CertificateLoader.LoadCertificate(data);
+ case X509ContentType.Pkcs12:
+ //case X509ContentType.Pfx: //(same thing)
+ return X509CertificateLoader.LoadPkcs12(data, pfxPassword, pfxFlags);
+ case X509ContentType.Pkcs7:
+ SignedCms cms = new SignedCms();
+ cms.Decode(data);
+ return cms.SignerInfos[0].Certificate ?? throw new CryptographicException();
+ case X509ContentType.SerializedCert:
+ case X509ContentType.Authenticode:
+ // These two formats are only supported on Windows,
+ // and only from the obsolete constructors.
+ X509ContentType actualType = X509Certificate2.GetCertContentType(data);
+
+ if (actualType != format)
+ {
+ throw new CryptographicException();
+ }
+
+#pragma warning disable SYSLIB0057
+ return new X509Certificate2(data);
+#pragma warning restore SYSLIB0057
+ default:
+ throw new CryptographicException();
+ }
+}
+
+private static X509Certificate2Collection LoadCertificateCollection(
+ byte[] data,
+ X509ContentType format,
+ string pfxPassword,
+ X509KeyStorageFlags pfxFlags)
+{
+ switch (format)
+ {
+ case X509ContentType.Pkcs12:
+ return X509CertificateLoader.LoadPkcs12Collection(data, pfxPassword, pfxFlags);
+ case X509ContentType.Pkcs7:
+ SignedCms cms = new SignedCms();
+ cms.Decode(data);
+ return cms.Certificates;
+ case X509ContentType.SerializedStore:
+ // Only supported on Windows, and only via the obsolete Import method
+ X509ContentType actualType = X509Certificate2.GetCertContentType(data);
+
+ if (actualType != format)
+ {
+ throw new CryptographicException();
+ }
+
+ X509Certificate2Collection coll = new X509Certificate2Collection();
+#pragma warning disable SYSLIB0057
+ coll.Import(data);
+#pragma warning restore SYSLIB0057
+
+ return coll;
+ default:
+ throw new CryptographicException();
+ }
+}
+```
+
+The X509CertificateLoader class is available for callers on older versions of .NET, and for callers on .NET Framework,
+via the Microsoft.Bcl.Cryptography compatibility package.
+
+## OpenSSL providers support
+
+In .NET 8, we introduced OpenSSL specific APIs: [SafeEvpPKeyHandle.OpenPrivateKeyFromEngine](https://learn.microsoft.com/dotnet/api/system.security.cryptography.safeevppkeyhandle.openprivatekeyfromengine) and [SafeEvpPKeyHandle.OpenPublicKeyFromEngine](https://learn.microsoft.com/dotnet/api/system.security.cryptography.safeevppkeyhandle.openpublickeyfromengine). They enable interacting with OpenSSL [`ENGINE` components](https://github.com/openssl/openssl/blob/master/README-ENGINES.md) and utilize hardware security modules (HSM), for example.
+.NET 9 introduces `SafeEvpPKeyHandle.OpenKeyFromProvider` which enables using [OpenSSL `providers`](https://docs.openssl.org/master/man7/provider/) and interacting with providers such as `tpm2` or `pkcs11`.
+
+Some distros have [removed `ENGINE` support](https://github.com/dotnet/runtime/issues/104775) since it is now deprecated.
+
+The following snippet shows basic usage:
+
+```csharp
+byte[] data = ...;
+
+// Refer to provider documentation you're using, i.e. https://github.com/tpm2-software/tpm2-openssl/tree/master
+// specific values are just an illustrative example
+using (SafeEvpPKeyHandle priKeyHandle = SafeEvpPKeyHandle.OpenKeyFromProvider("tpm2", "handle:0x81000007"))
+using (ECDsa ecdsaPri = new ECDsaOpenSsl(priKeyHandle))
+{
+ byte[] signature = ecdsaPri.SignData(data, HashAlgorithmName.SHA256);
+ // do stuff with signature created by TPM
+ // note that some providers i.e. tpm2 do not allow direct operations on public key (verify/encrypt), public key should be exported and re-imported into new ECDsa instance
+}
+```
+
+Performance improvements may be observed during the TLS handshake as well as improvements to interactions with RSA private keys using `ENGINE` components.
+
+## Windows CNG virtualization-based security
+
+Windows 11 has added new APIs to help secure Windows keys with [virtualization-based security (VBS)](https://techcommunity.microsoft.com/t5/windows-it-pro-blog/advancing-key-protection-in-windows-using-vbs/ba-p/4050988). With this new capability, keys can be protected from admin-level key theft attacks with negligible effect on performance, reliability, or scale.
+
+.NET 9 has added matching `CngKeyCreationOptions` flags.
+
+The following snippet demonstrates how to use one of those flags:
+
+```csharp
+using System.Security.Cryptography;
+
+CngKeyCreationParameters cngCreationParams = new()
+{
+ Provider = CngProvider.MicrosoftSoftwareKeyStorageProvider,
+ KeyCreationOptions = CngKeyCreationOptions.RequireVbs | CngKeyCreationOptions.OverwriteExistingKey,
+};
+
+using (CngKey key = CngKey.Create(CngAlgorithm.ECDsaP256, "myKey", cngCreationParams))
+using (ECDsaCng ecdsa = new ECDsaCng(key))
+{
+ // do stuff with the key
+}
+```
+
+In total 3 flags were added:
+- `CngKeyCreationOptions.PreferVbs` matching `NCRYPT_PREFER_VBS_FLAG`
+- `CngKeyCreationOptions.RequireVbs` matching `NCRYPT_REQUIRE_VBS_FLAG`
+- `CngKeyCreationOptions.UsePerBootKey` matching `NCRYPT_USE_PER_BOOT_KEY_FLAG`
+
+## Support for XPS documents from XPS virtual printer
+
+XPS documents coming from a V4 XPS virtual printer could not be opened using the `System.IO.Packaging` library, due to lack of support for handling `.piece` files. Addressing this has been a long-standing request, but now in .NET 9 the gap has been addressed. Thanks to [@edwardneal](https://github.com/edwardneal) for the improvement!
+
+## Marking `Tensor` as `[Experimental]`
+
+We announced the [addition of `Tensor`](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview4/libraries.md#new-tensort-type) earlier in .NET 9. Adding new built-in types for exchanging tensor data across libraries and allowing accelerated handling for core operations is an important but large undertaking. The work done in .NET 9 currently encompasses 8 types and nearly 600 new public APIs, many of which are generic and can support a `T` that is arbitrary or constrained to one of the [generic math interfaces](https://learn.microsoft.com/en-us/dotnet/standard/generics/math).
+
+Due to the size of this work and the recognized importance of it to the long term capability of the .NET ecosystem, it has been decided to mark these new APIs as `[Experimental]` (see https://learn.microsoft.com/dotnet/api/system.diagnostics.codeanalysis.experimentalattribute) for .NET 9 and to plan on supporting them officially in .NET 10 instead. This is being done to allow time for additional feedback from the community and important libraries in the .NET ecosystem that plan on taking advantage of the provided functionality. It also gives us additional time to coordinate with improvements in the C# language to ensure a great end-to-end experience.
+
+### Call to Action
+
+Please try out the new APIs and provide feedback on the overall experience. This includes (but is not limited to) the naming or shape of APIs, any core functionality that appears to be missing or that behaves unexpectedly, and how the general user experience was.
+
+Some additional callouts include:
+* Despite being marked `[Experimental]` much of the surface is relatively stable and isn't _expected_ to change. There isn't much you can get wrong for an API like `Add(x, y)` after all. This isn't a guarantee that we won't change such APIs, but the expected churn for these ones is minimal.
+* There's known missing functionality such as no operator support given that we want `Tensor` to work over all `T` but `operator +` can only be defined for types that implement the generic math `IAdditionOperators` interface. This requires language support for `extension operators`.
+* The `TensorSpan` types can wrap native allocations, but we don't have a non-ref struct type equivalent. Such a type would need to be disposable and needs additional design consideration around how ownership/lifetime tracking works. If this is an important scenario to you, we'd like to hear about it.
+* The names/concepts used for some APIs can be very inconsistent across the entire machine learning ecosystem (both inside and outside .NET) and in many cases we opted choose the name that was most consistent with existing .NET concepts or behavior. This decision is typically matching the same semantics given to other major tensor libraries (both in .NET and in other language ecosystems), but if there are any quirks or unexpected behaviors found then we'd like to hear about it.
+
+### `TensorPrimitives` is stable and improved
+
+As a final note, the `TensorPrimitives` class which we shipped in .NET 8 is stable and has been expanded in .NET 9 with additional API surface that is also considered stable. It is not marked as `[Experimental]`. It is the class that contains most of the accelerated algorithms that underpin the `Tensor` type and so they can still be used to accelerate your code where applicable. There are many potential applications for these algorithms including in machine learning/AI, image processing, games, and beyond.
\ No newline at end of file
diff --git a/release-notes/9.0/preview/preview7/media/Gen0_GC.png b/release-notes/9.0/preview/preview7/media/Gen0_GC.png
new file mode 100644
index 0000000000..cd636c6f4f
Binary files /dev/null and b/release-notes/9.0/preview/preview7/media/Gen0_GC.png differ
diff --git a/release-notes/9.0/preview/preview7/media/titlebar-full.png b/release-notes/9.0/preview/preview7/media/titlebar-full.png
new file mode 100644
index 0000000000..506db14145
Binary files /dev/null and b/release-notes/9.0/preview/preview7/media/titlebar-full.png differ
diff --git a/release-notes/9.0/preview/preview7/media/titlebar-overview.png b/release-notes/9.0/preview/preview7/media/titlebar-overview.png
new file mode 100644
index 0000000000..57d4a0be1e
Binary files /dev/null and b/release-notes/9.0/preview/preview7/media/titlebar-overview.png differ
diff --git a/release-notes/9.0/preview/preview7/media/titlebar.mp4 b/release-notes/9.0/preview/preview7/media/titlebar.mp4
new file mode 100644
index 0000000000..d9c7ede9f4
Binary files /dev/null and b/release-notes/9.0/preview/preview7/media/titlebar.mp4 differ
diff --git a/release-notes/9.0/preview/preview7/media/workingset.png b/release-notes/9.0/preview/preview7/media/workingset.png
new file mode 100644
index 0000000000..38f826ab60
Binary files /dev/null and b/release-notes/9.0/preview/preview7/media/workingset.png differ
diff --git a/release-notes/9.0/preview/preview7/runtime.md b/release-notes/9.0/preview/preview7/runtime.md
new file mode 100644
index 0000000000..2772cd8206
--- /dev/null
+++ b/release-notes/9.0/preview/preview7/runtime.md
@@ -0,0 +1,226 @@
+# Runtime updates in .NET 9 Preview 7
+
+.NET 9 Preview 7 includes several new runtime features. We focused on the following areas:
+
+- [ARM64 SVE Support](#arm64-sve-support)
+- [Post-Indexed Addressing on ARM64](#post-indexed-addressing-on-arm64)
+- [Strength Reduction in Loops](#strength-reduction-in-loops)
+- [Object Stack Allocation for Boxes](#object-stack-allocation-for-boxes)
+- [GC Dynamic Adaptation To Application Sizes](#gc-dynamic-adaptation-to-application-sizes)
+
+Runtime updates in .NET 9 Preview 7:
+
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/runtime.md)
+- [What's new in the .NET Runtime in .NET 9](https://learn.microsoft.com/dotnet/core/whats-new/dotnet-9/overview) documentation
+
+.NET 9 Preview 7:
+
+- [Discussion](https://aka.ms/dotnet/9/preview7)
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/README.md)
+- [Libraries release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/libraries.md)
+- [SDK release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/sdk.md)
+
+
+## ARM64 SVE Support
+.NET 9 introduces experimental support for the [Scalable Vector Extension (SVE)](https://en.wikipedia.org/wiki/AArch64#Scalable_Vector_Extension_(SVE)), a SIMD instruction set for ARM64 CPUs. .NET already supports the [NEON instruction set](https://en.wikipedia.org/wiki/AArch64#AArch64_features), so on NEON-capable hardware, your applications can leverage 128-bit vector registers. SVE supports flexible vector lengths all the way up to 2048 bits, unlocking more data processing per instruction; in .NET 9, `System.Numerics.Vector` is 128 bits wide when targeting SVE, and future work will enable scaling of its width to match the target machine's vector register size. You can accelerate your .NET applications on SVE-capable hardware using the new `System.Runtime.Intrinsics.Arm.Sve` APIs. To learn more about SVE in .NET, check out [dotnet/runtime #93095](https://github.com/dotnet/runtime/issues/93095), and to track which APIs are completed, check out [dotnet/runtime #99957](https://github.com/dotnet/runtime/issues/99957).
+
+Note that SVE support in .NET 9 is experimental. The APIs under `System.Runtime.Intrinsics.Arm.Sve` are marked with [`ExperimentalAttribute`](https://learn.microsoft.com/en-us/dotnet/fundamentals/apicompat/preview-apis#experimentalattribute), which means they are subject to change in future releases. Additionally, debugger stepping and breakpoints through SVE-generated code may not function properly, resulting in application crashes or corruption of data.
+
+## Post-Indexed Addressing on ARM64
+In .NET code, we frequently use index variables to read sequential regions of memory.
+
+Consider the idiomatic `for` loop:
+```csharp
+static int Sum(int[] nums)
+{
+ int sum = 0;
+
+ for (int i = 0; i < nums.Length; i++)
+ {
+ sum += nums[i];
+ }
+
+ return sum;
+}
+```
+
+For each iteration of the loop, we use `i` to read an integer in `nums`, and then increment `i`. In ARM64 assembly, these two operations look like this:
+```asm
+ldr w0, [x1]
+add x1, x1, #4
+```
+
+`ldr w0, [x1]` loads the integer at the memory address in `x1` into `w0`; this corresponds to the access of `nums[i]` in the above example. Then, `add x1, x1, #4` increases the address in `x1` by four bytes, moving to the next integer in `nums`. This corresponds to the `i++` operation executed at the end of each iteration.
+
+ARM64 supports post-indexed addressing, where the "index" register is automatically incremented after its address is used. This means we can combine the above instructions into one, making the loop more efficient: The CPU only needs to decode one instruction instead of two, and the loop's code is now more cache-friendly.
+
+Here's what the updated assembly looks like:
+```asm
+ldr w0, [x1], #0x04
+```
+
+The `#0x04` at the end means the address in `x1` will be incremented by four bytes after it is used to load an integer into `w0`. In Preview 7, RyuJIT now uses post-indexed addressing when generating ARM64 code. While x64 does not support post-indexed addressing, Preview 2 introduced [induction variable widening](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview2/runtime.md#loop-optimizations-iv-widening), which is similarly useful for optimizing memory accesses with loop index variables.
+
+To learn more about post-indexed addressing support in RyuJIT, check out [dotnet/runtime #105181](https://github.com/dotnet/runtime/pull/105181).
+
+## Strength Reduction in Loops
+Strength reduction is a compiler optimization where an operation is replaced with a faster, logically-equivalent operation. This technique is especially useful for optimizing loops.
+
+Let's revisit the example from above:
+```csharp
+static int Sum(int[] nums)
+{
+ int sum = 0;
+
+ for (int i = 0; i < nums.Length; i++)
+ {
+ sum += nums[i];
+ }
+
+ return sum;
+}
+```
+
+Here is a snippet of the code generated for the loop's body, in x64 assembly:
+```asm
+add ecx, dword ptr [rax+4*rdx+0x10]
+inc edx
+```
+
+These instructions correspond to the expressions `sum += nums[i]` and `i++`, respectively. `rcx` contains the value of `sum`, `rax` contains the base address of `nums`, and `rdx` contains the value of `i`. To compute the address of `nums[i]`, we multiply the index in `rdx` by four (the size of an integer), and then add this offset to the base address in `rax`, plus some padding. After we've read the integer at `nums[i]` and added it to `rcx`, we increment the index in `rdx`.
+
+In other words, imagine an array with a dozen integers. Given an index in the range `[0, 11]`, the above algorithm multiplies it by four to determine the integer's offset from the beginning of the array. So to get the first integer, we compute its address with `base_address + (4 * 0)`, and to get the last integer, we compute `base_address + (4 * 11)`. With this approach, each array access requires a multiplication and an addition operation.
+
+Multiplication is more expensive than addition, and replacing the former with the latter is a classic motivation for strength reduction. Imagine if we rewrote our example to access the integers in `nums` using a pointer, rather than an index variable. With this approach, each memory access wouldn't require us to compute the element's address.
+
+Here's the updated example:
+```csharp
+static int Sum(Span nums)
+{
+ int sum = 0;
+ ref int p = ref MemoryMarshal.GetReference(nums);
+ ref int end = ref Unsafe.Add(ref p, nums.Length);
+ while (Unsafe.IsAddressLessThan(ref p, ref end))
+ {
+ sum += p;
+ p = ref Unsafe.Add(ref p, 1);
+ }
+
+ return sum;
+}
+```
+
+The source code is quite a bit more complicated, but it is logically equivalent to our initial implementation, and the assembly looks better:
+```asm
+add ecx, dword ptr [rdx]
+add rdx, 4
+```
+
+`rcx` still holds the value of `sum`, but `rdx` now holds the address pointed to by `p`, so accessing elements in `nums` just requires us to dereference `rdx` -- all the multiplication and addition from the first example has been replaced by a single `add` instruction to move the pointer forward.
+
+In Preview 7, RyuJIT now transforms the first indexing pattern into the second, without requiring you to rewrite any code. To learn more about strength reduction in RyuJIT, check out [dotnet/runtime #100913](https://github.com/dotnet/runtime/issues/100913).
+
+## Object Stack Allocation for Boxes
+Value types, such as `int` and `struct`, are typically allocated on the stack instead of the heap. However, we frequently need to "box" these value types by wrapping them in objects to enable various code patterns.
+
+Consider the following snippet:
+```csharp
+static bool Compare(object? x, object? y)
+{
+ if ((x == null) || (y == null))
+ {
+ return x == y;
+ }
+
+ return x.Equals(y);
+}
+
+public static int Main()
+{
+ bool result = Compare(3, 4);
+ return result ? 0 : 100;
+}
+```
+
+`Compare` is conveniently written such that if we wanted to compare other types, like `strings` or `doubles`, we could reuse the same implementation. But in this example, it has the performance drawback of requiring us to box any value types we pass to it.
+
+Let's look at the code generated for `Main`, in x64 assembly:
+```asm
+push rbx
+sub rsp, 32
+mov rcx, 0x7FFB9F8074D0 ; System.Int32
+call CORINFO_HELP_NEWSFAST
+mov rbx, rax
+mov dword ptr [rbx+0x08], 3
+mov rcx, 0x7FFB9F8074D0 ; System.Int32
+call CORINFO_HELP_NEWSFAST
+mov dword ptr [rax+0x08], 4
+add rbx, 8
+mov ecx, dword ptr [rbx]
+cmp ecx, dword ptr [rax+0x08]
+sete al
+movzx rax, al
+xor ecx, ecx
+mov edx, 100
+test eax, eax
+mov eax, edx
+cmovne eax, ecx
+add rsp, 32
+pop rbx
+ret
+```
+
+Notice the calls to `CORINFO_HELP_NEWSFAST` -- those are the heap allocations for the boxed integer arguments. Also notice that there isn't any call to `Compare`; RyuJIT decided to inline it into `Main`. This means the boxes never "escape." In other words, throughout the execution of `Compare`, we know `x` and `y` are actually integers, and we can safely unbox them without affecting the comparison logic (`System.Int32:Equals` just compares the raw integers under-the-hood, anyway). In Preview 7, RyuJIT now allocates unescaped boxes on the stack, unlocking several other optimizations. In our example, not only does RyuJIT avoid the heap allocations, but it also evaluates the expressions `x.Equals(y)` and `result ? 0 : 100` at compile-time.
+
+Here's the updated assembly:
+```asm
+mov eax, 100
+ret
+```
+
+To learn more about object stack allocation in RyuJIT, check out [dotnet/runtime #104936](https://github.com/dotnet/runtime/issues/104936).
+
+
+## GC Dynamic Adaptation To Application Sizes
+
+Dynamic Adaptation To Application Sizes ([DATAS](https://github.com/dotnet/runtime/issues/79658)) is now [enabled by default](https://github.com/dotnet/runtime/issues/103110). It aims to adapt to application memory requirements, meaning the application heap size should be roughly proportional to the long lived data size. DATAS was introduced as an opt-in feature in .NET 8 and has been significantly updated and improved in .NET 9. Any .NET 8 DATAS users should move to .NET 9.
+
+The existing Server GC mode takes a different approach than DATAS. It aims to improve throughput and treats the process as the dominant one on the machine. The amount of allocations it allows before triggering the next GC is based on throughput, not application size. So it can grow the heap very aggressively if it needs to and there’s memory available. This can result in very different heap sizes when you run the process on machines with different hardware specs. What some folks have observed is the heap can grow much bigger when they move their process to a machine with many more cores and more memory. Server GC also doesn’t necessarily adjust the heap down aggressively if the workload becomes much lighter.
+
+Because DATAS aims to adapt to the application memory requirement, it means if your application is doing the same work, the heap size should be the same or similar when you run your app on machines with different specs. And if your workload becomes lighter or heavier the heap size is adjusted accordingly.
+
+DATAS helps most with bursty workloads where the heap size should be adjusted according to how demanding the workload is, particularly as demand decreases. This is especially important in memory-constrained environments where it’s important to fit more processes when some processes’ workloads lighten. It also helps with capacity planning.
+
+
+
+### DATAS Feature Description
+
+To achieve this adaptation and still maintain reasonable performance, DATAS does the following:
+
+- It sets the maximum amount of allocations allowed before the next GC is triggered based on the long lived data size. This helps with constraining the heap size.
+- It sets the actual amount of allocations allowed based on throughput.
+- It adjusts the number of heaps when needed. It starts with one heap which means if there are many threads allocating, some will need to wait and that negatively affects throughput. DATAS will grow and reduce the number of heaps as needed. In this way, it is a hybrid between the existing GC modes, capable of using as few as one heap (like workstation GC) and as many as matches the machine core count (like server GC).
+
+- When needed it does full compacting GCs to prevent fragmentation from getting too high which also helps with constraining the heap size.
+
+### Benchmark Results
+
+Here are some benchmarks results for TechEmpower JSON and Fortunes Benchmarks. Notice the significant reduction in working set when running the benchmarks on a 48 core machine with Linux. Max throughput (measured in rps) shows about a 2-3% reduction, but with an working set improvement of 80%+.
+
+
+
+
+With DATAS enabled # of Gen0 and Gen1 GCs are significantly higher
+
+
+
+Full .NET TechEmpower benchmark results are published [here](https://aka.ms/aspnet/benchmarks)
+
+### How to Disable DATAS
+
+If you notice a reduction in throughput, DATAS can be disabled using the following:
+
+- `DOTNET_GCDynamicAdaptationMode=0` environment veriable
+- setting `System.GC.DynamicAdaptationMode` to `0` in `runtimeconfig.json`
+- `GarbageCollectionAdaptationMode` msbuild property set to `0`
+
diff --git a/release-notes/9.0/preview/preview7/sdk.md b/release-notes/9.0/preview/preview7/sdk.md
new file mode 100644
index 0000000000..9c24b939d1
--- /dev/null
+++ b/release-notes/9.0/preview/preview7/sdk.md
@@ -0,0 +1,88 @@
+# SDK updates in .NET 9 Preview 7
+
+.NET 9 Preview 7 includes several new SDK features. We focused on the following areas:
+
+* [Container publishing support for insecure registries](#container-publishing-support-for-insecure-registries)
+* [More consistent environment variables for container publishing](#more-consistent-environment-variables-for-container-publishing)
+* [Introduction of Workload Sets for more control over workloads](#introduction-of-workload-sets-for-more-control-over-workloads)
+* [Mitigating analyzer mismatch issues aka 'torn SDK'](#mitigating-analyzer-mismatch-issues-aka-torn-sdk)
+
+SDK updates in .NET 7 Preview 7:
+
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/sdk.md)
+- [What's new in the .NET Runtime in .NET 9](https://learn.microsoft.com/dotnet/core/whats-new/dotnet-9/overview) documentation
+
+.NET 9 Preview 7:
+
+- [Discussion](https://aka.ms/dotnet/9/preview7)
+- [Release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/README.md)
+- [Runtime release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/runtime.md)
+- [Libraries release notes](https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/libraries.md)
+
+
+## Container publishing support for insecure registries
+
+The SDK's built-in container publishing support can publish images to container registries, but until this release those registries were required to be secured - they needed HTTPS support and valid certificates for the .NET SDK to work.
+Container engines can usually be configured to work with insecure registries as well - meaning registries that do not have TLS configured, or have TLS configured with a certificate that is invalid from the perspective of the container engine. This is a valid use case, but our tooling didn't support this mode of communication.
+
+In this release, [@tmds](https://github.com/tmds) enabled the SDK [to communicate with insecure registries](https://github.com/dotnet/sdk/pull/41506).
+
+Requirements (depending on your environment):
+
+* [Configure the Docker CLI to mark a registry as insecure](https://docs.docker.com/reference/cli/dockerd/#insecure-registries)
+* [Configure Podman to mark a registry as insecure](https://podman-desktop.io/docs/containers/registries)
+* Use the `DOTNET_CONTAINER_INSECURE_REGISTRIES` environment variable to pass a semicolon-delimited list of registry domains to treat as insecure
+
+
+## More consistent environment variables for container publishing
+
+[@kasperk81](https://github.com/kasperk81] noticed that the environment variables that the container publish tooling use to control some of the finer aspects of registry communication and security were not aligned with the existing conventions.
+Most of the rest of the CLI uses the `DOTNET` 'namespace' for environment variables, but the container tooling used `SDK` instead. They helpfully [unified our environment variables to the `DOTNET` version](https://github.com/dotnet/sdk/pull/41769), while keeping support for the older `SDK` prefix. Going forward, please use the `DOTNET` prefix for environment variables, as we will eventually deprecate the older form.
+
+## Introduction of Workload Sets for more control over workloads
+
+This preview is the first release of Workload Sets - an SDK feature intended to give users more control over the workloads they install and the cadence of change of those installed workloads. Prior to this release, workloads would periodically be updated as new versions of individual workloads were released onto any configured NuGet feeds. Now, after switching to this new opt-in mode of operation, users will stay at a specific single version of all of their workloads until they make an explicit update gesture.
+
+You can see what mode your SDK installation is in by running `dotnet workload --info`:
+
+```terminal
+> dotnet workload --info
+Workload version: 9.0.100-manifests.400dd185
+Configured to use loose manifests when installing new manifests.
+ [aspire]
+ Installation Source: VS 17.10.35027.167, VS 17.11.35111.106
+ Manifest Version: 8.0.2/8.0.100
+ Manifest Path: C:\Program Files\dotnet\sdk-manifests\8.0.100\microsoft.net.sdk.aspire\8.0.2\WorkloadManifest.json
+ Install Type: Msi
+```
+
+In this example, I am in 'manifest' mode, which is what we call the current mode of managing workloads.
+The simplest way to opt into the new mode is to add a `--version` option to a `dotnet workload install` or `dotnet workload update` command, but you can also explicitly control your mode of operation using the new `dotnet workload config` command:
+
+```terminal
+> dotnet workload config --update-mode workload-set
+Successfully updated workload install mode to use workload-set.
+```
+
+If you need to change back for any reason, you can run the same command with `manifests` instead of `workload-set`. You can also use `dotnet workload config --update-mode` to check what the current mode of operation is. You can read more about workload sets in [our documentation]().
+
+## Mitigating analyzer mismatch issues aka 'torn SDK'
+
+Many users install the .NET SDK and Visual Studio at different cadences, and while this flexibility is one of our goals, it can lead to problems for tooling that needs to interop between the two environments.
+
+One example of this kind of tooling is Roslyn Analyzers. Analyzer authors have to code for specific versions of Roslyn, but which versions are available and which is used by a given build has been unclear in the past.
+
+We call this kind of mismatch a 'torn SDK'. When you are in this torn state, you might see errors like this:
+
+```bash
+>CSC : warning CS9057: The analyzer assembly '..\dotnet\sdk\8.0.200\Sdks\Microsoft.NET.Sdk.Razor\source-generators\Microsoft.CodeAnalysis.Razor.Compiler.SourceGenerators.dll' references version '4.9.0.0' of the compiler, which is newer than the currently running version '4.8.0.0'.
+```
+
+Starting in this release, we have adopted a method of detecting and automatically adjusting for this 'torn' state.
+
+You can read more about it [in our documentation for the effort](https://github.com/dotnet/sdk/blob/main/documentation/general/torn-sdk.md).
+
+In short, the SDK's MSBuild logic embeds the version of MSBuild it shipped with, and we can use that information to detect when the SDK is running in an environment other than that version.
+
+When we detect this, the SDK inserts an implicit [PackageDownload](https://learn.microsoft.com/nuget/consume-packages/packagedownload-functionality) of a support package called `Microsoft.Net.Sdk.Compilers.Toolset` that ensures a consistent analyzer experience for users.
+
diff --git a/release-notes/9.0/releases.json b/release-notes/9.0/releases.json
index 3f5b41428e..df99e7b658 100644
--- a/release-notes/9.0/releases.json
+++ b/release-notes/9.0/releases.json
@@ -1,13 +1,525 @@
{
"channel-version": "9.0",
- "latest-release": "9.0.0-preview.6",
- "latest-release-date": "2024-07-09",
- "latest-runtime": "9.0.0-preview.6.24327.7",
- "latest-sdk": "9.0.100-preview.6.24328.19",
+ "latest-release": "9.0.0-preview.7",
+ "latest-release-date": "2024-08-13",
+ "latest-runtime": "9.0.0-preview.7.24405.7",
+ "latest-sdk": "9.0.100-preview.7.24407.12",
"support-phase": "preview",
"release-type": "sts",
"lifecycle-policy": "https://aka.ms/dotnetcoresupport",
"releases": [
+ {
+ "release-date": "2024-08-13",
+ "release-version": "9.0.0-preview.7",
+ "security": false,
+ "cve-list": [],
+ "release-notes": "https://github.com/dotnet/core/blob/main/release-notes/9.0/preview/preview7/9.0.0-preview.7.md",
+ "runtime": {
+ "version": "9.0.0-preview.7.24405.7",
+ "version-display": "9.0.0-preview.7",
+ "vs-version": "",
+ "vs-mac-version": "",
+ "files": [
+ {
+ "name": "dotnet-runtime-linux-arm.tar.gz",
+ "rid": "linux-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/074a9718-7e48-46ad-99c2-1de78504111f/23e4f1e407d3c7f019156e633a59f753/dotnet-runtime-9.0.0-preview.7.24405.7-linux-arm.tar.gz",
+ "hash": "6bf40d4e837f74f0ac92ce504c187b33ee1d6ba653dee8006bbaf5a6f923eeffba2cb9c2f938207856c84bb9e41d5c3f42d0a0b1dd62bbd9997e885beab6a3af"
+ },
+ {
+ "name": "dotnet-runtime-linux-arm64.tar.gz",
+ "rid": "linux-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/248e66b8-594d-4738-8b01-2aa045faf3fd/686e989ba0365848fb4f81f8d780812c/dotnet-runtime-9.0.0-preview.7.24405.7-linux-arm64.tar.gz",
+ "hash": "f7440b679315c6d35b12d839a1cf52c961784d56524f52e96a7834bbda7bf4e5bfd726081148cf71fb19b3107c7b1f39681a2fae7e87f1d9fa0634b70a47f4b2"
+ },
+ {
+ "name": "dotnet-runtime-linux-musl-arm.tar.gz",
+ "rid": "linux-musl-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/4c4efbb5-befb-41fd-aab2-7b1a0d0b4921/69e5daec0c5b967f7f27abbc49343c06/dotnet-runtime-9.0.0-preview.7.24405.7-linux-musl-arm.tar.gz",
+ "hash": "d627507d36e0ee3e8a6253d0488bb2c85458ba124016b32c8a481ec3d603f4393b700f1cd08c5640aad1971546526898ffb049e9590cbd655dda4375b7d7757e"
+ },
+ {
+ "name": "dotnet-runtime-linux-musl-arm64.tar.gz",
+ "rid": "linux-musl-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/d680fd8e-6530-4da3-85d9-9c76c56cc737/c4d4b30f592e8a374f86c7f261886207/dotnet-runtime-9.0.0-preview.7.24405.7-linux-musl-arm64.tar.gz",
+ "hash": "57bb109d2bd66c6e273b54d4bbb4836a53375f1cb13bed1139c6bc950f85de774070014fd19ddb8b43588fa32f6de60811b43cbff5d29b1f537cb8206561fc5c"
+ },
+ {
+ "name": "dotnet-runtime-linux-musl-x64.tar.gz",
+ "rid": "linux-musl-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/0c5ee877-7142-41e4-bca9-244fa4fa129f/46a54128a24c0a2c75ca2d4e8aca5f28/dotnet-runtime-9.0.0-preview.7.24405.7-linux-musl-x64.tar.gz",
+ "hash": "343d911894ff3b61cf6ee560b5a5da14a8b84e9dffa2211529d885e81314a6b0e88b6018b3a116f05b0bcd6e80b2a1e8cb45547f193a49a3aafcdf3992b580e7"
+ },
+ {
+ "name": "dotnet-runtime-linux-x64.tar.gz",
+ "rid": "linux-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/41a47c9d-c08b-4abe-a2d1-920b51fe16b0/f6af3aa0615cc1625bfc77cd38e16d02/dotnet-runtime-9.0.0-preview.7.24405.7-linux-x64.tar.gz",
+ "hash": "9ede46bc2e6f87a9f592f888562a4cdda6ffa01ca9822f6d4ae586a7c478d3e4fe6c70758a4e9ecbba86445978c68f805d1d6d6f4d37fc653a2b7510309dd5dc"
+ },
+ {
+ "name": "dotnet-runtime-osx-arm64.pkg",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/f79b68ef-768b-462d-a96a-33d7a8129021/94bcf8b454c20f901564223fcc5b4e76/dotnet-runtime-9.0.0-preview.7.24405.7-osx-arm64.pkg",
+ "hash": "b6d520b49da68a823a0279ab93f5aef4f8381fe8fb45ea3e0998eccd111300331f1196d95e22f9d7bb64e74cc5f0dde2c33b63a4db3b56da60b3e0cf8c9e4cbb"
+ },
+ {
+ "name": "dotnet-runtime-osx-arm64.tar.gz",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/a71e7742-36b6-4f68-a573-b3437fc53a77/571d8fff000e17abd5d820cafc600b63/dotnet-runtime-9.0.0-preview.7.24405.7-osx-arm64.tar.gz",
+ "hash": "ade75303e39c33af6d7ea10369bb87d5d446619d2ffa630db1e8342b1577efe6831d8f32316fb0e0536e56e0adb7978c4e1b75ddef9a2d1cda8657b8fc457356"
+ },
+ {
+ "name": "dotnet-runtime-osx-x64.pkg",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/117d87f9-aa46-4ca0-b884-a04580c7edac/3cdfbfd89b544c9726aedd7b32e00d3d/dotnet-runtime-9.0.0-preview.7.24405.7-osx-x64.pkg",
+ "hash": "1be6f9be0cab72e50a99350b4a8517a428c468b83e9c69eb0fe3253ae62586507f1600173efacc049dafae5252721120a27611c68854104d3f737ec3d87f47c7"
+ },
+ {
+ "name": "dotnet-runtime-osx-x64.tar.gz",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dc29a044-d48d-43cd-a56c-2b8cba456df2/888138574a36ee8c2fe1af2e33c1119d/dotnet-runtime-9.0.0-preview.7.24405.7-osx-x64.tar.gz",
+ "hash": "17352746d1b780272766c6ea20bdb0961f8004bafc529877644fa536bc0e7441eb48d65cd05c4eb9017249651361c773d89b1ec1c1720bd4fce0fe965614d48a"
+ },
+ {
+ "name": "dotnet-runtime-win-arm64.exe",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/89f9e7e7-67fd-4524-8dde-9b89ca1ca74a/7a5880589767e7270561fc544143493e/dotnet-runtime-9.0.0-preview.7.24405.7-win-arm64.exe",
+ "hash": "cf8b6518c1daf0d5c25d42c7ed5370a6f853b496903822cb254af9064bc91578ce8476d75c8373ad3492d182c3db4459a933afb28f134059937ab5b7c27b7dd6"
+ },
+ {
+ "name": "dotnet-runtime-win-arm64.zip",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/151ce0ec-b807-4a23-9ae4-ba674d45b29b/3853e079685484b17d9e38b17e3b2e10/dotnet-runtime-9.0.0-preview.7.24405.7-win-arm64.zip",
+ "hash": "5f45a3ccde7dd587451d45eaf70756877df4646f4b9411948e2b71bd7da2d48d513c54f0642e44d306d75e969a01f4d2931eb980de3c71cb1172604c89838432"
+ },
+ {
+ "name": "dotnet-runtime-win-x64.exe",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/7ed661b8-ac50-444b-9540-5ee529b2e4aa/8780dd90140b747748e1ec15705c64e2/dotnet-runtime-9.0.0-preview.7.24405.7-win-x64.exe",
+ "hash": "7246da48251745c46acba6c3cf0c53e66eed0c17c8579e167a0cec928190e7a38ecc905dd1dcefc7e9e3baaf633186858b6dc7d4b8d52218192bc3580fabd05b"
+ },
+ {
+ "name": "dotnet-runtime-win-x64.zip",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/e7391d24-2880-452a-8fd0-5b72cf81049c/fdd37234b82b7e50a8a1575680246df4/dotnet-runtime-9.0.0-preview.7.24405.7-win-x64.zip",
+ "hash": "063c60a61ef96c06be677f9a418e807134563b8cd03be861924ab13325051070a570457a1e32ac676e8e70158a5fcf5e652b4484f15b517086e34faaee1071ee"
+ },
+ {
+ "name": "dotnet-runtime-win-x86.exe",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/98c838c8-d2c9-4660-9bb0-2e4587a8e016/d1fc3857e4914f991bf3ef769972ee0e/dotnet-runtime-9.0.0-preview.7.24405.7-win-x86.exe",
+ "hash": "e3292dfa9b747f15d7a928b2f09cc0e1e3662276303aea0535f96018d9ea58bfd36d5353638438bab611e491551fea8bf38773351065b13a3ef69d7f19ab9ea6"
+ },
+ {
+ "name": "dotnet-runtime-win-x86.zip",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/bf90ebe8-dd13-49c1-9945-c62c742739f7/dc34e583261c1acb3de46c36e3837572/dotnet-runtime-9.0.0-preview.7.24405.7-win-x86.zip",
+ "hash": "545d98b9757995faff8222e18a918519ca0e4fe4ecfd3216d622bf380a5b1a49109b07957b22f7069b8aa2d1bc89e0d0be6dc1c079e7d95d481b77d164125923"
+ }
+ ]
+ },
+ "sdk": {
+ "version": "9.0.100-preview.7.24407.12",
+ "version-display": "9.0.100-preview.7",
+ "runtime-version": "9.0.0-preview.7.24405.7",
+ "vs-version": "",
+ "vs-mac-version": "",
+ "vs-support": "",
+ "vs-mac-support": "",
+ "csharp-version": "12.0",
+ "fsharp-version": "8.0",
+ "vb-version": "16.9",
+ "files": [
+ {
+ "name": "dotnet-sdk-linux-arm.tar.gz",
+ "rid": "linux-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/d684965c-26a1-4ad9-964e-eba707075cb2/a76775d98eb7565314c7061881ebda5e/dotnet-sdk-9.0.100-preview.7.24407.12-linux-arm.tar.gz",
+ "hash": "b97c357cf8a2e129b222748e23b59343c4264b6dc9dbe00c5a01bf2d3f57c1a6bc61e5ec053b75ce0d17434977e1616d3efb7c4642aca18d8bb5fe7b6c0f906d"
+ },
+ {
+ "name": "dotnet-sdk-linux-arm64.tar.gz",
+ "rid": "linux-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/9dce0bb1-16ab-4670-9af4-57b6bd1c0c21/ba6055b1ad714158742dd1b2373adaed/dotnet-sdk-9.0.100-preview.7.24407.12-linux-arm64.tar.gz",
+ "hash": "c8ae08858c9ccf16d7b4879b7201ea22bd59e97f1924d4ff2b25079168c906d88a2864e6796244b67db612a36170969fef212879aa3b2232418795c7e7e6d526"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-arm.tar.gz",
+ "rid": "linux-musl-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/ad7426e9-3acf-402b-a2d4-de7046d67137/8c596827e70ab0960dad22502e17d7fc/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-arm.tar.gz",
+ "hash": "cd27cfd56483c51f48d12c204e3de0bd490b081d2add0d3db9f1ae905cef7470613727beb5213c6e68a9dacd2c46ccab8e4bf2b37eb5a8ea19a5d30447c42918"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-arm64.tar.gz",
+ "rid": "linux-musl-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dbf65449-bd68-4127-b39e-0a63b7807d01/107d0ef2ea0f771da9922f9bde0f04c4/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-arm64.tar.gz",
+ "hash": "1ccb6b8ad6e2d32f3d27b234783cde01e25e5c319ca8c5f90320e1ea2cf4f2a3cc58841a9d781c3a63d8a03b458391dd45a16c96d20a0c4f80e570d6decd80f9"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-x64.tar.gz",
+ "rid": "linux-musl-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/0499097c-376a-4e66-b011-fe4996c96795/c3e842772e3edaedfd3410467b789519/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-x64.tar.gz",
+ "hash": "f558d4d3e8ae430ce544a8157197f9084849998f8788e26b9a20f742761ac1ab09c12423e0d1eed1d3bed7a25788b717e3525586b10977f9bec414ae76ac3515"
+ },
+ {
+ "name": "dotnet-sdk-linux-x64.tar.gz",
+ "rid": "linux-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/84a39cad-2147-4a3e-b8fd-ec6fca0f80dd/d86fc06f750e758770f5a2237e01f5c5/dotnet-sdk-9.0.100-preview.7.24407.12-linux-x64.tar.gz",
+ "hash": "3bc1bddb8bebbfa9e256487871c3984ebe2c9bc77b644dd25e4660f12c76042f500931135a080a97f265bc4c5504433150bde0a3ca19c3f7ad7127835076fc8e"
+ },
+ {
+ "name": "dotnet-sdk-osx-arm64.pkg",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1f851fbf-f9d3-4b2a-9189-a1686bcb4853/8f8c50e3186b29bfc0a65f9a0ba7c31d/dotnet-sdk-9.0.100-preview.7.24407.12-osx-arm64.pkg",
+ "hash": "43667fec64adddd6b61628a047c0cea2c4c14b4958a5e6589ba0df7a56727416d293c559c6a9089a8d703a8444ebf929df2db6f3362f40c96cee14aebcd6a815"
+ },
+ {
+ "name": "dotnet-sdk-osx-arm64.tar.gz",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/49e6076a-438d-44de-a34d-6ad47af02423/f20bca6b909e3bd42679c14c8288fd0f/dotnet-sdk-9.0.100-preview.7.24407.12-osx-arm64.tar.gz",
+ "hash": "0af77ffeb27e44b2e695caabfa85254f94c77807be6d96fc6abdda1d71be266857320c5dc02d5df968da8963a52cd2aea4b4cad6dfc6540ad26b7b532bf83fd9"
+ },
+ {
+ "name": "dotnet-sdk-osx-x64.pkg",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/8fe9315f-284a-400c-8e09-6f8ad474ad46/8ebb620e266c23d064f2cb7f0de1e635/dotnet-sdk-9.0.100-preview.7.24407.12-osx-x64.pkg",
+ "hash": "ff9d18978e2e6b18baeb5b731a52f39458fa65fe2f6ff758e5b1b31b831817ca27149ce9231840ba39a88e2ec5f649b734097129cd8dbfef7f96bf21ec8a23d7"
+ },
+ {
+ "name": "dotnet-sdk-osx-x64.tar.gz",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/4a7fc24d-481e-4202-8654-06cf5fba0ebd/a4084481acd9aa803ad1ebf3cd668646/dotnet-sdk-9.0.100-preview.7.24407.12-osx-x64.tar.gz",
+ "hash": "b410a65d69f991ea55c81e5f7ea58c98ceef309d63ddd21a7689848a4a4516cdb898f8e36702a554a51fc22420cfbffe7a662a785175bbc1ebe1c33fcf6ffbf8"
+ },
+ {
+ "name": "dotnet-sdk-win-arm64.exe",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1b2a7758-984e-43f4-9277-bf33de3b3c87/af83a9dc52a935e10e80f9584d8cfdb1/dotnet-sdk-9.0.100-preview.7.24407.12-win-arm64.exe",
+ "hash": "0d6db7e772809f87bd70c6b5468f37ff14b466c59f3f3c0f85848b2cb7e938f550768b0a8a70ddb3dae0f900a6abe69dd6c641393e772d857a5160167c4b76cc"
+ },
+ {
+ "name": "dotnet-sdk-win-arm64.zip",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/017ef318-d4b0-407a-8850-255a96480d9a/90cea33924e1ae3ddab243fb4c25ce41/dotnet-sdk-9.0.100-preview.7.24407.12-win-arm64.zip",
+ "hash": "69c9b7fd4772509a343907a3cc386660caff5295fda42e64ae62c52147ba2adbd9511fa976dd9738df0643a3596a5c7eaa3e51a0f8bc8ffd4101eea706a5dd2b"
+ },
+ {
+ "name": "dotnet-sdk-win-x64.exe",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/7f691a3a-ddc2-4d1e-b447-7e87da162f9f/b320579c671f8f08ed6979bb93f23ff4/dotnet-sdk-9.0.100-preview.7.24407.12-win-x64.exe",
+ "hash": "53a429eec91b4335d2ff1822bd2b41c826b06a53d187d24645a991066f28498d93f06557bd1c471a9334dc02bcdb3b6d075cfa9d6c894bdfc0f29c0b6e0d7a02"
+ },
+ {
+ "name": "dotnet-sdk-win-x64.zip",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dee149e6-a8bd-4290-ac01-ca2740fde18a/bffedcce6bab8b98bdbc75201cfbc9ad/dotnet-sdk-9.0.100-preview.7.24407.12-win-x64.zip",
+ "hash": "99ed1ff4207b8e465b0a483649be860164fb9d4003ee08b1758d0db0df194dda523be4896572c21bfc6ca333f3408b48c14872cf5748a5af7c4d2682f29d8d3b"
+ },
+ {
+ "name": "dotnet-sdk-win-x86.exe",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/c25296ec-5287-4386-9a05-d45536f34943/0050fe9eaf6e3c4bbaa150a179d01829/dotnet-sdk-9.0.100-preview.7.24407.12-win-x86.exe",
+ "hash": "fd527045869746eb27acde707a054618f5f9757ea44333d1088013de9d5efef0c398ebfc911127a6a1a3ea292572db4e1f5d0e687f3e3e44bf45a3aa7816595c"
+ },
+ {
+ "name": "dotnet-sdk-win-x86.zip",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/acffccad-e120-49de-b2a7-f02883a53063/6dbe2a464e389c3d2a57bf069538c44f/dotnet-sdk-9.0.100-preview.7.24407.12-win-x86.zip",
+ "hash": "ba3b33dc34e811e9d740e9af00844a5cc67372718e45226b859812b917ac50b9249397752c8b0b63ce87339df5530f1e27d8863bfd2690834e51c38cb3bf4be7"
+ }
+ ]
+ },
+ "sdks": [
+ {
+ "version": "9.0.100-preview.7.24407.12",
+ "version-display": "9.0.100-preview.7",
+ "runtime-version": "9.0.0-preview.7.24405.7",
+ "vs-version": "",
+ "vs-mac-version": "",
+ "vs-support": "",
+ "vs-mac-support": "",
+ "csharp-version": "12.0",
+ "fsharp-version": "8.0",
+ "vb-version": "16.9",
+ "files": [
+ {
+ "name": "dotnet-sdk-linux-arm.tar.gz",
+ "rid": "linux-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/d684965c-26a1-4ad9-964e-eba707075cb2/a76775d98eb7565314c7061881ebda5e/dotnet-sdk-9.0.100-preview.7.24407.12-linux-arm.tar.gz",
+ "hash": "b97c357cf8a2e129b222748e23b59343c4264b6dc9dbe00c5a01bf2d3f57c1a6bc61e5ec053b75ce0d17434977e1616d3efb7c4642aca18d8bb5fe7b6c0f906d"
+ },
+ {
+ "name": "dotnet-sdk-linux-arm64.tar.gz",
+ "rid": "linux-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/9dce0bb1-16ab-4670-9af4-57b6bd1c0c21/ba6055b1ad714158742dd1b2373adaed/dotnet-sdk-9.0.100-preview.7.24407.12-linux-arm64.tar.gz",
+ "hash": "c8ae08858c9ccf16d7b4879b7201ea22bd59e97f1924d4ff2b25079168c906d88a2864e6796244b67db612a36170969fef212879aa3b2232418795c7e7e6d526"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-arm.tar.gz",
+ "rid": "linux-musl-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/ad7426e9-3acf-402b-a2d4-de7046d67137/8c596827e70ab0960dad22502e17d7fc/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-arm.tar.gz",
+ "hash": "cd27cfd56483c51f48d12c204e3de0bd490b081d2add0d3db9f1ae905cef7470613727beb5213c6e68a9dacd2c46ccab8e4bf2b37eb5a8ea19a5d30447c42918"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-arm64.tar.gz",
+ "rid": "linux-musl-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dbf65449-bd68-4127-b39e-0a63b7807d01/107d0ef2ea0f771da9922f9bde0f04c4/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-arm64.tar.gz",
+ "hash": "1ccb6b8ad6e2d32f3d27b234783cde01e25e5c319ca8c5f90320e1ea2cf4f2a3cc58841a9d781c3a63d8a03b458391dd45a16c96d20a0c4f80e570d6decd80f9"
+ },
+ {
+ "name": "dotnet-sdk-linux-musl-x64.tar.gz",
+ "rid": "linux-musl-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/0499097c-376a-4e66-b011-fe4996c96795/c3e842772e3edaedfd3410467b789519/dotnet-sdk-9.0.100-preview.7.24407.12-linux-musl-x64.tar.gz",
+ "hash": "f558d4d3e8ae430ce544a8157197f9084849998f8788e26b9a20f742761ac1ab09c12423e0d1eed1d3bed7a25788b717e3525586b10977f9bec414ae76ac3515"
+ },
+ {
+ "name": "dotnet-sdk-linux-x64.tar.gz",
+ "rid": "linux-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/84a39cad-2147-4a3e-b8fd-ec6fca0f80dd/d86fc06f750e758770f5a2237e01f5c5/dotnet-sdk-9.0.100-preview.7.24407.12-linux-x64.tar.gz",
+ "hash": "3bc1bddb8bebbfa9e256487871c3984ebe2c9bc77b644dd25e4660f12c76042f500931135a080a97f265bc4c5504433150bde0a3ca19c3f7ad7127835076fc8e"
+ },
+ {
+ "name": "dotnet-sdk-osx-arm64.pkg",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1f851fbf-f9d3-4b2a-9189-a1686bcb4853/8f8c50e3186b29bfc0a65f9a0ba7c31d/dotnet-sdk-9.0.100-preview.7.24407.12-osx-arm64.pkg",
+ "hash": "43667fec64adddd6b61628a047c0cea2c4c14b4958a5e6589ba0df7a56727416d293c559c6a9089a8d703a8444ebf929df2db6f3362f40c96cee14aebcd6a815"
+ },
+ {
+ "name": "dotnet-sdk-osx-arm64.tar.gz",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/49e6076a-438d-44de-a34d-6ad47af02423/f20bca6b909e3bd42679c14c8288fd0f/dotnet-sdk-9.0.100-preview.7.24407.12-osx-arm64.tar.gz",
+ "hash": "0af77ffeb27e44b2e695caabfa85254f94c77807be6d96fc6abdda1d71be266857320c5dc02d5df968da8963a52cd2aea4b4cad6dfc6540ad26b7b532bf83fd9"
+ },
+ {
+ "name": "dotnet-sdk-osx-x64.pkg",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/8fe9315f-284a-400c-8e09-6f8ad474ad46/8ebb620e266c23d064f2cb7f0de1e635/dotnet-sdk-9.0.100-preview.7.24407.12-osx-x64.pkg",
+ "hash": "ff9d18978e2e6b18baeb5b731a52f39458fa65fe2f6ff758e5b1b31b831817ca27149ce9231840ba39a88e2ec5f649b734097129cd8dbfef7f96bf21ec8a23d7"
+ },
+ {
+ "name": "dotnet-sdk-osx-x64.tar.gz",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/4a7fc24d-481e-4202-8654-06cf5fba0ebd/a4084481acd9aa803ad1ebf3cd668646/dotnet-sdk-9.0.100-preview.7.24407.12-osx-x64.tar.gz",
+ "hash": "b410a65d69f991ea55c81e5f7ea58c98ceef309d63ddd21a7689848a4a4516cdb898f8e36702a554a51fc22420cfbffe7a662a785175bbc1ebe1c33fcf6ffbf8"
+ },
+ {
+ "name": "dotnet-sdk-win-arm64.exe",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1b2a7758-984e-43f4-9277-bf33de3b3c87/af83a9dc52a935e10e80f9584d8cfdb1/dotnet-sdk-9.0.100-preview.7.24407.12-win-arm64.exe",
+ "hash": "0d6db7e772809f87bd70c6b5468f37ff14b466c59f3f3c0f85848b2cb7e938f550768b0a8a70ddb3dae0f900a6abe69dd6c641393e772d857a5160167c4b76cc"
+ },
+ {
+ "name": "dotnet-sdk-win-arm64.zip",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/017ef318-d4b0-407a-8850-255a96480d9a/90cea33924e1ae3ddab243fb4c25ce41/dotnet-sdk-9.0.100-preview.7.24407.12-win-arm64.zip",
+ "hash": "69c9b7fd4772509a343907a3cc386660caff5295fda42e64ae62c52147ba2adbd9511fa976dd9738df0643a3596a5c7eaa3e51a0f8bc8ffd4101eea706a5dd2b"
+ },
+ {
+ "name": "dotnet-sdk-win-x64.exe",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/7f691a3a-ddc2-4d1e-b447-7e87da162f9f/b320579c671f8f08ed6979bb93f23ff4/dotnet-sdk-9.0.100-preview.7.24407.12-win-x64.exe",
+ "hash": "53a429eec91b4335d2ff1822bd2b41c826b06a53d187d24645a991066f28498d93f06557bd1c471a9334dc02bcdb3b6d075cfa9d6c894bdfc0f29c0b6e0d7a02"
+ },
+ {
+ "name": "dotnet-sdk-win-x64.zip",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dee149e6-a8bd-4290-ac01-ca2740fde18a/bffedcce6bab8b98bdbc75201cfbc9ad/dotnet-sdk-9.0.100-preview.7.24407.12-win-x64.zip",
+ "hash": "99ed1ff4207b8e465b0a483649be860164fb9d4003ee08b1758d0db0df194dda523be4896572c21bfc6ca333f3408b48c14872cf5748a5af7c4d2682f29d8d3b"
+ },
+ {
+ "name": "dotnet-sdk-win-x86.exe",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/c25296ec-5287-4386-9a05-d45536f34943/0050fe9eaf6e3c4bbaa150a179d01829/dotnet-sdk-9.0.100-preview.7.24407.12-win-x86.exe",
+ "hash": "fd527045869746eb27acde707a054618f5f9757ea44333d1088013de9d5efef0c398ebfc911127a6a1a3ea292572db4e1f5d0e687f3e3e44bf45a3aa7816595c"
+ },
+ {
+ "name": "dotnet-sdk-win-x86.zip",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/acffccad-e120-49de-b2a7-f02883a53063/6dbe2a464e389c3d2a57bf069538c44f/dotnet-sdk-9.0.100-preview.7.24407.12-win-x86.zip",
+ "hash": "ba3b33dc34e811e9d740e9af00844a5cc67372718e45226b859812b917ac50b9249397752c8b0b63ce87339df5530f1e27d8863bfd2690834e51c38cb3bf4be7"
+ }
+ ]
+ }
+ ],
+ "aspnetcore-runtime": {
+ "version": "9.0.0-preview.7.24406.2",
+ "version-display": "9.0.0-preview.7",
+ "version-aspnetcoremodule": [
+ "19.0.24219.0"
+ ],
+ "vs-version": "",
+ "files": [
+ {
+ "name": "aspnetcore-runtime-linux-arm.tar.gz",
+ "rid": "linux-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/5e16d860-eacd-48cb-9d3b-a29894cf74fc/f1e9a698798f7325b1e28588c7075cfb/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-arm.tar.gz",
+ "hash": "c5a60fc24cfd9ccb27c022938a93668a344f1f3f1bdb41e01f4740bb798ad04341b5b30fd4aef129d936c909ad8473cf6072a76f999ec626221df9696c73dcc5"
+ },
+ {
+ "name": "aspnetcore-runtime-linux-arm64.tar.gz",
+ "rid": "linux-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/28370706-3338-4dd5-9992-6cd1d86ba666/354c9434538f587c3198fe57fa0d2e00/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-arm64.tar.gz",
+ "hash": "706925fde5bb93b98e347540fe0983ce0819a2ca2520ed2d5bfc4515cb6852587a30f29852b512509b660daf8ee76ff3c8bb2d2fd78e47c6ae156e6f00cde918"
+ },
+ {
+ "name": "aspnetcore-runtime-linux-musl-arm.tar.gz",
+ "rid": "linux-musl-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/058d32bd-03e3-4867-8c62-79e88b5b9b69/784891ca110016d0afa902cc4176e46f/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-musl-arm.tar.gz",
+ "hash": "08b67ca34122f063370d0f24606174026d3e67f8767ac2e4c4393c214e608d47d82dad177a97c5e6e28d089412403f75012c00cdaabb109e461e266ad6a620c5"
+ },
+ {
+ "name": "aspnetcore-runtime-linux-musl-arm64.tar.gz",
+ "rid": "linux-musl-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/94ac38de-a00b-45a1-a37a-c7b4d8a52ddf/135aa93213a5f87c7feaf267e305a3b3/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-musl-arm64.tar.gz",
+ "hash": "df15606e28e68162739d6b5f3a3852664cbd8d78ff8e8ebed07e2f78c8699d0dd4bd2a3c3b5c98b63bfdae1106720fd4069d349d0d4e32037deea77a4e97efed"
+ },
+ {
+ "name": "aspnetcore-runtime-linux-musl-x64.tar.gz",
+ "rid": "linux-musl-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/60441f64-edc5-4c33-8022-107be30d728b/a3375f19b72b8e23d5394e3a1e2a1806/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-musl-x64.tar.gz",
+ "hash": "bddb66623e26d391d4587b46f6b7be5280788eb0355c558044016c1a12062005f2627bd3fdf51cb271f85eaa91fb920532ef235edd764e4ca63931595e1fb52b"
+ },
+ {
+ "name": "aspnetcore-runtime-linux-x64.tar.gz",
+ "rid": "linux-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/bdb8a419-432c-4f1c-b5ad-ae6e27617b5c/65b26a64e3dda62c456a7a45df73dc1e/aspnetcore-runtime-9.0.0-preview.7.24406.2-linux-x64.tar.gz",
+ "hash": "44f86c407b501a700aaeae2ce95cf544d85c08b41cdd12cee22bfcfdd03c4f6a16e495d9f8315f5e56a66b7e6187a4fc39d899f967a65f73883e40172343275c"
+ },
+ {
+ "name": "aspnetcore-runtime-osx-arm64.tar.gz",
+ "rid": "osx-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/b2836c76-8c1d-4030-b7f6-0cd5ec1b640b/ea922caf251b0245b96ba2afd7ebb2b4/aspnetcore-runtime-9.0.0-preview.7.24406.2-osx-arm64.tar.gz",
+ "hash": "8200af559c76f5bf12f5e0495c285a837dbe29c7ac2d6c562540f7077aa68fa65dc05205b4b219e72f78d55c20a75a514f6ccf3f53d6ecf34fd2cea0817a7ede"
+ },
+ {
+ "name": "aspnetcore-runtime-osx-x64.tar.gz",
+ "rid": "osx-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/d0813855-fdde-47df-8d71-119af034e409/40989f36db96de19bc682d62cbadd8e3/aspnetcore-runtime-9.0.0-preview.7.24406.2-osx-x64.tar.gz",
+ "hash": "0f309d6b849ccec8e13812de9ff70fac5cc78785b71f356fc63e5070296305766892a3dfd74bae9b4775ec4449335d03d046494a416304f56e5ba7746f3316ca"
+ },
+ {
+ "name": "aspnetcore-runtime-win-arm64.exe",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/d56241f9-9411-4ee7-b656-872d5666bb99/5015011e1f74c0be2e3e88ec842112d2/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-arm64.exe",
+ "hash": "c3acd624e17bf532bc7c3a1045d551e94a1cc70b8c126c816c64dc788db0152c6737cb703bc76a04a84cf6a11dc589f46e38c1c825860d5f32514bb2fa41e54b"
+ },
+ {
+ "name": "aspnetcore-runtime-win-arm64.zip",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/18014125-ce33-4c3b-94d1-365b12e16aee/c0981da139aa9fbb392cf9d88b8b3da6/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-arm64.zip",
+ "hash": "aa0fcb2d6f74856e9e65d13504c313d4237cb98e55b122c3a2fd89bb4c4307b65bd6386f7350e264d6e4499eaf55ff79766218a2708bb556a66502c62ecf6a7e"
+ },
+ {
+ "name": "aspnetcore-runtime-win-x64.exe",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/5e085306-10ef-4184-a5ef-113ccadcd55f/ac63196a2fcccbbcb41a7e73de73caca/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-x64.exe",
+ "hash": "a1b17cbe3b028f41c8d8b3c9608112692004259a62ce45efe658ff9506016b8c16e7482708b0f1a861bac21fed19205bed880c790d58c3d1cfd62b81933953ae"
+ },
+ {
+ "name": "aspnetcore-runtime-win-x64.zip",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/150e0d3c-4bca-4c0c-acc2-09ac93f32a6c/0ad15ba162c80b92f5bea820c6b646e4/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-x64.zip",
+ "hash": "ce32f77bfb17c15c85968bd3062d6d628ce5d7b1b1bc5d1cab1c7b659253ad869c264b6e98773a57ce80cb818c22db5da79ed6b32affe6f8be0f1952069c7714"
+ },
+ {
+ "name": "aspnetcore-runtime-win-x86.exe",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/b4aa5307-82ed-462f-aeb2-b461c4eeb6f6/875b2ae1460fff14911a6ae9ee723c15/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-x86.exe",
+ "hash": "3b3bdf4c59fea2035881a95d611f06f64d468e57c85f1c4c04566e6286bfebe1f35837f61c28504697856a782dbcf3b613b51fac41003b3f5bec0ac816894971"
+ },
+ {
+ "name": "aspnetcore-runtime-win-x86.zip",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/fb394383-000b-4ec1-a995-6270b205201f/74866e7e6391f5fa17c479ee0cd4b9e6/aspnetcore-runtime-9.0.0-preview.7.24406.2-win-x86.zip",
+ "hash": "42c04862e239e07b698dfdc1f39633c42ff196e84569660a1dc2f74ea910a705c91cd1f2453efbc8243de883c89452ede139647c272552e29fb9e57c7dacd494"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-arm.tar.gz",
+ "rid": "linux-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1c178b77-927a-4852-9637-6dc401a290a3/3c485a7d5ebd8e80d73d3d6c693e0f88/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-arm.tar.gz",
+ "hash": "7839fa20a2a6459f2c4ba41844ac6c57a0eff6ffd8eaef0463ca44918405a0ab3d1b80e7d3943d7c14db21d0d2cf5490a44d1bdfbc9492138d80dbe228910960"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-arm64.tar.gz",
+ "rid": "linux-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/ff3b69c9-f76f-4a7b-af13-123d491c0861/baf999495f1dd404918562f079db60fc/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-arm64.tar.gz",
+ "hash": "9805dfd4167cf7d67153044265921df12883d67812342779f26b7f400658a117a25b54e29e83bbc8757899d6c96af52d7b35226ebaf2b7a9524b1114d580a741"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-musl-arm.tar.gz",
+ "rid": "linux-musl-arm",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/6201b645-6b36-41ff-911a-3a2807b8ff22/efaabeb363f451008341297b8a500c53/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-musl-arm.tar.gz",
+ "hash": "ada585f833f0d4617d36df8ccdf716553e275cb7b49bae3e44945fd3826d3152eef1830339d069cdc0d60f3947f031647929c7580c97ad768e8b32b7f06274ef"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-musl-arm64.tar.gz",
+ "rid": "linux-musl-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/21b93eac-4fd9-4606-a87e-4c9e5ab2383f/f72967bdefbc4c75379a477bfbd10f02/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-musl-arm64.tar.gz",
+ "hash": "d4ec9d402d78a5da914642622a47da05e6c0b55c80ccbd1ba0c1a6c336e38f8598b0b30b986e5d0d296d1ff1783f53cb369d9a7a3c4da25b94c8c6ed4cf67291"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-musl-x64.tar.gz",
+ "rid": "linux-musl-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1a9130ec-0085-4a3e-8a24-1f8378108e84/a3d8bbd3d85578085cc5a3583f63d371/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-musl-x64.tar.gz",
+ "hash": "2edd041b05b65e35464d7941bd1453f97d510408f51ea6e08dadcc81a76529e3500f4c62c48249b68ac2662a42bf8b00d4bcc6f998d3bdf594929914a9d5deed"
+ },
+ {
+ "name": "aspnetcore-runtime-composite-linux-x64.tar.gz",
+ "rid": "linux-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/9c538089-9dc0-44bd-9872-34881002e6f9/6690bcaed6d067f6599420052968a9d0/aspnetcore-runtime-composite-9.0.0-preview.7.24406.2-linux-x64.tar.gz",
+ "hash": "5a580a89c144a268ceeaf2171f2a60f31ab99c3c1879d043920cf4a0a70eb5d3aa0419029408f64ddb1930ebf830e4988d9356dd7dd7819fde570622aeeab7b5"
+ },
+ {
+ "name": "dotnet-hosting-win.exe",
+ "rid": "",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/fdd84cd2-f012-47c1-bf90-df245aef7fdc/04161e728311f32a1ec0f9f973a9d606/dotnet-hosting-9.0.0-preview.7.24406.2-win.exe",
+ "hash": "84426e1c134c0bf6227ed9610a252c562470b65c76a10153e5123b2939f3daaa2e7e067f65de9629ed8542b480ba8549dd0301b58ad94380b8b35cf096882b56",
+ "akams": "https://aka.ms/dotnetcore-9-0-windowshosting"
+ }
+ ]
+ },
+ "windowsdesktop": {
+ "version": "9.0.0-preview.7.24405.2",
+ "version-display": "9.0.0-preview.7",
+ "files": [
+ {
+ "name": "windowsdesktop-runtime-win-arm64.exe",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/b0080098-a31b-49e1-9624-2864c4d2c4f1/843fbd5a038f44630b0e007da84a2ac1/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-arm64.exe",
+ "hash": "c559f8c488d2b94e12e5fe7e61c89eb28ef74b7fe0f52b991e52361d417385521e60384b7db8b7ade2b81cd5f8e905bb31b2d1574e16c506bc998e81171ed0e1"
+ },
+ {
+ "name": "windowsdesktop-runtime-win-arm64.zip",
+ "rid": "win-arm64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/1a4c7151-99b9-4601-b160-01d09cd8ed4c/893ed6327a2f1367c0d59d30121b0fc7/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-arm64.zip",
+ "hash": "463b8ac6e5b9f62eddec20009ff2517b2a5f90cc1d6047cc005fb446a344c1337cbf0f59ced2749e1b569ef44942c5c7150dbeb10e0ce1f9a76e9c45a1d1bbe4"
+ },
+ {
+ "name": "windowsdesktop-runtime-win-x64.exe",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/ef26a963-0101-4288-900e-71c17f210316/99d1cccde7fffb997ee4af1cf024ae54/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-x64.exe",
+ "hash": "77ffd490b614126debd79a3984df39cacfaa11049e4d209ccbde0e37e48f8169183b369c294b2f5b4e51ed1bee78ae56b4fcb794a663b6c4515248346f838ea3"
+ },
+ {
+ "name": "windowsdesktop-runtime-win-x64.zip",
+ "rid": "win-x64",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/dbecfc4d-1b43-4fe1-833c-6fc188f7b7eb/99b15fbc905fdf2343bc6813c8d4c6b7/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-x64.zip",
+ "hash": "296cf946d83670772dc6794f1019549f59987cfc50cdfa4d04e756fc16174381249b15fc0dd2b154f17be0df2fc4e2b25f95601a238765cf29ad103033125b2a"
+ },
+ {
+ "name": "windowsdesktop-runtime-win-x86.exe",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/f3373f83-b929-4d53-bf74-c0095ad6c900/e7f11b0a8e2a617fbbd55bba7dc15007/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-x86.exe",
+ "hash": "7eb2c020a8849ff267e6bbe441913773d5a1e8cdb4bcd81bccc73d424a55f398ca4228fcbbd48e191d333d4a6a0b37ed7a4db03edecdd19262dc3f0cbec77d03"
+ },
+ {
+ "name": "windowsdesktop-runtime-win-x86.zip",
+ "rid": "win-x86",
+ "url": "https://download.visualstudio.microsoft.com/download/pr/86a1653f-b9ca-4bc1-8b75-07d31812de15/de93ce0c63d3ff059f1e147ed3618680/windowsdesktop-runtime-9.0.0-preview.7.24405.2-win-x86.zip",
+ "hash": "d29732075a45d16dfde9c02957ab2532053721c9cf3e41f37cd59afe866ed06138d82b1aa94668f0f0697abd07c983a309e6f79aac9f0b17a8470cff6be8e281"
+ }
+ ]
+ }
+ },
{
"release-date": "2024-07-09",
"release-version": "9.0.0-preview.6",
diff --git a/release-notes/README.md b/release-notes/README.md
index 517e4c304f..f12a30e9a0 100644
--- a/release-notes/README.md
+++ b/release-notes/README.md
@@ -4,15 +4,15 @@ The following table lists [releases](../releases.md) under active development or
| Version | Release Date | Support | Latest Patch Version | End of Support |
| :-- | :-- | :-- | :-- | :-- |
-| [.NET 9](9.0/README.md) | November 12, 2024 | [STS][policies] | [9.0.0-preview.6][9.0.0-preview.6] | May 12, 2026 |
-| [.NET 8](8.0/README.md) | [November 14, 2023](https://devblogs.microsoft.com/dotnet/announcing-dotnet-8/) | [LTS][policies] | [8.0.7][8.0.7] | November 10, 2026 |
-| [.NET 6](6.0/README.md) | [November 8, 2021](https://devblogs.microsoft.com/dotnet/announcing-net-6/) | [LTS][policies] | [6.0.32][6.0.32] | November 12, 2024 |
+| [.NET 9](9.0/README.md) | November 12, 2024 | [STS][policies] | [9.0.0-preview.7][9.0.0-preview.7] | May 12, 2026 |
+| [.NET 8](8.0/README.md) | [November 14, 2023](https://devblogs.microsoft.com/dotnet/announcing-dotnet-8/) | [LTS][policies] | [8.0.8][8.0.8] | November 10, 2026 |
+| [.NET 6](6.0/README.md) | [November 8, 2021](https://devblogs.microsoft.com/dotnet/announcing-net-6/) | [LTS][policies] | [6.0.33][6.0.33] | November 12, 2024 |
You can find release notes for all releases, including out-of-support releases, in the [release-notes](.) directory.
-[9.0.0-preview.6]: 9.0/preview/preview6/9.0.0-preview.6.md
-[8.0.7]: 8.0/8.0.7/8.0.7.md
-[6.0.32]: 6.0/6.0.32/6.0.32.md
+[9.0.0-preview.7]: 9.0/preview/preview7/9.0.0-preview.7.md
+[8.0.8]: 8.0/8.0.8/8.0.8.md
+[6.0.33]: 6.0/6.0.33/6.0.33.md
* [Release note formats](./formats.md)
* [Releases index][releases-index.json]
diff --git a/release-notes/releases-index.json b/release-notes/releases-index.json
index 5cac449f02..548b5fd50a 100644
--- a/release-notes/releases-index.json
+++ b/release-notes/releases-index.json
@@ -3,11 +3,11 @@
"releases-index": [
{
"channel-version": "9.0",
- "latest-release": "9.0.0-preview.6",
- "latest-release-date": "2024-07-09",
+ "latest-release": "9.0.0-preview.7",
+ "latest-release-date": "2024-08-13",
"security": false,
- "latest-runtime": "9.0.0-preview.6.24327.7",
- "latest-sdk": "9.0.100-preview.6.24328.19",
+ "latest-runtime": "9.0.0-preview.7.24405.7",
+ "latest-sdk": "9.0.100-preview.7.24407.12",
"product": ".NET",
"support-phase": "preview",
"eol-date": "2026-05-11",
@@ -17,11 +17,11 @@
},
{
"channel-version": "8.0",
- "latest-release": "8.0.7",
- "latest-release-date": "2024-07-09",
+ "latest-release": "8.0.8",
+ "latest-release-date": "2024-08-13",
"security": true,
- "latest-runtime": "8.0.7",
- "latest-sdk": "8.0.303",
+ "latest-runtime": "8.0.8",
+ "latest-sdk": "8.0.400",
"product": ".NET",
"support-phase": "active",
"eol-date": "2026-11-10",
@@ -45,11 +45,11 @@
},
{
"channel-version": "6.0",
- "latest-release": "6.0.32",
- "latest-release-date": "2024-07-09",
- "security": true,
- "latest-runtime": "6.0.32",
- "latest-sdk": "6.0.424",
+ "latest-release": "6.0.33",
+ "latest-release-date": "2024-08-13",
+ "security": false,
+ "latest-runtime": "6.0.33",
+ "latest-sdk": "6.0.425",
"product": ".NET",
"support-phase": "maintenance",
"eol-date": "2024-11-12",
diff --git a/releases.md b/releases.md
index a3da8480a3..02943053c6 100644
--- a/releases.md
+++ b/releases.md
@@ -10,11 +10,11 @@ The following table lists supported releases.
| Version | Release Date | Support | Latest Patch Version | End of Support |
| :-- | :-- | :-- | :-- | :-- |
-| [.NET 8](release-notes/8.0/README.md) | [November 14, 2023](https://devblogs.microsoft.com/dotnet/announcing-dotnet-8/) | [LTS][policies] | [8.0.7][8.0.7] | November 10, 2026 |
-| [.NET 6](release-notes/6.0/README.md) | [November 8, 2021](https://devblogs.microsoft.com/dotnet/announcing-net-6/) | [LTS][policies] | [6.0.32][6.0.32] | November 12, 2024 |
+| [.NET 8](release-notes/8.0/README.md) | [November 14, 2023](https://devblogs.microsoft.com/dotnet/announcing-dotnet-8/) | [LTS][policies] | [8.0.8][8.0.8] | November 10, 2026 |
+| [.NET 6](release-notes/6.0/README.md) | [November 8, 2021](https://devblogs.microsoft.com/dotnet/announcing-net-6/) | [LTS][policies] | [6.0.33][6.0.33] | November 12, 2024 |
-[8.0.7]: release-notes/8.0/8.0.7/8.0.7.md
-[6.0.32]: release-notes/6.0/6.0.32/6.0.32.md
+[8.0.8]: release-notes/8.0/8.0.8/8.0.8.md
+[6.0.33]: release-notes/6.0/6.0.33/6.0.33.md
## Preview releases
@@ -22,9 +22,9 @@ The following table lists unsupported preview releases.
| Version | Release Date | Support | Latest Patch Version | End of Support |
| :-- | :-- | :-- | :-- | :-- |
-| [.NET 9](release-notes/9.0/README.md) | November 12, 2024 | [STS][policies] | [9.0.0-preview.6][9.0.0-preview.6] | May 12, 2026 |
+| [.NET 9](release-notes/9.0/README.md) | November 12, 2024 | [STS][policies] | [9.0.0-preview.7][9.0.0-preview.7] | May 12, 2026 |
-[9.0.0-preview.6]: release-notes/9.0/preview/preview6/9.0.0-preview.6.md
+[9.0.0-preview.7]: release-notes/9.0/preview/preview7/9.0.0-preview.7.md
## End-of-life releases