Skip to main content

How to Resolve Error "CS0034: Operator is ambiguous on operands of type 'type1' and 'type2'" in C#

The Compiler Error CS0034 is an Ambiguity Error. For example, a message could be: "Operator '+' is ambiguous on operands of type 'MyClass' and 'MyClass'".

This error occurs when the compiler finds multiple valid ways to interpret an operation (like +, -, ==) and cannot determine which one is the "best" match. This usually happens when you define multiple Implicit Conversions for a custom class, allowing it to act like several different built-in types (e.g., both a string and an int) that all support the same operator.

This guide explains how these collisions happen and how to resolve them using explicit casts.

Understanding Operator Ambiguity​

When you write a + b, the C# compiler looks for a matching operator:

  1. Is there an operator + defined directly on the class?
  2. If not, can a and b be implicitly converted to types that do have an operator + (like int or string)?

If the compiler finds two or more potential conversions that work, and neither is obviously "better" (more specific) than the other, it raises CS0034. It effectively asks: "Do you want me to add these as numbers, or concatenate them as strings? I can do both, so I won't guess."

Scenario 1: Multiple Conversions to Built-in Types​

The most common trigger is a class that can convert implicitly to both int and string. Since the + operator exists for both math (5 + 5) and text ("5" + "5"), the compiler is stuck.

Example of Ambiguous Code​

public class MagicValue
{
    // Implicitly converts to integer
    public static implicit operator int(MagicValue m) => 10;

    // Implicitly converts to string
    public static implicit operator string(MagicValue m) => "Hello";
}

public class Program
{
    static void Main()
    {
        MagicValue v1 = new MagicValue();
        MagicValue v2 = new MagicValue();

        // ⛔️ Error CS0034: Operator '+' is ambiguous on operands of type 'MagicValue' and 'MagicValue'
        // Path A: Convert both to int -> 10 + 10 = 20
        // Path B: Convert both to string -> "Hello" + "Hello" = "HelloHello"
        // The compiler refuses to choose.
        var result = v1 + v2;
    }
}

Solution: Explicit Casting​

You must tell the compiler which path to take by casting at least one operand.

// ✅ Correct: Treat them as integers
int sum = (int)v1 + (int)v2;

// ✅ Correct: Treat them as strings
string text = (string)v1 + (string)v2;

Scenario 2: Circular Conversions Between Custom Classes​

Ambiguity also arises if you have two classes, ClassA and ClassB, and they define operators or conversions that overlap.

Imagine:

  • ClassA can convert to ClassB.
  • ClassB can convert to ClassA.
  • Both classes define their own + operator.

Example of Ambiguous Code​

public class Alpha
{
    public static implicit operator Beta(Alpha a) => new Beta();
    public static Alpha operator +(Alpha a1, Alpha a2) => new Alpha();
}

public class Beta
{
    public static implicit operator Alpha(Beta b) => new Alpha();
    public static Beta operator +(Beta b1, Beta b2) => new Beta();
}

public class Program
{
    static void Main()
    {
        Alpha a = new Alpha();
        Beta b = new Beta();

        // ⛔️ Error CS0034: Operator '+' is ambiguous
        // Path A: Convert 'b' to Alpha. Use Alpha + Alpha. Returns Alpha.
        // Path B: Convert 'a' to Beta. Use Beta + Beta. Returns Beta.
        // Both require exactly one conversion, so neither is "better".
        var result = a + b;
    }
}

Solution: Be Specific​

Cast one side to the target type to lock in the operation.

// ✅ Correct: Explicitly convert 'b' to Alpha. Use Alpha's operator.
var resultA = a + (Alpha)b;

// ✅ Correct: Explicitly convert 'a' to Beta. Use Beta's operator.
var resultB = (Beta)a + b;
note

Best Practice: Avoid designing classes with circular implicit conversions (A -> B and B -> A). This often leads to confusing logic and ambiguity errors. Prefer explicit conversions or named conversion methods like ToAlpha() or ToBeta().

Solution: Use Explicit Casting​

Regardless of the specific types involved, the universal fix for CS0034 is Explicit Casting.

The error exists because the code relies on Implicit (automatic) behavior. By using a cast (Type), you switch to Explicit behavior, which removes the ambiguity.

MyType a = new MyType();
MyType b = new MyType();

// Ambiguous implicit call
// var x = a + b; 

// Unambiguous explicit call
var x = (int)a + (int)b;

Conclusion​

CS0034 is a safeguard against undefined behavior. It ensures the compiler doesn't accidentally perform string concatenation when you meant to do addition (or vice versa).

  1. Check Implicit Operators: Look at your class definitions. Do you convert to multiple types that support the same operator (like int and string)?
  2. Check Circular Logic: Do you have two classes that convert to each other?
  3. Cast Variables: Resolve the error immediately by adding (int), (string), or (YourType) before the variable name in the expression.

Table of Contents