L’altra settimana stavo guardando la sessione di Damian Edwards al Microsoft Build 2025 e mi sono imbattuto in una funzionalità che ha risolto uno dei miei problemi più fastidiosi. Fino ad ora, quando dovevo testare un codice veloce, andavo su internet a cercare un compilatore .NET online, incollavo il codice per vedere il risultato solo per non creare un progetto da zero. Questo è come faccio io, e probabilmente anche tu. Finalmente con .NET 10 posso dire addio a questa abitudine!

Il mio workflow prima (forse anche il tuo)

La situazione classica: sto scrivendo codice, mi viene un dubbio su come funziona una specifica funzione di LINQ, o voglio verificare rapidamente se un regex che ho scritto funziona come penso. Cosa facevo?

  • Apro il browser
  • Cerco “dotnet online compiler“
  • Finisco su dotnetfiddle.net o simili
  • Incollo il codice
  • Clicco Run
  • Spero che il sito non sia lento

Tutto questo solo per evitare di:

  • Creare una cartella
  • Fare dotnet new console
  • Modificare il Program.cs
  • Eseguire dotnet run

La rivoluzione di dotnet run in .NET 10

Con .NET 10, Microsoft ha finalmente ascoltato i nostri lamenti. Ora posso semplicemente creare un file .cs e eseguirlo direttamente con dotnet run. Niente più progetti, niente più configurazioni, niente più perdite di tempo.

Come funziona nella pratica

Immagina di avere un file chiamato test.cs con questo contenuto:

using System;
using System.Linq;

var numeri = new[] { 1, 2, 3, 4, 5 };
var risultato = numeri.Where(x => x % 2 == 0).Sum();
Console.WriteLine($"La somma dei numeri pari è: {risultato}");

Prima di .NET 10, avresti dovuto creare un progetto completo. Ora? Semplicemente:

dotnet run test.cs

E il gioco è fatto. Il codice viene compilato ed eseguito immediatamente.

Perché questa funzionalità mi entusiasma

Nella mia esperienza come sviluppatore, ho sempre creduto che la semplicità è l’ultima sofisticazione. Questa nuova funzionalità incarna perfettamente il principio KISS che tanto predico nei miei articoli. Non serve complicare le cose quando si può fare di meglio con meno.

Velocità di prototipazione

Quando sto esplorando una nuova libreria o testando un algoritmo, la velocità è tutto. Non voglio perdere il filo del pensiero per configurare un progetto. Voglio scrivere, testare, iterare. Questa funzionalità elimina completamente l’attrito tra idea e implementazione.

Addio ai compilatori online

Non devo più dipendere dalla connessione internet o da siti esterni per testare snippet di codice. Tutto rimane nel mio ambiente di sviluppo, con i miei strumenti, le mie configurazioni. È come avere sempre a portata di mano un blocco note per gli appunti, ma per il codice.

Esempi pratici che uso quotidianamente

Test rapidi di LINQ

using System;
using System.Linq;

var persone = new[]
{
    new { Nome = "Marco", Età = 25 },
    new { Nome = "Anna", Età = 18 },
    new { Nome = "Luca", Età = 15 }
};

var adulti = persone.Where(p => p.Età >= 18).Select(p => p.Nome);
Console.WriteLine(string.Join(", ", adulti));

Salvo questo come linq-test.cs e lo eseguo con dotnet run linq-test.cs. Immediato.

Verifica di regex

using System;
using System.Text.RegularExpressions;

var pattern = @"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$";
var emails = new[] { "test@example.com", "invalid-email", "user@domain.co.uk" };

foreach (var email in emails)
{
    var isValid = Regex.IsMatch(email, pattern);
    Console.WriteLine($"{email}: {(isValid ? "Valida" : "Non valida")}");
}

Perfetto per verificare rapidamente se un pattern funziona come previsto.

Calcoli matematici complessi

using System;

double CalcolaInteresseComposto(double capitale, double tasso, int anni)
{
    return capitale * Math.Pow(1 + tasso, anni);
}

var risultato = CalcolaInteresseComposto(1000, 0.05, 10);
Console.WriteLine($"Dopo 10 anni: €{risultato:F2}");

I vantaggi nascosti

Anche se si tratta di file singoli, posso comunque usare il debugger. Basta aggiungere il flag --debug:

dotnet run --debug test.cs

Gestione delle dipendenze

Se ho bisogno di NuGet packages, posso specificarli direttamente nel file:

#:package Newtonsoft.Json@13.*

using System;
using Newtonsoft.Json;

var obj = new { Nome = "Test", Valore = 42 };
var json = JsonConvert.SerializeObject(obj);
Console.WriteLine(json);

Quando non usarla

Come sempre, non esiste una soluzione universale. Questa funzionalità è perfetta per:

  • Prototipazione rapida
  • Test di algoritmi
  • Verifica di snippet
  • Esempi didattici

Ma se stai sviluppando un’applicazione vera, con più file e dipendenze complesse, un progetto strutturato rimane la scelta migliore. Come dico sempre nei miei articoli, l’architettura software non è una taglia unica.

Conclusione

Questa funzionalità di .NET 10 rappresenta per me un perfetto esempio di come Microsoft stia ascoltando la community. Non è una feature rivoluzionaria che cambierà il mondo, ma risolve un problema reale che tutti noi sviluppatori abbiamo vissuto.
La prossima volta che avrai bisogno di testare rapidamente un pezzo di codice, ricordati di questa funzionalità. Ti farà risparmiare tempo e ti permetterà di rimanere nel flusso del pensiero, che è esattamente quello che serve quando stai programmando.


E tu? Hai mai perso tempo a cercare compilatori online per testare snippet di codice? Fammi sapere nei commenti come questa nuova funzionalità cambierà il tuo workflow quotidiano!

Taggato in:

, , , , ,