Novità .Net 11
Novità .NET 11
Il 10 novembre 2026 Microsoft ha rilasciato .NET 11, una release a supporto standard (STS) di due anni che porta con sé C# 15 con le union types, un SDK più veloce, un runtime ancora più ottimizzato, ASP.NET Core con validazione asincrona e OpenAPI 3.2 e i primi componenti Blazor pensati per le interfacce con agenti AI. In questo articolo vediamo cosa cambia per chi sviluppa ogni giorno, con piccoli esempi di codice da provare subito.
Una scena del keynote di apertura di .NET Conf 2026 riassume bene lo spirito di questa release. Scott Hanselman ha ripescato il minuscolo sistema operativo virtuale che scrisse come progetto universitario ai tempi di .NET 1.0, nei primi anni Duemila, e lo ha fatto girare su .NET 11: floppy virtuali, memoria osservabile in tempo reale e perfino l’effetto «vetro CRT». Il codice di allora vive ancora, su una piattaforma che nel frattempo è diventata open source, multipiattaforma e orientata all’intelligenza artificiale. È la dimostrazione più concreta di una parola che Damian Edwards ha ripetuto più volte: durevolezza.
Ci rivolgiamo a sviluppatori .NET, ingegneri informatici e sviluppatori web: partiamo dalle date, poi entriamo nel dettaglio di linguaggio, runtime, web, Blazor e AI.
Indice dei contenuti – Novità .Net 11
1. Quando esce .NET 11 e che tipo di release è
2. Le novità principali in sintesi
3. C# 15: union types e closed hierarchies
4. C# 15: le altre novità del linguaggio
6. SDK e CLI: meno attese nel lavoro quotidiano
7. ASP.NET Core 11: API, validazione e OpenAPI
9. Componenti AI e sviluppo agentico
10. Come iniziare e pianificare l’aggiornamento
11. Conclusioni: la formazione continua come vantaggio competitivo
1. Quando esce .NET 11 e che tipo di release è
La data da segnare è il 10 novembre 2026: quel giorno il team .NET ha pubblicato l’annuncio ufficiale sul blog e ha reso disponibile il download, in concomitanza con l’apertura di .NET Conf 2026, in programma dal 10 al 13 novembre. Le prime due giornate sono dedicate ai team di prodotto, le ultime due alla community. Nel keynote, Damian Edwards ha spiegato che la distribuzione era in corso proprio in quelle ore.
Il dettaglio da non trascurare riguarda il ciclo di vita. .NET 11 è una release Standard Term Support (STS) con due anni di supporto. STS e LTS hanno le stesse politiche di qualità e di servicing: cambia solo la durata. .NET 10 resta l’opzione LTS per chi preferisce un orizzonte più lungo.
C’è poi una scadenza che riguarda molti team: .NET 8 e .NET 9 raggiungono la fine del supporto il 10 novembre 2026, lo stesso giorno del lancio. Chi è ancora su queste versioni deve pianificare il passaggio a .NET 10 o a .NET 11. Dietro la release ci sono oltre 7.000 contributor, e NuGet supera i 589.000 pacchetti unici: numeri che raccontano un ecosistema tutt’altro che fermo.
2. Le novità principali in sintesi
Iniziamo a raccontare le Novità .Net 11. Prima di entrare nei dettagli, ecco la mappa delle novità che l’annuncio ufficiale mette in evidenza:
- C# 15: union types e closed hierarchies, con controlli di esaustività del compilatore.
- SDK e CLI: host Native AOT per la CLI e MSBuild server mantenuto «caldo» tra un comando e l’altro.
- ASP.NET Core: validazione asincrona, OpenAPI 3.2, novità per Blazor e SignalR.
- Blazor AI components: componenti sperimentali integrati con il protocollo AG-UI per esperienze web agentiche.
- AI in .NET: Microsoft.Extensions.AI, MCP per l’integrazione di strumenti e Microsoft Agent Framework per agenti e workflow.
- Strumenti agentici: .NET Skills, .NET MAUI DevFlow e .NET Upgrade canvas.
- .NET MAUI: CoreCLR diventa il runtime predefinito.
- Librerie: compressione Zstandard, API Process più semplici, adattatori di stream in memoria, supporto JSON per le union e LINQ FullJoin.
Nelle prossime sezioni ci concentriamo su ciò che interessa di più a chi scrive C# e applicazioni web.
3. C# 15: union types e closed hierarchies – Novità .Net 11
Immaginate di scrivere un metodo che restituisce “un animale domestico”. Nel vostro dominio i candidati sono cani, gatti e uccelli, ma nel codice quelle classi non hanno nulla in comune. Finora l’unica strada era un tipo base comune, spesso object, con il risultato che nello switch poteva entrare qualsiasi cosa, perfino uno squalo. Mads Torgersen, nel keynote, ha scelto proprio questo esempio per presentare la novità più attesa di C# 15: le union types.
Pet pet = new Dog("Rex");
string name = pet switch
{
Dog d => d.Name,
Cat c => c.Name,
Bird b => b.Name,
};
public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);
public union Pet(Cat, Dog, Bird);
La parola chiave union dichiara un tipo i cui case type sono elencati tra parentesi. Il compilatore genera conversioni implicite da ciascun case type e verifica che lo switch sia esaustivo: niente ramo default «di sicurezza» e niente warning. Un tipo che non fa parte dell’union, come lo squalo, non si converte implicitamente e quindi non può finire nella vostra collezione.
La parte più interessante arriva quando il modello evolve. Se aggiungete un criceto all’union, ogni switch che non lo gestisce segnala subito il problema: il controllo di esaustività diventa finalmente un alleato. Chiarezza e sicurezza servono a chi legge il codice, che sia una persona o un agente AI, e Torgersen sottolinea proprio questo aspetto.
Le union servono per combinare tipi esistenti. Quando invece siete voi a possedere la gerarchia, C# 15 introduce le closed hierarchies: una classe marcata closed può essere derivata solo nell’assembly che la dichiara, quindi il compilatore conosce tutti i discendenti diretti.
public closed record class GateState;
public record class Closed : GateState;
public record class Open(float Percent) : GateState;
string Describe(GateState state) => state switch
{
Closed => "closed",
Open(var percent) => $"{percent}% open",
// Nessun warning: ogni discendente diretto è gestito.
};
Due dettagli utili: una classe closed è implicitamente abstract e la derivazione non è transitiva, quindi per estendere l’esaustività ai livelli più bassi bisogna marcare closed anche i discendenti intermedi. Entrambe le funzionalità non richiedono la versione preview del linguaggio: C# 15 è la versione predefinita per i progetti che puntano a net11.0.
4. C# 15: le altre novità del linguaggio – Novità .Net 11
Oltre alle union, C# 15 porta alcune migliorie pensate per il codice di tutti i giorni. La prima sono gli argomenti nelle collection expression: con un elemento with(…) in prima posizione potete passare parametri al costruttore o al metodo factory della collezione senza rinunciare alla sintassi compatta.
string[] values = ["one", "two", "three"];
// Capacità iniziale per List<T>
List<string> names = [with(capacity: values.Length * 2), .. values];
// Comparer per HashSet<T>: contiene un solo elemento
HashSet<string> set =
[with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO", "hello"];
Arrivano poi gli extension indexers, cioè indicizzatori dichiarati in un blocco extension, e i break e continue con etichetta, che eliminano i flag booleani e i goto usati per uscire da cicli annidati:
outer: for (int row = 0; row < grid.Height; row++)
{
for (int column = 0; column < grid.Width; column++)
{
if (grid[row, column].IsBlocked) continue outer;
if (grid[row, column].IsGoal) break outer;
}
}
Completa il quadro il supporto ai membri statici non virtuali delle interfacce anche su runtime meno recenti.
Capitolo a parte per la memory safety, ancora in preview. L’idea è legare il contesto unsafe alle operazioni che accedono davvero alla memoria non gestita, non alla semplice presenza di puntatori. Alcune operazioni, come dichiarare un puntatore o usare fixed, non richiedono più un contesto unsafe con la versione preview del linguaggio, mentre la dereferenziazione lo richiede ancora. Nasce anche l’espressione unsafe(…), utile dove un blocco unsafe non può comparire, per esempio in un inizializzatore di campo:
// Richiede LangVersion=preview e AllowUnsafeBlocks
static readonly int Signature = unsafe(ReadSignature());
Per le regole aggiornate serve anche il flag di compilatore updated-memory-safety-rules. Nel keynote, Rich Lander ha spiegato che la proprietà AllowUnsafeBlocks resta falsa per impostazione predefinita e che l’obiettivo è portare la funzionalità in produzione in .NET 12. Il contesto è noto: secondo i dati citati dal team, circa il 70% delle vulnerabilità deriva da problemi di sicurezza della memoria.
5. Performance e Runtime
Continuiamo con le Novità .Net 11. Il motto di Damian Edwards, “le prestazioni sono una funzionalità”, si vede nella quantità di lavoro di ottimizzazione di questa release. Per un viaggio completo tra benchmark e codice, l’articolo di Stephen Toub sulle performance di .NET 11 resta il riferimento: parla di centinaia di ottimizzazioni tra runtime e librerie. Qui ci limitiamo a ciò che cambia nel vostro codice senza riscriverlo.
JIT più intelligente. Il compilatore elimina più controlli sui limiti degli array, migliora la devirtualizzazione e piega più operazioni in costanti. Un esempio: dopo l’inlining, il JIT può risolvere a compile time un confronto tra stringhe note.
static bool IsAdmin(string role) => role == "Admin";
// Se IsAdmin viene inlinato in un chiamante che passa "Guest",
// il JIT vede "Guest" == "Admin" e lo riduce a false.
Native AOT e ReadyToRun. Il dispatch delle interfacce in Native AOT passa da un helper condiviso, che riduce il codice nei punti di chiamata e migliora il throughput. In ReadyToRun, i comparer predefiniti (Comparer<T>.Default ed EqualityComparer<T>.Default) sono ora specializzati, con miglioramenti fino a 20 volte in alcune operazioni su collezioni, secondo i benchmark della documentazione.
Runtime Async. È la novità che ha più fascino per chi scrive codice asincrono. Oggi il compilatore C# trasforma ogni metodo async in una macchina a stati. Con Runtime Async è il runtime a gestire sospensione e ripresa, quindi niente classi di state machine generate. Nel keynote è stato mostrato un caso di completamento sincrono con allocazioni costanti a zero byte al variare della profondità dello stack. Un effetto concreto è lo stack trace “dal vivo”, quello che vedono profiler e debugger: nell’esempio della documentazione si passa da 13 frame con infrastruttura visibile a 5 frame con la vera catena di chiamate.
<PropertyGroup>
<Features>runtime-async=on</Features>
</PropertyGroup>
Attenzione: Runtime Async è ancora una funzionalità in preview e va attivata esplicitamente nel progetto. Le librerie del runtime sono già compilate con questa modalità, mentre per il codice della vostra applicazione l’adozione è una scelta separata: provatela in un ambiente di test, controllando dipendenze e diagnostica. Il keynote indica come aspettativa di renderla predefinita in .NET 12.
Hardware minimo aggiornato. Un cambiamento che può sorprendere: il baseline x86/x64 passa a x86-64-v2 e, su Windows Arm64, è richiesto il set di istruzioni LSE. Su hardware troppo vecchio .NET 11 non parte. Se gestite macchine datate o ambienti virtualizzati con CPU emulate, verificate prima dell’aggiornamento.
Tra le novità minori ma preziose: il report di crash in-process, ora disponibile anche su Linux e macOS, che registra stack trace gestito, moduli e stato del runtime prima che il processo termini. Come sempre, misurate sul vostro carico reale: throughput, avvio, memoria e dimensione dipendono dal workload.
6. SDK e CLI: meno attese nel lavoro quotidiano
Entriamo nel pratico con le Novità .Net 11. Chad Husk ha aperto la sezione sul CLI con un dato che fa sorridere: l’utilizzo della CLI è circa triplicato in un anno, anche per effetto degli strumenti agentici. Era quindi inevitabile lavorare su velocità e copertura dei comandi.
- CLI Native AOT: l’host della CLI è compilato Native AOT, quindi comandi come help e version partono senza avviare la CLI gestita, tagliando centinaia di millisecondi di overhead.
- MSBuild server sempre caldo: resta attivo tra un’invocazione e l’altra, riducendo il lavoro ripetuto. Nel keynote è stata citata anche la modalità multi-thread, attivabile con il flag -mt.
- File-based app più mature: possono includere altri file sorgente con #:include, e più comandi (come dotnet package add e dotnet reference add) funzionano con loro.
- dotnet watch e dotnet run: watch gestisce meglio i crash dell’applicazione e si integra con Aspire, mentre run chiede interattivamente framework, runtime identifier o dispositivo.
- Container e test: pubblicazione di immagini riproducibili con SOURCE_DATE_EPOCH, timeout e limiti di errore per dotnet test con Microsoft.Testing.Platform.
- NuGet: nuova impostazione per un’età minima di pubblicazione dei pacchetti, utile come ulteriore politica di prudenza, non come sostituto dei controlli sulle vulnerabilità.
- dotnetup: nuovo gestore di toolchain in public preview per installare e aggiornare SDK e runtime nel proprio account utente.
7. ASP.NET Core 11: API, validazione e OpenAPI – Novità .Net 11
Per Dan, product manager di ASP.NET Core, il filo conduttore è costruire software di cui ci si può fidare. Nel suo demo un’applicazione di assistenza clienti gestisce un reso che può essere un rimborso oppure una sostituzione: un caso perfetto per le union, che ASP.NET Core supporta ovunque si usi System.Text.Json, cioè nei body JSON di Minimal API ed MVC. Niente wrapper e niente discriminatori: viene serializzato il case attivo.
public record Refund(decimal Amount);
public record Replacement(string Model);
public union Resolution(Refund, Replacement);
app.MapGet("/returns/{id}", (int id) =>
id % 2 == 0
? new Resolution(new Refund(49.90m))
: new Resolution(new Replacement("Dock-X2")));
Nel documento OpenAPI l’endpoint viene descritto con uno schema anyOf che elenca i case type. Il supporto riguarda i body JSON, non il binding da route, query string, header o form. Se più case hanno la stessa forma JSON serve un classificatore con l’attributo [JsonUnion].
Validazione asincrona. Finora le regole che richiedevano I/O (un controllo su database o una chiamata remota) erano scomode. Ora si derivano da AsyncValidationAttribute e funzionano sia con le Minimal API sia con i form Blazor:
public sealed class UniqueEmailAttribute : AsyncValidationAttribute
{
protected override ValidationResult? IsValid(object? value, ValidationContext context) =>
throw new InvalidOperationException("Usare IsValidAsync.");
protected override async Task<ValidationResult?> IsValidAsync(
object? value, ValidationContext context, CancellationToken ct)
{
var users = context.GetRequiredService<IUserService>();
if (value is string email && await users.EmailExistsAsync(email, ct))
return new ValidationResult("Email già registrata.");
return ValidationResult.Success;
}
}
builder.Services.AddValidation();
OpenAPI 3.2 di default. I documenti generati puntano ora alla versione 3.2, che tra l’altro descrive il payload di ogni evento nei flussi Server-Sent Events. Se un generatore di client o un altro strumento della toolchain non la supporta ancora, potete scegliere esplicitamente una versione precedente:
builder.Services.AddOpenApi(options =>
{
options.OpenApiVersion = Microsoft.OpenApi.OpenApiSpecVersion.OpenApi3_1;
});
Altre novità utili per chi lavora sul web:
- Protezione CSRF automatica: nel demo del keynote una richiesta da un’altra origine veniva respinta grazie agli header Fetch Metadata, senza token antiforgery. Nei Blazor Web App la chiamata esplicita a UseAntiforgery non è più necessaria e non compare nel template.
- SignalR: refresh dell’autenticazione senza riconnessione, anche nel client TypeScript, e annullamento dal client delle invocazioni degli hub.
- Attributo [ShortCircuit]: fa eseguire un endpoint subito dopo il routing, saltando il resto della pipeline (utile per health check e robots.txt).
- Zstandard: supporto per compressione delle risposte e decompressione delle richieste, abilitato di default.
- OpenTelemetry nativo: ASP.NET Core aggiunge direttamente gli attributi semantici HTTP all’activity del server, senza libreria di instrumentation aggiuntiva.
- Kestrel: parser HTTP/1.1 senza eccezioni per le richieste malformate, con miglioramenti di throughput fino al 20-40% in quegli scenari.
8. Blazor in .NET 11
Passiamo alle Novità .Net 11 in Blazor. Blazor riceve molte rifiniture pratiche, soprattutto sul rendering statico e sulle prestazioni percepite. Le più interessanti per un team web sono queste.
CacheView. Memorizza il markup renderizzato di un sottoalbero di componenti durante lo static SSR. In caso di cache hit i componenti figli non vengono nemmeno istanziati:
<CacheView VaryByQuery="category" ExpiresAfter="TimeSpan.FromMinutes(5)">
<ProductList Category="@Category" />
</CacheView>
Form più reattivi. Lo static SSR ottiene la validazione lato client per i form con DataAnnotationsValidator, e gli EditForm attendono end-to-end le regole asincrone. Potete mostrare lo stato con IsValidationPending:
<InputText @bind-Value="model.Username" />
@if (editContext.IsValidationPending(() => model.Username))
{
<span>Controllo disponibilità in corso...</span>
}
<ValidationMessage For="() => model.Username" />
Risparmio di risorse sul server. La pausa automatica del circuito quando la scheda del browser resta nascosta libera memoria e connessioni SignalR. È una funzionalità opt-in, fornita dal pacchetto Microsoft.AspNetCore.Components.Server.AutoPause:
app.MapRazorComponents<App>()
.WithBrowserOptions(options =>
options.AddAutoPause(p => p.HiddenDelay = TimeSpan.FromSeconds(30)));
Altre novità da tenere d’occhio:
- TempData e dati di sessione persistenti durante lo static SSR, con gli attributi [SupplyParameterFromTempData] e [SupplyParameterFromSession].
- Virtualize più robusto: supporta altezze variabili, offre InitialItemIndex e ScrollToItemAsync, e ha un nuovo parametro AnchorMode (utile, ad esempio, per le chat).
- QuickGrid con paginazione e ordinamento nell’URL, quindi link condivisibili, e il nuovo evento OnRowClick.
- IHostedService e variabili d’ambiente in IConfiguration anche in Blazor WebAssembly.
- Nuovo server di sviluppo leggero (Microsoft.AspNetCore.Components.Gateway) per le app WebAssembly standalone.
- Configurazione del comportamento del client direttamente da C# con WithBrowserOptions, al posto di Blazor.start scritto a mano.
9. Componenti AI e sviluppo agentico
Luis, che guida il prodotto delle librerie AI di .NET, ha riassunto un messaggio che vale per molti progetti esistenti: non serve riscrivere l’applicazione per avere l’AI, basta aggiungere capacità nuove. Il suo esempio è Jellyfin, un media server open source in .NET a cui è stata aggiunta la ricerca semantica con le librerie AI di .NET.
Le fondamenta. Microsoft.Extensions.AI (MEAI) offre astrazioni come IChatClient e IEmbeddingGenerator, componibili con dependency injection, cache e OpenTelemetry. Sopra, il Microsoft Agent Framework (MAF) aggiunge agenti che chiamano strumenti e mantengono lo stato della conversazione, più workflow che coordinano agenti e codice applicativo. Per esporre le vostre funzionalità agli agenti c’è MCP, e il template dell’SDK permette di partire in un comando:
dotnet new mcpserver -o MyMcpServer
Blazor AI components. Il nuovo pacchetto Microsoft.AspNetCore.Components.AI offre componenti per chat in streaming, rendering di rich text e di tool, flussi di approvazione umana e stato condiviso. Con qualsiasi IChatClient funziona la chat di base; per un agente remoto, l’integrazione AG-UI trasporta risposte in streaming, eventi dei tool e richieste di approvazione tra endpoint ASP.NET Core e interfaccia Blazor. Potete personalizzare il rendering dei blocchi di risposta:
<ChatPage Agent="agent">
<MessageListContent>
<BlockRenderer TBlock="RichContentBlock" Context="block">
<div class="agent-response">@block.RawText</div>
</BlockRenderer>
</MessageListContent>
</ChatPage>
Attenzione: il pacchetto dei Blazor AI components è sperimentale e resta prerelease per tutto .NET 11, quindi è un’occasione per provare la direzione e dare feedback, non una componente stabile del framework condiviso. Lo stesso vale per l’integrazione AG-UI nell’hosting ASP.NET Core e per le funzionalità di ricerca vettoriale di EF Core su SQL Server.
Strumenti per sviluppare con gli agenti. Il team ha pubblicato .NET Skills, un insieme curato di competenze che guidano gli agenti di coding sui temi .NET (Entity Framework, Blazor, MAUI e altri), con una dashboard di valutazione che misura risparmio di tempo e token. Il toolkit sperimentale .NET MAUI DevFlow permette a un agente di ispezionare albero visuale e screenshot dell’app in esecuzione, mentre il .NET Upgrade canvas mostra l’avanzamento di un aggiornamento guidato da GitHub Copilot. Dal keynote emergono anche dati sul lavoro sugli strumenti: la nuova versione di Roslyn riduce fino al 50% l’uso di memoria con più agenti attivi, e la riprogettazione di C# Dev Kit 11 promette caricamenti del workspace molto più rapidi, secondo i test presentati.
10. Come iniziare e pianificare l’aggiornamento
Installate l’SDK di .NET 11 e usate una versione compatibile e aggiornata di Visual Studio 2026 oppure Visual Studio Code con C# Dev Kit. Per un primo esperimento:
dotnet new console -n HelloDotnet11 -f net11.0
dotnet run --project HelloDotnet11
Poi incollate nel Program uno degli esempi delle sezioni precedenti per provare union e closed hierarchies. Per un’applicazione esistente, l’annuncio ufficiale suggerisce un percorso in quattro passi:
- aggiornare la selezione dell’SDK in global.json, se il repository la fissa, e installare l’SDK corrispondente su macchine di sviluppo e build agent;
- portare i target framework a .NET 11, preservando eventuali suffissi di piattaforma, e aggiornare pacchetti e workload;
- leggere le breaking changes di .NET 11, compresi i nuovi requisiti minimi di CPU: installare un nuovo SDK non basta a riportare l’app sulla nuova versione;
- eseguire i test e misurare l’applicazione con un carico rappresentativo, verificando modalità di pubblicazione, immagini container, dipendenze native e host di destinazione.
Se arrivate da una release candidate, passate agli SDK, runtime, pacchetti e workload finali. Ricordate anche che EF Core 11 richiede .NET 11 e che .NET MAUI segue una propria politica di supporto, distinta da quella del runtime.
11. Conclusioni: la formazione continua come vantaggio competitivo
Venticinque anni di .NET raccontano una verità semplice: il nostro mestiere cambia di continuo. Siamo passati da Windows e SOAP al web, poi al mobile, al cloud multipiattaforma e oggi all’intelligenza artificiale e allo sviluppo con agenti. Nel keynote è stato detto che questo è probabilmente l’anno che ha cambiato di più lo sviluppo software, e che siamo solo all’inizio. .NET 11, con le union di C# 15, Runtime Async, ASP.NET Core più solido e i componenti AI, è l’ennesimo passo di un percorso che non si ferma.
In un contesto così, la formazione continua del team IT è l’unico strumento che permette alle persone di restare aggiornate su un settore che cambia. Una piattaforma durevole non basta: servono competenze che si rinnovano con la stessa velocità, per evitare che il debito tecnico e il divario di conoscenze rallentino i progetti.
Innovaformazione offre corsi per sviluppatori in ambito Microsoft .NET. Potete consultare il catalogo QUI: Se le esigenze della vostra azienda sono specifiche, è possibile attivare corsi personalizzati su richiesta, costruiti sui progetti e sulle tecnologie del vostro team.
- Modalità: online in classe virtuale.
- Calendario: da concordare con l’azienda.
- Finanziamenti: accesso ai fondi Fondimpresa per la formazione gratuita dei dipendenti.
Contatti
Richiedete informazioni e un preventivo scrivendo a info@innovaformazione.net oppure chiamando il
numero 347 1012275 (Dario Carrassi).
Per altri articoli tecnici consigliamo di navigare sul nostro blog QUI.
Articoli correlati
Claude Code con Arduino
Backdoor nei modelli AI open-weight
Opportunità di lavoro Bari
Spieghiamo il Weight space programming
Guida Unsloth AI Locale
