【C#】演算子オーバーロード可能な演算子一覧と実装のコツ

2025-04-30更新日: 2025-04-30

C#では演算子を自由に上書きできるわけではなく、対象は単項+ - ! ~ ++ -- true false、二項+ - * / % & | ^ << >>、比較== != < > <= >=、そして明示的・暗黙的キャストに限られます。

&& ||や複合代入、=、?:などはオーバーロード不可です。

目次から探す

演算子オーバーロードの基本
オーバーロード可能な演算子一覧
オーバーロードできない演算子
演算子オーバーロードの文法
必須ルールと慣習
実装サンプル集
パフォーマンスへの影響
テスト戦略
デバッグの勘所
よくある落とし穴
ジェネリックコードとの相性
- 演算子制約の現状
- 型パラメータでの演算呼び出し手法
別アプローチの選択肢
- メソッド提供との比較検討
- 拡張メソッドで補完するケース
言語バージョン別の差異
- C# 2.0 からの変更点
- C# 最新版での追加機能
まとめ

演算子オーバーロードの基本

演算子オーバーロードとは

C#における演算子オーバーロードとは、独自に定義したクラスや構造体に対して、標準の演算子(例えば+や-など)を使って操作できるようにする機能です。

通常、演算子は組み込み型に対して定義されていますが、演算子オーバーロードを使うことで、ユーザー定義型でも自然な形で演算子を利用できるようになります。

たとえば、複素数やベクトルのような数学的な型を作成した場合、+演算子をオーバーロードすれば、a + bのように書くだけで加算処理が実行されるようになります。

これにより、コードの可読性が向上し、直感的な操作が可能になります。

演算子オーバーロードは、メソッドの一種として定義され、operatorキーワードを使って宣言します。

オーバーロードできる演算子は限られており、すべての演算子が対象ではありません。

演算子の意味を変えすぎるとコードの理解が難しくなるため、適切な使い方が求められます。

対象となる型と制限

演算子オーバーロードは、クラスclassや構造体structに対してのみ定義できます。

組み込み型や列挙型enumには適用できません。

また、オーバーロードする演算子は静的メソッドとして実装しなければならず、インスタンスメソッドとしては定義できません。

C#でオーバーロード可能な演算子は以下の通りです。

演算子の種類	オーバーロード可能な演算子例
単項演算子	`+`、`-`、`!`、`~`、`++`、`--`、`true`、`false`
二項演算子	`+`、`-`、`*`、`/`、`%`、`&`、`\|`、`^`、`<<`、`>>`、`==`、`!=`、`<`、`>`、`<=`、`>=`
型変換演算子	`implicit`(暗黙的変換)、`explicit`(明示的変換)

一方で、以下の演算子はオーバーロードできません。

論理演算子の&&、||(これらは&、|、true、falseのオーバーロードで間接的に制御可能)
代入演算子(=, +=, -=など)
三項演算子?:
その他、言語仕様によりオーバーロード不可な演算子(.、=>、awaitなど)

また、比較演算子==、!=、<、>、<=、>=をオーバーロードする場合は、必ずペアで実装しなければなりません。

例えば、==をオーバーロードしたら、!=も必ずオーバーロードする必要があります。

これにより、整合性のある比較が保証されます。

使用シーンの典型例

演算子オーバーロードは、特に以下のようなシーンで活用されます。

数学的な型の表現

複素数やベクトル、行列などの数学的なデータ型を作成する際に、加算や減算、乗算などの演算子をオーバーロードして自然な計算式を実現します。

public struct Complex
{
    public double Real { get; }
    public double Imaginary { get; }
    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }
    // 複素数の加算演算子オーバーロード
    public static Complex operator +(Complex a, Complex b)
    {
        return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
}

このように定義すると、Complex型のインスタンス同士を+で加算でき、コードが直感的になります。

単位変換やラッパークラス

物理量の単位を表すクラスで、異なる単位間の変換を演算子で表現したり、ラッパークラスで数値演算を拡張したりする場合に使います。

例えば、メートルとキロメートルの変換を暗黙的キャストで実装することも可能です。

論理判定のカスタマイズ

true、false演算子をオーバーロードすることで、独自の型に対して条件式の判定をカスタマイズできます。

これにより、if文やwhile文での条件判定が自然な形で行えます。

public struct MyBool
{
    private readonly bool value;
    public MyBool(bool value)
    {
        this.value = value;
    }
    public static bool operator true(MyBool b) => b.value;
    public static bool operator false(MyBool b) => !b.value;
}

比較演算の拡張

独自の比較ロジックを持つクラスで、==や<などの比較演算子をオーバーロードして、等価性や大小関係を定義します。

これにより、if (a == b)のようなコードが使いやすくなります。

このように、演算子オーバーロードはクラスや構造体の使い勝手を大きく向上させる機能です。

ただし、過度に使うとコードの意味がわかりにくくなることもあるため、適切な範囲で利用することが望ましいです。

オーバーロード可能な演算子一覧

単項演算子

+ 正符号

単項の+演算子は、数値の正符号を表します。

通常は値をそのまま返すため、オーバーロードするケースは少ないですが、独自の数値型で符号を明示的に扱いたい場合に実装します。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // 正符号演算子のオーバーロード
    public static MyNumber operator +(MyNumber n)
    {
        // そのまま返す
        return n;
    }
}
class Program
{
    static void Main()
    {
        MyNumber num = new MyNumber(5);
        MyNumber result = +num;
        Console.WriteLine(result.Value); // 5
    }
}

– 負符号

単項の-演算子は値の符号を反転させます。

独自の数値型で符号反転を実装する際に使います。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // 負符号演算子のオーバーロード
    public static MyNumber operator -(MyNumber n)
    {
        return new MyNumber(-n.Value);
    }
}
class Program
{
    static void Main()
    {
        MyNumber num = new MyNumber(5);
        MyNumber result = -num;
        Console.WriteLine(result.Value); // -5
    }
}

-5

! 論理否定

!演算子は論理値の否定を表します。

ブール値を持つ独自型で論理否定を定義する際に使います。

public struct MyBool
{
    private readonly bool value;
    public MyBool(bool value)
    {
        this.value = value;
    }
    // 論理否定演算子のオーバーロード
    public static MyBool operator !(MyBool b)
    {
        return new MyBool(!b.value);
    }
    public override string ToString() => value.ToString();
}
class Program
{
    static void Main()
    {
        MyBool b = new MyBool(true);
        MyBool notB = !b;
        Console.WriteLine(notB); // False
    }
}

False

~ ビット反転

~演算子はビット単位の反転を行います。

ビット演算を扱う独自型で使います。

public struct MyBits
{
    public int Bits { get; }
    public MyBits(int bits)
    {
        Bits = bits;
    }
    // ビット反転演算子のオーバーロード
    public static MyBits operator ~(MyBits b)
    {
        return new MyBits(~b.Bits);
    }
    public override string ToString() => Bits.ToString();
}
class Program
{
    static void Main()
    {
        MyBits bits = new MyBits(0b_1010);
        MyBits inverted = ~bits;
        Console.WriteLine(Convert.ToString(inverted.Bits, 2)); // 11111111111111111111111111110101 (32bit)
    }
}

11111111111111111111111111110101

++ インクリメント

++演算子は値を1増やします。

数値型やカウンター型でよく使われます。

public struct Counter
{
    public int Value { get; }
    public Counter(int value)
    {
        Value = value;
    }
    // インクリメント演算子のオーバーロード
    public static Counter operator ++(Counter c)
    {
        return new Counter(c.Value + 1);
    }
}
class Program
{
    static void Main()
    {
        Counter c = new Counter(10);
        c++;
        Console.WriteLine(c.Value); // 11
    }
}

— デクリメント

--演算子は値を1減らします。

インクリメントと同様にカウンター型などで使います。

public struct Counter
{
    public int Value { get; }
    public Counter(int value)
    {
        Value = value;
    }
    // デクリメント演算子のオーバーロード
    public static Counter operator --(Counter c)
    {
        return new Counter(c.Value - 1);
    }
}
class Program
{
    static void Main()
    {
        Counter c = new Counter(10);
        c--;
        Console.WriteLine(c.Value); // 9
    }
}

true 条件判定

true演算子は、条件式での真判定をカスタマイズします。

if文などで使われる条件判定の基準を定義できます。

public struct MyBool
{
    private readonly bool value;
    public MyBool(bool value)
    {
        this.value = value;
    }
    public static bool operator true(MyBool b) => b.value;
    public static bool operator false(MyBool b) => !b.value;
    public override string ToString() => value.ToString();
}
class Program
{
    static void Main()
    {
        MyBool b = new MyBool(true);
        if (b)
        {
            Console.WriteLine("条件は真です");
        }
    }
}

条件は真です

false 条件判定

false演算子は、条件式での偽判定を定義します。

true演算子とセットで実装する必要があります。

(上記MyBoolの例に含まれています)

二項演算子

算術演算子 + – * / %

これらは数値型の基本的な算術演算を表します。

独自の数値型やラッパークラスでオーバーロードして自然な計算を実現します。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
    public static MyNumber operator -(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value - b.Value);
    }
    public static MyNumber operator *(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value * b.Value);
    }
    public static MyNumber operator /(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value / b.Value);
    }
    public static MyNumber operator %(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value % b.Value);
    }
}
class Program
{
    static void Main()
    {
        MyNumber a = new MyNumber(10);
        MyNumber b = new MyNumber(3);
        Console.WriteLine((a + b).Value); // 13
        Console.WriteLine((a - b).Value); // 7
        Console.WriteLine((a * b).Value); // 30
        Console.WriteLine((a / b).Value); // 3
        Console.WriteLine((a % b).Value); // 1
    }
}

ビット演算子 & | ^

ビット単位のAND、OR、XOR演算子です。

ビットフラグやビットマスクを扱う型で使います。

public struct MyBits
{
    public int Bits { get; }
    public MyBits(int bits)
    {
        Bits = bits;
    }
    public static MyBits operator &(MyBits a, MyBits b)
    {
        return new MyBits(a.Bits & b.Bits);
    }
    public static MyBits operator |(MyBits a, MyBits b)
    {
        return new MyBits(a.Bits | b.Bits);
    }
    public static MyBits operator ^(MyBits a, MyBits b)
    {
        return new MyBits(a.Bits ^ b.Bits);
    }
}
class Program
{
    static void Main()
    {
        MyBits a = new MyBits(0b_1010);
        MyBits b = new MyBits(0b_1100);
        Console.WriteLine(Convert.ToString((a & b).Bits, 2)); // 1000
        Console.WriteLine(Convert.ToString((a | b).Bits, 2)); // 1110
        Console.WriteLine(Convert.ToString((a ^ b).Bits, 2)); // 0110
    }
}

1000
1110
110

シフト演算子 << >>

ビットの左シフト、右シフトを表します。

ビット操作を行う型で使います。

public struct MyBits
{
    public int Bits { get; }
    public MyBits(int bits)
    {
        Bits = bits;
    }
    public static MyBits operator <<(MyBits a, int shift)
    {
        return new MyBits(a.Bits << shift);
    }
    public static MyBits operator >>(MyBits a, int shift)
    {
        return new MyBits(a.Bits >> shift);
    }
}
class Program
{
    static void Main()
    {
        MyBits bits = new MyBits(0b_0011);
        Console.WriteLine(Convert.ToString((bits << 2).Bits, 2)); // 1100
        Console.WriteLine(Convert.ToString((bits >> 1).Bits, 2)); // 1
    }
}

1100
1

比較演算子

等価比較 == !=

等価比較演算子は、オブジェクトの等価性を判定します。

オーバーロードする場合は必ずペアで実装します。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static bool operator ==(MyNumber a, MyNumber b)
    {
        return a.Value == b.Value;
    }
    public static bool operator !=(MyNumber a, MyNumber b)
    {
        return a.Value != b.Value;
    }
    public override bool Equals(object obj)
    {
        if (obj is MyNumber other)
            return this == other;
        return false;
    }
    public override int GetHashCode() => Value.GetHashCode();
}
class Program
{
    static void Main()
    {
        MyNumber a = new MyNumber(5);
        MyNumber b = new MyNumber(5);
        MyNumber c = new MyNumber(3);
        Console.WriteLine(a == b); // True
        Console.WriteLine(a != c); // True
    }
}

True
True

大小比較 < > <= >=

大小比較演算子は、値の大小関係を判定します。

こちらもペアで実装することが推奨されます。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static bool operator <(MyNumber a, MyNumber b)
    {
        return a.Value < b.Value;
    }
    public static bool operator >(MyNumber a, MyNumber b)
    {
        return a.Value > b.Value;
    }
    public static bool operator <=(MyNumber a, MyNumber b)
    {
        return a.Value <= b.Value;
    }
    public static bool operator >=(MyNumber a, MyNumber b)
    {
        return a.Value >= b.Value;
    }
}
class Program
{
    static void Main()
    {
        MyNumber a = new MyNumber(5);
        MyNumber b = new MyNumber(10);
        Console.WriteLine(a < b);  // True
        Console.WriteLine(a > b);  // False
        Console.WriteLine(a <= b); // True
        Console.WriteLine(a >= b); // False
    }
}

True
False
True
False

型変換演算子

implicit

暗黙的型変換演算子は、明示的なキャストなしに型変換を可能にします。

安全な変換に使います。

public struct Meter
{
    public double Value { get; }
    public Meter(double value)
    {
        Value = value;
    }
    // メートルからキロメートルへの暗黙的変換
    public static implicit operator Kilometer(Meter m)
    {
        return new Kilometer(m.Value / 1000);
    }
}
public struct Kilometer
{
    public double Value { get; }
    public Kilometer(double value)
    {
        Value = value;
    }
}
class Program
{
    static void Main()
    {
        Meter m = new Meter(1500);
        Kilometer km = m; // 暗黙的変換
        Console.WriteLine(km.Value); // 1.5
    }
}

1.5

explicit

明示的型変換演算子は、キャスト演算子を使って明示的に変換を行います。

安全性が保証されない変換に使います。

public struct Kilometer
{
    public double Value { get; }
    public Kilometer(double value)
    {
        Value = value;
    }
    // キロメートルからメートルへの明示的変換
    public static explicit operator Meter(Kilometer km)
    {
        return new Meter(km.Value * 1000);
    }
}
public struct Meter
{
    public double Value { get; }
    public Meter(double value)
    {
        Value = value;
    }
}
class Program
{
    static void Main()
    {
        Kilometer km = new Kilometer(1.5);
        Meter m = (Meter)km; // 明示的変換
        Console.WriteLine(m.Value); // 1500
    }
}

オーバーロードできない演算子

短絡論理演算子 && ||

C#では、&&(論理AND)と||(論理OR)の短絡論理演算子は直接オーバーロードできません。

これは、これらの演算子が「短絡評価」を行うためです。

つまり、左辺の評価結果によって右辺の評価が省略されることがあり、単純なメソッド呼び出しではこの動作を再現できないためです。

ただし、&&や||の動作は、対応するビット演算子である&と|、およびtrueとfalse演算子のオーバーロードによって間接的に制御できます。

これにより、独自の型で条件判定をカスタマイズしつつ、&&や||を使った条件式を記述可能です。

以下は&&や||の短絡評価が直接オーバーロードできないことを示す例です。

public struct MyBool
{
    private readonly bool value;
    public MyBool(bool value)
    {
        this.value = value;
    }
    public static MyBool operator &(MyBool a, MyBool b)
    {
        return new MyBool(a.value & b.value);
    }
    public static MyBool operator |(MyBool a, MyBool b)
    {
        return new MyBool(a.value | b.value);
    }
    public static bool operator true(MyBool b) => b.value;
    public static bool operator false(MyBool b) => !b.value;
}
class Program
{
    static void Main()
    {
        MyBool a = new MyBool(true);
        MyBool b = new MyBool(false);
        // 以下はコンパイル可能だが、&& と || は直接オーバーロード不可
        var resultAnd = a && b; // 実際は operator & と true/false が使われる
        var resultOr = a || b;
        Console.WriteLine(resultAnd); // False
        Console.WriteLine(resultOr);  // True
    }
}

False
True

このように、&&や||は&、|、true、falseの組み合わせで動作を制御しますが、短絡評価の挙動は完全に模倣できないため注意が必要です。

代入・複合代入演算子

代入演算子=および複合代入演算子+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=はC#で直接オーバーロードできません。

しかし、複合代入演算子は対応する二項演算子のオーバーロードを利用して間接的に動作します。

例えば、+=は+演算子のオーバーロードがあれば利用可能です。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
}
class Program
{
    static void Main()
    {
        MyNumber a = new MyNumber(5);
        MyNumber b = new MyNumber(3);
        a = a + b; // これはOK
        // a += b; // これもOKだが、operator += は存在しない。内部で operator + が使われます。
        Console.WriteLine(a.Value); // 8
    }
}

代入演算子自体はオーバーロードできないため、代入の挙動をカスタマイズしたい場合は、プロパティのセッターやメソッドで制御する必要があります。

三項演算子 ?:

三項演算子(条件演算子)?:はC#でオーバーロードできません。

これは言語仕様で定められており、演算子オーバーロードの対象外です。

三項演算子は条件式の評価結果に応じて値を選択する構文であり、オーバーロード可能な演算子の組み合わせで代替することも難しいため、独自の型で三項演算子の動作をカスタマイズすることはできません。

代わりに、メソッドやプロパティを使って条件に応じた値を返すロジックを実装することが一般的です。

Null 合体演算子 ?? 系

Null 合体演算子??およびNull 合体代入演算子??=はオーバーロードできません。

これらは言語の構文として特別に扱われており、演算子オーバーロードの対象外です。

??は左辺がnullの場合に右辺を返す演算子であり、参照型やNullable型に対して使われます。

独自の型で同様の動作を実現したい場合は、メソッドやプロパティでnullチェックを行う必要があります。

その他特殊構文

以下の演算子や構文はC#でオーバーロードできません。

代入演算子 =
メンバーアクセス演算子 .
三項条件演算子 ?:
Null 合体演算子 ??、??=
範囲演算子 ..
ポインタ演算子 ->
ラムダ演算子 =>
キーワード演算子 as、await、checked、unchecked、default、delegate、is、nameof、new、sizeof、stackalloc、switch、typeof

これらは言語の構文やキーワードとして特別に扱われているため、演算子オーバーロードの対象外です。

独自の動作を実装したい場合は、別の方法(メソッドやプロパティ、拡張メソッドなど)で対応する必要があります。

演算子オーバーロードの文法

宣言場所とアクセス修飾子

演算子オーバーロードは、クラスまたは構造体の内部で宣言します。

外部のクラスや名前空間のスコープでは定義できません。

これは、演算子が特定の型に対して動作するため、その型のメンバーとして実装する必要があるためです。

アクセス修飾子は通常publicで宣言します。

演算子は型の外部からも利用されることが多いため、privateやprotectedにすると利用できなくなります。

internalも可能ですが、同一アセンブリ内でのみ使いたい場合に限定されます。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // publicで宣言するのが一般的
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
}

アクセス修飾子を省略するとprivate扱いになるため、外部から演算子を使えなくなります。

必ずpublicを指定しましょう。

static 修飾子の必須性

演算子オーバーロードは必ずstaticメソッドとして定義しなければなりません。

インスタンスメソッドとしては宣言できません。

これは、演算子が左辺・右辺のオペランドを引数として受け取り、結果を返す静的な関数として扱われるためです。

staticを付け忘れるとコンパイルエラーになります。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // staticが必須
    public static MyNumber operator -(MyNumber n)
    {
        return new MyNumber(-n.Value);
    }
}

staticであるため、thisキーワードは使えません。

すべてのオペランドは引数として受け取ります。

戻り値と引数の型規則

演算子オーバーロードの戻り値と引数の型は、演算子の意味に応じて適切に設定する必要があります。

引数の数
- 単項演算子は引数を1つ取ります
- 二項演算子は引数を2つ取ります
- 型変換演算子は引数を1つ取ります
引数の型
- 少なくとも1つの引数は、演算子を定義するクラスまたは構造体の型でなければなりません
- 例えば、MyNumber型の演算子なら、引数のどちらか(単項なら唯一の引数)はMyNumber型である必要があります
戻り値の型
- 演算子の結果を表す型を返します。通常は同じ型か、関連する型を返します
- 型変換演算子の場合は変換先の型を返します

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // 単項演算子：引数1つ、戻り値はMyNumber
    public static MyNumber operator -(MyNumber n)
    {
        return new MyNumber(-n.Value);
    }
    // 二項演算子：引数2つ、戻り値はMyNumber
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
    // 型変換演算子：引数1つ、戻り値は変換先の型
    public static implicit operator int(MyNumber n)
    {
        return n.Value;
    }
}

引数や戻り値の型が不適切だとコンパイルエラーになります。

例外のスロー方針

演算子オーバーロード内で例外をスローすることは可能ですが、注意が必要です。

演算子は通常、簡潔で直感的な操作を期待されるため、例外が発生すると予期しない動作やパフォーマンス低下を招くことがあります。

例えば、ゼロ除算や範囲外アクセスなど、明確にエラーとなるケースでは例外をスローして問題ありません。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static MyNumber operator /(MyNumber a, MyNumber b)
    {
        if (b.Value == 0)
            throw new DivideByZeroException("ゼロで除算はできません。");
        return new MyNumber(a.Value / b.Value);
    }
}

ただし、例外を多用すると演算子の使用が煩雑になるため、可能な限り例外を避ける設計や、事前チェックを行うことが望ましいです。

また、例外の種類は標準的な.NET例外を使うのが一般的で、独自例外を使う場合はドキュメントで明示しましょう。

演算子オーバーロードの文法は厳格で、正しく実装しないとコンパイルエラーになるため、上記のポイントを押さえて実装してください。

必須ルールと慣習

比較演算子のペア実装

C#では、比較演算子をオーバーロードする際に必ずペアで実装するルールがあります。

具体的には、==をオーバーロードした場合は必ず!=も、<をオーバーロードした場合は必ず>も、<=をオーバーロードした場合は必ず>=も実装しなければなりません。

このルールは、比較演算の整合性を保つために重要です。

片方だけを実装すると、等価性や大小関係の判定が不完全になり、予期しない動作やバグの原因になります。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static bool operator ==(MyNumber a, MyNumber b)
    {
        return a.Value == b.Value;
    }
    public static bool operator !=(MyNumber a, MyNumber b)
    {
        return a.Value != b.Value;
    }
    public static bool operator <(MyNumber a, MyNumber b)
    {
        return a.Value < b.Value;
    }
    public static bool operator >(MyNumber a, MyNumber b)
    {
        return a.Value > b.Value;
    }
    public static bool operator <=(MyNumber a, MyNumber b)
    {
        return a.Value <= b.Value;
    }
    public static bool operator >=(MyNumber a, MyNumber b)
    {
        return a.Value >= b.Value;
    }
    public override bool Equals(object obj)
    {
        if (obj is MyNumber other)
            return this == other;
        return false;
    }
    public override int GetHashCode() => Value.GetHashCode();
}

このようにペアで実装することで、==と!=、<と>、<=と>=の関係が一貫し、比較演算が正しく機能します。

&& || と true false の関係

&&(論理AND)と||(論理OR)の短絡論理演算子は直接オーバーロードできませんが、trueおよびfalse演算子とビット演算子&、|をオーバーロードすることで、独自型に対して条件式の評価をカスタマイズできます。

true演算子は条件式で「真」と判定される基準を定義し、false演算子は「偽」と判定される基準を定義します。

これらがあることで、if文やwhile文で独自型を使った条件判定が可能になります。

public struct MyBool
{
    private readonly bool value;
    public MyBool(bool value)
    {
        this.value = value;
    }
    public static bool operator true(MyBool b) => b.value;
    public static bool operator false(MyBool b) => !b.value;
    public static MyBool operator &(MyBool a, MyBool b)
    {
        return new MyBool(a.value & b.value);
    }
    public static MyBool operator |(MyBool a, MyBool b)
    {
        return new MyBool(a.value | b.value);
    }
}

この実装により、&&や||を使った条件式は、&や|、true、falseのオーバーロードを組み合わせて動作します。

ただし、短絡評価は行われないため、注意が必要です。

オーバーロード後の優先順位と結合規則

演算子オーバーロードを行っても、演算子の優先順位や結合規則はC#言語仕様に従います。

つまり、オーバーロードした演算子の優先順位が変わることはありません。

例えば、*は+より優先順位が高いため、a + b * cはa + (b * c)として評価されます。

オーバーロードしてもこの規則は変わらず、演算子の結合方向も左結合や右結合のままです。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
    public static MyNumber operator *(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value * b.Value);
    }
    public override string ToString() => Value.ToString();
}
class Program
{
    static void Main()
    {
        MyNumber a = new MyNumber(2);
        MyNumber b = new MyNumber(3);
        MyNumber c = new MyNumber(4);
        var result = a + b * c; // b * c が先に計算される
        Console.WriteLine(result); // 14
    }
}

このように、オーバーロードしても演算子の評価順序は変わらないため、複雑な式を書く際は優先順位を意識してコードを書くことが重要です。

可読性確保のポイント

演算子オーバーロードはコードを直感的に書ける反面、過度に使うと動作がわかりにくくなるリスクがあります。

可読性を保つために以下のポイントを意識しましょう。

意味が明確な演算子だけをオーバーロードする

演算子の意味と異なる動作を実装すると混乱を招きます。

例えば、+は加算的な意味で使うのが望ましいです。

ペアの演算子は必ず実装する

比較演算子はペアで実装し、整合性を保ちます。

ドキュメントやコメントを充実させる

オーバーロードした演算子の動作を明示的に説明し、利用者が理解しやすいようにします。

複雑なロジックはメソッドに分ける

演算子の中に複雑な処理を詰め込みすぎず、必要に応じてヘルパーメソッドを使いましょう。

テストを充実させる

演算子の動作を網羅的にテストし、意図しない動作を防ぎます。

これらを守ることで、演算子オーバーロードを活用しつつ、保守性の高いコードを維持できます。

実装サンプル集

数値ラッパーでの + –

クラス設計

数値ラッパークラスは、基本的な数値型(例えばintやdouble)を内部に保持し、演算子オーバーロードで加算や減算を自然に扱えるように設計します。

ここではintをラップするMyNumberクラスを例にします。

public class MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    // 加算演算子オーバーロード
    public static MyNumber operator +(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value + b.Value);
    }
    // 減算演算子オーバーロード
    public static MyNumber operator -(MyNumber a, MyNumber b)
    {
        return new MyNumber(a.Value - b.Value);
    }
    public override string ToString() => Value.ToString();
}

この設計では、Valueプロパティで内部の整数値を保持し、+と-演算子をオーバーロードしてMyNumber同士の加減算を可能にしています。

メソッド内部処理

加算・減算演算子の内部処理は、単純にラップしているintの値同士を演算し、新しいMyNumberインスタンスを返す形です。

副作用はなく、イミュータブルな設計を意識しています。

public static MyNumber operator +(MyNumber a, MyNumber b)
{
    // 内部のint値を加算し、新しいMyNumberを返す
    return new MyNumber(a.Value + b.Value);
}
public static MyNumber operator -(MyNumber a, MyNumber b)
{
    // 内部のint値を減算し、新しいMyNumberを返す
    return new MyNumber(a.Value - b.Value);
}

このように、演算子は引数の値を変更せず、新しいオブジェクトを返すことで安全に使えます。

複素数構造体での演算子一式

加算・減算

複素数は実部と虚部を持つ数学的な型です。

加算・減算はそれぞれの成分ごとに行います。

public struct Complex
{
    public double Real { get; }
    public double Imaginary { get; }
    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }
    public static Complex operator +(Complex a, Complex b)
    {
        return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
    public static Complex operator -(Complex a, Complex b)
    {
        return new Complex(a.Real - b.Real, a.Imaginary - b.Imaginary);
    }
    public override string ToString() => $"({Real} + {Imaginary}i)";
}

乗算・除算

乗算は複素数の乗法規則に従い、除算は共役複素数を使って計算します。

public static Complex operator *(Complex a, Complex b)
{
    double real = a.Real * b.Real - a.Imaginary * b.Imaginary;
    double imaginary = a.Real * b.Imaginary + a.Imaginary * b.Real;
    return new Complex(real, imaginary);
}
public static Complex operator /(Complex a, Complex b)
{
    double denom = b.Real * b.Real + b.Imaginary * b.Imaginary;
    if (denom == 0)
        throw new DivideByZeroException("複素数の除算でゼロ除算が発生しました。");
    double real = (a.Real * b.Real + a.Imaginary * b.Imaginary) / denom;
    double imaginary = (a.Imaginary * b.Real - a.Real * b.Imaginary) / denom;
    return new Complex(real, imaginary);
}

等価比較

複素数の等価比較は実部と虚部が等しいかで判定します。

==と!=はペアで実装し、EqualsとGetHashCodeもオーバーライドします。

public static bool operator ==(Complex a, Complex b)
{
    return a.Real == b.Real && a.Imaginary == b.Imaginary;
}
public static bool operator !=(Complex a, Complex b)
{
    return !(a == b);
}
public override bool Equals(object obj)
{
    if (obj is Complex other)
        return this == other;
    return false;
}
public override int GetHashCode()
{
    return Real.GetHashCode() ^ Imaginary.GetHashCode();
}

ベクトル型での true false

ゼロ判定ロジック

ベクトル型でtrueとfalse演算子をオーバーロードすると、条件式での判定が可能になります。

ここでは、ベクトルのすべての成分がゼロならfalse、そうでなければtrueと判定します。

public struct Vector2D
{
    public double X { get; }
    public double Y { get; }
    public Vector2D(double x, double y)
    {
        X = x;
        Y = y;
    }
    public static bool operator true(Vector2D v)
    {
        return v.X != 0 || v.Y != 0;
    }
    public static bool operator false(Vector2D v)
    {
        return v.X == 0 && v.Y == 0;
    }
    public override string ToString() => $"({X}, {Y})";
}

&& || と組み合わせた使用例

trueとfalse演算子を実装すると、&&や||を使った条件式でベクトルの真偽判定が可能になります。

ただし、短絡評価は行われません。

class Program
{
    static void Main()
    {
        Vector2D v1 = new Vector2D(1, 0);
        Vector2D v2 = new Vector2D(0, 0);
        if (v1 && v2)
        {
            Console.WriteLine("両方とも真");
        }
        else
        {
            Console.WriteLine("どちらかが偽");
        }
    }
}

どちらかが偽

この例では、v1は真、v2は偽と判定され、&&の結果は偽となります。

implicit と explicit の活用

単位変換シナリオ

単位変換でimplicitとexplicitを使うと、型安全かつ自然な変換が可能です。

例えば、メートルとキロメートルの変換を実装します。

public struct Meter
{
    public double Value { get; }
    public Meter(double value)
    {
        Value = value;
    }
    public static implicit operator Kilometer(Meter m)
    {
        return new Kilometer(m.Value / 1000);
    }
    public override string ToString() => $"{Value} m";
}
public struct Kilometer
{
    public double Value { get; }
    public Kilometer(double value)
    {
        Value = value;
    }
    public static explicit operator Meter(Kilometer km)
    {
        return new Meter(km.Value * 1000);
    }
    public override string ToString() => $"{Value} km";
}

class Program
{
    static void Main()
    {
        Meter m = new Meter(1500);
        Kilometer km = m; // implicit変換
        Console.WriteLine(km); // 1.5 km
        Meter m2 = (Meter)km; // explicit変換
        Console.WriteLine(m2); // 1500 m
    }
}

1.5 km
1500 m

型安全性とのバランス

implicitは安全な変換に使い、キャストなしで変換できるため便利ですが、誤用すると意図しない変換が起こるリスクがあります。

一方、explicitはキャストが必要なため、変換の意図が明確になります。

設計時には、変換の安全性や使いやすさを考慮し、適切に使い分けることが重要です。

例えば、単位の縮小(メートル→キロメートル)はimplicit、拡大(キロメートル→メートル)はexplicitにするのが一般的です。

パフォーマンスへの影響

インライン化と JIT 最適化

演算子オーバーロードは、JIT(Just-In-Time)コンパイラによるインライン化の対象となることが多く、適切に実装すればパフォーマンスへの影響を最小限に抑えられます。

インライン化とは、メソッド呼び出しのオーバーヘッドを削減するために、呼び出し先のコードを呼び出し元に展開する最適化技術です。

演算子オーバーロードは静的メソッドであり、引数や戻り値が単純な型や構造体の場合、JITはこれらをインライン化しやすい傾向にあります。

特に、演算子の中身が単純な計算やフィールドアクセスであれば、インライン化される可能性が高いです。

ただし、演算子の実装が複雑であったり、例外処理や条件分岐が多い場合はインライン化されにくくなり、パフォーマンスに影響を与えることがあります。

パフォーマンスを重視する場合は、演算子の実装をシンプルに保つことが望ましいです。

また、JITの最適化は実行環境や.NETのバージョンによって異なるため、パフォーマンスを正確に把握するにはプロファイリングツールを使った測定が必要です。

struct と class の選択基準

演算子オーバーロードを実装する際、型をstruct(値型)にするかclass(参照型)にするかはパフォーマンスに大きく影響します。

struct(値型)

値型はスタック上に配置されることが多く、ヒープ割り当てが不要なため、メモリアロケーションのコストが低いです。

小さくて不変なデータを表現するのに適しています。

演算子オーバーロードと組み合わせると、コピーコストが低く高速に動作することが多いです。

ただし、サイズが大きいstructはコピーコストが高くなり、パフォーマンスが低下する可能性があります。

また、structは継承できないため、設計上の制約もあります。

class(参照型)

参照型はヒープに割り当てられ、ガベージコレクションの対象となります。

大きなデータや継承が必要な場合に適していますが、頻繁なインスタンス生成や破棄があるとGC負荷が増え、パフォーマンスに影響します。

演算子オーバーロードをclassで実装すると、参照のコピーが行われるため、値のコピーに比べてコストは低いですが、ヒープ割り当てのオーバーヘッドがあります。

選択基準のまとめ

特徴	struct(値型)	class(参照型)
メモリ配置	スタックまたはインライン	ヒープ
コピーコスト	サイズに依存し高くなる場合あり	参照のコピーで低い
継承	不可	可能
ガベージコレクション	なし	あり
適用例	小さく不変なデータ型	大きなデータや継承が必要な型

演算子オーバーロードを多用する数値型や数学的型は、一般的にstructで実装されることが多いです。

ref 戻り値の利用可能性

C#では、メソッドの戻り値をrefで返すことが可能ですが、演算子オーバーロードにおいてはref戻り値の利用は制限されています。

具体的には、演算子オーバーロードのメソッドはrefやref readonlyの戻り値を返すことができません。

これは言語仕様で定められており、コンパイラがエラーを出します。

public struct MyNumber
{
    public int Value;
    // 以下はコンパイルエラーになる
    // public static ref MyNumber operator +(MyNumber a, MyNumber b)
    // {
    //     // 処理
    // }
}

この制限は、演算子の呼び出しが式の中で使われることが多く、ref戻り値の管理が複雑になるためです。

そのため、演算子オーバーロードでは値を返す形で実装し、パフォーマンスが気になる場合はstructの設計やメモリ管理を工夫する必要があります。

一方で、通常のメソッドではref戻り値を使うことで、コピーを避けてパフォーマンスを向上させることが可能です。

演算子オーバーロード以外のAPI設計で検討するとよいでしょう。

テスト戦略

単体テストでの網羅項目

演算子オーバーロードを実装したクラスや構造体では、単体テストで以下の項目を網羅的に検証することが重要です。

基本的な演算結果の正確性

各演算子が期待通りの結果を返すかを確認します。

例えば、加算演算子なら正しい和が計算されるかをテストします。

境界値や特殊値の処理

0や負の値、最大値・最小値などの境界条件で正しく動作するかを検証します。

例外の発生確認

ゼロ除算や不正な操作で例外が正しくスローされるかをテストします。

不変条件の保持

演算子の呼び出し前後でオペランドが変更されていないか(イミュータブル設計の場合)を確認します。

ペア演算子の整合性

比較演算子のペア(==と!=、<と>など)が一貫した結果を返すかを検証します。

型変換演算子の動作

implicitやexplicitのキャストが正しく機能するかをテストします。

これらを網羅することで、演算子の動作に関する信頼性を高められます。

精度誤差と境界値

特に浮動小数点数や複素数、ベクトルなどの数学的型では、計算結果に精度誤差が生じることがあります。

テストでは以下の点に注意します。

許容誤差の設定

浮動小数点の比較は厳密な等価ではなく、許容誤差(イプシロン)を設けて比較します。

例えば、Math.Abs(a - b) < 1e-10のように判定します。

境界値の検証

0、正負の極端な値、無限大やNaN(非数)などの特殊値に対して演算子が適切に動作するかを確認します。

丸め誤差の影響

連続した演算で誤差が累積しないか、または許容範囲内に収まっているかを検証します。

[TestMethod]
public void ComplexAddition_PrecisionTest()
{
    var a = new Complex(0.1, 0.2);
    var b = new Complex(0.2, 0.3);
    var result = a + b;
    Assert.IsTrue(Math.Abs(result.Real - 0.3) < 1e-10);
    Assert.IsTrue(Math.Abs(result.Imaginary - 0.5) < 1e-10);
}

演算子間の整合性チェック

演算子オーバーロードでは、複数の演算子が関連し合うため、整合性を保つことが重要です。

テストでは以下の点を確認します。

比較演算子の一貫性

==と!=、<と>、<=と>=が互いに矛盾しない結果を返すかを検証します。

例えば、a == bがtrueならa != bはfalseであるべきです。

算術演算子の交換法則・結合法則

加算や乗算など、数学的に成立する法則が成り立つかをチェックします。

例えば、a + b == b + aや(a + b) + c == a + (b + c)など。

型変換と演算子の連携

型変換演算子を使った後の演算が正しく動作するかをテストします。

例えば、implicit変換後に加算ができるかなど。

副作用の有無

演算子の呼び出しがオペランドの状態を変更しないことを確認します。

[TestMethod]
public void EqualityOperators_ConsistencyTest()
{
    var a = new MyNumber(5);
    var b = new MyNumber(5);
    var c = new MyNumber(3);
    Assert.IsTrue(a == b);
    Assert.IsFalse(a != b);
    Assert.IsFalse(a == c);
    Assert.IsTrue(a != c);
}

これらの整合性チェックを行うことで、演算子の動作が論理的に矛盾しないことを保証できます。

デバッグの勘所

Visual Studio の式評価

Visual Studioのデバッガでは、ブレークポイントで停止中に「式評価」機能を使って変数や式の値を確認できます。

演算子オーバーロードを実装した型の場合も、オーバーロードされた演算子が正しく呼び出されているかを確認するのに役立ちます。

例えば、ウォッチウィンドウや即時ウィンドウで、オーバーロードされた+演算子を使った式を入力すると、その結果が表示されます。

これにより、演算子の動作をリアルタイムで検証できます。

MyNumber a = new MyNumber(3);
MyNumber b = new MyNumber(4);
var c = a + b; // ブレークポイントをここに設定

ブレークポイントで停止した状態で、即時ウィンドウにa + bと入力すると、MyNumberの+演算子が呼ばれた結果が表示されます。

ただし、式評価では副作用のある演算子や複雑なロジックが含まれる場合、評価が失敗したり、予期しない動作をすることがあります。

演算子の実装はできるだけ副作用を避けることが望ましいです。

オーバーロード解決の衝突事例

複数の演算子オーバーロードが存在する場合、どのオーバーロードが呼ばれるかが曖昧になることがあります。

特に、暗黙的・明示的な型変換演算子と演算子オーバーロードが組み合わさると、コンパイラがどのメソッドを選択すべきか判断に迷うことがあります。

例えば、以下のようなケースです。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value) => Value = value;
    public static implicit operator int(MyNumber n) => n.Value;
    public static MyNumber operator +(MyNumber a, MyNumber b) => new MyNumber(a.Value + b.Value);
    public static MyNumber operator +(MyNumber a, int b) => new MyNumber(a.Value + b);
}

この場合、MyNumber + intの演算子が2つ存在し、MyNumber + MyNumberへの暗黙的変換もあるため、MyNumber + intの呼び出し時にどちらの演算子が使われるかコンパイラが迷うことがあります。

このような衝突は、曖昧な呼び出しエラーや意図しない演算子の呼び出しを引き起こすため、設計段階で演算子のオーバーロードを整理し、明確に区別できるようにすることが重要です。

スタックトレース読解

演算子オーバーロードを使ったコードで例外が発生した場合、スタックトレースにはオーバーロードされた演算子メソッド名が表示されます。

通常、メソッド名はop_演算子名の形式で表されます。

例えば、+演算子のオーバーロードはop_Addition、-はop_Subtraction、==はop_Equalityという名前になります。

System.DivideByZeroException: ゼロで除算はできません。
   at Namespace.Complex.op_Division(Complex a, Complex b)
   at Namespace.Program.Main()

この例では、Complex構造体の/演算子op_Divisionで例外が発生したことがわかります。

スタックトレースを読む際は、以下のポイントに注意してください。

演算子名の対応を理解する

演算子のメソッド名はop_に続く英語名で表現されるため、どの演算子かを把握しておくと原因特定がスムーズです。

呼び出し階層を追う

演算子オーバーロードがどのメソッドから呼ばれているかを確認し、例外の発生箇所を特定します。

例外メッセージを活用する

例外の内容とスタックトレースを組み合わせて、演算子の実装に問題がないか検証します。

これらを踏まえ、演算子オーバーロードのデバッグを効率的に行いましょう。

よくある落とし穴

Equals と GetHashCode の未実装

演算子オーバーロードで特に比較演算子==、!=を実装した場合、EqualsメソッドとGetHashCodeメソッドも必ずオーバーライドしなければなりません。

これを怠ると、コレクションやハッシュベースのデータ構造で不整合が発生し、予期しない動作を引き起こします。

例えば、DictionaryやHashSetなどはGetHashCodeとEqualsを使って要素の同一性を判断します。

演算子だけをオーバーロードしても、これらのメソッドがデフォルトのままだと、等価判定が正しく機能しません。

public struct MyNumber
{
    public int Value { get; }
    public MyNumber(int value)
    {
        Value = value;
    }
    public static bool operator ==(MyNumber a, MyNumber b)
    {
        return a.Value == b.Value;
    }
    public static bool operator !=(MyNumber a, MyNumber b)
    {
        return a.Value != b.Value;
    }
    // Equals と GetHashCode をオーバーライドしないと問題が起きる
    public override bool Equals(object obj)
    {
        if (obj is MyNumber other)
            return this == other;
        return false;
    }
    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }
}

このように、EqualsとGetHashCodeを演算子のロジックと整合させることが重要です。

未実装の場合、コレクションの検索や比較でバグが発生しやすくなります。

ボックス化による性能低下

構造体structに対して演算子オーバーロードを実装した場合、ボックス化(Boxing)が発生するとパフォーマンスが低下することがあります。

ボックス化とは、値型を参照型として扱うためにヒープ上にコピーを作成する処理で、GC負荷やメモリ使用量の増加を招きます。

例えば、object型にキャストしたり、インターフェイスを通じて呼び出す場合に発生します。

演算子オーバーロード自体はボックス化を直接引き起こしませんが、演算子の内部でobject型のメソッド(例えばEquals(object))を呼ぶとボックス化が発生します。

MyNumber a = new MyNumber(5);
object o = a; // ここでボックス化が発生
bool equals = a.Equals(o); // Equals呼び出し時にボックス化の影響を受ける可能性あり

パフォーマンスを重視する場合は、Equalsのオーバーロードに加えて、IEquatable<T>インターフェイスを実装し、型安全な比較メソッドを用意することが推奨されます。

public struct MyNumber : IEquatable<MyNumber>
{
    public int Value { get; }
    public bool Equals(MyNumber other)
    {
        return Value == other.Value;
    }
    public override bool Equals(object obj)
    {
        if (obj is MyNumber other)
            return Equals(other);
        return false;
    }
    public override int GetHashCode() => Value.GetHashCode();
}

これにより、ボックス化を回避しつつ効率的な比較が可能になります。

null 許容参照型との相互作用

C# 8.0以降のnull許容参照型(Nullable Reference Types)機能を使う場合、演算子オーバーロードとnullチェックの相互作用に注意が必要です。

例えば、==演算子をオーバーロードしたクラスで、nullとの比較を適切に扱わないと、null判定が正しく機能せず、NullReferenceExceptionが発生したり、意図しない結果になることがあります。

public class MyClass
{
    public int Value { get; }
    public MyClass(int value)
    {
        Value = value;
    }
    public static bool operator ==(MyClass? a, MyClass? b)
    {
        if (ReferenceEquals(a, b))
            return true;
        if (a is null || b is null)
            return false;
        return a.Value == b.Value;
    }
    public static bool operator !=(MyClass? a, MyClass? b) => !(a == b);
    public override bool Equals(object? obj)
    {
        if (obj is MyClass other)
            return this == other;
        return false;
    }
    public override int GetHashCode() => Value.GetHashCode();
}

この例では、nullチェックを明示的に行い、null同士の比較や片方がnullの場合の挙動を正しく定義しています。

null許容参照型を使う場合は、演算子オーバーロードの引数や戻り値に?を付けてnull許容を明示し、nullチェックを適切に実装することが重要です。

これにより、コンパイラの警告を抑えつつ安全なコードを書けます。

また、EqualsやGetHashCodeもnull対応を考慮して実装しましょう。

ジェネリックコードとの相性

演算子制約の現状

C#のジェネリックでは、型パラメータに対してメソッドやプロパティの存在を制約として指定できますが、残念ながら演算子の存在を直接制約として指定することはできません。

つまり、where T : operator+のような構文は存在しません。

このため、ジェネリック型やメソッド内で、型パラメータに対して演算子を使いたい場合、コンパイル時に演算子の存在を保証できず、直接的に演算子を呼び出すことができません。

これがジェネリックコードと演算子オーバーロードの相性の難しさの一つです。

.NET 7以降では、static abstractメンバーをインターフェイスに定義できる機能が導入され、これを利用して演算子を含む静的メンバーを制約として指定することが可能になりました。

これにより、演算子を含むインターフェイスを定義し、ジェネリック型パラメータにそのインターフェイスを指定することで、演算子の呼び出しを型安全に行えるようになりました。

しかし、これらの機能は比較的新しく、古いバージョンのC#や.NETでは利用できません。

型パラメータでの演算呼び出し手法

演算子制約がない環境やバージョンでは、ジェネリックコード内で演算子を使うためにいくつかの代替手法があります。

インターフェイスとメソッドによる抽象化

演算子の代わりに、加算や比較などの操作をメソッドとしてインターフェイスに定義し、型パラメータにそのインターフェイスを制約として指定します。

これにより、ジェネリックコード内でメソッド呼び出しとして演算を行えます。

public interface IAddable<T>
{
    T Add(T other);
}
public struct MyNumber : IAddable<MyNumber>
{
    public int Value { get; }
    public MyNumber(int value) => Value = value;
    public MyNumber Add(MyNumber other) => new MyNumber(Value + other.Value);
}
public static T Add<T>(T a, T b) where T : IAddable<T>
{
    return a.Add(b);
}

この方法は演算子の自然な記述には劣りますが、型安全で明示的な制約が可能です。

動的型(dynamic)の利用

dynamic型を使うと、実行時に演算子の呼び出しが解決されるため、ジェネリックコード内で演算子を使えます。

ただし、実行時のオーバーヘッドがあり、型安全性が失われるため注意が必要です。

public static T Add<T>(T a, T b)
{
    dynamic da = a;
    dynamic db = b;
    return da + db;
}

式ツリーやデリゲートの活用

式ツリーやデリゲートを使って、演算子を呼び出す関数を事前に生成し、ジェネリックコードで利用する方法もあります。

これにより、実行時のパフォーマンスをある程度確保しつつ、演算子呼び出しを抽象化できます。

ただし、実装が複雑になるため、用途に応じて検討が必要です。

これらの手法を組み合わせて、ジェネリックコード内で演算子オーバーロードを活用することが可能です。

最新のC#バージョンを使える場合は、static abstractメンバーを使ったインターフェイス制約が最も推奨されます。

別アプローチの選択肢

メソッド提供との比較検討

演算子オーバーロードはコードを直感的に書けるメリットがありますが、すべてのケースで最適とは限りません。

代わりにメソッドを提供するアプローチも検討すべきです。

メソッドのメリット

明示的な呼び出し

メソッド名が明確なので、何をしているかが一目でわかります。

例えば、AddやSubtractといった名前は処理内容を直感的に伝えます。

柔軟な引数設計

メソッドはオーバーロードやデフォルト引数を使いやすく、複雑なパラメータを扱う場合に適しています。

拡張性

新しい機能を追加しやすく、演算子では表現しにくい複雑な処理も実装可能です。

デバッグしやすい

メソッド呼び出しはスタックトレースに明確に現れ、デバッグが容易です。

演算子オーバーロードのメリット

簡潔で自然な記述

数学的な型やラッパー型で、a + bのように書けるため、コードが読みやすくなります。

言語機能との親和性

LINQや式ツリーなど、演算子を使うコードと親和性が高いです。

比較検討のポイント

項目	メソッド提供	演算子オーバーロード
可読性	明示的でわかりやすい	簡潔で直感的
柔軟性	高い(複雑な引数や処理に対応)	制限あり(演算子の意味に依存)
拡張性	高い	制限あり
デバッグのしやすさ	良好	場合によっては難しい
使用シーン	複雑な処理や明示的な操作が必要な場合	数学的演算や簡単な操作に適する

用途や設計方針に応じて、演算子オーバーロードとメソッド提供を使い分けることが望ましいです。

拡張メソッドで補完するケース

既存の型に対して演算子オーバーロードを追加できない場合や、演算子以外の機能を追加したい場合に、拡張メソッドが有効です。

拡張メソッドは、既存のクラスや構造体に新しいメソッドを追加する手段で、元の型を変更せずに機能拡張が可能です。

public static class MyNumberExtensions
{
    public static MyNumber MultiplyBy(this MyNumber n, int factor)
    {
        return new MyNumber(n.Value * factor);
    }
}

class Program
{
    static void Main()
    {
        MyNumber n = new MyNumber(5);
        MyNumber result = n.MultiplyBy(3);
        Console.WriteLine(result.Value); // 15
    }
}