.NET 8 (LTS) and .NET 9 (STS) both reached end of support on 10 November 2026. Applications on either runtime no longer receive security fixes. This checklist is the order we work through when moving an ASP.NET Core application to .NET 10.

Where the versions stand

According to Microsoft's .NET support policy:

VersionTypeReleasedEnd of support
.NET 8LTSNovember 202310 November 2026 (ended)
.NET 9STSNovember 202410 November 2026 (ended)
.NET 10LTS11 November 202514 November 2028
.NET 11STS10 November 202614 November 2028

Standard Term Support releases are now supported for 24 months, so .NET 10 and .NET 11 end on the same day. For most business applications we still recommend .NET 10: it has had a year of servicing releases, and third-party packages have caught up with it. Choose .NET 11 only if you need something it adds. Either way, put the next upgrade in the plan now. Under Microsoft's annual release cadence the next LTS version is expected in November 2027.

End of support does not stop an application from running. It means no more patches, vulnerability scanners and auditors will flag the runtime, and hosting platforms tend to withdraw out-of-support runtimes over time.

1. Take an inventory

Before changing anything, write down what you actually have. In a solution with several services, this usually turns up a forgotten worker service or a test project still targeting an older framework.

  • Target frameworks. Search every .csproj, Directory.Build.props and Directory.Build.targets for TargetFramework and TargetFrameworks.
  • SDK pinning. Check for a global.json file and the SDK version it requests.
  • Packages. List direct and transitive packages, including any central versions in Directory.Packages.props.
  • Tools. Local and global .NET tools such as dotnet-ef, listed in .config/dotnet-tools.json.
  • Build and run environments. CI agents, Dockerfiles, IIS servers, App Service plans, Kubernetes manifests.

These commands give a quick first picture:

dotnet --list-sdks
dotnet --list-runtimes
dotnet list package --outdated
dotnet list package --vulnerable --include-transitive

2. Pin the SDK with global.json

Pinning the SDK means every developer machine and CI agent builds with the same toolchain. A global.json at the repository root such as this one requests a .NET 10 SDK and allows newer feature bands and patches:

{
  "sdk": {
    "version": "10.0.100",
    "rollForward": "latestFeature"
  }
}

See the global.json reference for the roll-forward options. Commit this change on its own, before the framework change, so build problems caused by the new SDK are separated from problems caused by the new runtime.

3. Change the target framework

Update each project from net8.0 (or net9.0) to net10.0. Windows-specific projects use net10.0-windows. If the value lives in Directory.Build.props, one edit covers the solution.

<PropertyGroup>
  <TargetFramework>net10.0</TargetFramework>
</PropertyGroup>

Libraries shared with other teams may need to multi-target (for example net10.0;net8.0) for a period, but do not keep an unsupported target longer than your consumers need it.

4. Upgrade Microsoft and EF Core packages together

Move the Microsoft.AspNetCore.*, Microsoft.Extensions.* and Microsoft.EntityFrameworkCore.* packages to their 10.x versions in one step. Mixing major versions of these families produces confusing restore and runtime errors. EF Core 10 requires .NET 10, so the runtime and EF Core move together; update the dotnet-ef tool at the same time.

For third-party packages, check each one's release notes for .NET 10 support. Packages that have not been updated for a long time are worth noting even if they still compile, because you will be relying on them until 2028.

5. Read the official breaking-change lists

Moving from .NET 8 to .NET 10 crosses two releases, so read both lists rather than relying on memory or blog posts:

The lists are grouped by area (ASP.NET Core, SDK and MSBuild, containers, serialisation, cryptography and others). Go through each entry and record whether it applies to you. Keeping that record in the pull request is useful later, when someone asks why a behaviour changed.

6. Build, then treat warnings as information

A new SDK brings new analysers and may report new obsolescence warnings. If the solution uses TreatWarningsAsErrors, expect the first build to fail on warnings rather than errors. Read them: obsolete-API warnings tell you what to change before the API is removed in a later release. Suppress a warning only with a comment explaining why.

7. Update CI images and pipelines

The build agent needs the .NET 10 SDK. If you use GitHub Actions, actions/setup-dotnet can read the version from global.json, so the pipeline and developers stay in step:

- uses: actions/setup-dotnet@v4
  with:
    global-json-file: global.json
- run: dotnet restore
- run: dotnet build --no-restore -c Release
- run: dotnet test --no-build -c Release

Azure DevOps and other CI systems have equivalent tasks. Check self-hosted agents as well: they often have an old SDK installed by hand.

8. Update container base images

For containerised applications, move both stages of the Dockerfile:

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish MyApp/MyApp.csproj -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Check which Linux distribution the tag you use is based on, and read the containers section of the breaking-change list, since changes there affect anything your Dockerfile installs or assumes. Run your image scanner against the new image before release.

9. Prepare the hosting environment

  • IIS. Install the .NET 10 Hosting Bundle on every server before deploying, then restart IIS. The bundle includes the runtime and the ASP.NET Core Module.
  • Self-contained publish. Publishing with --self-contained removes the dependency on a machine-wide runtime, but you then apply runtime security patches by rebuilding and redeploying. Make sure someone owns that monthly task.
  • Azure App Service and other platforms. Change the runtime stack setting to .NET 10, ideally on a staging slot first.
  • Linux hosts. Install the ASP.NET Core 10 runtime from Microsoft's package feed or your distribution, or use self-contained deployment.

10. Test what actually changes

A green unit-test run is necessary but not sufficient. Upgrades tend to show up at the edges of the application:

  • Integration tests using WebApplicationFactory, covering authentication, authorisation policies and middleware order.
  • API contract tests. Snapshot the JSON your endpoints return and compare before and after, so serialisation differences are caught before clients notice.
  • Data access. Run the EF Core query tests against a real database engine, not only an in-memory provider, and generate migration scripts to confirm the model has not changed unexpectedly.
  • Background work. Hosted services, scheduled jobs and message consumers.
  • Performance baseline. Run the same load test before and after, and compare latency and memory rather than assuming they will improve.

11. Roll out in stages

  1. Deploy to a staging environment that matches production configuration.
  2. Release to a small share of traffic or one instance (a deployment slot, a canary pod or one server behind the load balancer).
  3. Watch error rates, latency and logs for a defined period.
  4. Complete the rollout, keeping the previous build available for rollback.

Rolling back the code is easy; rolling back data is not. If the release includes database migrations, make them backward compatible so the .NET 8 build can still run against the new schema during the rollout window.

The checklist in short

  • Inventory frameworks, SDKs, packages, tools and environments.
  • Pin the .NET 10 SDK in global.json.
  • Change every project to net10.0.
  • Upgrade Microsoft and EF Core packages to 10.x together.
  • Review the .NET 9 and .NET 10 breaking-change lists and record decisions.
  • Fix warnings, update CI agents and container images.
  • Install the Hosting Bundle or switch to self-contained deployment.
  • Test contracts, data access and background work, then roll out in stages.

Need a second pair of hands on the upgrade?

We help teams plan and carry out .NET upgrades and modernisation, from the inventory to the production rollout.

.NET modernisation