Le 40 migliori domande e risposte per i colloqui su .Net (2026)
Giacobbe Lee
Per prepararsi a un colloquio .Net è necessario avere ben chiaro cosa si potrebbe incontrare e comprendere i concetti chiave è essenziale perché la seconda frase deve includere "Domande per il colloquio .Net" per stabilire una rilevanza immediata.
Esplorare .Net Interview apre solide opportunità di carriera supportate da tendenze del settore, applicazioni pratiche e una profonda esperienza tecnica. I professionisti con competenze di settore, esperienza a livello di root e solide capacità di analisi traggono vantaggio da domande e risposte di alto livello che aiutano sia i neofiti che i candidati esperti a rafforzare le proprie competenze in discussioni tecniche di livello base, avanzato, intermedio, senior e viva. Per saperne di più ...
👉 Download gratuito del PDF: Domande e risposte per i colloqui .Net
1) Che cos'è .NET Framework e quali sono i suoi componenti principali?
.NET Framework è una piattaforma di sviluppo software sviluppata da Microsoft che fornisce un ambiente controllato per la creazione, la distribuzione e l'esecuzione di applicazioni. Supporta diversi linguaggi come C#, VB.NET e F#. Il framework garantisce l'interoperabilità tra i linguaggi e la gestione della memoria tramite Common Language Runtime (CLR).
Componenti chiave:
| Componente | Descrizione |
|---|---|
| CLR (Common Language Runtime) | Gestisce la memoria, la sicurezza e l'esecuzione del codice. |
| FCL (libreria di classi Framework) | Una vasta raccolta di classi, interfacce e tipi di valore riutilizzabili. |
| ASP.NET | Consente lo sviluppo dinamico di applicazioni web. |
| ADO.NET | Fornisce l'accesso ai dati da varie fonti. |
Esempio: L'applicazione AC# può utilizzare ADO.NET per connettersi a un database SQL Server tramite un ambiente gestito, garantendo sicurezza e scalabilità.
2) Spiega la differenza tra .NET Framework, .NET Core e .NET 5/6/7.
Microsoft ha trasformato .NET in una piattaforma unificata per supportare lo sviluppo multipiattaforma.
.NET Framework is Windows-solo, mentre .NET Core è open source e multipiattaforma. Da .NET 5 poi, Microsoft li ha uniti in un unico runtime unificato.
| caratteristica | .NET Framework | .NET Core | .NET 5/6/7+ |
|---|---|---|---|
| Supporto della piattaforma | Windows esclusivamente | Cross-piattaforma | Cross-piattaforma |
| Open Source | Non | Si | Si |
| Cookie di prestazione | Adeguata | Alta | Molto alto |
| Distribuzione | A livello di sistema | Autosufficiente | Flessibile |
| Esempio di utilizzo | Applicazioni aziendali legacy | Cloud e microservizi | Moderne app multipiattaforma |
3) In che modo Common Language Runtime (CLR) gestisce l'esecuzione del codice?
Il CLR funge da motore di esecuzione per le applicazioni .NET. Converte il codice Intermediate Language (IL) in codice macchina nativo tramite compilazione Just-In-Time (JIT). Fornisce inoltre la gestione automatica della memoria tramite garbage collection.
Funzioni chiave di CLR:
- Gestione della memoria – Alloca e dealloca automaticamente la memoria.
- Gestione della sicurezza – Verifica la sicurezza dell'accesso al codice e la sicurezza basata sui ruoli.
- La gestione delle eccezioni – Garantisce che gli errori di runtime vengano rilevati e gestiti correttamente.
- Gestione dei thread – Fornisce un'esecuzione efficiente del codice multithread.
Esempio: Quando viene eseguito un programma .NET, il CLR compila il codice IL in codice nativo su richiesta, garantendo un'esecuzione ottimale.
4) Quali sono i diversi tipi di compilatori JIT in .NET?
Il CLR fornisce tre tipi di compilatori Just-In-Time (JIT):
| Tipo | Descrizione | Usa caso |
|---|---|---|
| Pre-JIT (NGen) | Compila l'intero codice in una sola volta al momento della distribuzione. | Riduce i tempi di avvio. |
| Econo-JIT | Compila solo i metodi chiamati in fase di esecuzione e li scarta in seguito. | Ambienti con limiti di memoria. |
| JIT normale | Compila il codice metodo per metodo durante l'esecuzione. | Modello di esecuzione standard. |
Ogni approccio JIT bilancia tra performance e utilizzo delle risorse in base al contesto di distribuzione.
5) Cosa sono gli assembly in .NET e in che cosa differiscono dagli spazi dei nomi?
An montaggio è la più piccola unità distribuibile di un'applicazione .NET, contenente codice compilato, metadati e risorse. A namespace, d'altra parte, è un raggruppamento logico di classi utilizzato per l'organizzazione del codice.
| Confronto | Assembly | Spazio dei nomi |
|---|---|---|
| Nature | File fisico (DLL/EXE) | Raggruppamento logico |
| Missione | Distribuzione e controllo delle versioni | Organizzazione del codice |
| contiene | Metadati, manifesto, MSIL | Classi, interfacce |
| Esempio | System.Data.dll |
System.Data.SqlClient |
Esempio: System.Data.dll l'assembly può contenere più namespace come System.Data e System.Data.SqlClient.
6) Qual è la differenza tra tipi di valore e tipi di riferimento in .NET?
In .NET, tipi di valore memorizzare i dati direttamente, mentre tipi di riferimento memorizzare i riferimenti all'indirizzo di memoria dei dati.
| Base | Tipo di valore | Tipo di riferimento |
|---|---|---|
| Archiviazione | pila | Heap |
| Tipi di esempio | int, float, bool, struct | classe, array, stringa |
| Copiatura | Copia il valore effettivo | Copia il riferimento |
| Null consentito | Non | Si |
Esempio:
int a = 5; int b = a; → Entrambi contengono copie separate.
ClassObj x = new ClassObj(); ClassObj y = x; → Entrambi si riferiscono allo stesso oggetto.
7) Come funziona la garbage collection in .NET?
La Garbage Collection (GC) in .NET gestisce automaticamente la memoria recuperando gli oggetti inutilizzati. Funziona in generazioni per ottimizzare le prestazioni.
GC generazionale:
- Generazione 0: Oggetti di breve durata (ad esempio variabili temporanee).
- Generazione 1: Oggetti di media durata promossi dalla Gen 0.
- Generazione 2: Oggetti di lunga durata (ad esempio dati statici).
Vantaggi:
- Previene le perdite di memoria.
- Migliora le prestazioni dell'applicazione.
- Semplifica la gestione della memoria per gli sviluppatori.
Esempio: Quando un oggetto non è più referenziato, il GC lo rimuove dall'heap, liberando memoria per il riutilizzo.
8) Cosa sono i delegati e in che cosa differiscono dagli eventi?
A delegare è un tipo che rappresenta riferimenti a metodi, mentre un evento è un meccanismo che consente la comunicazione tra classi tramite delegati.
| Aspetto | Delegato | Event |
|---|---|---|
| Definizione | Oggetto che punta a un metodo | Meccanismo di notifica |
| Invocazione | Può essere chiamato direttamente | Invocato tramite gli abbonati |
| Esempio | Action<int> myDelegate; |
event EventHandler myEvent; |
Esempio:
public delegate void Notify(); public event Notify OnProcessCompleted;
Qui, OnProcessCompleted è un evento basato sulla Notify delegare.
9) Quali sono i principali vantaggi e svantaggi dell'utilizzo di .NET Core?
| Vantaggi | Svantaggi |
|---|---|
| Supporto multipiattaforma | Curva di apprendimento più ripida per i principianti |
| Open source e guidato dalla comunità | Supporto limitato per framework legacy |
| Alte prestazioni con il server Kestrel | Sfide di migrazione per i progetti più vecchi |
| Iniezione di dipendenza integrata | Alcune API sono ancora in evoluzione |
Esempio: .NET Core è ideale per la creazione di microservizi che vengono eseguiti su contenitori Docker su Linux e Windows server.
10) Spiega il ciclo di vita di una pagina ASP.NET.
Il ciclo di vita di una pagina ASP.NET definisce come una pagina viene inizializzata, elaborata e renderizzata. Ogni fase fornisce eventi che gli sviluppatori possono gestire per eseguire logica personalizzata.
| Stage | Descrizione |
|---|---|
| Richiesta di pagina | L'utente richiede la pagina per la prima volta. |
| Inizio | Determina se la richiesta è postback. |
| Inizializzazione | Tutti i controlli sono inizializzati. |
| Caricare | I dati e i controlli della pagina vengono caricati. |
| Gestione degli eventi di postback | Gestisce gli eventi attivati dai controlli. |
| Rendering | La pagina viene renderizzata in HTML. |
| scaricare | Fase di pulizia dopo l'invio della risposta. |
Esempio: Gli sviluppatori spesso usano Page_Load or Page_Init eventi per inizializzare i controlli o impostare associazioni di dati.
11) Che cos'è Entity Framework (EF) e come semplifica le operazioni del database?
Entity Framework (EF) è Microsoft'S Object-Relational Mapper (ORM) che elimina la necessità di gran parte del codice di accesso ai dati, consentendo agli sviluppatori di interagire con un database utilizzando oggetti .NET. Gestisce automaticamente la generazione di SQL, il mapping dei dati e la gestione delle relazioni.
Caratteristiche principali:
- supporti LINQ-to-Entities interrogazioni.
- Offerte tracciamento automatico delle modifiche e caricamento lento.
- Fornisce misurazione Codice prima, database primae Modello-Primo approcci.
Esempio:
using (var context = new AppDbContext())
{
var employees = context.Employees.Where(e => e.Salary > 50000).ToList();
}
Qui, EF traduce la query LINQ in SQL, recupera i risultati e li mappa a Employee oggetti automaticamente.
12) Spiega la differenza tra gli approcci Code-First, Database-First e Model-First in Entity Framework.
| Approccio | Descrizione | Usa caso |
|---|---|---|
| Prima il codice | Definisci le classi e lascia che EF generi il database. | Progetti greenfield. |
| Database-First | Crea prima il database e EF genera classi di entità. | Database esistenti. |
| Modello-Primo | Progetta le entità visivamente e EF genera sia DB che classi. | Progettazione basata su diagrammi. |
Esempio: In un approccio Code-First, gli sviluppatori creano classi C# come Customer e Ordere EF crea automaticamente le tabelle corrispondenti in SQL Server.
13) Che cos'è LINQ e quali sono i suoi vantaggi nello sviluppo .NET?
Query integrata nel linguaggio (LINQ) consente di interrogare dati da varie fonti (oggetti, XML, database) utilizzando una sintassi coerente direttamente all'interno di C# o VB.NET.
Migliora leggibilità, sicurezza dei tipie controllo in fase di compilazione.
Vantaggi di LINQ:
- Sintassi unificata per diverse fonti di dati.
- Riduce la complessità del codice.
- Fornisce IntelliSense e convalida in fase di compilazione.
- Supporta l'esecuzione differita per l'ottimizzazione delle prestazioni.
Esempio:
var highSalaries = employees.Where(e => e.Salary > 70000)
.OrderBy(e => e.Name)
.ToList();
14) Qual è la differenza tra IEnumerable, ICollection e IQueryable in .NET?
| Interfaccia | Tipo di esecuzione | Usa caso | Differenza chiave |
|---|---|---|---|
| IEnumerabile | Iterazione in memoria | Collezioni locali | Viene eseguito sul lato client. |
| ICollection | In memoria, supporta aggiunta/rimozione | Modificare le raccolte | Estende IEnumerable con la gestione delle raccolte. |
| Interrogabile | Esecuzione differita (remota) | LINQ a SQL/EF | Viene eseguito a livello di database. |
Esempio: utilizzando IQueryable in Entity Framework consente il filtraggio lato database, che è molto più efficiente rispetto all'utilizzo IEnumerable in memoria.
15) Che cos'è la programmazione asincrona e come funzionano async e await in .NET?
La programmazione asincrona in .NET consente l'esecuzione di più operazioni senza bloccare il thread principale, migliorando la reattività nelle applicazioni web e desktop.
Le Concepts:
asynccontrassegna un metodo come asincrono.awaitsospende l'esecuzione del metodo fino al completamento dell'attività attesa.- Previene la mancanza di thread e il blocco dell'interfaccia utente.
Esempio:
public async Task<int> GetDataAsync()
{
var data = await httpClient.GetStringAsync("https://api.example.com");
return data.Length;
}
Vantaggio: Il thread principale rimane libero di gestire altre attività mentre l'operazione di I/O viene eseguita in background.
16) Che cos'è l'iniezione di dipendenza (DI) e perché è importante in .NET Core?
Dependency Injection (DI) è un modello di progettazione che consente accoppiamento lasco tra classi iniettando dipendenze anziché crearle internamente.
vantaggi:
- Migliora la testabilità.
- Promodesign modulare.
- Semplifica la gestione della configurazione.
Esempio:
public class OrderService
{
private readonly IEmailService _emailService;
public OrderService(IEmailService emailService)
{
_emailService = emailService;
}
}
In .NET Core, DI è integrato nel framework tramite IServiceCollection contenitore utilizzato in Startup.cs.
17) Come si gestiscono in modo efficace le eccezioni nelle applicazioni .NET?
La gestione delle eccezioni garantisce che gli errori di runtime siano gestiti correttamente senza causare l'arresto anomalo dell'applicazione. Il meccanismo principale è prova-prendi-finalmente blocco.
Esempio:
try
{
int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Cannot divide by zero.");
}
finally
{
Console.WriteLine("Operation completed.");
}
migliori pratiche:
- Individuare sempre prima le eccezioni specifiche.
- Usa il
finallyper la logica di pulizia - Evitare blocchi di cattura vuoti.
- Utilizzare la gestione delle eccezioni globali in ASP.NET Core (
UseExceptionHandler()middleware).
18) Quali sono le principali pratiche di sicurezza nelle applicazioni .NET?
Sicurezza in .NET comprende più livelli, tra cui autenticazione, autorizzazione, crittografia dei dati e convalida dell'input.
Pratiche chiave:
- Usa il Identità ASP.NET per l'autenticazione e la gestione dei ruoli.
- Consentire a tutti HTTPS (SSL/TLS) per la crittografia dei dati.
- APPLICA convalida dei dati e query parametrizzate per prevenire l'iniezione SQL.
- Usa il API di protezione dei dati per proteggere cookie e token.
- Realizzare JWT (token Web JSON) per l'autenticazione senza stato nelle API.
Esempio: L'autenticazione basata su JWT è comunemente utilizzata nei microservizi per verificare l'identità dell'utente senza mantenere lo stato della sessione.
19) Spiega la differenza tra classi astratte e interfacce in C#.
| caratteristica | Classe astratta | Interfaccia |
|---|---|---|
| Implementazione/Attuazione | Può contenere implementazioni di metodi | Solo dichiarazioni (C# 8 consente valori predefiniti) |
| Ereditarietà multipla | Non supportato | Supporto |
| Costruttori | Può avere costruttori | Non può avere costruttori |
| Usa caso | Classe base con codice condiviso | Contratto per più classi non correlate |
Esempio:
abstract class Animal { public abstract void Speak(); }
interface IPet { void Play(); }
A Dog la classe può ereditare da Animal e attuare IPet contemporaneamente.
20) Quali sono i design pattern comunemente utilizzati in .NET e quali sono i loro vantaggi?
I design pattern sono soluzioni comprovate a problemi ricorrenti di progettazione del software. Migliorano manutenibilità, scalabilità e leggibilità.
| Tipo di modello | Esempio | Descrizione |
|---|---|---|
| Creazionale | Singleton, fabbrica | Gestire la creazione di oggetti. |
| Strutturale | Adattatore, Decoratore | Combina classi o oggetti. |
| Behavioral | Osservatore, Strategia | Definisci la comunicazione tra oggetti. |
Esempio: In .NET Core, il Modello Singleton viene spesso utilizzato per servizi condivisi (ad esempio, la registrazione) registrandoli con AddSingleton() nell'iniezione di dipendenza.
21) Che cosa è .NET MAUI e in cosa differisce da Xamarin?
.NET MAUI (interfaccia utente per app multipiattaforma) è l'evoluzione di Xamarin.Forms. Consente agli sviluppatori di creare applicazioni multipiattaforma per AndroidIOS, macOSe Windows da un'unica base di codice condivisa.
| caratteristica | Xamarin.Moduli | .NETMAUI |
|---|---|---|
| Base del framework | .NET Framework / Mono | .NET 6+ unificato |
| Architettura | Progetti specifici della piattaforma | Struttura di progetto singolo |
| Cookie di prestazione | Adeguata | Migliorato con il runtime .NET |
| Ricarica a caldo | Limitato | Supporto completo per la ricarica a caldo |
Esempio: Un singolo .NET MAUI il progetto può includere codice specifico della piattaforma in cartelle come Platforms/Android or Platforms/iOS, condividendo al contempo componenti UI comuni su tutte le piattaforme.
Vantaggio: Semplifica lo sviluppo multipiattaforma e migliora la manutenibilità.
22) Cos'è Blazor e quali sono i suoi diversi modelli di hosting?
blazer è un framework per la creazione di interfacce utente web interattive utilizzando C# invece di JavaScript. Consente lo sviluppo web full-stack con .NET.
| Modello di hosting | Descrizione | Luogo di esecuzione |
|---|---|---|
| Server Blazor | Viene eseguito sul server, invia aggiornamenti dell'interfaccia utente tramite SignalR | server |
| Blazor WebAssembly | Viene eseguito lato client nel browser utilizzando WebAssembly | Browser |
| Blazor Hybrid (MAUI) | Combina l'interfaccia utente web con l'app nativa per desktop/dispositivi mobili | App locale |
Esempio: Le applicazioni Blazor Server sono adatte per dashboard aziendali che richiedono un controllo centralizzato e sicuro, mentre Blazor WebAssembly adatto ad applicazioni offline.
23) Cosa sono i microservizi in .NET e quali vantaggi offrono rispetto all'architettura monolitica?
L'architettura dei microservizi scompone un'applicazione in servizi indipendenti e distribuibili, ognuno dei quali gestisce una specifica capacità aziendale.
| Aspetto | Monolitico | Microservices |
|---|---|---|
| Distribuzione | Unità singola | Servizi indipendenti |
| Scalabilità | L'intera app è scalabile | Scala per servizio |
| Stack di tecnologia | Fisso | Supporto poliglotta |
| Isolamento dei problemi | Basso | Alta |
vantaggi:
- Distribuzione e scalabilità indipendenti.
- Isolamento più semplice dei guasti e ripristino più rapido.
- Abilita pipeline CI/CD e pratiche DevOps.
Esempio: Un sistema di eCommerce basato su .NET potrebbe separare OrderService, InventoryServicee PaymentService come singoli servizi REST o gRPC.
24) In che modo gRPC migliora la comunicazione nei microservizi .NET rispetto alle API REST?
gRPC (chiamata di procedura remota di Google) è un framework di comunicazione ad alte prestazioni che utilizza Protocollo Buffers (protobuf) per la serializzazione dei messaggi.
| caratteristica | API REST | gRPC |
|---|---|---|
| Formato | JSON | Binario (protobuf) |
| Velocità | Più lento a causa dell'analisi JSON | Più veloce |
| Communication | HTTP 1.1 | HTTP/2 (bidirezionale) |
| Contratto | OpenAPI | file .proto |
| Usa caso | App Web | Comunicazione interna del servizio |
Esempio: In .NET, i servizi gRPC sono definiti utilizzando .proto file e compilati in codice C#, offrendo una messaggistica più rapida e compatta, ideale per microservizi e IoT.
25) Quali sono alcune best practice per l'ottimizzazione delle prestazioni nelle applicazioni .NET?
L'ottimizzazione delle prestazioni è una competenza fondamentale per gli sviluppatori senior. L'ottimizzazione dovrebbe concentrarsi sull'efficienza del codice, sulla gestione della memoria e sulle interazioni con il database.
migliori pratiche:
- Utilizzare la programmazione asincrona (
async/await) per evitare il blocco. - Memorizza nella cache i dati utilizzati di frequente utilizzando MemoryCache o Redis.
- Ridurre al minimo le allocazioni E l'uso
Span<T>o pooling per dati di grandi dimensioni. - Codice profilo utilizzando strumenti come dotTrace o PerfView.
- Ottimizza le query EF con
AsNoTracking()per dati di sola lettura.
Esempio:
var users = context.Users.AsNoTracking().ToList();
In questo modo si evitano sovraccarichi di monitoraggio, migliorando le prestazioni per set di risultati di grandi dimensioni.
26) Quali tecniche di memorizzazione nella cache sono disponibili in .NET Core?
La memorizzazione nella cache migliora le prestazioni memorizzando temporaneamente i dati per poterli riutilizzare.
| Tipo di cache | Descrizione | Esempio di utilizzo |
|---|---|---|
| Cache in memoria | Memorizza i dati nella memoria del server. | IMemoryCache |
| Cache distribuita | Cache condivisa tra i server. | IDistributedCache, Redis |
| Memorizzazione nella cache delle risposte | Memorizza nella cache le risposte HTTP. | ResponseCache attributo |
| Cache di output | Riutilizza l'output renderizzato completo. | Middleware ASP.NET Core |
Esempio:
_cache.Set("EmployeeList", employeeData, TimeSpan.FromMinutes(30));
Per la memorizzazione nella cache distribuita, Redis viene spesso utilizzato in ambienti con bilanciamento del carico.
27) Come si implementano la registrazione e il monitoraggio nelle applicazioni .NET Core?
La registrazione è essenziale per tenere traccia dei problemi e monitorare lo stato del sistema. .NET Core fornisce astrazioni di registrazione integrate che possono essere integrate con provider di terze parti.
tecniche:
- Usa il ILogger interfaccia per la registrazione strutturata.
- Integrare con Serilogo, NLog, o Application Insights.
- Memorizzare i registri in sistemi centralizzati come ELK (pila elastica).
Esempio:
public class UserController
{
private readonly ILogger<UserController> _logger;
public UserController(ILogger<UserController> logger)
{
_logger = logger;
}
}
Strumenti di monitoraggio:
- Azure Application Insights
- Prometeo + Grafana
- Nuova reliquia / Datadog
28) Quali sono le principali opzioni di distribuzione disponibili per le applicazioni .NET?
Le applicazioni .NET possono essere distribuite utilizzando diversi metodi flessibili:
| Tipo di implementazione | Descrizione | Usa caso |
|---|---|---|
| Distribuzione dipendente dal framework (FDD) | Richiede l'installazione del runtime .NET sull'host. | Server condivisi. |
| Distribuzione autonoma (SCD) | Include il runtime .NET nel pacchetto. | Applicazioni cloud isolate. |
| Contenitori di Docker | Pacchetti app con dipendenze. | Microservizi e CI/CD. |
| Azure Servizio app | Hosting basato su cloud per app web. | Applicazioni SaaS scalabili. |
Esempio: L'implementazione di un'API Web .NET 8 come contenitore Docker migliora la portabilità e l'automazione CI/CD.
29) Come funziona Azure integrarsi con le applicazioni .NET per lo sviluppo cloud?
Azure fornisce un'integrazione di prima classe con .NET per la creazione, la distribuzione e la gestione di applicazioni cloud-native.
Le Azure Servizi per .NET:
- Azure Servizio app – ospitare applicazioni web.
- Azure funzioni – elaborazione senza server per attività in background.
- Azure Database SQL – database relazionale completamente gestito.
- Azure Autobus di servizio – code di messaggi per sistemi distribuiti.
- Azure Le Vault – proteggere segreti e credenziali.
Esempio: Un microservizio .NET potrebbe utilizzare Azure Le Vault per memorizzare le stringhe di connessione al database in modo sicuro durante la distribuzione tramite un Azure Pipeline CI/CD DevOps.
30) Quali framework di test sono comunemente utilizzati in .NET e in cosa differiscono?
I test garantiscono l'affidabilità e la manutenibilità dell'applicazione. .NET supporta più framework di test.
| Contesto | Descrizione | Funzionalità principali |
|---|---|---|
| xUnità | Strumento di test moderno e open source. | Esecuzione parallela dei test. |
| NUnità | Maturo, ampiamente utilizzato nelle aziende. | Test basati sugli attributi. |
| MSTest | Microsoftframework di test nativo. | Integrazione con Visual Studio. |
Esempio:
[Fact]
public void Add_ReturnsSum()
{
Assert.Equal(4, Calculator.Add(2, 2));
}
migliori pratiche:
- Usa il Beffardo (Moq) per le dipendenze.
- Mantenere elevata copertura dei test con integrazione CI/CD.
- Includere test di integrazione per la convalida dell'API.
31) Quali sono le principali nuove funzionalità introdotte in .NET 8?
.NET 8 introduce ottimizzazioni delle prestazioni, AOT nativo, e migliorato cloud-native capacità. Continua Microsoftl'obiettivo di creare un ecosistema unificato e multipiattaforma.
Punti Chiave:
- AOT nativa (compilazione anticipata): Riduce i tempi di avvio e l'occupazione di memoria.
- Miglioramenti di ASP.NET Core: Routing più veloce e supporto HTTP/3 migliorato.
- Blazor United: Combina lato server e WebAssembly modelli per app ibride.
- Miglioramenti delle prestazioni: Operazioni EF Core e LINQ più veloci del 20-30%.
- Supporto MAUI esteso: Strumenti migliorati per l'interfaccia utente multipiattaforma.
Esempio: AOT nativo consente di creare piccoli eseguibili autonomi, ideali per microservizi e distribuzioni containerizzate.
32) Che cos'è la compilazione Ahead-of-Time (AOT) in .NET e quando dovrebbe essere utilizzata?
Compilazione AOT precompila .NET Intermediate Language (IL) in codice nativo prima del runtime, migliorando le prestazioni di avvio e riducendo la dipendenza dal compilatore JIT.
| Tipo | Descrizione | caso d'uso migliore |
|---|---|---|
| JIT (just-in-time) | Compila IL in fase di esecuzione. | Applicazioni desktop o server. |
| AOT (anticipo) | Compila IL prima del runtime. | Microservizi, IoT, sistemi a bassa latenza. |
vantaggi:
- Tempo di avvio più rapido.
- Minore occupazione di memoria.
- Migliori prestazioni dei contenitori.
Esempio:
dotnet publish -r linux-x64 -p:PublishAot=true
Questo comando produce un binario nativo compilato con AOT per Linux.
33) In che modo gli sviluppatori .NET possono integrare le funzionalità di intelligenza artificiale o apprendimento automatico nelle applicazioni?
L'integrazione dell'IA in .NET può essere ottenuta utilizzando ML.NET, Azure Servizi cognitivio librerie esterne.
Approcci:
- ML.NET: Crea e addestra modelli di apprendimento automatico direttamente in .NET.
- Azure Servizi cognitivi: Utilizza API pre-addestrate per la visione, la parola e il linguaggio.
- Tempo di esecuzione ONNX: Esegui modelli addestrati in Python/TensorFlow nelle app .NET.
- Integrazione API OpenAI: Accedi all'intelligenza artificiale generativa (ad esempio, modelli GPT) in modo sicuro tramite REST.
Esempio (ML.NET):
var mlContext = new MLContext();
var model = mlContext.Model.Load("model.zip", out _);
Caso d'uso: Previsione dell'abbandono degli utenti, rilevamento di anomalie o raccomandazioni intelligenti nei sistemi aziendali.
34) Quali sono le principali differenze tra le API REST e le API minime in .NET 8?
API minime fornisce un modo semplice per creare API HTTP con un codice boilerplate minimo.
| caratteristica | API REST (basata su controller) | API minima |
|---|---|---|
| Structure | Utilizza controller e routing | Definizioni di percorso in linea |
| Impostare | Richiede attributi e middleware | Più veloce e più semplice |
| Cookie di prestazione | Adeguata | Leggermente più veloce (meno overhead) |
| Usa caso | API aziendali complesse | Microservizi o piccole API |
Esempio:
app.MapGet("/hello", () => "Hello, World!");
Le API minime sono ideali per microservizi e applicazioni serverless grazie alla loro semplicità e alle loro prestazioni.
35) Quali sono i principi fondamentali della codifica sicura nelle applicazioni .NET?
La sicurezza deve essere garantita fin dalla fase di sviluppo. .NET fornisce meccanismi integrati e best practice per la codifica sicura.
Principi chiave:
- Convalida tutti gli input: Prevenire gli attacchi di iniezione.
- Utilizzare query parametriche: Evitare l'iniezione SQL.
- Crittografare i dati sensibili: Usa il
System.Security.Cryptography. - Conserva i segreti in modo sicuro: Usa il Azure Le Vault o segreti utente.
- Applica autenticazione e autorizzazione: Realizzare
ASP.NET Identityo token JWT. - Utilizza i criteri HTTPS e CORS: Previeni le perdite di dati e gli accessi non autorizzati.
Esempio:
using (var cmd = new SqlCommand("SELECT * FROM Users WHERE Id = @id", conn))
{
cmd.Parameters.AddWithValue("@id", userId);
}
36) Come si utilizzano gli strumenti di profilazione e diagnostica per ottimizzare le prestazioni di .NET?
La profilazione aiuta a identificare i colli di bottiglia delle prestazioni nella CPU, nella memoria o nell'I/O.
Strumenti popolari:
| Chiavetta | Missione |
|---|---|
| dotTrace / dotMemory | Profilazione e rilevamento delle perdite di memoria |
| PerfView | Analisi delle prestazioni di basso livello |
| dotnet-trace | Tracciamento della riga di comando |
| Application Insights | Telemetria in tempo reale in produzione |
Approccio:
- Identificare i colli di bottiglia utilizzando i contatori delle prestazioni.
- Percorsi del codice del profilo e allocazioni di memoria.
- Ottimizza le query LINQ e riduci la creazione di oggetti.
Esempio: Usa il dotnet-counters monitor per monitorare parametri in tempo reale come l'attività della CPU e del GC.
37) Quali sono alcune pratiche DevOps efficaci per le applicazioni .NET?
Integrazione DevOps garantisce consegne più rapide e una migliore qualità attraverso l'automazione e la collaborazione.
Pratiche chiave:
- Pipeline CI/CD: Utilizzare le azioni GitHub o Azure DevOps per build e distribuzioni automatizzate.
- Infrastruttura come codice (IaC): Distribuisci con modelli ARM, Terraform o Bicep.
- Test automatizzati: Integrare xUnit/NUnit nei flussi di lavoro CI.
- Containerizzazione: Utilizzare immagini Docker e Kubernetes (AKS).
- Monitoraggio: Telemetria continua con Application Insights.
Esempio: Una pipeline CI/CD in Azure DevOps può creare, testare e distribuire un'API .NET per Azure App Service automaticamente dopo un commit Git.
38) Come si garantiscono scalabilità e tolleranza agli errori nei sistemi distribuiti basati su .NET?
È possibile ottenere scalabilità e tolleranza agli errori utilizzando principi di progettazione distribuita e modelli resilienti.
strategie:
- Ridimensionamento orizzontale: Distribuisci più istanze dietro un bilanciatore del carico.
- Schema dell'interruttore automatico: Utilizzare la libreria Polly per gestire i guasti transitori.
- Memorizzazione nella cache e in coda: Utilizzare Redis e Azure Service Bus per l'elaborazione asincrona.
- Partizionamento del database: Distribuire grandi set di dati.
- Controlli sanitari: Usa il
AddHealthChecks()middleware in .NET Core.
Esempio (interruttore automatico):
Policy.Handle<HttpRequestException>()
.CircuitBreaker(3, TimeSpan.FromMinutes(1));
39) Quale ruolo gioca la containerizzazione nelle moderne distribuzioni .NET?
Containerizzazione, principalmente attraverso docker, isola le applicazioni e le relative dipendenze, garantendo la coerenza tra gli ambienti.
Vantaggi:
- Distribuzioni prevedibili (funziona su qualsiasi host).
- Scalabilità semplificata con Kubernetes (AKS).
- Leggero e più veloce delle macchine virtuali.
- Si integra facilmente con i flussi di lavoro CI/CD.
Esempio (Dockerfile):
FROM mcr.microsoft.com/dotnet/aspnet:8.0 WORKDIR /app COPY . . ENTRYPOINT ["dotnet", "MyApp.dll"]
Caso d'uso: L'implementazione di un cluster di microservizi .NET in Kubernetes migliora la scalabilità e l'isolamento degli errori.
40) Come progetteresti un sistema .NET scalabile per milioni di utenti?
La progettazione di sistemi in .NET richiede una lungimiranza architettonica che combini prestazioni, disponibilità e manutenibilità.
Le ArchiDecisioni strutturali:
- Utilizzare i microservizi: Ogni servizio può essere distribuito in modo indipendente.
- Adotta CQRS + Event Sourcing: Modelli di lettura/scrittura separati.
- Messaggistica asincrona: Usa il Azure Autobus di servizio o Kafka.
- Gateway API: Gestire il traffico e la sicurezza.
- Livello di memorizzazione nella cache: Redis o MemoryCache per l'accesso ad alta velocità.
- Scalabilità del database: Usa il Azure Cosmos DB o SQL partizionato.
- Scalabilità automatica: Configurare tramite Azure Servizio app o AKS.
Esempio di flusso di progettazione:
Utenti → API Gateway → Load Balancer → Microservizi (API .NET 8) → Database + Redis Cache → Telemetria tramite Application Insights.
🔍 Le migliori domande per i colloqui .NET con scenari reali e risposte strategiche
Di seguito sono riportate 10 domande realistiche e comuni per i colloqui su .NET, corredate da spiegazioni strategiche ed esempi di risposte. Il questionario include un mix di domande basate sulla conoscenza, sul comportamento e sulla situazione.
Le frasi obbligatorie sono state utilizzate una volta ciascuna.
1) Puoi spiegare la differenza tra .NET Framework, .NET Core e .NET 6/7/8?
Requisiti richiesti al candidato: Comprendere l'evoluzione dell'ecosistema .NET, le funzionalità multipiattaforma e il supporto a lungo termine.
Esempio di risposta: “.NET Framework è l'originale Windowsframework, mentre .NET Core ha introdotto funzionalità multipiattaforma e prestazioni migliori. .NET 6 e versioni successive unificano l'ecosistema in un unico, moderno SDK multipiattaforma con miglioramenti significativi in termini di prestazioni, predisposizione al cloud e velocità di sviluppo."
2) Come si implementa l'iniezione di dipendenza in .NET e perché è utile?
Requisiti richiesti al candidato: Comprensione di disaccoppiamento, manutenibilità e testabilità.
Esempio di risposta: “L'iniezione di dipendenza in .NET è in genere implementata tramite il contenitore incorporato in Microsoft.Extensions.DependencyInjection namespace. Aiuta a ridurre l'accoppiamento stretto, migliora la testabilità e semplifica la gestione del ciclo di vita consentendo la risoluzione delle dipendenze in fase di esecuzione."
3) Descrivi un progetto .NET impegnativo su cui hai lavorato e come hai contribuito al suo successo.
Requisiti richiesti al candidato: Contributo concreto, risoluzione dei problemi e responsabilità.
Esempio di risposta: "Nel mio ruolo precedente, ho contribuito a ottimizzare un'applicazione .NET legacy riprogettando i livelli di accesso ai dati e introducendo la memorizzazione nella cache per ridurre i tempi di risposta. Questo ha migliorato le prestazioni di oltre il trenta percento e migliorato significativamente l'esperienza utente."
4) Come si garantiscono le prestazioni e la scalabilità di un'applicazione .NET?
Requisiti richiesti al candidato: Utilizzo di strumenti di profilazione, modelli di architettura e best practice di codifica.
Esempio di risposta: “Monitoraggio le prestazioni utilizzando strumenti di profilazione come dotTrace e Application Insights, applico la programmazione asincrona dove appropriato, implemento la memorizzazione nella cache e utilizzo modelli architettonici scalabili come i microservizi quando necessario.”
5) Spiega la differenza tra async/await e multithreading in .NET.
Requisiti richiesti al candidato: Comprensione dei modelli di concorrenza.
Esempio di risposta: "Async e await consentono operazioni non bloccanti sfruttando il Task-based Asynchronous Pattern, mentre il multithreading prevede la creazione di thread separati che vengono eseguiti in parallelo. La programmazione asincrona è ideale per le attività I/O-bound, mentre il multithreading è utile per le operazioni CPU-bound."
6) Raccontami di una situazione in cui hai dovuto imparare rapidamente una nuova tecnologia .NET. Come hai affrontato la situazione?
Requisiti richiesti al candidato: Adattabilità e apprendimento continuo.
Esempio di risposta: “In una posizione precedente, avevo bisogno di imparare rapidamente Blazor per un progetto cliente. Ho dedicato tempo alla parte ufficiale Microsoft documentazione, ho fatto pratica con piccoli progetti sandbox e ho collaborato con i membri del team per garantire di ottenere risultati di qualità nei tempi previsti."
7) Come progetteresti un'API RESTful in ASP.NET Core? Quali principi chiave segui?
Requisiti richiesti al candidato: Conoscenza dei metodi HTTP, del routing, del versioning e delle best practice.
Esempio di risposta: “Seguo i principi REST, come la corretta denominazione delle risorse, l'assenza di stato e l'uso corretto dei verbi HTTP. Implemento anche la convalida dei modelli, codici di stato corretti, il controllo delle versioni e meccanismi di autenticazione come JWT.”
8) Come gestisci le scadenze strette quando lavori contemporaneamente su più progetti .NET?
Requisiti richiesti al candidato: Priorità, organizzazione, comunicazione.
Esempio di risposta: “Nel mio precedente lavoro, gestivo scadenze strette suddividendo le attività in componenti gestibili, dando priorità alle funzionalità critiche e mantenendo una comunicazione continua con le parti interessate per definire aspettative realistiche.”
9) Come si mantiene la qualità del codice nelle applicazioni .NET?
Requisiti richiesti al candidato: Familiarità con test, revisioni e strumenti.
Esempio di risposta: "Mantengo la qualità del codice attraverso test unitari con xUnit, revisioni del codice, analisi statica del codice e rispetto dei principi SOLID. Questi passaggi garantiscono manutenibilità e affidabilità a lungo termine."
10) Supponiamo che un'API .NET di produzione inizi a restituire errori 500 in modo intermittente. Come affronteresti la diagnosi del problema?
Requisiti richiesti al candidato: Debug strutturato, utilizzo di strumenti e calma sotto pressione.
Esempio di risposta: "Nel mio ultimo ruolo, iniziavo esaminando i log, verificando lo stato delle dipendenze e utilizzando Application Insights o strumenti simili per tracciare i guasti. Quindi, isolavo se il problema era correlato al database, alla configurazione o al codice e distribuivo correzioni mirate dopo la replica e la convalida."
