Skip to main content

How to Resolve Warning "CS0184: The given expression is never of the provided ('type') type" in C#

The Compiler Warning CS0184 is a Redundancy/Logic warning. The message reads: "The given expression is never of the provided ('Type') type".

This warning is the opposite of CS0183. While CS0183 warns you when a check is always true, CS0184 warns you when a check is always false. The compiler has analyzed the variables and types involved and determined that it is impossible for the variable to match the type you are checking against. This usually indicates a logic bug, dead code, or a misunderstanding of the inheritance hierarchy.

This guide explains why the compiler flags these impossible checks and how to fix them.

Understanding the Impossible Check​

The is operator checks compatibility at runtime. However, the compiler performs a static check first.

If you ask: if (x is Y) The compiler checks:

  1. Does x inherit from Y? (Always True -> CS0183)
  2. Does Y inherit from x? (Maybe True at runtime -> Valid Check)
  3. Is there an implicit/explicit conversion? (Maybe True -> Valid Check)
  4. Are x and Y completely unrelated and x is sealed? (Always False -> CS0184)

If the compiler knows that no object can ever exist that satisfies both the type of x and the type Y, it issues this warning.

Scenario 1: Sealed Classes (No Inheritance Possible)​

If a class is marked sealed, no other class can inherit from it. If you check if a variable of a sealed type is actually a different, unrelated type, the answer is mathematically guaranteed to be false.

Example of warning​

public sealed class Robot { }
public class Animal { }

public class Program
{
    static void Main()
    {
        Robot r2d2 = new Robot();

        // ⛔️ Warning CS0184: The given expression is never of the provided ('Animal') type.
        // Since 'Robot' is sealed, no subclass of Robot can ever exist 
        // that also inherits from 'Animal'. This check will always be false.
        if (r2d2 is Animal) 
        {
            System.Console.WriteLine("This code is unreachable.");
        }
    }
}

Solution: Remove the Logic​

Since the check is impossible, the code block inside the if statement is dead code. Remove it.

public class Program
{
    static void Main()
    {
        Robot r2d2 = new Robot();

        // ✅ Correct: Logic removed because a Robot is never an Animal.
        // If you expected this to work, you likely have a design flaw 
        // or confused variables.
    }
}

Scenario 2: Incompatible Value Types​

Structs (Value Types) like int, double, DateTime, or custom structs are implicitly sealed. An int variable can never contain a double object, nor can a custom struct contain another struct type via inheritance (because structs don't support inheritance).

Example of warning​

public void ProcessNumber(int number)
{
    // ⛔️ Warning CS0184: An 'int' is never a 'string'.
    if (number is string)
    {
        System.Console.WriteLine("This is text.");
    }
}

Solution: Fix the Logic​

You probably meant to compare values or convert types, not check the type identity.

public void ProcessNumber(int number)
{
    // ✅ Correct: Maybe you wanted to convert it?
    string text = number.ToString();
    System.Console.WriteLine("This is text: " + text);
}

Scenario 3: Generic Constraint Conflicts​

This can occur in generic methods where the constraints on T make the check impossible.

Example of warning​

// T is constrained to be a struct (Value Type)
public void Check<T>(T item) where T : struct
{
    // ⛔️ Warning CS0184: The given expression is never of the provided ('string') type.
    // 'string' is a Reference Type (class). 
    // Since T must be a Value Type, T can never be a string.
    if (item is string) 
    {
        // ...
    }
}

Solution: Review Constraints​

Check your where clauses. If you need to handle strings, you cannot constrain T to be a struct.

// ✅ Correct: Removed 'struct' constraint, or changed the logic inside.
public void Check<T>(T item)
{
    if (item is string s)
    {
        System.Console.WriteLine(s);
    }
}

Conclusion​

CS0184 is a helpful alert that you are asking a question with an obvious answer ("No").

  1. Check Sealed Types: If comparing Classes, is one of them sealed? If so, they cannot be related.
  2. Check Value Types: You cannot check if an int is a bool. They are fundamentally different memory structures.
  3. The Fix: Delete the if block because it will never execute. If you thought it should execute, rethink your class hierarchy or variable types.

Table of Contents