C# hanterar fel med undantag som fångas via try/catch/finally. Korrekt undantagshantering betyder att fånga specifika undantagstyper, rensa resurser (ofta med using), skapa meningsfulla anpassade undantag och inte dölja fel tyst.
C# hanterar fel med undantag som fångas via try/catch/finally. Korrekt undantagshantering betyder att fånga specifika undantagstyper, rensa resurser (ofta med using), skapa meningsfulla anpassade undantag och inte dölja fel tyst.
try
{
var data = RiskyOperation();
}
catch (FileNotFoundException ex) // catch SPECIFIC types (most specific first)
{
Console.WriteLine($"File missing: {ex.Message}");
}
catch (IOException ex)
{
Log(ex);
throw; // re-throw, PRESERVING the stack trace (not `throw ex`)
}
catch (Exception ex) // catch-all (last) — base of all exceptions
{
Log(ex);
}
finally
{
Cleanup(); // ALWAYS runs (success, exception, or return)
}
Fånga specifika undantagstyper först, använd Exception som en slutlig catch-all, och finally för rengöring som alltid måste köras. Viktigt: använd throw; (inte throw ex;) för att återkasta — det bevarar den ursprungliga stackspårningen.
if (amount < 0)
throw new ArgumentException("Amount must be positive", nameof(amount));
// a custom exception for your domain
public class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message) { }
}
throw new InsufficientFundsException("Balance too low");
// `using` guarantees Dispose() is called (close files/connections) even on exception
using (var file = new StreamReader("data.txt"))
{
var content = file.ReadToEnd();
} // file.Dispose() called automatically here
using var conn = new SqlConnection(...); // C# 8 simplified form
using-satsen säkerställer att IDisposable-resurser (filer, anslutningar) kasseras korrekt — det föredragna sättet att hantera resurssanering, mer tillförlitligt än manuell finally.
catch (Exception ex) when (ex.Message.Contains("timeout")) // exception filter (when)
{ ... }
✓ Catch SPECIFIC exceptions, not just Exception
✓ Use `using` for IDisposable resources (reliable cleanup)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use `throw;` (not `throw ex;`) to preserve the stack trace
✓ Create meaningful custom exceptions; don't use exceptions for normal control flow
Korrekt undantagshantering är väsentlig för att bygga robusta och pålitliga C#-applikationer, därför är det viktigt att förstå det grundligt.
try/catch/finally-strukturen, fångst av specifika undantagstyper (för målriktad hantering) med Exception som en slutlig catch-all, och finally för garanterad rengöring är grundläggande.
Flera C#-specifika bästa praxis är särskilt viktiga: att använda throw; snarare än throw ex; när du återkastar (en subtil men avgörande detalj — throw ex; återställer stackspårningen, vilket förlorar värdefull felsökningsinformation), att använda using-satsen för IDisposable-resurser (det föredragna, tillförlitliga sättet att säkerställa att filer, anslutningar och andra resurser kasseras korrekt även när undantag inträffar — mer robust än manuella finally-block och centralt för C#:s resurshanteringsmodell), och att inte dölja undantag tyst.
Att förstå undantagshantering — strukturen, specifika catches, anpassade undantag, stackspårningsbevarande återkastning och särskilt using för resurssanering — är viktigt för att skriva pålitlig C# som hanterar fel elegant och hanterar resurser korrekt.
Eftersom ohanterade undantag och resursläckor orsakar verkliga tillförlitlighetsproblem, och eftersom C# har specifika idiom (using-mönstret, throw;-bevarande) som skiljer robust kod från skör kod, är det viktigt att behärska undantagshantering, ofta använd kunskap för professionell C#-utveckling.
Ett bibliotek med IT-intervjufrågor och detaljerade svar — från Junior till Senior.
Donera