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.
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.
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.
| Superficie | Rischio | Controllo |
|---|---|---|
| SQL scripts | Mutazioni non intenzionali | Account read-only, transazioni e ambienti di test |
| AI tool calls | Esfiltrazione, modifiche non approvate | Permission gating, review, audit |
| NuGet | Supply-chain compromise | Version pinning, feed policy, source mapping |
| Dump / DataGrid | Esposizione dati sensibili | Mascheramento, dataset sintetici |
| File esterni | Script non attendibili | Mark-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
| Release | Innovazioni documentate |
|---|---|
| 9.5 / 9.4 | SQL-to-LINQ con AI, SQL completion, schema-aware agent |
| 9.6 | Util.AI.Ask, source generators, Util.Markdown |
| 9.7 | GitHub Copilot provider, ECharts, nuovi HTML controls |
| 9.8 | Tool agentici, .NET 11/C# 15 preview, CLR host |
| 9.9 | Claude Code, strumenti su assembly e progetti esterni, JSON outlining |
| 9.10 | SQL Server 2025 JSON/VECTOR, LINQ-to-SQL avanzato, sicurezza file/NuGet |
| 9.11 | Self-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
- LINQPad 9 — What’s New, file HTML di release note fornito per la redazione dell’articolo (versioni 9.4–9.11).
- LINQPad — sito ufficiale.
- Microsoft Learn — C#.
- Microsoft Learn — Entity Framework Core.
- Microsoft Learn — SQL Server.
- 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.
Commenti