How to Resolve Error "CS0724: A throw statement with no arguments is not allowed in a finally clause" in C#

The Compiler Error CS0724 is a syntax restriction regarding Exception Handling. The message reads: "A throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause".

In C#, the throw; statement (with no arguments) is used to re-throw the currently active exception while preserving its original stack trace. This statement is only valid inside a catch block.

The error occurs when you attempt to use throw; inside a finally block that is nested within a catch block. The compiler forbids this because the execution flow in a finally block is guaranteed to run regardless of success or failure. Using a context-dependent re-throw (throw;) inside this cleanup block creates ambiguity about which exception is being thrown and interferes with the correct unwinding of the stack.

This guide explains how to restructure your exception handling to re-throw correctly.

Understanding throw; vs throw ex;

• throw ex;: Throws the exception object ex. This resets the stack trace to the current line. Generally discouraged for re-throwing.
• throw;: Re-throws the exception that was caught by the catch block. This preserves the original stack trace. This is the preferred way to bubble up errors.

However, throw; is strictly limited to the direct scope of the catch block. It cannot be used inside a finally block, even if that finally block is physically located inside a catch.

Scenario: Re-throwing Inside a Nested Finally

This error typically happens when you catch an exception, perform some secondary operations (that require their own cleanup using try/finally), and then attempt to re-throw the original exception inside that cleanup code.

Example of error

You want to handle an error, run a cleanup sub-task, and then crash (rethrow). You place the throw; inside the sub-task's finally.

using System;
using System.IO;

public class LogManager
{
    public void ProcessData()
    {
        try
        {
            // Main logic that fails
            throw new InvalidOperationException("Something went wrong");
        }
        catch (Exception)
        {
            // We caught the exception. Now we try to log it.
            // This inner try/finally triggers the error context.
            try
            {
                Console.WriteLine("Attempting cleanup...");
            }
            finally
            {
                Console.WriteLine("Cleanup Done.");
                
                // ⛔️ Error CS0724: A throw statement with no arguments is not allowed 
                // in a finally clause that is nested inside the nearest enclosing catch clause.
                // You cannot re-throw the OUTER exception from the INNER finally.
                throw; 
            }
        }
    }
}

Solution: Move throw; After the Finally

You must allow the finally block to complete its execution normally. Place the throw; statement immediately after the inner try/finally block, but still inside the catch block.

using System;

public class LogManager
{
    public void ProcessData()
    {
        try
        {
            throw new InvalidOperationException("Something went wrong");
        }
        catch (Exception)
        {
            try
            {
                Console.WriteLine("Attempting cleanup...");
            }
            finally
            {
                // Cleanup runs guaranteed
                Console.WriteLine("Cleanup Done.");
            }

            // ✅ Correct: The inner 'try/finally' has finished.
            // We are still inside the 'catch', so 'throw;' correctly re-throws the original exception.
            throw;
        }
    }
}

note

This logic ensures that if the cleanup code itself throws an exception (inside the inner try or finally), that new exception takes precedence. If cleanup succeeds, the code proceeds to the throw; line and bubbles up the original error.

Conclusion

CS0724 prevents ambiguous control flow during exception handling.

1. Identify the Scope: Check if your throw; is inside a finally { ... } block.
2. Move the Throw: Move the throw; statement outside the finally block, placing it at the very end of the surrounding catch block.