.CS File Format – Exceptions

throw

throw new ArgumentNullException(nameof(name));

try { Save(); }
catch (IOException)
{
    Log();
    throw;                   // rethrows, keeping the original stack trace
}

string s = name ?? throw new ArgumentNullException(nameof(name));   // throw expression, C# 7.0

• The operand must be of type System.Exception, a class derived from it, or a type parameter constrained to it (clause 13.10.6). If it evaluates to null, a NullReferenceException is thrown instead.
• A plain throw; is allowed only in a catch block. It rethrows the current exception and preserves its stack trace. throw ex; resets the stack trace to this point.
• System.Runtime.ExceptionServices.ExceptionDispatchInfo rethrows an exception later and keeps its original trace.

try, catch and finally

try_statement:
    try block catch_clauses
    try block [catch_clauses] finally block

specific_catch_clause:
    catch ( type [identifier] ) [exception_filter] block

general_catch_clause:
    catch [exception_filter] block

exception_filter:
    when ( boolean_expression )

try
{
    Process(path);
}
catch (FileNotFoundException e)
{
    Console.WriteLine(e.FileName);
}
catch (IOException e) when (e.HResult == 32)
{
    Retry();
}
catch (Exception)
{
    throw;
}
finally
{
    Cleanup();
}

• A try needs at least one catch or a finally.
• Catch clauses are tried in order (clause 13.11). A clause for a base type before one for a derived type is a compile-time error, because the later clause could never run.
• A catch without a type catches everything, and can appear once, last.
• A finally block runs when the try statement is left in any way: normally, by a jump, or by an exception. Control cannot jump out of it with return or goto. An exception thrown inside replaces the one in flight.
• await is allowed in catch and finally since C# 6.

The Exception class

public class ParseException : Exception
{
    public ParseException(string message, Exception? inner = null) : base(message, inner) { }
    public int Line { get; init; }
}

Common exception classes

The runtime throws these for failures of basic operations (clause 22.5):

Libraries often throw ArgumentException and its subclasses ArgumentNullException and ArgumentOutOfRangeException, and InvalidOperationException and NotSupportedException. See also exceptions in async methods.