Why is an explicit int conversion preferred over an implicit double conversion?

[jnm2]

I added an explicit int conversion and it silently affected the explicit float conversion in a different project in the solution than the one I was working in. This resulted in fractions being lost.

SharpLab

using System;

var number = new AWrapperType(123.456);

Console.WriteLine((float)number); // Prints "Oops" and "123" 

public readonly struct AWrapperType
{
    private readonly double value;
    
    public AWrapperType(double value) => this.value = value;
    
    public static implicit operator double(AWrapperType value)
    {
        return value.value;
    }
    
    public static explicit operator int(AWrapperType value)
    {
        Console.WriteLine("Oops");
        return (int)value.value;
    }
}

[svick]

I believe this happens because of these parts of the section Processing of user-defined explicit conversions in the spec (emphasis mine):

• Find the set of applicable user-defined and lifted conversion operators, U. This set consists of the user-defined and lifted implicit or explicit conversion operators declared by the classes or structs in D that convert from a type encompassing or encompassed by S to a type encompassing or encompassed by T. […]
  […]
• Find the most specific target type, TX, of the operators in U:
  • If any of the operators in U convert to T, then TX is T.
  • Otherwise, if any of the operators in U convert to types that are encompassed by T, then TX is the most encompassing type in the combined set of target types of those operators. If exactly one most encompassing type cannot be found, then the conversion is ambiguous and a compile-time error occurs.
  • Otherwise, TX is the most encompassed type in the combined set of target types of the operators in U. If no most encompassed type can be found, then the conversion is ambiguous and a compile-time error occurs.

In more concrete language, if you're doing an explicit cast, both implicit and explicit operators are considered, equally. What makes the difference here is the next step, where subsequent standard implicit conversions are considered (that's what "encompassed by" refers to), in both directions, but ones in the "correct" direction are preferred.

Since there are standard implicit conversions from int to float and from float to double, both the int and double operators are considered when converting to float, but the int operator is preferred.