C#コンパイラエラーCS0216の原因と解決方法について解説

// CS0216_Error.cs
using System;
class MyClass
{
    // == 演算子の定義(!= 演算子が不足しているためエラーとなる)
    public static bool operator ==(MyClass left, MyClass right)
    {
        // 左辺と右辺の等価性を判定(ここではEqualsを利用)
        return left.Equals(right);
    }
    /*
    // CS0216エラー解決のために必要な!=演算子の定義
    public static bool operator !=(MyClass left, MyClass right)
    {
        // ==演算子の逆を返す
        return !left.Equals(right);
    }
    */
    // ObjectクラスのEqualsメソッドをオーバーライド
    public override bool Equals(object obj)
    {
        // シンプルな等価性の判定として、参照が一致するかどうか確認
        return base.Equals(obj);
    }
    // ObjectクラスのGetHashCodeメソッドをオーバーライド
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
    // エントリーポイント
    public static void Main()
    {
        // この状態でコンパイルすると、!=が定義されていないためエラーが発生します。
    }
}

// コンパイラエラー：演算子 'operator' を定義するには、合致する演算子 '!=' が必要です。

// TrueFalse_Error.cs
using System;
class SampleClass
{
    // true演算子のみ定義(false演算子が不足しているため問題となる)
    public static bool operator true(SampleClass instance)
    {
        // インスタンスが有効かどうかの判定(ここではnullでないかをチェック)
        return instance != null;
    }
    /*
    // エラー解消のため、false演算子の定義も必要です。
    public static bool operator false(SampleClass instance)
    {
        return instance == null;
    }
    */
    public static void Main()
    {
        SampleClass obj = new SampleClass();
        // 条件文内でユーザー定義の真偽値評価を行う際、falseが定義されていないとエラーとなります。
        if (obj)
        {
            Console.WriteLine("オブジェクトは真と評価されます。");
        }
    }
}

// コンパイラエラー：ユーザー定義の true 演算子には、ユーザー定義の false 演算子が必要です。

// InfiniteRecursion.cs
using System;
class RecursiveClass
{
    // 無限再帰が発生する例：自分自身の等価判定を再帰的に呼び出してしまう
    public static bool operator ==(RecursiveClass left, RecursiveClass right)
    {
        // 以下の呼び出しは再帰的に自分自身を呼び出すため、無限ループとなる
        return left == right;
    }
    // 正しく実装するには、Equalsや別の比較手段を用いる必要があります。
    public static bool operator !=(RecursiveClass left, RecursiveClass right)
    {
        return !(left == right);
    }
    public static void Main()
    {
        RecursiveClass instanceA = new RecursiveClass();
        RecursiveClass instanceB = new RecursiveClass();
        // 実行すると、無限再帰によりクラッシュする恐れがあります。
        Console.WriteLine(instanceA == instanceB);
    }
}

// 実行時エラー：StackOverflowException(無限再帰によるスタックオーバーフロー)

// ConsistentOperators.cs
using System;
class ConsistentClass
{
    // == 演算子と != 演算子を対で実装
    public static bool operator ==(ConsistentClass left, ConsistentClass right)
    {
        if (ReferenceEquals(left, right))
        {
            return true;
        }
        if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
        {
            return false;
        }
        // 本来の意味に基づいた等価判定(ここでは任意の条件を設定)
        return left.Value == right.Value;
    }
    public static bool operator !=(ConsistentClass left, ConsistentClass right)
    {
        return !(left == right);
    }
    public int Value { get; set; }
    public ConsistentClass(int value)
    {
        Value = value;
    }
    public override bool Equals(object obj)
    {
        if (obj is ConsistentClass other)
        {
            return this.Value == other.Value;
        }
        return false;
    }
    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }
    public static void Main()
    {
        ConsistentClass objA = new ConsistentClass(10);
        ConsistentClass objB = new ConsistentClass(10);
        // 両演算子が正しく実装されていれば、一貫した結果が得られる
        Console.WriteLine(objA == objB);  // Trueが出力される
    }
}

True

// CS0216_Example.cs
using System;
class MyClass
{
    // == 演算子のみが定義され、不足している!=演算子が原因でエラーとなる
    public static bool operator ==(MyClass left, MyClass right)
    {
        return left.Equals(right);
    }
    // == 演算子に対して!=演算子の実装が必要であるが、未実装のためエラーになる
    // コメント内のコードを有効にすることで問題は解消される
    /*
    public static bool operator !=(MyClass left, MyClass right)
    {
        return !left.Equals(right);
    }
    */
    public override bool Equals(object obj)
    {
        return base.Equals(obj);
    }
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
    public static void Main()
    {
        // Main関数はコンパイラーテスト用として含まれています
    }
}

// コンパイラエラー：演算子 'operator' を定義するには、合致する演算子 '!=' が必要です。

// CS0216_Fixed.cs
using System;
class MyClass
{
    // == 演算子の定義
    public static bool operator ==(MyClass left, MyClass right)
    {
        // 両オブジェクトが同一参照かどうか確認
        if (ReferenceEquals(left, right))
        {
            return true;
        }
        if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
        {
            return false;
        }
        return left.Equals(right);
    }
    // != 演算子の定義(== 演算子と対になるように実装)
    public static bool operator !=(MyClass left, MyClass right)
    {
        return !(left == right);
    }
    public override bool Equals(object obj)
    {
        // 型が一致し、値が等しい場合はtrueと判定
        if (obj is MyClass other)
        {
            // 任意の等価判定処理を実装
            return true; // サンプルでは常にtrueを返す(実際には適切な比較処理を実装)
        }
        return false;
    }
    public override int GetHashCode()
    {
        // 適切なハッシュコードの算出方法を実装
        return 1; // サンプルのため固定値(実際は値に基づく算出が必要)
    }
    public static void Main()
    {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        // ==と!=が正しく実装されているため、エラーなく比較が実施される
        Console.WriteLine(obj1 == obj2);  // Trueが出力される
        Console.WriteLine(obj1 != obj2);  // Falseが出力される
    }
}

True
False

// VerificationSample.cs
using System;
class VerificationClass
{
    public int Number { get; set; }
    public VerificationClass(int number)
    {
        Number = number;
    }
    // == 演算子の定義
    public static bool operator ==(VerificationClass left, VerificationClass right)
    {
        if (ReferenceEquals(left, right))
        {
            return true;
        }
        if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
        {
            return false;
        }
        return left.Number == right.Number;
    }
    // != 演算子の定義
    public static bool operator !=(VerificationClass left, VerificationClass right)
    {
        return !(left == right);
    }
    public override bool Equals(object obj)
    {
        if (obj is VerificationClass other)
        {
            return this.Number == other.Number;
        }
        return false;
    }
    public override int GetHashCode()
    {
        return Number.GetHashCode();
    }
    public static void Main()
    {
        VerificationClass instance1 = new VerificationClass(5);
        VerificationClass instance2 = new VerificationClass(5);
        VerificationClass instance3 = new VerificationClass(10);
        // 同じ値の場合、==はTrue、!=はFalseを返す
        Console.WriteLine(instance1 == instance2);  // True
        Console.WriteLine(instance1 != instance2);  // False
        // 異なる値の場合、==はFalse、!=はTrueを返す
        Console.WriteLine(instance1 == instance3);  // False
        Console.WriteLine(instance1 != instance3);  // True
    }
}

True
False
False
True