C#のCS0457エラーについて解説 – ユーザー定義変換の曖昧性と原因・対策紹介

// SampleClassでは、意図せず同じ変換定義が重複してしまっている例です
public class SampleClass
{
    // 明示的な変換演算子定義1
    public static explicit operator int(SampleClass s)
    {
        // 任意の変換処理を記載
        return 1;
    }
    // 明示的な変換演算子定義2(同じシグネチャのため曖昧になります)
    public static explicit operator int(SampleClass s)
    {
        // 異なる変換処理を記載
        return 2;
    }
    public static void Main(string[] args)
    {
        SampleClass instance = new SampleClass();
        // どの変換演算子を使用するべきかコンパイラが判断できないためエラーとなります
        int converted = (int)instance;
        System.Console.WriteLine(converted);
    }
}

public class SampleConversion
{
    // 正しくは1つだけ定義する必要がある
    public static explicit operator int(SampleConversion s)
    {
        // シンプルな変換処理
        return 10;
    }
    // 同じシグネチャで再度定義しているためエラーとなります
    public static explicit operator int(SampleConversion s)
    {
        // 変換処理の内容が異なっても、シグネチャが同一では曖昧となります
        return 20;
    }
    public static void Main(string[] args)
    {
        SampleConversion instance = new SampleConversion();
        // 明示的なキャストによる変換を試みると、どちらの変換を使用するか明確でありません
        int converted = (int)instance;
        System.Console.WriteLine(converted);
    }
}

// クラスAでは、何らかの変換定義がされていると仮定します
public class A { }
public class B
{
    // クラスBで定義されたユーザー定義変換(クラスAからクラスBへの変換)
    public static explicit operator B(A a)
    {
        // 任意の変換処理を記載
        return new B();
    }
}
public class C
{
    // クラスCでも同じ変換が定義されている場合、呼び出しが曖昧となります
    public static explicit operator B(A a)
    {
        // 別の変換処理を記載
        return new B();
    }
    public static void Main(string[] args)
    {
        A instance = new A();
        // どちらのユーザー定義変換を使用すべきかコンパイラが判断できず、エラーが発生します
        B b = (B)instance;
        System.Console.WriteLine("変換実行");
    }
}

public class SampleFix
{
    // 正しく定義された明示的な変換演算子(重複がなく、一意の定義になっている)
    public static explicit operator int(SampleFix s)
    {
        // シンプルな変換処理を実装
        return 100;
    }
    public static void Main(string[] args)
    {
        SampleFix instance = new SampleFix();
        // 明示的なキャストを用いて変換を実施
        int converted = (int)instance;
        System.Console.WriteLine($"変換結果: {converted}");
    }
}

変換結果: 100

public class AmbiguousConversionA { }
public class AmbiguousConversionB
{
    // 変換定義1: AmbiguousConversionAからAmbiguousConversionBへの変換(候補1)
    public static explicit operator AmbiguousConversionB(AmbiguousConversionA a)
    {
        return new AmbiguousConversionB();
    }
}
public class AmbiguousConversionC
{
    // 変換定義2: 同じ変換元型に対して別の変換定義(候補2)
    public static explicit operator AmbiguousConversionB(AmbiguousConversionA a)
    {
        return new AmbiguousConversionB();
    }
    public static void Main(string[] args)
    {
        AmbiguousConversionA instance = new AmbiguousConversionA();
        // 明示的なキャストにより、どちらの定義を使用するか明示的に指定する方法を検討してください
        // ここでは一例として、AmbiguousConversionBへのキャストを行っていますが、根本的には定義の見直しが必要です
        AmbiguousConversionB b = (AmbiguousConversionB)instance;
        System.Console.WriteLine("変換完了");
    }
}

public class Temperature
{
    public double Celsius { get; set; }
    // Temperature型からdouble型への明示的な変換を定義
    public static explicit operator double(Temperature t)
    {
        // 体温の摂氏値をそのまま返す
        return t.Celsius;
    }
    public static void Main(string[] args)
    {
        Temperature temp = new Temperature { Celsius = 36.5 };
        double celsiusValue = (double)temp;
        System.Console.WriteLine($"体温: {celsiusValue}");
    }
}

体温: 36.5

public class Fraction
{
    public int Numerator { get; set; }
    public int Denominator { get; set; }
    // Fraction型からdouble型への明示的な変換を定義
    public static explicit operator double(Fraction f)
    {
        // ゼロ除算の簡単なチェックを実施
        return f.Denominator != 0 ? (double)f.Numerator / f.Denominator : 0;
    }
    public static void Main(string[] args)
    {
        Fraction frac = new Fraction { Numerator = 1, Denominator = 3 };
        double result = (double)frac;
        System.Console.WriteLine($"小数値: {result}");
    }
}

小数値: 0.3333333333333333