Skip to main content

How to Resolve Error "CS0715: Static classes cannot contain user-defined operators" in C#

The Compiler Error CS0715 is a structural logic error. The message reads: " 'StaticClass': static classes cannot contain user-defined operators".

In C#, Operator Overloading (defining how +, -, ==, or implicit conversions work) is meant to define how instances of a type interact. For example, Vector v3 = v1 + v2 adds two specific vector objects together.

A static class, by definition, cannot be instantiated. You cannot create variables of that type, pass them as parameters, or return them from methods. Since you can never have "two instances of a static class" to add together, defining an operator for a static class is logically impossible.

This guide explains how to fix this design flaw by choosing between value-type semantics or utility methods.

Understanding Operators and Instantiation​

An operator declaration must follow this syntax: public static ReturnType operator +(Type a, Type b)

Crucially, at least one of the parameters (a or b) must be of the containing type. If Type is a static class:

  1. You cannot write Type variableName.
  2. Therefore, you cannot pass it as a parameter to the operator.
  3. Therefore, the operator signature is impossible to satisfy.

Scenario: The "Singleton Value" Mistake​

This error often happens when a developer creates a class to represent a concept (like "Temperature" or "Currency") but marks it static because they initially thought of it as a utility library, yet later tried to treat it like a value.

Example of error: trying to define addition logic inside a static container.

public static class Temperature
{
    public static double Celsius;

    // ⛔️ Error CS0715: Static classes cannot contain user-defined operators.
    // Why? Because you cannot have variables of type 'Temperature' to pass into 'a' or 'b'.
    public static Temperature operator +(Temperature a, Temperature b)
    {
        return new Temperature(); // Error: Cannot create instance of static class
    }
}

Solution 1: Make the Class Non-Static (Value Object)​

If the goal is to represent data (like a specific temperature, a complex number, or a coordinate) and perform math on it, the type must be instantiated. Use a struct or a standard class.

Solution: change static class to public struct (or class).

// ✅ Correct: A struct represents a value that can be instantiated.
public struct Temperature
{
    public double Degrees;

    public Temperature(double degrees)
    {
        Degrees = degrees;
    }

    // Now valid because we can have instances 'a' and 'b'
    public static Temperature operator +(Temperature a, Temperature b)
    {
        return new Temperature(a.Degrees + b.Degrees);
    }
}

public class Program
{
    static void Main()
    {
        var t1 = new Temperature(10);
        var t2 = new Temperature(20);
        
        // Use the operator
        var sum = t1 + t2; 
    }
}

Solution 2: Use Static Methods (Utility Class)​

If the goal is simply to perform math on primitive types (like double or int) without holding state, keep the class static, but remove the operator keyword. Use standard static methods instead.

Solution: replace operator + with a method like Add.

// ✅ Correct: A utility library
public static class TemperatureUtils
{
    // A standard static method accepting primitives
    public static double AddCelsius(double t1, double t2)
    {
        return t1 + t2;
    }
    
    public static double ConvertToFahrenheit(double celsius)
    {
        return (celsius * 9 / 5) + 32;
    }
}

public class Program
{
    static void Main()
    {
        double temp1 = 10.5;
        double temp2 = 20.0;

        // Use the method call
        double result = TemperatureUtils.AddCelsius(temp1, temp2);
    }
}

Conclusion​

CS0715 reminds you that operators require operands (objects).

  1. Check the Intent:
    • Do you want to write obj1 + obj2? -> You need instances. Remove static from the class definition.
    • Do you want to calculate Math.Add(1, 2)? -> You need a utility. Remove operator and write a public static method.

Table of Contents