Using ASP.NET Core in .NET 11 Without Changing Your Existing Controllers

When upgrading an ASP.NET Core application, one of the biggest concerns is whether existing controllers and business logic will continue working without modification.

Consider an application that has been running on .NET 10 for several months. It contains multiple API controllers, authentication middleware, dependency injection registrations, database services, and third-party integrations. The application is stable, and the team wants to move to .NET 11 to benefit from the latest framework improvements.

The obvious question is whether the team needs to rewrite its controllers or change the existing API architecture.

In most cases, the answer is no.

ASP.NET Core continues to support the familiar MVC controller model in .NET 11. Existing attributes such as [ApiController], [HttpGet], [HttpPost], [Route], and [Authorize] remain part of the development experience.

The migration mainly involves updating the target framework, reviewing dependencies, checking framework changes, and validating the application's existing behavior.

In this article, we will upgrade a small ASP.NET Core Web API from .NET 10 to .NET 11 while keeping the existing controllers unchanged.

Understanding the ASP.NET Core Migration

ASP.NET Core applications generally follow a familiar architecture.

The controller handles HTTP requests, services contain business logic, and repositories or database contexts handle data access.

For example:

Client Application
       |
       v
ASP.NET Core Middleware
       |
       v
API Controller
       |
       v
Business Service
       |
       v
Database Repository
       |
       v
Database

Moving to .NET 11 does not require changing this architecture.

The framework continues supporting MVC controllers, dependency injection, routing, model binding, filters, authentication, and authorization.

However, some framework-level behaviors and dependencies have changed. These should be reviewed before upgrading a production application.

Step 1: Review the Existing .NET 10 Project

Let's start with a typical ASP.NET Core Web API project.

The existing project file might look like this:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

The application uses the standard ASP.NET Core Web SDK.

There is no requirement to replace this SDK or move to Minimal APIs.

The first step is to identify the current target framework, package references, SDK configuration, and any custom middleware.

If your solution contains multiple projects, review each project individually. Updating the API project alone may not be sufficient if shared libraries still target older frameworks.

Step 2: Update the Target Framework to .NET 11

The first code change is usually the project configuration.

Change:

<TargetFramework>net10.0</TargetFramework>

To:

<TargetFramework>net11.0</TargetFramework>

The updated project file becomes:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net11.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

If your solution uses a global.json file, check its SDK version as well.

For example:

{
  "sdk": {
    "version": "11.0.100"
  }
}

Use an SDK version that is actually installed in your development or build environment.

This prevents the CLI from selecting an older SDK when building the solution.

Step 3: Keep Your Existing Controllers

Now let's look at the most important part of this migration.

Suppose your .NET 10 application contains the following controller:

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpGet]
    public IActionResult GetProducts()
    {
        var products = new[]
        {
            new { Id = 1, Name = "Laptop", Price = 65000 },
            new { Id = 2, Name = "Keyboard", Price = 2500 }
        };

        return Ok(products);
    }

    [HttpGet("{id:int}")]
    public IActionResult GetProduct(int id)
    {
        return Ok(new
        {
            Id = id,
            Name = "Laptop",
            Price = 65000
        });
    }

    [HttpPost]
    public IActionResult CreateProduct(
        [FromBody] ProductRequest request)
    {
        return CreatedAtAction(
            nameof(GetProduct),
            new { id = 3 },
            request);
    }
}

public record ProductRequest(
    string Name,
    decimal Price);

This controller uses standard ASP.NET Core MVC features.

After changing the project target framework to .NET 11, you do not need to rewrite these actions.

The routing attributes, action methods, model binding, and response types continue working.

This is important for applications containing dozens or hundreds of controllers. A framework upgrade should not automatically become a controller refactoring project.

Step 4: Review Program.cs

The next place to check is the application's startup configuration.

A typical .NET 10 application might contain:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

builder.Services.AddScoped<IProductService, ProductService>();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseAuthentication();

app.UseAuthorization();

app.MapControllers();

app.Run();

This configuration remains a valid starting point in .NET 11.

The controller registration, dependency injection, authentication, authorization, and endpoint mapping do not need to be replaced with a different programming model.

However, review custom middleware and framework integrations before deployment.

For example, .NET 11 introduces automatic CSRF protection for endpoints that require antiforgery validation. MVC actions using [ValidateAntiForgeryToken] or [AutoValidateAntiforgeryToken] participate in this behavior.

A normal JSON-based Web API action using [HttpPost] does not automatically become subject to form antiforgery validation simply because the application targets .NET 11.

This distinction is important when troubleshooting unexpected HTTP 400 responses after an upgrade.

Step 5: Update Framework-Related NuGet Packages