Skip to main content

How to Resolve Error "CS0160: A previous catch clause already catches all exceptions of this or of a super type" in C#

The Compiler Error CS0160 is a logic error related to Exception Handling. The message reads: "A previous catch clause already catches all exceptions of this or of a super type ('Type')".

In C#, catch blocks are evaluated sequentially from top to bottom. Once an exception matches a catch clause, that block is executed, and the rest are ignored. This error occurs when you place a general catch block (e.g., catching System.Exception) before a more specific catch block (e.g., catching ArgumentNullException). Because the general block catches everything, the specific block beneath it becomes unreachable code.

This guide explains how exception inheritance works and how to order your catch blocks correctly.

Understanding Exception Hierarchy​

Exceptions in .NET follow an inheritance tree. System.Exception is the base class for all exceptions.

  • System.Exception (Base)
    • System.SystemException
      • System.ArithmeticException
        • System.DivideByZeroException (Derived)

If you write catch (Exception e), you are saying "Catch any object that inherits from Exception." Since DivideByZeroException inherits from Exception, the first block catches it, leaving nothing for the specific block to do.

Scenario: Placing Generic Before Specific​

The most common mistake is putting the "catch-all" handler at the top of the list.

Example of error:

public void Calculate(int a, int b)
{
    try
    {
        int result = a / b;
    }
    // ⛔️ Error CS0160: A previous catch clause already catches all exceptions of this or of a super type
    // 'Exception' is the super type of 'DivideByZeroException'.
    // This block creates a "bucket" that catches everything.
    catch (System.Exception ex)
    {
        System.Console.WriteLine("A generic error occurred.");
    }
    // This block is unreachable. The compiler knows it can never be executed.
    catch (System.DivideByZeroException ex) 
    {
        System.Console.WriteLine("Cannot divide by zero.");
    }
}

Solution: Order from Specific to Generic​

To fix this, you must arrange your catch blocks from most specific (derived classes) to least specific (base classes).

Think of it like a sieve: put the fine mesh (specific checks) at the top to catch small items, and the coarse mesh (generic checks) at the bottom to catch whatever is left.

Solution: move the specific DivideByZeroException block to the top.

public void Calculate(int a, int b)
{
    try
    {
        int result = a / b;
    }
    // ✅ Correct: Check for specific errors first
    catch (System.DivideByZeroException ex)
    {
        System.Console.WriteLine("Cannot divide by zero.");
    }
    // ✅ Correct: Catch anything else that wasn't a division error here
    catch (System.Exception ex)
    {
        System.Console.WriteLine($"A generic error occurred: {ex.Message}");
    }
}
note

Intermediate Hierarchies: This rule applies to intermediate classes too. For example, ArgumentNullException inherits from ArgumentException. You must catch ArgumentNullException before ArgumentException.

Conclusion​

CS0160 is the compiler telling you that your code contains a logical contradiction (unreachable code).

  1. Identify the Base Class: Look at the types in your catch blocks.
  2. Reorder: Always place catch (Exception) at the very bottom.
  3. Sort Specifics: Ensure derived exceptions (like FileNotFoundException) appear before their parents (IOException).

Table of Contents