-----------------------------------

Acquista i software ArcGIS tramite Studio A&T srl, rivenditore autorizzato dei prodotti Esri.

I migliori software GIS, il miglior supporto tecnico!

I migliori software GIS, il miglior supporto tecnico!
Azienda operante nel settore GIS dal 2001, specializzata nell’utilizzo della tecnologia ArcGIS e aderente ai programmi Esri Italia Business Network ed Esri Partner Network

-----------------------------------



Visualizzazione post con etichetta .NET 11. Mostra tutti i post
Visualizzazione post con etichetta .NET 11. Mostra tutti i post

venerdì 30 ottobre 2026

LINQPad 9 — Beyond LINQ - Runtime Internals, C# 15 Preview, SQL Server 2025 Vector Search, AI Agents, MCP & Advanced .NET Engineering

Un laboratorio per software architect: dalle expression trees al SQL generato, dal toolchain preview agli agenti con strumenti, fino a performance, sicurezza e risultati verificabili.

Executive summary: LINQPad come runtime di sperimentazione

LINQPad 9 unifica le codebase Windows e macOS e introduce un agente AI integrato. Il valore architetturale non consiste nel sostituire una IDE, ma nel ridurre il costo di una verifica tecnica: una query SQL, una pipeline LINQ, un parser, una API, un esperimento con un assembly o un modello linguistico diventano script eseguibili e osservabili.

Questo articolo separa sistematicamente tre piani: funzionalità documentate nelle note di rilascio fornite, laboratori C# riproducibili e considerazioni ingegneristiche da validare nel proprio ambiente. Non sono presentati benchmark numerici non misurati.

1. Architettura: script host, compilazione, runtime e confini

Uno script LINQPad vive in un contesto che risolve riferimenti, package NuGet, namespace, connessioni e modalità di esecuzione. La compilazione è distinta dal provider di accesso ai dati: il compilatore verifica C#, mentre il driver e il provider EF Core o LINQ-to-SQL decidono come una expression tree diventa SQL.

Script .linq / file .cs
↓
Compiler + references + source generators
↓
CLR / .NET runtime selezionato
↓
Query providers · HTTP · NuGet · external assemblies
↓
Dump / DataGrid / Charts / diagnostics

Non bisogna confondere un processo di scripting con un application host completo: lifecycle, dependency injection, secret management, osservabilità, deployment e isolamento richiedono scelte esplicite. Gli script che mutano sistemi esterni hanno effetti reali e devono essere trattati come codice operativo.

Le note 9.8 descrivono un host CLR C++ personalizzato per la selezione della versione .NET; le note principali descrivono una DataGrid riscritta con feed IPC ad alte prestazioni. Queste sono proprietà del prodotto, non garanzie di isolamento di sicurezza.

2. C# 15 preview: come verificare il toolchain effettivo

Le note 9.8 indicano: installare .NET 10 e .NET 11 Preview, attivare entrambe le opzioni preview in Settings → Scripts e utilizzare i sample “What’s new in C# 15”. Gli esempi includono union types, closed hierarchies, collection expression arguments e memory safety; la sintassi preview può cambiare e non va copiata senza verificare il compilatore.

using System;
using System.Runtime.InteropServices;

new
{
    Framework = RuntimeInformation.FrameworkDescription,
    Runtime = Environment.Version.ToString(),
    OS = RuntimeInformation.OSDescription,
    Architecture = RuntimeInformation.ProcessArchitecture.ToString()
}.Dump();

Il runtime effettivo non identifica da solo la versione del linguaggio. La versione del compilatore, la configurazione preview e il target framework vanno controllati separatamente. Per test di regressione, fissare esplicitamente le versioni e conservare lo script insieme ai risultati.

3. IEnumerable vs IQueryable: il punto in cui cambia l’esecuzione

IEnumerable<T> rappresenta un flusso di elementi elaborato con delegate .NET; IQueryable<T> conserva un albero di espressioni che un provider può tradurre. Il confine fra i due determina dove vengono eseguiti filtri, proiezioni e aggregazioni. AsEnumerable() non materializza da solo, ma sposta le operazioni successive verso LINQ-to-Objects.

var source = Enumerable.Range(1, 1_000_000);
var query = source.Where(x => x % 7 == 0).Select(x => x * 2);

// Deferred execution: la pipeline non è stata ancora enumerata.
var first = query.Take(5).ToArray();
first.Dump("Prime cinque righe");

// Per misurazioni attendibili: warm-up, più iterazioni,
// evitare Dump all'interno della regione misurata.

Per EF Core, verificare il SQL generato tramite ToQueryString() quando disponibile e confrontare il piano di esecuzione reale nel database. Una query apparentemente elegante può introdurre cardinalità elevate, round trip multipli, proiezioni eccessive o client-side processing.

4. SQL Server 2025: JSON, VECTOR e semantica dei provider

La versione 9.10 dichiara il mapping dei tipi SQL Server 2025 JSON e VECTOR nei driver LINQ-to-SQL ed EF Core. Le funzioni SQL sono esposte tramite SqlMethods nel driver LINQ-to-SQL e EF.Functions con EF Core 11+. Questo non significa che tutte le funzioni siano disponibili su ogni versione di EF Core o SQL Server.

-- Laboratorio SQL Server 2025: eseguire in SQL mode
-- su un database di test con supporto VECTOR abilitato.
SELECT TOP (10)
    Id,
    VECTOR_DISTANCE('cosine', Embedding, @queryVector) AS Distance
FROM dbo.Documents
ORDER BY Distance ASC;

La similarità vettoriale non equivale alla correttezza semantica. Occorre valutare normalizzazione degli embedding, scelta della metrica, dimensione dei vettori, filtri relazionali, cardinalità, piani SQL, costo CPU e qualità del retrieval con un dataset di valutazione. LINQPad è utile per ispezionare query e risultati, non sostituisce un benchmark ripetibile.

5. Operatori LINQ-to-SQL 9.10: traduzione e rischi

Le note 9.10 elencano LeftJoin, RightJoin, FullJoin (.NET 11), CountBy, MinBy, MaxBy, DistinctBy, Shuffle e altri operatori. string.Join su gruppi può essere tradotto in STRING_AGG. Queste sono capacità del driver LINQ-to-SQL LINQPad, non promesse generalizzabili a qualsiasi provider IQueryable.

// Query da eseguire con una connessione LINQ-to-SQL LINQPad
// che esponga la tabella Products.
var report = Products
    .GroupBy(p => p.Category)
    .Select(g => new
    {
        Category = g.Key,
        Names = string.Join(", ", g.Select(p => p.Name))
    });
report.Dump();

Controllare ordinamento, gestione dei null, collation, tipi numerici e traduzione del provider. Il fatto che una query compili non implica che sia stata eseguita sul server né che produca un piano efficiente.

6. DML set-based: ExecuteUpdate e ExecuteDelete

LINQPad 9.10 aggiunge ExecuteUpdate e ExecuteDelete al proprio driver LINQ-to-SQL. Operano senza caricare entità e senza passare per un change tracker. È un vantaggio per batch ampi, ma elimina anche eventuali controlli applicativi che normalmente avvengono nel ciclo di vita dell’entità.

// SOLO su database di test e dentro una transazione controllata.
// Esempi documentati dal driver LINQ-to-SQL di LINQPad:
Products.Where(p => p.Discontinued).ExecuteDelete();

Products.Where(p => p.Stock == 0)
    .ExecuteUpdate(s => s.SetProperty(
        p => p.Price, p => p.Price * 0.9m));

La 9.10 introduce anche TagWith e TagWithCallSite per correlare il LINQ al SQL generato. I tag migliorano la diagnostica, ma non sono un meccanismo di sicurezza né un sostituto della telemetria lato database.

7. PostgreSQL e scaffolding: enum, timestamptz e differenze temporali

LINQPad 9 introduce uno scaffolder PostgreSQL capace di gestire enum e timestamptz, oltre al filtro degli oggetti nello schema. È utile per database con migliaia di oggetti e per evitare conflitti fra nomi. La semantica di timestamp with time zone va distinta dalla rappresentazione di un fuso orario nominato: l’istante e l’offset originale non sono la stessa informazione.

Il confronto con SQL Server dovrebbe coprire mapping CLR, nullability, precisione temporale, collation, query parametrizzate, transazioni e comportamento del provider durante la traduzione.

8. LINQPad 9 come ambiente di test HTTP e JSON

Una query C# può invocare un endpoint REST senza scaffolding di un progetto. Questo rende LINQPad utile per isolare errori di serializzazione, autenticazione, negoziazione TLS e parsing. Occorre tuttavia imporre timeout, cancellation e gestione degli errori.

using System.Net.Http;
using System.Text.Json;

using var client = new HttpClient
{
    Timeout = TimeSpan.FromSeconds(10)
};

using var response = await client.GetAsync(
    "https://httpbin.org/json",
    HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();

await using var stream = await response.Content.ReadAsStreamAsync();
using var json = await JsonDocument.ParseAsync(stream);
json.RootElement.Clone().Dump(true);

Questo laboratorio richiede connettività Internet. Per dati aziendali o API protette usare endpoint di test autorizzati; non stampare bearer token, segreti o risposte contenenti informazioni riservate. Dump(true) su JsonDocument offre, dalla 9.9, un visualizzatore con outlining interattivo.

9. AI Agent: dal completamento al ciclo di verifica

La versione 9 introduce un coding agent capace di ottenere contesto, applicare diff, verificare errori di compilazione e proporre correzioni. Con 9.8 sono documentati tool per interrogare assembly, decompilare, leggere file, eseguire script esplorativi e recuperare URI. La 9.9 aggiunge Claude Code integrato con oltre 20 tool personalizzati; la 9.11 permette a Claude Code e Copilot, previo consenso, di accedere ai risultati del pannello principale e delle DataGrid.

Intent + scope autorizzato
↓
Agent → tool LINQPad → codice / query
↓
Compile → run → inspect output
↓
Tests + invarianti + diff review
↓
Accettazione umana / commit

Un compilatore può dimostrare che il codice è sintatticamente e tipologicamente valido, non che il comportamento sia corretto. Anche test generati dall’agente possono essere incompleti. Occorre separare osservazione, modifica e approvazione; un agente non deve poter autoattribuirsi privilegi attraverso testo o output di tool.

Le note 9.10 aggiungono controlli di sicurezza per Mark-of-the-Web, percorsi UNC e source mapping NuGet. Le note 9.11 introducono l’auto-approvazione persistente per operazioni classificate non distruttive: una lettura di file o una fetch web può comunque comportare divulgazione di dati; valutare l’ambiente e le policy prima di abilitarla.

10. AI Runtime: Util.AI.Ask e separazione fra API e provider

LINQPad 9.6 introduce una API per richiamare direttamente dagli script i modelli configurati nell’interfaccia. La documentazione conferma selezione del modello, streaming e cronologia, oltre agli esempi minimi seguenti.

// Richiede un provider AI configurato in LINQPad.
Util.AI.Ask("Explain special relativity").Dump();

var response = await Util.AI.Ask(
    "Explain why IQueryable is not IEnumerable").GetResponseAsync();
response.Text.Dump();

L’API è utile per prototipare classificazione, estrazione, RAG e agent workflows. Per un’applicazione di produzione è però preferibile separare il client LLM, le policy di retry, il controllo costi, la validazione JSON/schema e la telemetria dalla UI di sviluppo. La 9.0 dichiara supporto a OpenAI, Anthropic, Azure OpenAI, Azure Foundry, OpenRouter, GitHub Copilot ed endpoint compatibili; l’effettiva disponibilità dipende dalla configurazione e dalle credenziali.

11. MCP e reverse engineering controllato

Le note 9.9 indicano che Claude Code può essere personalizzato con istruzioni, skill e server MCP. Questo consente di utilizzare LINQPad come superficie di esplorazione di SDK e assembly: interrogare tipi, metodi, attributi e comportamenti con piccoli esperimenti, quindi produrre test ripetibili. MCP è un protocollo di collegamento ai tool, non una garanzia di correttezza o autorizzazione.

using System.Reflection;

var t = typeof(HttpClient);
var api = t.GetMethods(BindingFlags.Public | BindingFlags.Instance)
    .Where(m => m.Name.Contains("Send", StringComparison.Ordinal))
    .Select(m => new
    {
        m.Name,
        ReturnType = m.ReturnType.FullName,
        Parameters = string.Join(", ", m.GetParameters()
            .Select(p => $"{p.ParameterType.Name} {p.Name}"))
    });
api.Dump();

Per assembly esterni, il reverse engineering deve rispettare licenze, confidenzialità e perimetro autorizzato. Il modello non deve essere considerato una fonte autorevole per le firme delle API: verificarle contro metadata, IntelliSense, sorgente e test compilati.

12. Source generators e file-based apps

La 9.6 dichiara il supporto ai source generator .NET integrati, tra cui quelli per regex, JSON e interop. La versione principale supporta le direttive #:project e #:package e file-based apps C# 14, salvabili come .cs e avviabili anche con dotnet run.

#:package Humanizer.Core@*
using Humanizer;
Console.WriteLine(1234567.ToWords());

Per evitare accoppiamenti non necessari, separare il nucleo di calcolo in metodi o librerie .NET standard e lasciare .Dump() soltanto nel layer di ispezione. Il simbolo di compilazione LINQPAD permette percorsi diversi per l’esecuzione nell’host o nella CLI.

13. Visualizzazione: Dump, ECharts, HTML controls e Dataflow

LINQPad 9.7 introduce EChart e un rendering moderno tramite Apache ECharts; in Windows Util.Chart(...).DumpInline() oppure .ToEChart().Dump() selezionano il nuovo backend documentato. La versione include FlexBox, TabControl, MarkdownViewer e LatexViewer. La 9.6 aggiunge Util.Markdown.

Util.Markdown("# Report\n\n**Status:** OK").Dump();
Util.Latex(@"\int_0^\infty e^{-x^2} dx").Dump();

new [] {
    new { Stage = "Parse", Milliseconds = 12 },
    new { Stage = "Validate", Milliseconds = 8 },
    new { Stage = "Persist", Milliseconds = 23 }
}.Dump();

I grafici sono un mezzo per capire una pipeline, non una prova di performance. Separare la raccolta dei dati dal rendering; in particolare, misurare l’algoritmo senza Dump, serializzazione, UI e trasferimento IPC.

14. Benchmarking: metodologia per risultati difendibili

Per un confronto serio occorrono almeno: warm-up, numero sufficiente di iterazioni, controllo del garbage collector, stessa architettura CPU, stessa build .NET, stesso dataset, stesse condizioni del database, misurazioni P50/P95/P99 e intervalli di confidenza quando applicabili. Per microbenchmark del codice .NET, BenchmarkDotNet è normalmente più adatto di un singolo Stopwatch; LINQPad resta eccellente per esplorare il fenomeno.

using System.Diagnostics;

static long SumSquares(int n)
{
    long sum = 0;
    for (int i = 0; i < n; i++) sum += (long)i * i;
    return sum;
}

for (int i = 0; i < 100; i++) _ = SumSquares(100_000); // warm-up
var samples = new List<double>();
for (int i = 0; i < 50; i++)
{
    var sw = Stopwatch.StartNew();
    _ = SumSquares(100_000);
    sw.Stop();
    samples.Add(sw.Elapsed.TotalMilliseconds);
}
samples.Sort();
new { MedianMs = samples[samples.Count / 2],
      P95Ms = samples[(int)Math.Ceiling(samples.Count * .95) - 1] }.Dump();

15. Security engineering: trust boundaries, segreti e supply chain

La versione 9 memorizza i segreti nel Password Manager integrato, basato su Windows DPAPI o macOS Keychain. La 9.10 introduce screening di file provenienti da Internet, percorsi UNC e regole opzionali di source mapping per NuGet; la 9.11 avvisa prima di aprire link con schemi non riconosciuti. Sono mitigazioni importanti, ma non sostituiscono il principio del minimo privilegio.

SuperficieRischioControllo
SQL scriptsMutazioni non intenzionaliAccount read-only, transazioni e ambienti di test
AI tool callsEsfiltrazione, modifiche non approvatePermission gating, review, audit
NuGetSupply-chain compromiseVersion pinning, feed policy, source mapping
Dump / DataGridEsposizione dati sensibiliMascheramento, dataset sintetici
File esterniScript non attendibiliMark-of-the-Web, UNC screening, sandbox operativo

Un database connection string con privilegi amministrativi, uno script con DML e un agente con accesso al file system costituiscono un insieme ad alto rischio. Applicare controlli fuori dal prompt: credenziali limitate, segregazione degli ambienti, approvazione delle operazioni e logging indipendente.

16. LINQPad vs Visual Studio: complementarità, non sostituzione

LINQPad eccelle in sperimentazione, introspezione, query ad hoc, test di API, piccoli parser e analisi di output. Visual Studio e toolchain CI/CD restano centrali per grandi codebase, debugging distribuito, packaging, test suite strutturate, profiling, code review e deployment. La strategia più robusta è: esplorare in LINQPad → formalizzare in libreria/test → validare in CI.

Un prototipo che funziona in un host interattivo non dimostra che funzionerà sotto carico, in un servizio Windows, in un container, con un diverso account o dietro un reverse proxy. Portare in produzione richiede gestione delle dipendenze, configurazione, cancellazione, timeout, osservabilità e gestione degli errori.

17. Roadmap delle release 9.5–9.11

ReleaseInnovazioni documentate
9.5 / 9.4SQL-to-LINQ con AI, SQL completion, schema-aware agent
9.6Util.AI.Ask, source generators, Util.Markdown
9.7GitHub Copilot provider, ECharts, nuovi HTML controls
9.8Tool agentici, .NET 11/C# 15 preview, CLR host
9.9Claude Code, strumenti su assembly e progetti esterni, JSON outlining
9.10SQL Server 2025 JSON/VECTOR, LINQ-to-SQL avanzato, sicurezza file/NuGet
9.11Self-contained scripts, AI access ai risultati con consenso, nuovi controlli sicurezza

La disponibilità di singole funzioni può dipendere da licenza, piattaforma, runtime, provider e impostazioni. Verificare sempre la build installata e la pagina delle release note del prodotto.

18. Conclusioni: un laboratorio tecnico che produce evidenze

Il contributo più importante di LINQPad 9 è l’unione di esecuzione rapida, introspezione, accesso dati, visualizzazione e assistenza AI in un singolo ciclo di lavoro. Il valore reale emerge quando ogni ipotesi viene trasformata in un esperimento ripetibile e ogni risultato in un’evidenza verificabile.

Per un senior engineer, la regola resta invariata: non fidarsi di una query perché compila, di un agente perché risponde, o di un benchmark perché produce un numero. Verificare semantica, autorizzazioni, piani di esecuzione, condizioni di misura e limiti del toolchain.

Fonti e note metodologiche

  1. LINQPad 9 — What’s New, file HTML di release note fornito per la redazione dell’articolo (versioni 9.4–9.11).
  2. LINQPad — sito ufficiale.
  3. Microsoft Learn — C#.
  4. Microsoft Learn — Entity Framework Core.
  5. Microsoft Learn — SQL Server.
  6. Model Context Protocol — specifica.

Nota editoriale: le descrizioni delle funzionalità LINQPad sono basate sulle release note fornite. I laboratori C# sono esempi didattici; non è stata eseguita una sessione LINQPad 9 nel presente ambiente e non vengono dichiarati test di esecuzione o benchmark verificati. Le osservazioni architetturali sono analisi tecniche, non dichiarazioni del produttore.

lunedì 19 ottobre 2026

NicoGIS Tech Weekly — .NET 11 RC2, GeoAI Retrieval, Agent Skills e Durable AI Agents

Settimana del 12–18 ottobre 2026 · Pubblicazione: 19 ottobre 2026. Una release candidate, un cambio di rappresentazione nel runtime, una nuova frontiera per il retrieval geografico e un problema ancora irrisolto nei sistemi agentici: l'affidabilità delle operazioni esterne. Il punto comune non è il numero di nuove API, ma il luogo nel quale viene trasferita la complessità: dal compilatore al runtime, dalle coordinate agli embedding, dal programmatore alle convenzioni che guidano gli agenti, dall'esecuzione volatile alla persistenza dei workflow.

.NET 11 RC2: ottimizzare le astrazioni, non soltanto i cicli

Il 13 ottobre 2026 Microsoft ha rilasciato .NET 11 Release Candidate 2, con licenza go-live. Non è la versione finale; la compatibilità di applicazioni e dipendenze va verificata sui workload reali. Tra i cambiamenti specifici di RC2 figurano CborReader incrementale, API sperimentali di crittografia post-quantum, una nuova impostazione per la concorrenza iniziale HTTP/2 e modifiche comportamentali al file locking su iOS/tvOS. Fonti: annuncio .NET 11 RC2 (13 ottobre) · release notes delle librerie RC2.

Runtime async: il confine Task<T> non deve necessariamente diventare un oggetto

Il lavoro descritto da Stephen Toub in Performance Improvements in .NET 11 (15 settembre) è il contesto tecnico più importante per leggere la release. Il lowering classico di C# produce per ogni metodo async una state machine con MoveNext e un builder; un metodo A che attende B che attende C porta con sé confini logici spesso materializzati in task intermedi. In runtime async, invece, il compilatore emette IL più compatto e il runtime/JIT può usare una variante AsyncCall della chiamata per passare direttamente il risultato o collegare le continuation, evitando la materializzazione dei task intermedi quando non sono osservabili. Un'API che espone un Task continua a rispettare il suo contratto. Fonte: analisi originale del runtime e benchmark di Toub.

// Applicazione .NET 11: feature opt-in (non default)
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net11.0</TargetFramework>
    <Features>$(Features);runtime-async=on</Features>
  </PropertyGroup>
</Project>

La feature è opt-in per l'applicazione, mentre gran parte del framework incluso in .NET 11 è già compilato con questo meccanismo. Sono supportati Task, Task<T>, ValueTask e ValueTask<T>; async void, iteratori asincroni e alcuni task-like personalizzati mantengono il lowering tradizionale. Il guadagno dipende dalla forma della call chain e dalla quota di confini realmente eliminabili. Non equivale a una garanzia di zero allocazioni, né rende ValueTask obsoleto. Fonte: limiti e compatibilità di runtime async.

Analisi architetturale. Si riduce la penalità storica del codice fortemente composto in metodi asincroni brevi. Le astrazioni di dominio, i decorator, la telemetria e i livelli di servizio possono rimanere leggibili senza assumere che ogni await comporti necessariamente una nuova allocazione. Ma non è lecito estrapolare il vantaggio dalle catene sintetiche a un servizio dominato da database, rete o lock.

JIT, GC e JSON: tre ottimizzazioni con meccanismi distinti

Il JIT continua il lavoro di deabstraction: quando riesce a determinare il target effettivo di una chiamata virtuale, può devirtualizzare e rendere possibile l'inlining, aprendo la strada a constant propagation ed eliminazione di controlli superflui. Il beneficio non è “un'interfaccia più veloce” in astratto, ma una porzione più ampia di codice disponibile per l'ottimizzatore. Fonte: sezione JIT e devirtualization.

Sul fronte GC, il post documenta interventi alla gestione di metadata e handle durante le collection generazionali e ottimizzazioni Arm64: nei casi che sfruttano molti ConditionalWeakTable e dependent handles, l'età generazionale associata ai metadata condiziona quanta struttura il GC deve riesaminare. I microbenchmark pubblicati mostrano differenze importanti in configurazioni artificiali con centinaia di migliaia di handle; non sono un moltiplicatore di throughput applicativo. Fonte: sezione GC e dependent handles.

System.Text.Json sfrutta nuove scansioni basate su SearchValues per individuare byte da escapare o whitespace da saltare; una modifica al writer consente inoltre al JIT di dimostrare in anticipo che una sequenza escapata entra nel buffer, evitando bounds check ripetuti. Nel benchmark di Microsoft su una stringa volutamente satura di caratteri da escapare, la serializzazione passa da 30,83 μs (.NET 10) a 7,875 μs (.NET 11). È un caso di test mirato, non una previsione generale per i JSON REST. Fonte e codice riproducibile: JSON writer e reader in .NET 11.

HTTP/2: proteggere il burst prima del primo SETTINGS

Una novità di RC2 riguarda SocketsHttpHandler.InitialHttp2MaxConcurrentStreams. Prima che arrivi il frame SETTINGS del server, un client HTTP/2 non conosce ancora il limite effettivo di stream concorrenti della nuova connessione. La proprietà permette di impostare una soglia iniziale più bassa del default documentato di 100; dopo il frame SETTINGS prevale il valore annunciato dal peer. Un limite inferiore precedentemente osservato dallo stesso host può ridurre ulteriormente l'avvio. Fonte: API e semantica nelle release notes RC2.

using System.Net;
using System.Net.Http;

var handler = new SocketsHttpHandler
{
    InitialHttp2MaxConcurrentStreams = 32
};

using var client = new HttpClient(handler);
using var request = new HttpRequestMessage(HttpMethod.Get, "https://example.org/")
{
    Version = HttpVersion.Version20,
    VersionPolicy = HttpVersionPolicy.RequestVersionExact
};
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();

Valutazione. È un controllo di admission per il burst di avvio, non una sostituzione di rate limiting, backpressure e limiti di connessione. Per servizi con centinaia di richieste simultanee su connessioni appena aperte, questa impostazione merita un test che includa handshake, RTT, frame SETTINGS e numero di connessioni effettive; misurare soltanto il p50 su connessioni calde non basta.

Cryptography: “post-quantum” non significa interoperabilità automatica

Le nuove API sperimentali CompositeMLKem e Hpke richiedono controlli di supporto sulla piattaforma e opt-in agli avvisi sperimentali (SYSLIB5006 e SYSLIB5009). CompositeMLKem combina contributi classici e post-quantum; Hpke in RC2 implementa suite classiche DHKEM, non ancora suite HPKE ML-KEM o hybrid ML-KEM. Il supporto ML-KEM per destinatari CMS è documentato in RC2 per piattaforme non Windows. Fonte: precisazioni crittografiche della RC2.

Analisi. Nella progettazione di protocolli federati e applicazioni che scambiano chiavi, l'adozione dipende da profili standardizzati, suite negoziate, librerie delle controparti e policy di certificazione. Un'API sperimentale nel BCL non autorizza a modificare unilateralmente i wire format di OIDC, TLS o CMS.

Toolchain watch. Il 15 ottobre Microsoft ha presentato in preview dotnetup per macOS/Linux: installazione user-local di SDK/runtime side-by-side e rispetto dei vincoli global.json. È un miglioramento dell'ergonomia degli ambienti, non una sostituzione del pinning degli SDK nelle pipeline CI. Fonte: Introducing dotnetup (15 ottobre).

GeoAI: somiglianza semantica e vicinanza geografica non sono la stessa metrica

La documentazione ArcGIS Pro sugli embedding chiarisce un dettaglio infrastrutturale cruciale: la feature class risultante contiene un campo Embedding di tipo BLOB, con valori IEEE-754 Float32 little-endian contigui. Un vettore di dimensione D occupa esattamente 4 × D byte; quando transita in un Feature Service JSON viene veicolato in Base64. Non è un array di double e non contiene header o informazioni di modello: dimensione, versione e semantica del modello vanno gestite esternamente. Fonti: funzionamento del tool Generate Embeddings · formato BLOB e convenzioni di trasporto.

Il motore del retrieval: query polygon, aggregazione e coseno

Il tool Find Similar Features Using Embeddings prende una feature class di embedding e feature di query poligonali. Identifica gli embedding che intersecano i poligoni, ne calcola il vettore medio e confronta tale query aggregata con i candidati utilizzando la cosine similarity; la soglia filtra i risultati e l'output è una feature class. La ricerca opera sui vettori associati alle celle/feature, non sui pixel dell'immagine visualizzata nella mappa. Per la ricerca estesa Esri propone il tool di geoprocessing invece dell'esplorazione interattiva. Fonte: How Find Similar Features Using Embeddings works.

Query polygon
    | spatial overlap
    v
{e1, e2, ..., ek}    ->    q = mean(e1, ..., ek)
                                     |
                                     v
                         cosine(q, candidate_i)
                                     |
                        threshold + feature output
                                     |
                                     v
                            GIS result layer

Questo meccanismo stabilisce una relazione di similarità nel latent space del modello, non una relazione di prossimità euclidea o topologica. Due aree lontane possono essere semanticamente simili; due aree contigue possono essere molto diverse per uso del suolo, tipologia edilizia o contesto ambientale. Aumentare la soglia del coseno non equivale a restringere un buffer geografico.

Analisi: spatial-semantic retrieval a due stadi. Per casi d’uso con vincoli spaziali obbligatori, conviene eseguire prima un filtro geografico esatto (intersezione, buffer, confine amministrativo, area di competenza) e poi il ranking vettoriale all’interno dei candidati ammissibili. Una combinazione pesata tra distanza geografica e coseno è possibile, ma è una politica applicativa da calibrare: non è la semantica predefinita del tool Esri.

Filtro di ammissibilità:    A = {i : intersects(geometry_i, AOI)}
Ranking all'interno di A:  s_i = cosine(q, embedding_i)
Risultati:                  topK({i in A : s_i >= soglia})

Alternativa analitica (non API Esri):
score_i = alpha * cosine_i + (1 - alpha) * exp(-distance_km_i / tau)
con alpha in [0, 1], tau > 0 e distanze in km

Il ranking misto necessita di normalizzazione, scelta del parametro di decadimento spaziale e validazione su query reali. In particolare, la media di embedding all'interno di un poligono attenua configurazioni multimodali: un'area contenente sia infrastrutture industriali sia vegetazione può generare una query che non rappresenta bene nessuna delle due classi. Un test con più query poligonali o cluster distinti può essere preferibile alla media cieca.

GeoAI interpretabile: 256 dimensioni non sono 256 variabili leggibili

Nel workflow Esri pubblicato il 6 ottobre, gli USA Geodemographic Embeddings prodotti dal GDFM sono organizzati in quattro blocchi da 64 dimensioni: housing/household, environment, American Community Survey e age/race census. AutoML con SHAP misura l'importanza media assoluta delle singole dimensioni rispetto a uno specifico task predittivo; sommare le importanze di un blocco produce una attribuzione aggregata descrittiva, non una stima causale e nemmeno un vero SHAP di gruppo. Fonte: Interpret embeddings using AutoML and SHAP (6 ottobre).

Ad esempio, un valore elevato di embedding_137 non permette di concludere che la dimensione codifichi direttamente il reddito: è un fattore latente all'interno della vista ACS. Analogamente, la somma di mean(abs(SHAP)) non coincide necessariamente con il valore di mean(abs(sum(SHAP))). Per attribuire valore predittivo incrementale a un segmento occorrono studi di ablation, retraining o permutazioni congiunte e split spaziali adeguati. Fonte: avvertenze interpretative Esri.

Interoperabilità C# e costo dei dati

Un decoder indipendente da architettura può ricostruire il formato descritto da Esri senza assumere l'endianness della macchina. Il codice seguente è un esempio .NET senza dipendenze Esri; expectedDimensions deve venire dai metadata del modello effettivamente usato.

using System;
using System.Buffers.Binary;

static float[] ReadEmbedding(ReadOnlySpan<byte> blob, int expectedDimensions)
{
    if (expectedDimensions <= 0 || blob.Length != checked(expectedDimensions * 4))
        throw new ArgumentException("Unexpected embedding payload size");

    var result = new float[expectedDimensions];
    for (int i = 0; i < result.Length; i++)
    {
        int bits = BinaryPrimitives.ReadInt32LittleEndian(blob.Slice(i * 4, 4));
        result[i] = BitConverter.Int32BitsToSingle(bits);
    }
    return result;
}

Valutazione. Con 256 dimensioni, il payload grezzo per feature è 1.024 byte; un milione di feature corrisponde a circa 1,024 GB decimal di soli valori vettoriali, prima di geometrie, indici, overhead geodatabase, Base64 e copie in memoria. Questa è una semplice stima D×4×N, non un benchmark del motore Esri. È necessario conservare il model identity insieme ai dati ed evitare ranking incrociati fra versioni dello stesso encoder senza valutazione di compatibilità. Documentazione: storage degli embedding · tool e requisiti CPU/GPU/licenze.

Experience Builder: un Agent Skill è una specifica operativa, non una garanzia di correttezza

Esri ha pubblicato a settembre un Agent Skill open source per lo sviluppo di custom widget ArcGIS Experience Builder. Contiene regole di struttura, riferimenti alle API, separazione fra settings e runtime, indicazioni su data source, map view, tema, traduzioni e skeleton. La guida Esri descrive l'inserimento del pacchetto skills/arcgis-exb-widget-dev nelle cartelle riconosciute da agenti compatibili; l'estensione non sostituisce il progetto Developer Edition né compila automaticamente ogni widget. Fonti: articolo tecnico Esri (14 settembre) · repository SDK Resources e skill ufficiale.

Natural-language requirement
          |
          v
    Coding agent
       /      \
Skill references   Repository constraints
       \      /
       Generated widget
      /    |     \
manifest config  runtime/setting
       |       |       |
       +---- build + tests ----+
                 |
        runtime verification

Nel codice reale un widget deve rispettare le convenzioni del repository di estensioni, collocarsi sotto client/your-extensions/widgets/ (o repository equivalente), pubblicare un manifest.json corretto e distinguere configurazione persistita da codice di esecuzione. Un agente che genera un componente React visivamente plausibile ma aggira DataSourceComponent, JimuMapViewComponent o le API di configurazione non ha risolto il problema di integrazione. Fonti: getting started with widget development · contratto del manifest.

Esiste anche un vincolo di ciclo di vita verificabile: Esri ha annunciato il pensionamento dei Maps SDK for JavaScript widgets utilizzati dai custom widget nelle versioni interessate a partire da Q1 2027, raccomandando la migrazione a web components. Non significa che ogni custom widget Experience Builder smetterà di funzionare: la criticità riguarda quelli che dipendono dalle vecchie API widget del Maps SDK. Esri indica inoltre il passaggio a React 19 in Experience Builder 1.19 e successivi. Fonte: avviso ufficiale di retirement e perimetro di impatto.

Analisi architetturale. Uno skill di sviluppo diventa parte della supply chain: va versionato e verificato rispetto alla versione di Experience Builder effettivamente distribuita. Il controllo automatico deve verificare dipendenze Maps SDK deprecate, API Jimu usate, manifest, compatibilità del builder, bundle e smoke test in browser. Un agent skill riduce l’incertezza sulle convenzioni, ma non sposta la responsabilità della qualità dal maintainer all’agente.

Durable AI Agents: replay deterministico, side effect non deterministici

Il 12 ottobre Microsoft ha pubblicato una lettura concreta di Durable Task con scenari di provisioning Azure, approvazione umana, pagamenti, webhook e incident management. Il riferimento usato negli esempi è il Durable Task .NET SDK v1.26.0 con Durable Task Scheduler. La lezione architetturale è precisa: una cronologia persistente consente la ricostruzione deterministica del flusso, ma non garantisce exactly-once per le operazioni sui sistemi esterni. Fonte: Durable Task in the Real World (12 ottobre).

Incident -> Collect evidence -> Generate proposal -> Save proposal identity
                                                |
                                        Human approval
                                                |
                          proposal hash + authorized decision
                                                |
                                Execute remediation (idempotency key)
                                                |
                                   Read-back / reconciliation
                                                |
                                          Verification

In un workflow agentico la generazione del modello è un side effect: un retry può produrre un piano differente. L'output autorizzato deve avere identità immutabile e fingerprint dei parametri. Se un worker termina dopo che un provider ha eseguito l'operazione ma prima che la sua risposta sia registrata nell'orchestrazione, la ripartenza non può presumere che l'operazione sia fallita. Occorre interrogare il sistema esterno con una chiave stabile, riconciliare lo stato ed eventualmente marcare NeedsIntervention. Fonte: failure windows e riconciliazione documentati da Microsoft.

Analisi. Qui si separano tre livelli spesso confusi: deterministic replay dell'orchestrazione, idempotency dell'operazione applicativa e authorization dell'effetto richiesto. Un orchestratore può riprodurre la stessa decisione di workflow; non può rendere idempotente un pagamento, una DELETE, un deployment ARM o un tool MCP privo di meccanismi di deduplicazione e read-back. Nei sistemi agentici questa separazione è un confine di sicurezza, non soltanto una tecnica di recovery.

LLM/API lifecycle: il breaking change più costoso può arrivare dal modello, non dal codice

Nella settimana appena conclusa sono documentati due cambiamenti operativi rilevanti nell'API OpenAI. Il 14 ottobre è stata comunicata la deprecazione di snapshot GPT-4o, GPT-4o mini e GPT-4.1, con rimozione indicata al 14 gennaio 2027 e migrazione raccomandata verso gpt-6-luna. Il 15 ottobre GPT-Live ha aggiunto l'integrazione nativa con Decisions: decisioni attivabili tramite delega o dai delta di trascrizione in input/output. Fonti: tabella ufficiale delle deprecazioni · changelog API del 15 ottobre.

La Decisions API, introdotta in beta il 6 ottobre, espone classificazioni/valutazioni tipizzate (predicate, choice, score) e al momento documenta gpt-6-luna come modello supportato. Questo pattern è diverso dal tool calling generale della Responses API: è un percorso per decisioni strutturate su input testuali o visivi, non un runtime universale per tool e workflow. Fonte: riferimento POST /decisions.

Voice conversation (GPT-Live)
       |
 input/output transcript deltas
       |
   Decision evaluation
       |
 typed predicate / choice / score
       |
 policy checks + application authority
       |
      allowed action

Analisi. L'integrazione voice/decisions può ridurre il lavoro applicativo di instradamento dei segnali in scenari vocali a bassa latenza, ma crea un tema di consistenza: i transcript delta sono aggiornamenti intermedi e una decisione statistica non conferisce autorizzazione. Le azioni con effetti permanenti devono restare sotto controllo di un backend con identità, policy, conferma e journal. Anche con delega a Responses, le credenziali e il modello di autorizzazione devono restare nell'applicazione. Fonti: delegation, tools e responsabilità applicative · schema delle sessioni e trigger Decisions.

Per la migrazione dei modelli, il piano corretto non è sostituire una stringa in configurazione: occorre misurare regressioni su schemi JSON, tool use, politiche di rifiuto, latenza p95/p99, costo per task riuscito e probabilità di escalation. Un modello sostitutivo nominalmente consigliato dal provider non prova l'equivalenza sul dominio applicativo. È necessaria una suite di eval ripetibile con rollback e osservabilità per versione.

Technical Takeaways

  • Runtime async. Misurare le call chain reali: meno state machine materializzate non equivale a meno attese di I/O, né garantisce compatibilità perfetta di tooling non aggiornato.
  • .NET 11 RC2. HTTP/2, CBOR e crittografia sperimentale riguardano confini di protocollo: le prove di interoperabilità contano più dell'elenco di API.
  • GeoAI. Separare filtro spaziale e ranking semantico; conservare metadata del modello, definizione di soglia e unità geografiche insieme ai risultati.
  • SHAP. Spiegare un modello basato su embedding non significa recuperare causalità né il significato univoco delle coordinate latenti.
  • Experience Builder. Skills, repository conventions, version pinning e CI compongono un unico contratto tecnico; la migrazione ai web components è una verifica concreta di questo contratto.
  • Agenti durevoli. Replay deterministico, idempotenza e permessi sono tre problemi distinti. Il fallimento da testare è quello tra l'effetto esterno e il suo acknowledgement.
  • Model lifecycle. La scadenza di uno snapshot è un evento di release engineering: migrare con eval, canary, metriche e piano di ripristino.

Lab della settimana

Lab 1 — .NET 11: verificare la riduzione del lowering async

Prerequisiti: SDK .NET 11 RC2, shell e un progetto console. Copiare Program.cs qui sotto e aggiungere la proprietà Features in forma condizionale nel .csproj. Compilare due volte in Release, confrontando la dimensione della DLL; successivamente eseguire lo stesso carico con e senza opt-in per isolare throughput e allocazioni. La differenza di dimensione è osservabile direttamente, quella prestazionale va misurata per il workload. Protocollo e benchmark estesi: sorgenti originali dei benchmark · SDK RC2.

<PropertyGroup>
  <TargetFramework>net11.0</TargetFramework>
  <Features Condition="'$(RuntimeAsync)' == 'true'">$(Features);runtime-async=on</Features>
</PropertyGroup>
Console.WriteLine(await Steps.A());

static class Steps
{
    public static async Task<int> A() => await B();
    private static async Task<int> B() => await C();
    private static async Task<int> C()
    {
        await Task.Yield();
        return 42;
    }
}
dotnet build -c Release -p:RuntimeAsync=false -o classic --no-incremental
dotnet build -c Release -p:RuntimeAsync=true  -o runtime --no-incremental
# Confrontare la dimensione delle DLL nei due output.

Criterio di successo: la build si conclude in entrambe le configurazioni, l'output del programma è identico e la DLL viene confrontata separatamente dai file di runtime e dalle dipendenze. Con soli tre metodi il delta può essere modesto; il post Microsoft mostra anche un campione a dieci layer.

Lab 2 — ArcGIS Pro: retrieval vettoriale su query poligonale

Prerequisiti: ArcGIS Pro con licenza Advanced, una feature class di embedding compatibili e un layer poligonale che rappresenti la query. La generazione preventiva degli embedding richiede un model definition .emd/.dlpk e framework deep learning, con Image Analyst per embedding da immagini. I parametri qui sotto corrispondono all'API documentata. Fonti: Generate Embeddings Using AI Models · Find Similar Features Using Embeddings.

import arcpy

embedding_features = r"C:\lab\gis.gdb\embeddings"
query_features = r"C:\lab\gis.gdb\query_polygon"
output_features = r"C:\lab\gis.gdb\similar_results"

arcpy.geoai.FindSimilarFeaturesUsingEmbeddings(
    embedding_features, query_features, output_features, 0.75
)

Controlli: ripetere la query cambiando soltanto poligono e soglia; confrontare risultati ad alta similarità con un buffer geografico. Se una feature risulta semanticamente simile ma lontana, non è necessariamente un errore: è il comportamento che l'esperimento deve distinguere. Documentare modello, dimensione D, extent, dataset e percentuale di candidati che superano la soglia.

Lab 3 — Agent Skill per Experience Builder: A/B test sulle convenzioni

Usare lo stesso requisito e lo stesso coding agent in due directory pulite della stessa versione di Experience Builder Developer Edition: una senza skill e una con la cartella skills/arcgis-exb-widget-dev di Esri installata secondo le istruzioni dell'agente. Implementare un widget che scelga una feature layer nelle impostazioni e mostri al runtime il conteggio delle feature filtrate nella mappa attiva. Non cambiare prompt, agent model, dipendenze o versione del builder tra le prove. Fonti: tutorial dell’Agent Skill · repository ufficiale · guida ai custom widget.

Metriche: build pass/fail; errori di manifest; uso corretto delle API data source e Jimu map view; accessibilità e traduzioni; numero di correzioni manuali; numero di iterazioni dell'agente; test del widget nell'app pubblicata. Ripetere su più run, registrando anche i fallimenti: un singolo risultato riuscito non è una misura dell'affidabilità.

Riferimenti tecnici primari: Microsoft .NET 11 RC2 · Stephen Toub — Performance Improvements in .NET 11 · Esri — Generate Embeddings internals · Esri — Similar Features internals · Esri — AutoML/SHAP · Esri — Experience Builder Agent Skill · Microsoft — Durable Task · OpenAI API changelog.

mercoledì 14 ottobre 2026

.NET 11 RC2, C#, sicurezza e architettura

La crittografia post-quantistica non richiede di aspettare l'arrivo di un computer quantistico capace di violare RSA. Il rischio harvest now, decrypt later riguarda i dati cifrati oggi e conservati per essere decifrati in futuro. Con .NET 11 RC2 Microsoft amplia le primitive crittografiche disponibili in C#, introducendo API sperimentali per Composite ML-KEM e HPKE. Per comprendere la portata del cambiamento occorre distinguere algoritmi, protocolli, formati di chiave e disponibilità effettiva delle implementazioni native.

1. Perché RSA ed ECC richiedono una transizione

RSA ed ECC basano la propria sicurezza computazionale su problemi matematici per i quali l'algoritmo quantistico di Shor, eseguito su hardware sufficientemente potente e affidabile, offre una minaccia sostanziale. Gli algoritmi simmetrici come AES non sono colpiti nello stesso modo: Grover comporta un vantaggio quadratico teorico nella ricerca esaustiva, non una rottura equivalente. Questo spiega perché la migrazione interessa soprattutto scambio di chiavi e firme digitali.

2. Il punto di partenza è .NET 10

.NET 10 ha introdotto le classi MLKem, MLDsa, SlhDsa e CompositeMLDsa in System.Security.Cryptography. ML-KEM è un meccanismo di incapsulamento di chiavi, standardizzato da NIST FIPS 203; ML-DSA e SLH-DSA sono schemi di firma, rispettivamente FIPS 204 e FIPS 205. Le classi e i metodi possono avere stati di maturità differenti: alcune API restano marcate [Experimental].

3. KEM non significa cifratura dei documenti

Un KEM produce un segreto condiviso tra mittente e destinatario. Il segreto alimenta normalmente una KDF, dalla quale si ricava una chiave per un algoritmo simmetrico autenticato come AES-GCM. Il KEM non è un sostituto diretto di AesGcm.

Recipient public key
       |
       v
   KEM Encapsulate --------> Encapsulation ciphertext
       |
       v
   Shared secret
       |
       v
  Key derivation
       |
       v
     AES-GCM ------------> Encrypted payload + authentication tag

Recipient private key + encapsulation ciphertext
       |
       v
   KEM Decapsulate --> same shared secret

4. Composite ML-KEM: il nuovo tassello di .NET 11

La RC2 introduce API sperimentali per combinare un meccanismo post-quantum ML-KEM con un meccanismo classico. L'obiettivo dei KEM compositi è ottenere una costruzione che mantenga proprietà di sicurezza anche qualora una delle componenti risulti vulnerabile, secondo le ipotesi e il combiner specificati. Non è corretto concatenare arbitrariamente due segreti e chiamare il risultato 'hybrid secure': il formato, il contesto e la derivazione devono essere definiti da una specifica interoperabile.

Il supporto dipende dalla piattaforma, dai parametri algoritmici e dallo stato delle API sperimentali. Prima di introdurle in un protocollo occorre fissare una versione, verificare gli algoritmi disponibili e testare interoperabilità e downgrade resistance.

5. HPKE: un framework, non un singolo algoritmo post-quantum

Hybrid Public Key Encryption (HPKE) è un framework di cifratura che combina KEM, KDF e AEAD. Il nome 'Hybrid' non significa automaticamente 'classico + post-quantum': HPKE può essere implementato con suite completamente classiche. Nella RC2 il supporto .NET è sperimentale e le suite post-quantum ML-KEM/ibride non risultano ancora implementate. È quindi scorretto presentare la sola presenza di Hpke come prova che un'applicazione utilizzi già cifratura post-quantum end-to-end.

6. Firme post-quantum e certificati

ML-DSA e SLH-DSA rispondono a un problema differente dal KEM: autenticità e integrità. La transizione interessa certificati X.509, CA, trust store, TLS, HSM, firme di software e documenti. Un certificato firmato con un nuovo algoritmo non diventa utilizzabile ovunque soltanto perché il runtime conosce la primitiva: il sistema operativo, la catena di fiducia, il peer e il protocollo devono supportarlo. Microsoft sta sperimentando ecosistemi PKI post-quantum in ambienti controllati, non con certificati pilota pubblicamente trusted.

7. Laboratorio 1: capability detection in C#

Il primo test riproducibile consiste nel verificare il supporto delle primitive già introdotte in .NET 10. È preferibile a un esempio che presupponga l'esistenza di algoritmi nativi su qualsiasi sistema.

using System;
using System.Security.Cryptography;

Console.WriteLine($"ML-KEM supported: {MLKem.IsSupported}");
Console.WriteLine($"ML-DSA supported: {MLDsa.IsSupported}");
Console.WriteLine($"SLH-DSA supported: {SlhDsa.IsSupported}");

if (!MLKem.IsSupported)
{
    Console.Error.WriteLine("ML-KEM unavailable on this platform.");
    return;
}

Console.WriteLine("ML-KEM available: ready for platform-specific tests.");

Creazione del progetto: dotnet new console -f net11.0. Installare SDK .NET 11 RC2 e controllare la versione con dotnet --info. Su Linux il supporto dipende anche da OpenSSL (per le primitive .NET 10, Microsoft indica OpenSSL 3.5 o successivo). Non sopprimere indiscriminatamente i warning SYSLIB: sono indicatori di contratti ancora sperimentali.

8. Laboratorio 2: una firma ML-DSA in ambiente compatibile

La prova seguente mostra la struttura dell'API, da validare sulla piattaforma e sulla specifica build SDK utilizzata.

using System;
using System.Security.Cryptography;
using System.Text;

if (!MLDsa.IsSupported)
{
    Console.WriteLine("ML-DSA not supported on this host.");
    return;
}

byte[] message = Encoding.UTF8.GetBytes("Post-quantum signature test");
using MLDsa signer = MLDsa.GenerateKey(MLDsaAlgorithm.MLDsa65);
byte[] signature = signer.SignData(message);
bool valid = signer.VerifyData(message, signature);
Console.WriteLine($"Signature valid: {valid}");

La firma non cifra il messaggio. In un'applicazione reale, verificare sempre la provenienza della chiave pubblica, il formato di esportazione, l'identità del firmatario e le policy di rotazione.

9. Architettura di un servizio di cifratura crypto-agile

Application API
    |
    v
Cryptography abstraction
    |-- Algorithm policy / versioning
    |-- Key management / KMS / HSM
    |-- KEM + KDF
    |-- AEAD encryption
    |-- Signature validation
    |-- Telemetry (never log secrets)
    v
Versioned encrypted envelope
    |-- suite identifier
    |-- key identifier
    |-- encapsulated key
    |-- nonce
    |-- ciphertext
    |-- authentication tag

Un envelope cifrato dovrebbe includere identificatori di versione e suite, e associare metadati critici come additional authenticated data (AAD). Le chiavi non devono essere registrate nei log. Il cambio di algoritmo deve essere governato da policy, non da un fallback silenzioso verso suite più deboli.

10. Minacce e verifiche indispensabili

Una migrazione richiede test di downgrade, manipolazione dei ciphertext, error handling indistinguibile quando necessario, controllo della memoria, zeroization, gestione delle chiavi e compatibilità con certificati e protocolli. Per la crittografia composita verificare esplicitamente il comportamento quando una delle componenti fallisce. Per HPKE verificare che le suite realmente negoziate soddisfino la policy richiesta.

11. Benchmark: misurare l'intero protocollo

Misurare soltanto il tempo di una firma o di un'incapsulazione è insufficiente. Servono throughput, latenza p50/p95/p99, allocazioni, dimensioni di chiavi e ciphertext, handshake TLS, dimensioni delle catene X.509, CPU e interoperabilità tra sistemi operativi. Confrontare i risultati su hardware e implementazioni native dichiarate, evitando di presentare misure locali come caratteristiche universali dell'algoritmo.

12. Strategia di migrazione enterprise

La prima fase è un inventario: TLS endpoint, certificati, CA, HSM, JWT, CMS, firme del codice, VPN, backup e archivi con confidenzialità di lungo periodo. Segue la classificazione dei dati in base alla durata della riservatezza. Poi vengono introdotti test di interoperabilità in ambienti non produttivi, telemetria sugli algoritmi negoziati e un piano di rotazione e rollback esplicito. La scelta di una nuova API .NET non rende automaticamente post-quantum l'intera infrastruttura.

13. Cosa cambia davvero con .NET 11 RC2

La novità è l'arrivo di API sperimentali per Composite ML-KEM e HPKE, che completano il percorso avviato con le primitive PQC di .NET 10. Composite ML-KEM riguarda il key establishment composito; HPKE fornisce un framework di cifratura, ma il supporto iniziale non equivale a suite post-quantum già disponibili. Per progettare un sistema sicuro occorre verificare build, piattaforma, algoritmi supportati, standard e interoperabilità.

14. Conclusioni

La post-quantum cryptography è soprattutto un problema di architettura e migrazione: protocolli, formati, certificati, chiavi e dipendenze infrastrutturali. .NET 11 mette a disposizione ulteriori strumenti, ma la proprietà più preziosa resta la crypto-agility: poter aggiornare gli algoritmi senza riscrivere l'intero sistema e senza compromettere le garanzie di sicurezza.

Fonti tecniche

martedì 13 ottobre 2026

.NET 11 DNS Deep Dive: DnsResolver, record DNS tipizzati, negative caching e HTTP Connection Eviction

Il DNS non è una semplice traduzione da hostname a indirizzo IP

Per anni, molte applicazioni .NET hanno trattato la risoluzione DNS come un'operazione elementare: chiamare Dns.GetHostAddressesAsync(), ottenere uno o più indirizzi e lasciare al sistema operativo il resto. In un'applicazione distribuita moderna questa astrazione è insufficiente per diagnosticare failover, errori intermittenti, divergenze tra resolver e connessioni HTTP persistenti.

.NET 11 introduce due tasselli complementari: API DNS tipizzate in System.Net e una politica programmabile di eliminazione delle connessioni nel pool di SocketsHttpHandler. Non sono la stessa funzionalità: la prima osserva la risoluzione, la seconda influenza il riutilizzo delle connessioni.

Stato al 12 ottobre 2026: .NET 11 è ancora prerelease. Le API e i dettagli di comportamento vanno ricontrollati prima della release stabile. Gli esempi qui riportati si basano sulle API documentate da Microsoft; dove indicato, il codice è uno scheletro architetturale e non una libreria pronta per la produzione.

1. Il problema reale: tre stati che possono divergere

Authoritative DNS Zone
         |
         v
Recursive Resolver / Cache
         |
         v
Application DNS Lookup
         |
         v
HttpClient Connection Pool
         |
         v
Established TCP/TLS Connection
         |
         v
Remote Service

Il record pubblicato dal DNS autorevole non coincide necessariamente con la risposta osservata da un resolver ricorsivo. E la risposta del resolver non coincide necessariamente con l'indirizzo remoto di una connessione TCP/TLS già aperta. Il DNS risolve nomi; non interrompe le connessioni esistenti.

Questo è cruciale per Azure, servizi dietro bilanciatori, ArcGIS Enterprise, API distribuite e ambienti con DNS privati. Un cambiamento di record può essere normale, ma può anche spiegare un degrado se coincide con errori applicativi. La correlazione temporale non è però una prova di causalità.

2. Cosa cambia in System.Net.Dns

Le nuove API comprendono ResolveAddresses, ResolveSrv, ResolveMx, ResolveTxt, ResolveCName, ResolvePtr e ResolveNs, insieme alle varianti asincrone. Il risultato è tipizzato come DnsResult<T>.

APIRecordScenario
ResolveAddressesAsyncA / AAAARisoluzione degli endpoint IPv4/IPv6
ResolveCNameAsyncCNAMEAlias e dipendenze di naming
ResolveSrvAsyncSRVService discovery con porta, priorità e peso
ResolveMxAsyncMXRouting della posta
ResolveTxtAsyncTXTRecord testuali, configurazioni e verifiche
ResolvePtrAsyncPTRReverse lookup
ResolveNsAsyncNSDeleghe e name server

Il vantaggio non è soltanto evitare parsing manuale. È ottenere una rappresentazione del risultato DNS con informazioni sullo stato della risposta, che consente diagnosi più accurate rispetto al semplice successo/fallimento di GetHostAddressesAsync.

3. DnsResult<T>: distinguere risposta, record e cache negativa

Microsoft documenta tre informazioni chiave: Records, ResponseCode e NegativeCacheTtl. Questo permette di distinguere almeno tre condizioni: risposta senza errori con record; risposta senza errori ma senza record del tipo richiesto; risposta DNS negativa o con errore.

using System.Net;

DnsResult<SrvRecord> result =
    await Dns.ResolveSrvAsync("_ldap._tcp.example.com");

if (result.ResponseCode == DnsResponseCode.NoError)
{
    if (result.Records.Count == 0)
    {
        Console.WriteLine("Nessun record SRV restituito.");
    }
    else
    {
        foreach (SrvRecord record in result.Records)
        {
            Console.WriteLine(
                $"{record.Target}:{record.Port} " +
                $"priority={record.Priority} weight={record.Weight}");
        }
    }
}
else
{
    Console.WriteLine($"DNS response: {result.ResponseCode}");
}

Il codice riprende la superficie pubblica mostrata nelle release notes Microsoft. Un monitor non dovrebbe considerare automaticamente un risultato vuoto come errore infrastrutturale: potrebbe non esistere alcun record di quel tipo per il nome interrogato.

4. Negative caching: il dettaglio che cambia la diagnostica

Quando un nome non esiste, o non è disponibile il tipo di record richiesto, un resolver può conservare temporaneamente una risposta negativa. Il caching negativo è descritto dal protocollo DNS e impedisce di ripetere continuamente interrogazioni inutili.

NegativeCacheTtl espone metadati relativi a questa durata. Non va confuso con il TTL dei record positivi né interpretato come una promessa assoluta del tempo di propagazione globale. Cache del sistema operativo, resolver intermedi, policy locali e comportamento dei client possono introdurre differenze.

Un alerting engine dovrebbe perciò distinguere:

  • NXDOMAIN persistente;
  • assenza del record richiesto con nome esistente;
  • errore temporaneo del resolver;
  • timeout di rete;
  • risposta positiva che cambia nel tempo.

Una classificazione grossolana in Up / Down perde informazioni diagnostiche essenziali.

5. DnsResolver: query verso server DNS specifici

Il nuovo DnsResolver, configurato tramite DnsResolverOptions, introduce un modello a istanza e la possibilità di utilizzare una lista di server DNS personalizzati anziché affidarsi esclusivamente alla configurazione del sistema.

Questo cambia il modo in cui si può progettare un monitor. Per lo stesso hostname è possibile confrontare la prospettiva del resolver aziendale, di un resolver pubblico e di un resolver raggiungibile da una rete Azure, purché tali interrogazioni siano consentite dalla rete e dalla policy di sicurezza.

Hostname: gis.example.com
             |
    +--------+---------+
    |        |         |
    v        v         v
Resolver A Resolver B Resolver C
    |        |         |
    v        v         v
  A/AAAA   A/AAAA    A/AAAA
    |        |         |
    +--------+---------+
             |
             v
     Compare Answer Sets

Attenzione: due resolver che restituiscono IP differenti non sono necessariamente incoerenti. GeoDNS, CDN, split-horizon DNS, round-robin e bilanciamento geografico possono produrre risposte diverse per scelta progettuale. Serve una policy per endpoint, non una regola universale di uguaglianza.

Secondo la documentazione Microsoft aggiornata a settembre 2026, le API di risoluzione tipizzata e DnsResolver supportano Windows, Linux e macOS. Le note iniziali della Preview 7 descrivevano invece un'implementazione inizialmente Windows-only: è un esempio concreto del perché occorre leggere lo stato più recente della documentazione prerelease.

6. DNS TTL, cache e misurazione della latenza: tre trappole

Primo: il TTL osservato in una risposta ricorsiva può essere il tempo residuo della cache, non quello originariamente pubblicato dalla zona autorevole.

Secondo: una query completata in un millisecondo potrebbe aver utilizzato una cache locale; non prova che il server autorevole sia raggiungibile in un millisecondo.

Terzo: il tempo della query DNS non misura il tempo di connessione TCP, l'handshake TLS o la latenza HTTP. Questi indicatori vanno raccolti e rappresentati separatamente.

Per un monitor di qualità, i risultati dovrebbero contenere almeno timestamp UTC, identificativo della probe, resolver utilizzato, tipo di record, durata osservata, codice di risposta, record normalizzati e classificazione dell'errore.

7. DNS e HttpClient: perché PooledConnectionLifetime non basta a spiegare tutto

HttpClient utilizza connessioni persistenti per ridurre handshake e overhead. Se il DNS cambia, una connessione già stabilita può continuare a servire richieste verso il precedente indirizzo remoto.

Per questo Microsoft raccomanda da tempo di gestire la durata delle connessioni, per esempio con PooledConnectionLifetime. Ma una durata fissa ricicla connessioni anche quando il DNS non è cambiato.

var handler = new SocketsHttpHandler
{
    PooledConnectionLifetime = TimeSpan.FromMinutes(5)
};

using var client = new HttpClient(handler);

Questa è una strategia semplice, consolidata e generalmente prevedibile. Non è però equivalente a una politica DNS-aware.

8. .NET 11: ShouldEvictConnection

SocketsHttpHandler.ShouldEvictConnection introduce un callback asincrono per decidere se una connessione del pool debba essere ritirata. Il contesto include, fra le altre proprietà, età della connessione, endpoint DNS, endpoint remoto, versione HTTP e identificativo della connessione.

Microsoft presenta un esempio che controlla se l'indirizzo IP della connessione sia ancora presente fra quelli restituiti dal DNS:

using System.Net;

var handler = new SocketsHttpHandler
{
    PooledConnectionLifetime = Timeout.InfiniteTimeSpan,
    ShouldEvictConnection = async (context, ct) =>
    {
        if (context.RemoteEndPoint is IPEndPoint connectionIp)
        {
            var addresses = await Dns.GetHostAddressesAsync(
                context.DnsEndPoint.Host,
                connectionIp.AddressFamily,
                ct);

            return !addresses.Contains(connectionIp.Address);
        }

        return context.Age > TimeSpan.FromMinutes(10);
    }
};

È un esempio didattico, non una configurazione che adotterei automaticamente in produzione. Eseguire una risoluzione DNS all'interno di una decisione di eviction può aumentare lavoro e latenza; bisogna comprendere frequenza di invocazione, timeout, eccezioni, cache e possibili oscillazioni delle risposte.

Inoltre la proprietà è stata introdotta come sperimentale nelle release notes della Preview 7. Occorre verificare gli attributi e le eventuali diagnostiche del compilatore nella build di SDK effettivamente utilizzata.

9. Progettare una policy DNS-aware senza creare un nuovo problema

Un approccio robusto dovrebbe evitare interrogazioni ripetitive verso il DNS a ogni decisione del pool. Una possibile architettura applicativa prevede un servizio separato che mantiene snapshot DNS periodici, con TTL e limiti di aggiornamento, e una policy di eviction che legge uno snapshot immutabile.

DNS Poller --> Immutable DNS Snapshot
                    |
                    v
             Eviction Policy
                    |
                    v
             Connection Pool

Questa è una proposta di design: non è un comportamento automatico del runtime. La policy deve gestire il caso in cui lo snapshot sia vecchio, non disponibile o temporaneamente vuoto. Evitare che un errore DNS transitorio provochi l'eliminazione massiva di connessioni ancora sane è spesso più importante che reagire immediatamente a ogni variazione.

Una politica ragionevole potrebbe prevedere: tempo minimo di permanenza, snapshot validi, più osservazioni consecutive, limiti alla frequenza di eviction e fallback a una durata massima fissa. I parametri vanno misurati con benchmark e fault injection.

10. A/AAAA e IPv6: il risultato DNS non determina da solo la connessione

Quando un hostname dispone di record IPv4 e IPv6, il sistema può scegliere l'indirizzo remoto secondo policy di rete e strategie di connessione. Un monitor che verifica soltanto A può risultare verde mentre i client IPv6 incontrano problemi, o viceversa.

Conviene conservare distintamente gli insiemi A e AAAA e, quando si monitorano le connessioni HTTP, osservare l'effettivo RemoteEndPoint. L'ordine degli indirizzi nella risposta DNS non va considerato un identificatore stabile della configurazione.

11. CNAME: non confondere alias e indirizzi finali

Una catena di CNAME può essere parte della configurazione normale di servizi cloud. Monitorare l'alias è utile per diagnosticare errori di configurazione, ma non bisogna presumere che ogni nome esponga sempre un record CNAME esplicito. Alcuni provider utilizzano record sintetizzati, alias proprietari o risposte che dipendono dal resolver.

Un buon monitor distingue il nome richiesto, gli eventuali alias osservati e l'insieme finale degli indirizzi. In presenza di variazioni, registra gli eventi senza classificarli automaticamente come incidenti.

12. SRV: service discovery, priority e weight

I record SRV sono interessanti perché includono un endpoint di servizio e non soltanto un nome host. Ogni record può specificare target, porta, priorità e peso.

La priorità più bassa viene preferita; il peso contribuisce alla selezione tra record della stessa priorità secondo le regole del protocollo. Un client non dovrebbe trattare l'elenco come un semplice array ordinato di server equivalenti.

Un monitor può verificare che i target siano risolvibili e che le porte siano raggiungibili, ma deve distinguere la validità del record DNS dalla disponibilità effettiva del servizio pubblicato.

13. MX, TXT, NS e PTR: non soltanto endpoint web

MX: permette di osservare variazioni dei server di posta e delle preferenze; non dimostra che SMTP funzioni.

TXT: utile per verificare la presenza di configurazioni testuali attese. Non ogni stringa TXT è un record SPF o una configurazione di sicurezza.

NS: utile per analizzare deleghe e modifiche dei name server; la diagnosi completa delle deleghe può richiedere query iterative e verifiche della catena DNS.

PTR: associa indirizzi a nomi in reverse DNS; la sua presenza non dimostra automaticamente l'identità o l'affidabilità di un host.

14. Diagnostica: NXDOMAIN, NODATA, SERVFAIL e timeout

Un monitor DNS serio deve distinguere le risposte del protocollo dalle eccezioni di trasporto. Un nome inesistente, un record mancante, un errore del resolver e un timeout non descrivono lo stesso incidente.

CondizioneInterpretazione operativa
Risposta positivaRecord ricevuti, senza garanzia sulla raggiungibilità applicativa
Risposta senza record del tipo richiestoPossibile configurazione normale o record mancante
NXDOMAINNome inesistente nella vista DNS interrogata
SERVFAILIl resolver non è riuscito a completare la risoluzione
TimeoutAssenza di risposta nei limiti configurati
Risposte divergentiPossibile GeoDNS, split-horizon, cache o problema da indagare

Non assocerei mai automaticamente NXDOMAIN a un errore HTTP 404: il primo riguarda il DNS, il secondo è una risposta di un server HTTP raggiunto con successo.

15. Un laboratorio riproducibile: la baseline compatibile con .NET 10

Prima di sperimentare le nuove API, è utile costruire una baseline con API consolidate. Questo esempio misura la durata osservata della risoluzione A/AAAA attraverso il resolver di sistema, senza pretendere di misurare il tempo del server autorevole.

dotnet new console -n DnsBaseline -f net10.0
cd DnsBaseline
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;

string hostname = args.Length > 0
    ? args[0]
    : "example.com";

using var cts = new CancellationTokenSource(
    TimeSpan.FromSeconds(5));

var sw = Stopwatch.StartNew();

try
{
    IPAddress[] addresses =
        await Dns.GetHostAddressesAsync(hostname, cts.Token);

    sw.Stop();

    var normalized = addresses
        .Distinct()
        .OrderBy(ip => ip.AddressFamily)
        .ThenBy(ip => ip.ToString(), StringComparer.Ordinal)
        .ToArray();

    Console.WriteLine($"Host: {hostname}");
    Console.WriteLine($"Elapsed: {sw.Elapsed.TotalMilliseconds:F2} ms");

    foreach (IPAddress address in normalized)
    {
        string family = address.AddressFamily ==
            AddressFamily.InterNetwork ? "A" : "AAAA";

        Console.WriteLine($"{family}: {address}");
    }
}
catch (OperationCanceledException)
{
    Console.Error.WriteLine("DNS lookup timed out/cancelled.");
}
catch (SocketException ex)
{
    Console.Error.WriteLine(
        $"DNS lookup failed: {ex.SocketErrorCode}");
}

La baseline è intenzionalmente semplice. Non espone il DNS response code completo, la cache negativa, il resolver interrogato né i record SRV/MX/TXT. È proprio questa lacuna che le API .NET 11 iniziano a colmare.

16. Laboratorio .NET 11: record SRV e classificazione

Con un SDK .NET 11 prerelease installato, il seguente frammento illustra l'uso delle API tipizzate:

using System.Net;

string service = "_ldap._tcp.example.com";
DnsResult<SrvRecord> response =
    await Dns.ResolveSrvAsync(service);

Console.WriteLine($"Response: {response.ResponseCode}");
Console.WriteLine($"Records: {response.Records.Count}");

foreach (SrvRecord srv in response.Records)
{
    Console.WriteLine(
        $"target={srv.Target} port={srv.Port} " +
        $"priority={srv.Priority} weight={srv.Weight}");
}

Per una prova reale è necessario utilizzare un nome SRV effettivamente pubblicato nell'ambiente di test. La stringa example.com è illustrativa e non implica l'esistenza del servizio LDAP.

Una suite completa dovrebbe includere query separate per record A/AAAA, CNAME, MX, TXT, PTR e NS, raccogliendo gli stessi campi diagnostici in un formato comune.

17. Benchmark: non misurare soltanto la media

Un benchmark DNS affidabile dovrebbe separare query cold e warm, distinguere cache locale e remota, confrontare più resolver e misurare percentili di latenza. La sola media può nascondere code molto lunghe.

Metriche suggerite: dns_lookup_duration_ms (p50/p95/p99), dns_lookup_failures_total per classificazione, dns_answer_set_changes_total, dns_negative_responses_total e dns_resolver_disagreement_total.

Non utilizzare il nome host grezzo come label ad alta cardinalità in un sistema multi-tenant: una crescita incontrollata delle serie temporali può diventare più costosa del monitoraggio stesso. Usare identificativi di monitor stabili e metadata separati.

18. Fault injection: testare la diagnosi prima dell'incidente

Un laboratorio avanzato dovrebbe includere un resolver DNS di test controllato, ad esempio in un ambiente isolato, capace di rispondere con:

  • un set A/AAAA stabile;
  • un cambio di IP dopo un intervallo definito;
  • NXDOMAIN;
  • SERVFAIL;
  • risposte ritardate;
  • record multipli e rotazione dell'ordine;
  • TTL differenti.

Il client HTTP dovrebbe essere testato separatamente con un server raggiungibile ai diversi indirizzi, in modo da distinguere cambio DNS, errore di connessione, handshake TLS e risposta HTTP. Non è sufficiente cambiare un record e osservare che il client prima o poi raggiunge un altro server: occorre misurare tempi di convergenza e richieste fallite.

19. Da availability check a DNS observability: architettura di un servizio enterprise

Un sistema di osservabilità può integrare un DNS Health Check come controllo autonomo, mantenendo separati i monitor HTTP e TLS. Questo permette di diagnosticare le cause dei problemi senza confondere la risoluzione dei nomi con la disponibilità applicativa.

Monitoring Scheduler
       |
       +-- HTTP Monitor
       |
       +-- TLS Certificate Monitor
       |
       +-- DNS Monitor
                 |
                 +-- A / AAAA
                 +-- CNAME / SRV / MX / TXT / NS / PTR
                 +-- Resolver Comparison
                 +-- Answer Set History
                 +-- Response Classification
       |
       v
Correlation / Alert Engine
       |
       v
Dashboard + Notifications

Il monitor dovrebbe registrare la prospettiva di ciascuna probe. Un resolver interno Azure può restituire indirizzi privati dove un resolver pubblico restituisce indirizzi pubblici o nessuna risposta. Questo può essere un comportamento corretto in presenza di Private Endpoint e Private DNS Zone.

La correlazione DNS/HTTP deve restare diagnostica. Non è opportuno forzare HttpClient a utilizzare gli IP raccolti dal monitor DNS: ciò altererebbe il normale percorso di risoluzione, la selezione degli endpoint e potenzialmente le garanzie TLS.

20. Schema dati proposto per il monitor

{
  "monitorId": "api-production-dns",
  "hostname": "api.example.com",
  "recordType": "A",
  "probeId": "azure-italynorth-01",
  "resolverProfile": "system",
  "timestampUtc": "2026-10-12T08:00:00Z",
  "durationMs": 13.4,
  "responseClass": "Positive",
  "answers": ["192.0.2.10", "192.0.2.11"],
  "answerSetChanged": false,
  "status": "Healthy"
}

Gli indirizzi 192.0.2.0/24 appartengono allo spazio riservato agli esempi documentali. Il JSON è una proposta di contratto applicativo, non un formato nativo di .NET 11.

Le modifiche del set di indirizzi devono essere confrontate come insiemi normalizzati, non come stringhe concatenate nell'ordine ricevuto. Per servizi con GeoDNS o CDN conviene introdurre una modalità di baseline dinamica, per evitare falsi positivi.

21. Alerting: distinguere change event e incident

Un cambio IP è un evento; un servizio non raggiungibile è un possibile incidente. Non devono essere sinonimi.

Una classificazione operativa può prevedere tre livelli:

  • Informational: variazione dell'answer set, nuovo CNAME, modifica del TTL osservato.
  • Warning: divergenza persistente rispetto a una policy esplicita, aumento del p95, errori intermittenti.
  • Critical: impossibilità persistente di risolvere un nome essenziale, confermata da più campioni e correlata a fallimenti del servizio.

Le soglie vanno parametrizzate per monitor e ambiente. Un nome interno risolvibile soltanto nella VNet non dovrebbe essere considerato guasto perché non si risolve da Internet.

22. Sicurezza: un DNS monitor può diventare uno strumento di scansione

Se un servizio di monitoraggio accetta hostname e resolver arbitrari, occorre evitare che utenti non autorizzati possano utilizzarlo per enumerare reti interne, interrogare server riservati o generare carico verso infrastrutture DNS.

Le contromisure comprendono validazione degli hostname, policy di autorizzazione per i resolver, limiti di frequenza, timeout, limiti di concorrenza, audit log e separazione delle probe per rete/tenant. Non assumere che un hostname innocuo rimanga sempre associato agli stessi IP.

23. Strategia di adozione: non migrare a .NET 11 soltanto per il DNS

Questa è la distinzione più importante dal punto di vista architetturale. Una nuova API di runtime non impone automaticamente l'aggiornamento dell'intera applicazione.

Per un sistema in esecuzione su una versione LTS stabile, è consigliabile definire un'astrazione IDnsProbe con implementazione compatibile con il runtime corrente e un adapter opzionale specifico per .NET 11. L'adozione della versione prerelease dovrebbe rimanere confinata al laboratorio.

La funzionalità può essere progettata oggi con contratti stabili e test indipendenti dal provider DNS. Quando .NET 11 sarà stabile, sarà possibile valutare se le nuove API riducono davvero dipendenze, codice e complessità operativa.

24. Checklist per un DNS Health Monitor enterprise

  • Distinguere resolver di sistema e resolver esplicito.
  • Registrare record A e AAAA separatamente.
  • Gestire NXDOMAIN, NODATA, SERVFAIL, timeout ed errori locali.
  • Separare TTL positivo e negative caching.
  • Conservare lo storico degli answer set normalizzati.
  • Identificare probe e rete di provenienza.
  • Misurare p50, p95 e p99 senza creare cardinalità incontrollata.
  • Non generare alert critici per ogni cambio IP.
  • Non sostituire il controllo HTTP con il controllo DNS.
  • Testare failover, split-horizon e Azure Private DNS.
  • Proteggere i resolver configurabili da abusi.
  • Verificare API e attributi sperimentali prima della release stabile.

Conclusioni: DNS-aware non significa automaticamente resilient

.NET 11 migliora l'osservabilità del DNS e rende più espressiva la gestione delle connessioni HTTP. Ma un sistema resiliente non nasce da una singola API. Nasce da politiche di cache, controllo delle dipendenze, gestione dei fallimenti, osservabilità e test riproducibili.

L'obiettivo di un sistema DNS-aware non è mostrare semplicemente l'indirizzo IP risolto, ma ricostruire la storia di un incidente: quale resolver ha risposto, quali record erano visibili, quali connessioni HTTP erano in uso e quando sono comparsi gli errori.

Il DNS dice dove un servizio dovrebbe essere raggiungibile. Il connection pool rivela dove il client è ancora connesso. L'observability deve raccontare la differenza.

Riferimenti ufficiali

lunedì 12 ottobre 2026

NicoGIS Tech Weekly — .NET 11 Runtime Async, GeoAI interpretabile, Agent Skills e Decisions API

NicoGIS Tech Weekly  •  12 ottobre 2026  •  Osservatorio tecnico: 5–11 ottobre

Focus di questa edizione
.NET 11: il passaggio dello stato async dal compilatore al runtime e il costo reale delle astrazioni; GeoAI: interpretabilità dei 256 embedding geodemografici con SHAP, più il conflitto fra prossimità geografica e semantica; Experience Builder: Agent Skills come conoscenza architetturale verificabile; LLM: Decisions API e Ultrafast come nuove scelte di orchestrazione.

Una settimana, un problema architetturale: dove finisce la rappresentazione e chi prende la decisione?

Quattro tecnologie apparentemente separate descrivono lo stesso spostamento di responsabilità. In .NET 11, per alcuni metodi async, la trasformazione che gestisce la sospensione si sposta dal compilatore C# al runtime/JIT; nella GeoAI, le migliaia di variabili che descrivono un territorio vengono compresse in uno spazio latente da cui vogliamo però ricavare spiegazioni controllabili; nello sviluppo di Experience Builder, le convenzioni di un framework vengono fornite al coding agent sotto forma di skill; nella nuova Decisions API, un modello non restituisce prosa ma probabilità o scelte tipizzate.

Il tema non è semplicemente migliorare le performance o produrre codice più velocemente. È decidere quali responsabilità possano essere trasferite a un livello intelligente o ottimizzante, quali contratti devono rimanere invarianti e quali verifiche debbano restare sotto il controllo dell’applicazione. In questo numero i fatti documentati sono separati dalle mie analisi: un microbenchmark non diventa uno SLA, SHAP non diventa causalità e la confidenza di un modello non diventa autorizzazione.

Nota sulla selezione. Le notizie realmente nuove della settimana sono il post Microsoft del 6 ottobre su C# Dev Kit, l’articolo Esri del 6 ottobre su AutoML/SHAP e gli annunci OpenAI del 6 e 8 ottobre. Il grande approfondimento di Stephen Toub su .NET 11 (15 settembre) e lo skill Esri (14 settembre) sono ripresi intenzionalmente come fonti tecniche di base: sono troppo importanti per essere liquidati.

01 — .NET 11: Runtime Async cambia il confine compiler/runtime

Dal lowering C# alla generazione JIT della sospensione

Nel lowering tradizionale, Roslyn converte il metodo async in una macchina a stati: tipo generato, MoveNext, campi per gli awaiter e per le variabili ancora vive dopo la sospensione, più il builder del risultato. Il JIT vede già questa rappresentazione trasformata. Il nuovo meccanismo runtime async, descritto da Stephen Toub il 15 settembre 2026, cambia la divisione del lavoro: per i metodi compatibili il compilatore emette IL più compatto, marcato come async, e il runtime/JIT decide come materializzare continuazioni e oggetti Task. Il modello C# pubblico, inclusi await, eccezioni, cancellazione e ConfigureAwait, resta semanticamente invariato.

// Modello concettuale, non una rappresentazione IL letterale.

// Lowering classico
C# async method
    -> compiler-generated state machine
    -> MoveNext + awaiter fields + builder
    -> JIT of already-lowered IL

// Runtime async (.NET 11, opt-in per l'applicazione)
C# async method
    -> compact suspension-aware IL + async metadata
    -> JIT/runtime builds suspend/resume machinery
    -> Task materialized when required by the observable contract

Il dettaglio che merita attenzione è il doppio accesso al metodo: il runtime può gestire un entry point pubblico che restituisce Task<T> e una variante interna AsyncCall capace di passare direttamente T a un chiamante runtime-async che esegue immediatamente await. Nel caso A → await B → await C, i confini intermedi possono essere fusi: se non esiste un consumatore che osservi il Task come oggetto, non è obbligatorio materializzarne uno per ogni livello. Gli adapter preservano interoperabilità con le librerie compilate secondo il modello tradizionale.

// File .csproj: esperimento .NET 11, non feature abilitata
// automaticamente nel codice applicativo.
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net11.0</TargetFramework>
    <Features>$(Features);runtime-async=on</Features>
  </PropertyGroup>
</Project>
FATTO
Nel .NET 11 documentato da Microsoft il meccanismo è opt-in per il codice applicativo, tramite runtime-async=on. La stessa fonte segnala che non tutti i casi sono già ottimizzati e che l’obiettivo iniziale è la compatibilità semantica, non promettere una riduzione universale delle allocazioni. Non confondere quindi “runtime async disponibile” con “runtime async abilitato di default per ogni progetto”.

Quanto vale? Microbenchmark, non capacità produttiva

Nel benchmark di Toub su due livelli async, una catena che completa sincronicamente passa, sulla macchina e con il setup Microsoft, da 21,221 ns e 144 B a 6,151 ns e 0 B; il percorso con un reale Task.Yield() passa da 254,139 ns e 248 B a 116,927 ns e 168 B. In un altro esperimento un assembly con dieci livelli async passa da 10.752 a 5.632 byte. Sono risultati di workload specifici, non coefficienti da applicare a una Web API qualsiasi.

Scenario misurato da MicrosoftLowering classicoRuntime asyncLettura corretta
Catena async, completamento sincrono21,221 ns · 144 B6,151 ns · 0 BBeneficio della mancata materializzazione di task intermedi.
Catena async, sospensione reale254,139 ns · 248 B116,927 ns · 168 BAnche una sospensione può evitare parte del costo delle continuazioni.
Assembly sperimentale, 10 livelli10.752 byte5.632 byteDimensione IL/binary, non tempo di risposta HTTP.

Se un endpoint è dominato da SQL Server, chiamate ArcGIS REST, traffico di rete o latenza cloud, il beneficio globale dell’ottimizzazione di pochi nanosecondi può risultare marginale. Se, invece, il servizio crea milioni di continuazioni brevi — per esempio un middleware che attraversa molti livelli e termina spesso su cache — allora diminuzioni di allocazioni e overhead possono ridurre pressione sul GC e costo CPU. La misura corretta richiede almeno throughput, p95/p99, allocazioni per operazione, pause GC e utilizzo ThreadPool sotto carico reale.

ANALISI
Runtime async è anche un cambiamento di forma del programma. L’ottimizzatore potrà ragionare su liveness e sospensione prima che una state machine esplicita abbia cristallizzato il controllo di flusso. Questo amplia le ottimizzazioni possibili, ma rende ancora più importante disporre di test di compatibilità, tracing dei task e confronti fra runtime quando un’applicazione fa uso di reflection, diagnosi delle stack trace o librerie complesse.

JIT, GC e JSON: la prestazione è una catena di costi

Nello stesso articolo, Microsoft descrive l’escape analysis sui boxing temporanei: in un esempio Nullable<int> che viene formattato attraverso un’interfaccia, il JIT riesce a eliminare un boxing da 24 B perché l’oggetto non esce dal metodo. Per una funzione che restituisce l’oggetto boxed, quell’allocazione resta necessaria. Non è “zero boxing” in senso generale: è una prova sull’observability dell’allocazione.

Sul lato GC, l’espansione di alcune operazioni di store su array espone al JIT i controlli di covarianza e le write barrier, permettendo di eliminarli o semplificarli quando il tipo effettivo è noto. Sulla serializzazione, Utf8JsonWriter usa percorsi basati su SearchValues per identificare i caratteri da sottoporre a escaping; Utf8JsonReader sfrutta IndexOfAnyExcept per saltare sequenze di whitespace. In un microbenchmark altamente favorevole al nuovo percorso, una scrittura JSON scende da 30,83 μs a 7,875 μs: caso utile a capire il meccanismo, non una promessa “JSON 4× più veloce” per ogni payload.

Hot path di un servizio .NET

parse JSON ─► validation ─► async call chain ─► downstream I/O
    │             │               │                 │
SearchValues   JIT/PGO       runtime-async        network/DB
    │             │               │                 │
    └─────────────┴───────────────┴─────────────────┘
                        ↓
              p95 latency + CPU + GC

Un miglioramento locale conta solo rispetto al peso del suo segmento.

Il tema AOT va letto nello stesso modo: Native AOT può eliminare la compilazione JIT dal percorso di avvio e migliorare startup e ingombro operativo di determinati eseguibili; non significa automaticamente che un’app ASP.NET Core con reflection dinamica, plugin o dipendenze non compatibili possa essere pubblicata senza modifiche. Le scelte tra JIT, ReadyToRun e Native AOT richiedono un inventario delle dipendenze e una misura del cold start rispetto allo steady state.

Fonti primarie: Stephen Toub, Performance Improvements in .NET 11 — 15 settembre 2026

Aggiornamento della settimana — C# Dev Kit 11.0, il tooling ridisegnato attorno al tempo di feedback

Il 6 ottobre Microsoft presenta la prerelease di C# Dev Kit 11.0, che succede alla serie 3.3. Qui non stiamo misurando il runtime della nostra applicazione, ma l’infrastruttura che carica soluzioni, produce build incrementali e rende disponibili IntelliSense, test e navigazione del codice. Il cambiamento è concreto: sei processi managed precedenti vengono consolidati in un processo server CSDevKit compilato con Native AOT; la soluzione usa una cache del modello dei progetti, apre per primo il file attivo e carica il resto in modo progressivo.

I dati Microsoft sono rilevanti ma vanno letti con precisione: sulla soluzione Aspire di 407 progetti, active file ready passa fino a 84,1 s → 0,47 s e whole solution ready da 84,1 s → 3,0 s. Nella stessa soluzione una build senza modifiche passa da 34,4 s a 0,88 s, e una con un singolo file C# modificato da 36,1 s a 2,1 s. La memoria dei processi server C# Dev Kit su Aspire scende da 2.072 a 316 MB: Microsoft precisa esplicitamente che questi numeri escludono il processo language service Roslyn e VS Code. La prerelease aggiunge anche supporto semantico ai file MSBuild e il diagnostico C# Doctor.

ANALISI
Questa architettura ha conseguenze importanti per agenti di coding e workspace effimeri: ridurre il costo di ogni nuovo processo, riutilizzare l’analisi dei progetti e rendere rapidamente disponibile il file attivo migliora il feedback loop sia umano sia automatizzato. Attenzione però alla cache versionata: va verificato quali artefatti sono riproducibili, quali sono specifici della macchina e come vengono invalidati, invece di committare indiscriminatamente directory locali nel repository.

Fonti primarie: Microsoft .NET Blog, A faster, lighter C# Dev Kit — 6 ottobre 2026 · Microsoft, Performance Improvements in .NET 11

02 — ArcGIS GeoAI: 256 embedding, quattro segmenti e il rischio di confondere spiegazione con causalità

Il fatto nuovo: AutoML + SHAP con struttura semantica documentata

Il 6 ottobre 2026 Pamir Roy (Esri) pubblica un workflow di interpretabilità per gli USA Geodemographic Embeddings in ArcGIS Pro. Il Geodemographic Foundation Model (GDFM) comprime quattro viste di contesto territoriale in 256 dimensioni, suddivise in quattro segmenti contigui da 64. La documentazione tecnica Esri descrive un multiview autoencoder: ciascuna vista ha un encoder che produce una rappresentazione latente; i vettori vengono concatenati e un’architettura di decoder ricostruisce gli input per guidare l’apprendimento. La layer pubblicata in Living Atlas associa gli embedding a celle Uber H3 di risoluzione 7, con vettori serializzati in campi BLOB e dimensioni disponibili anche come campi numerici.

SegmentoDimensioniVista di origineCosa non è lecito dedurre
S11–64Housing & Household CharacteristicsUna dimensione non equivale a “prezzo abitazione”.
S265–128EnvironmentUna componente non equivale a “temperatura” o “NDVI”.
S3129–192American Community SurveyUn alto SHAP del segmento non dimostra causalità del reddito.
S4193–256Age & Race CensusLa rilevanza predittiva non costituisce giustificazione etica per un uso decisionale.

Le quattro viste non sono indipendenti per costruzione semantica: realtà abitative, ambientali e socioeconomiche si correlano nel mondo reale. Inoltre un autoencoder non conserva i nomi delle variabili come assi interpretabili. Esri mostra l’uso di Train Using AutoML in modalità Basic e dell’output importance table per una previsione della food insecurity basata su dati County Health Rankings 2025; nella tabella vengono riportati i campi VARIABLES e IMPORTANCE. Un embedding come embedding_137 può avere elevata attribuzione nel modello, ma non va rinominato “income” o “employment” soltanto perché appartiene alla terza vista.

La matematica minima necessaria: quale SHAP stiamo sommando?

Esri specifica che IMPORTANCE rappresenta un’media globale del valore assoluto delle attribuzioni SHAP della singola dimensione sul campione di valutazione. La metrica aggregata per una vista viene calcolata sommando quelle importanze delle 64 dimensioni. Se φ(i,j) è la contribuzione firmata della dimensione j sull’osservazione i, si sta quindi leggendo:

S_segmento = somma_j[ (1/N) * somma_i |SHAP(i,j)| ]
              j nel segmento

NON e’ lo stesso oggetto di:

G_segmento = (1/N) * somma_i | somma_j SHAP(i,j) |
                                  j nel segmento

In generale S_segmento >= G_segmento, perche’ le
attribuzioni positive e negative possono compensarsi.

Questa differenza non è un dettaglio: due dimensioni possono avere ciascuna una forte attribuzione assoluta e annullarsi all’interno della stessa osservazione. La somma delle importanze descrive il volume delle attribuzioni individuali, non l’effetto congiunto netto del gruppo e neppure l’ipotetica perdita di accuratezza rimuovendo quel segmento. Per stimare il valore informativo incrementale occorrono esperimenti di ablation (riaddestramento senza una vista) o permutazioni di gruppo, con una validazione coerente con la struttura spaziale dei dati.

FATTO
Nell’esempio pubblicato da Esri il segmento ACS risulta quello con maggiore aggregato di SHAP assoluto per il modello specifico di food insecurity. Esri ribadisce che la graduatoria dipende da task, campione, algoritmo e configurazione: non è una gerarchia universale dei fattori socioeconomici né una conclusione causale.

Una strategia pratica per la produzione consiste nel mantenere separati predictive quality, explainability e robustness: un valore elevato di SHAP racconta come il modello ha sfruttato una rappresentazione, non se la fonte è appropriata, stabile nel tempo o idonea a una decisione amministrativa. Per contesti sensibili, in particolare quando compaiono proxy demografici, è necessario un controllo aggiuntivo di bias, finalità d’uso e possibili differenze di errore fra aree/popolazioni.

Prossimità geografica, prossimità latente e prossimità operativa

La disponibilità della ricerca Find Similar Features Using Embeddings cambia il tipo di domanda che un analista GIS può porre. Due celle H3 distanti centinaia di chilometri possono essere vicine nello spazio dei 256 valori, mentre celle contigue possono differire in condizioni socioeconomiche e ambientali. Esri descrive esplicitamente questa distinzione nei workflow per cercare aree contestualmente simili. Ma per una pianificazione di servizi, “simile” non coincide automaticamente con “raggiungibile”, “vicino” o “ammissibile”.

p = punto/cella di interesse; q = candidato

d_geo(p,q) = distanza geodesica o costo di rete

d_latent(p,q) = distanza nell’embedding
                 (metrica e scaling da validare)

score(p,q) = alpha * normalize(d_geo)
           + beta  * normalize(d_latent)
           + gamma * task_constraints(p,q)

ATTENZIONE: score e pesi sono proposta architetturale,
NON un algoritmo dichiarato da Esri.

Un motore di spatial-semantic retrieval credibile dovrebbe separare almeno tre fasi: (1) filtro spaziale o di rete per eliminare candidati impossibili; (2) ranking nello spazio latente secondo una metrica sperimentata sul dataset e sul tipo di embedding; (3) verifica su attributi espliciti e vincoli di dominio. In alternativa la priorità può essere invertita (prima semantic retrieval, poi validazione GIS), ma la scelta influisce su recall, costi e falsi positivi. Non combinerei direttamente gradi, chilometri, distanza coseno e indicatori socioeconomici senza normalizzazione e calibrazione.

Il secondo errore sistematico è il leakage spaziale. Uno split casuale del dataset può mettere nelle partizioni di training e test celle contigue e fortemente autocorrelate, ottenendo metriche eccessivamente ottimistiche. La letteratura scientifica sulle strategie di cross-validation per dati spaziali documenta il problema. Per un esperimento credibile bisogna confrontare holdout casuale e holdout per blocchi geografici, idealmente valutando anche l’effetto della dimensione del buffer rispetto alla correlazione residua. Non è un’impostazione di SHAP: è una proprietà del disegno sperimentale.

VALUTAZIONE
Gli embedding aprono una ricerca “per analogia territoriale”, ma l’analogia dipende dal modello e dalla finestra temporale dei dati che lo hanno addestrato. La documentazione GDFM riporta viste con anni di riferimento differenti (Census, ACS, dataset ambientali): usare questi vettori per una decisione corrente senza verificare l’aggiornamento delle sorgenti può trasformare un raffinato similarity search in una mappa di contesti storici.

Fonti primarie: Esri, Interpret embeddings using AutoML and SHAP — 6 ottobre 2026 · Esri, Concepts of USA Geodemographic Embeddings · Esri, Introducing USA Geodemographic Embeddings — 9 luglio 2026 · Lundberg & Lee, paper SHAP originale (NeurIPS 2017) · Roberts et al., spatial cross-validation (Ecography 2017)

03 — Experience Builder Agent Skills: il framework diventa conoscenza caricabile, ma la CI resta il giudice

La skill Esri non è un generatore magico di widget

Il 14 settembre Esri ha distribuito come open source arcgis-exb-widget-dev nel repository ufficiale delle risorse SDK di Experience Builder. Lo skill codifica struttura del progetto, convenzioni delle directory di Developer Edition, separazione fra pannello di settings e runtime, interazione con map/data source, state management, accessibility, theming, compatibilità delle configurazioni e riferimenti specifici richiamabili in modo selettivo dall’agente. Per Codex il post Esri suggerisce la cartella .agents/skills/; gli altri agent usano directory proprie. Non c’è un nuovo runtime Esri coinvolto: è contesto procedurale per un coding agent, non un’API eseguibile dal browser.

Developer Edition (esempio concettuale)
client/
  your-extensions/
    widgets/
      my-widget/
        manifest.json
        config.json
        src/   <-- runtime / setting / config, secondo template

.agents/skills/
  arcgis-exb-widget-dev/
    SKILL.md
    references/
    assets/

source code + framework skill + tests/CI
          -> 
      validazione

Esri specifica che i widget custom devono utilizzare le astrazioni di Experience Builder: in settings DataSourceSelector e altri selector di framework, con persistenza di useDataSources nell’appConfig; a runtime DataSourceComponent e, quando serve una mappa, JimuMapViewComponent. Questi contratti sono più importanti della generazione di uno scaffold che “compila”: gestiscono il lifecycle del builder, la selezione dei campi, le dipendenze da altri widget e l’interoperabilità dell’applicazione.

La frattura architetturale concreta: 2027 e web components

Esri ha comunicato che i custom widget Experience Builder dipendenti dai widget del Maps SDK for JavaScript dovranno migrare verso i web components del Maps SDK prima di adottare le release Experience Builder previste da Q1 2027 in poi che li sostituiscono. La stessa comunicazione distingue il momento in cui l’applicazione smette di funzionare: è legato all’upgrade della versione utilizzata, non al semplice scoccare della data di calendario. Non significa che ogni custom widget sarà automaticamente incompatibile: riguarda quelli che utilizzano i vecchi widget JS SDK.

Questa transizione rende particolarmente pericoloso un coding agent addestrato su esempi eterogenei: può generare codice sintatticamente coerente ma vincolato a componenti destinati alla rimozione. Lo skill vendor dovrebbe quindi essere version-aware e l’applicazione dovrebbe avere una matrice di versioni realmente testate. Il repository Esri include anche cartelle di patch specifiche per release: una convenzione attuale non è automaticamente compatibile con qualunque ArcGIS Enterprise installato.

Controlli proposti per una pull request di widget

[1] Versione Experience Builder esplicita
[2] Framework API e web components compatibili
[3] No API obsolete di Maps SDK widgets
[4] Settings/runtime separation preservata
[5] appConfig aggiornabile senza perdita di dati
[6] Lifecycle Map / DataSource gestito
[7] Keyboard, ARIA, tema e responsive layout
[8] Test di build, lint e smoke test UI
[9] Nessun segreto o token hardcoded nel client

Questa checklist e’ una proposta editoriale,
non uno script CI ufficiale Esri.
ANALISI
Tre livelli da tenere distinti. (1) Vendor skill: conoscenza del framework e delle versioni. (2) Repository skill: invarianti del progetto, convenzioni locali, procedure di packaging e release. (3) Validation gate: compilazione, test automatici, regression e review. Il terzo è indispensabile: i file di istruzioni aumentano la probabilità di codice corretto, ma non provano che il codice generato sia corretto. Inoltre lo skill è un input potenzialmente non attendibile nella supply chain dell’agente: va revisionato e versionato come qualunque dipendenza che può influenzare modifiche al repository.

Fonti primarie: Esri, Building Custom Experience Builder Widgets with an Agent Skill — 14 settembre 2026 · Repository GitHub ufficiale, SDK Resources e skill · Esri Developer, concetti dei widget · Esri Developer, Use data source in widget · Esri, retirement dei widget JS SDK — 8 aprile 2026

04 — LLM architecture: Decisions API e Ultrafast dividono il reasoning dal decision plane

6 ottobre: una API tipizzata per scegliere, non per “rispondere in JSON”

Il 6 ottobre 2026 OpenAI ha introdotto in beta pubblica la Decisions API con il modello gpt-6-luna e l’endpoint POST /v1/decisions. La superficie è deliberatamente più stretta della Responses API: riceve input testuale o immagini e valuta domande dichiarate dall’applicazione, restituendo predicate (probabilità booleana), choice (una delle alternative date) o score (punteggio su livelli ordinati). OpenAI dichiara una velocità “circa 10×” rispetto alla Responses API per questo tipo di task: è un claim del vendor su una classe di operazioni, non un benchmark indipendente su qualsiasi prompt o ambiente. Il modello attualmente previsto dalla documentazione per questa API è solo gpt-6-luna.

Il prezzo pubblicato per /v1/decisions con Luna è 0,10 USD per milione di token di input, senza addebito di token in output né letture/scritture della cache per questa specifica API. Sono previste maggiorazioni regionali e per contesti lunghi. Per testi, dati o immagini regolamentati, il supporto a ZDR, HIPAA e residenza geografica dipende dall’idoneità dell’organizzazione e dai relativi accordi: non equivale a una certificazione automatica di conformità del progetto.

La distinzione di prodotto è cruciale: se serve estrarre un oggetto arbitrario conforme a schema JSON, la documentazione rimanda agli Structured Outputs nella Responses API; se serve eseguire strumenti, usa function calling. La Decisions API, invece, formalizza un output decisionale ristretto. Questo può semplificare i confini fra classifier, policy engine e orchestratore, ma non li deve fondere.

INPUT: "Errore 500 al servizio di mappe pioggia"
            |
            v
     Decisions API (beta)
       type=choice
   gis | infrastructure | other
            |
            v
   probabilita’ + confidence
            |
            v
   Threshold + policy + audit
         /          \
        v            v
 Escalation      Workflow
   umana         autorizzato
            |
            v
       Strumenti reali
       (token limitati)

La decisione del modello NON autorizza strumenti.

Richiesta riproducibile, senza inventare SDK .NET non documentati

L’esempio seguente usa semplicemente la normale HttpClient di .NET, l’endpoint REST pubblicato e System.Net.Http.Json. È una demo di routing e non una autorizzazione ad aprire ticket o mutare dati GIS. Il valore 0.90 è una soglia illustrativa da sostituire con una soglia scelta e calibrata su un dataset reale; nessuna probabilità del modello va considerata automaticamente calibrata.

// Console .NET 10/11: OPENAI_API_KEY nell’ambiente.
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;

var key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")
    ?? throw new InvalidOperationException("Missing OPENAI_API_KEY");

using var http = new HttpClient {
    BaseAddress = new Uri("https://api.openai.com/")
};
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", key);

var request = new {
    model = "gpt-6-luna",
    input = "The rain map service returns HTTP 500",
    questions = new[] { new {
        type = "choice",
        name = "triage",
        instructions = "Which team should investigate this issue?",
        choices = new[] {
            new { value = "gis", description = "Map, GIS or spatial service" },
            new { value = "infra", description = "Host, network, certificate" },
            new { value = "other", description = "Ambiguous or unrelated" }
        }
    }}
};

using var response = await http.PostAsJsonAsync("v1/decisions", request);
response.EnsureSuccessStatusCode();
using var body = await JsonDocument.ParseAsync(
    await response.Content.ReadAsStreamAsync());
var answer = body.RootElement.GetProperty("answers")[0];

if (answer.GetProperty("type").GetString() != "choice") {
    Console.WriteLine("Review required: no choice answer");
    return;
}
var team = answer.GetProperty("choice").GetString();
var confidence = answer.GetProperty("confidence").GetDouble();

// Demo only: calibrare su ground truth e costo degli errori.
Console.WriteLine(confidence >= 0.90 && team != "other"
    ? $"Proposed triage: {team} (review/policy still required)"
    : "Human review required");

La risposta alle domande choice include sia una distribuzione di probabilità sulle categorie sia un campo confidence; per predicate viene fornita una stima della probabilità della condizione. Non vanno confusi: sono grandezze emesse dall’API, non la garanzia che su 100 casi con score 0,9 se ne azzecchino esattamente 90. Servono dati etichettati, curva di calibrazione, matrice di confusione, costi asimmetrici di falsi positivi e negativi e un percorso per i rifiuti o i casi other. Per una scelta binaria con probabilità calibrata p, il classico cutoff derivato dai costi C_FP/(C_FP+C_FN) è significativo solo dopo avere esplicitato le ipotesi su perdite e distribuzione delle classi.

8 ottobre: GPT-6.1 Sol Ultrafast e la latenza di orchestrazione

L’8 ottobre il changelog OpenAI registra il supporto Ultrafast per gpt-6.1-sol nella Responses API. La configurazione è service_tier: "ultrafast"; il servizio dichiara rate limit separati e supporto alla residenza dati negli Stati Uniti e nell’area EU per Sol, secondo i requisiti applicabili. La guida raccomanda connessioni WebSocket persistenti, soprattutto per applicazioni agentiche con molte chiamate consecutive a tool: senza riuso della connessione il costo di rete può erodere il beneficio della velocità di generazione.

// Corpo JSON minimale documentato per Responses API
{
  "model": "gpt-6.1-sol",
  "service_tier": "ultrafast",
  "input": "Produce a concise incident summary."
}

// Performance engineering: non misurare solo tokens/sec.
T_task = T_network + T_inference + T_tools + T_retries
       + T_validation + T_commit

C_success = (C_model + C_tools + C_retries + C_ops)
          / P(task completed correctly)

Formule architetturali illustrative, non metriche vendor.

Per un agente che fa dieci chiamate sequenziali, il tempo totale non coincide con il tempo della singola generazione. Bisogna isolare TTFT (time to first token), intervalli fra token, p95 end-to-end, latenza delle chiamate a strumenti e tempi di validazione, controllando differenze fra processing tier e region. Ultrafast ha un costo più elevato documentato dal vendor: la decisione economica va presa sul costo per task corretto entro SLA, non sul miglior risultato isolato di streaming.

Un altro aggiornamento, del 7 ottobre, modifica il puntatore chat-latest verso lo snapshot più recente di ChatGPT. Per una pipeline riproducibile questo è un promemoria: un alias mobile facilita la sperimentazione ma non è una promessa di immutabilità delle risposte. Per test e produzione conviene registrare almeno model ID effettivo, versione del prompt, parametri, dataset eval e data dell’esperimento.

VISIONE
Si sta formando una separazione architetturale interessante: decision service economico e tipizzato per classificazioni ad alto volume, reasoning/orchestrator per task non deterministici complessi, policy engine deterministico per autorizzazione e invarianti. Non tutto ciò che chiamiamo “agente” ha bisogno di un orchestratore generale; in alcuni workflow la scelta migliore è una decisione probabilistica circoscritta seguita da un comando tradizionale verificabile.

Fonti primarie: OpenAI API Changelog — 6, 7 e 8 ottobre 2026 · OpenAI, Decisions API (beta), schema e pricing · OpenAI, Ultrafast mode, configurazione e limiti

05 — Sintesi architetturale: AI nel control plane, invarianti nel dominio

Il collegamento fra le quattro notizie è più concreto di una narrativa sull’intelligenza artificiale. Il runtime async elimina oggetti quando dimostra che il programma non li può osservare; SHAP offre una spiegazione sulla rappresentazione sfruttata dal modello, ma non sostituisce la verifica causale o spaziale; gli Agent Skills aumentano la probabilità di una corretta implementazione, ma non sostituiscono compilazione e regression; una API di decisione tipizzata produce una proposta probabilistica, ma non ha alcuna autorità sul dominio.

OSSERVAZIONI + DATI
                       |
       [normalizzazione e provenienza]
                       |
                  EMBEDDING
                       |
         [modello, versione, drift]
                       |
                INFERENZA / SHAP
                       |
               DECISION PROPOSAL
                       |
       [policy, permission, validation]
                       |
                 DOMAIN COMMAND
                       |
             AUTHORITATIVE STATE
                       |
           [audit, rollback, metrics]

Separazione architetturale proposta, non diagramma vendor.

Per un’app GIS enterprise potremmo tradurre questo schema in un servizio .NET che acquisisce dati da ArcGIS, calcola o recupera descrittori contestuali, usa un classificatore tipizzato per suggerire una categoria, impone policy e controllo dell’utente per le operazioni mutative e infine registra un comando validato. La UI, realizzata con Experience Builder o Blazor, visualizza stato e proposta ma non diventa l’autorità sulle modifiche. La tracciabilità minima include input data version, modello, prompt, score, utente approvatore, comando e risultato operativo.

VALUTAZIONE
Questo disegno evita due estremi: trattare la GenAI come un semplice widget di chat decorativo e, all’opposto, concederle accesso diretto a qualsiasi funzione applicativa. Il guadagno principale può essere una migliore divisione dei compiti: probabilistico dove serve inferire, deterministico dove serve garantire.

Technical Takeaways

  • .NET 11 runtime async: il confine fra metodi async e oggetti Task diventa più ottimizzabile; applicazioni ancora opt-in, beneficio da misurare su allocazioni e latenza reali, non solo sui nanosecondi di un esempio.
  • C# Dev Kit 11.0: Native AOT, meno processi e cache dei progetti sono scelte architetturali che accorciano il feedback loop; i benchmark Microsoft si riferiscono al server Dev Kit, non alla memoria totale dell’IDE.
  • GeoAI e SHAP: l’interpretabilità dei quattro segmenti è un buon punto di partenza, non una decomposizione causale. La domanda successiva è sempre: quanto regge su territori e tempi mai visti?
  • Experience Builder: uno skill formalizza convenzioni e conoscenza tecnica; release matrix, test, web components e review continuano a definire la compatibilità effettiva.
  • LLM systems: Decisions API e Ultrafast suggeriscono di selezionare la superficie API per il lavoro richiesto. Confidence, latenza e costo hanno senso soltanto rispetto a qualità, policy, SLA e dataset di valutazione.

Lab della settimana

Lab 1 — Runtime async: lo stesso workload, due lowering, risultati falsificabili

Setup: installare .NET 10 e una RC di .NET 11, creare un progetto di benchmark, eseguire in Release sullo stesso computer senza cambiare governor/affinità o condizioni di carico. Usare l’esperimento pubblicato da Toub con metodi RuntimeAsyncMethodGeneration(false) e le varianti runtime-async in un progetto con <Features>$(Features);runtime-async=on</Features>. Misurare metodo senza sospensione e con Task.Yield(); registrare runtime build, architettura CPU, throughput, media, deviazione e allocazioni. Poi ripetere su una catena applicativa reale: qui il risultato può essere nullo, positivo o regressivo. Documentazione e codice completo: Stephen Toub, sezione Runtime Async.

Lab 2 — SHAP a segmenti: importanza globale contro ablation e spatial holdout

Setup: in ArcGIS Pro usare la layer USA Geodemographic Embeddings di Living Atlas, una variabile target appropriata e Train Using AutoML in Basic Mode con Output Importance Table. Raggruppare i record embedding_1..256 in quattro intervalli di 64, sommare IMPORTANCE e normalizzare la quota di ogni gruppo. Addestrare un secondo modello senza il segmento dominante; confrontare il decadimento della metrica su validazione casuale e per blocchi spaziali. Non attribuire il decadimento esclusivamente a causalità: la prova valuta il valore predittivo incrementale nel disegno scelto. Fonti: workflow Esri del 6 ottobre, modello e dataset, fondamento scientifico dello spatial holdout.

Lab 3 — Experience Builder skill A/B: dalle istruzioni al contratto verificato

Setup: clonare le risorse SDK ufficiali Esri, predisporre una Developer Edition esplicitamente versionata e chiedere al medesimo coding agent di realizzare un widget che legge una FeatureLayer, risponde alla selezione della mappa e mantiene compatibile la configurazione. Eseguire tre run con prompt identico: senza skill, skill Esri, skill Esri + regole locali (solo se tali regole sono state effettivamente create). Per ogni run misurare build/test passati, riferimenti ad API obsolete, errori di runtime, accessibilità, correzioni umane, tool calls e tempo al widget funzionante. Includere test su almeno due versioni supportate se disponibili. Fonti: repository SDK/skill, contratti DataSource, migrazione 2027.

Micro-esperimento extra, già incorporato nella sezione LLM: eseguire il client HttpClient della Decisions API su un set di incident già etichettati. Confrontare accuracy, false-route rate e coverage rispetto a un router deterministico; solo in un secondo momento valutare latenza e prezzo. Documentazione: Decisions API.


NicoGIS Tech Weekly · edizione del 12 ottobre 2026. Analisi indipendente e non promozionale. Nessun benchmark dell’autore viene spacciato per misurazione svolta: i numeri citati sono quelli delle fonti primarie, con ambito e limiti esplicitati. “Analisi”, “Valutazione” e “Visione” identificano inferenze o proposte progettuali, non comunicazioni ufficiali dei vendor.