Curioso comportamiento de conversión implícito personalizado del operador de coalescencia nula

Esto es definitivamente un error.

public class Program {
    static A? X() {
        Console.WriteLine("X()");
        return new A();
    }
    static B? Y() {
        Console.WriteLine("Y()");
        return new B();
    }
    static C? Z() {
        Console.WriteLine("Z()");
        return new C();
    }

    public static void Main() {
        C? test = (X() ?? Y()) ?? Z();
    }
}

Este código producirá:

X()
X()
A to B (0)
X()
X()
A to B (0)
B to C (0)

Eso me hizo pensar que la primera parte de cada ?? expresión de fusión se evalúa dos veces. Este código lo demostró:

B? test= (X() ?? Y());

Salidas:

X()
X()
A to B (0)

Esto parece suceder solo cuando la expresión requiere una conversión entre dos tipos nullables; he intentado varias permutaciones con uno de los lados siendo una cadena, y ninguno de ellos causó este comportamiento.

Si echas un vistazo al código generado para el caso agrupado a la izquierda, en realidad hace algo como esto (csc /optimize-):

C? first;
A? atemp = a;
B? btemp = (atemp.HasValue ? new B?(a.Value) : b);
if (btemp.HasValue)
{
    first = new C?((atemp.HasValue ? new B?(a.Value) : b).Value);
}

Otro hallazgo, si utiliza first generará un atajo si ambos a y b son null y devuelven c. Sin embargo, si a o b no es nulo, vuelve a evaluar a como parte de la conversión implícita a B antes de devolver cuál de a o b no es nulo.

De la especificación C # 4.0, §6.1.4:

• Si la conversión nullable es de S? a T?:
  • Si el valor de origen es null (HasValue la propiedad es false), el resultado es el valor null del tipo T?.
  • De lo contrario, la conversión se evalúa como un desenvolvimiento de S? a S, seguido de la conversión subyacente de S a T, seguido de una envoltura (§4.1.10) de T a T?.

Esto parece explicar el segundo desenvolver-envolver combinado.

El compilador C# 2008 y 2010 producen código muy similar, sin embargo esto parece una regresión del compilador C # 2005 (8.00.50727.4927) que genera el siguiente código para lo anterior:

A? a = x;
B? b = a.HasValue ? new B?(a.GetValueOrDefault()) : y;
C? first = b.HasValue ? new C?(b.GetValueOrDefault()) : z;

Me pregunto si esto no se debe a la magia adicional dada al sistema de inferencia de tipos?

En realidad, voy a llamar a esto un error ahora, con el ejemplo más claro. Esto sigue siendo así, pero la doble evaluación no es ciertamente buena.

Parece que A ?? B se implementa como A.HasValue ? A : B. En este caso, también hay mucho casting (siguiendo el casting regular para el operador ternary ?:). Pero si ignoras todo eso, entonces esto tiene sentido basado en cómo se implementa:

1. A ?? B se expande a A.HasValue ? A : B
2. A es nuestro x ?? y. Ampliar a x.HasValue : x ? y
3. reemplazar todas las ocurrencias de A - > (x.HasValue : x ? y).HasValue ? (x.HasValue : x ? y) : B

Aquí puedes ver que x.HasValue se marca dos veces, y si x ?? y requiere fundición, x se lanzará dos veces.

Yo lo pondría simplemente como un artefacto de cómo ?? se implementa, en lugar de un error del compilador. Take-Away: No cree operadores de casting implícitos con efectos secundarios.

Parece ser un error del compilador que gira en torno a cómo se implementa ??. Para llevar: no anidar coalescente expresiones con efectos secundarios.

No soy un experto en C# en absoluto como se puede ver en mi historial de preguntas, pero, probé esto y creo que es un error.... pero como novato, tengo que decir que no entiendo todo lo que pasa aquí, así que voy a borrar mi respuesta si estoy lejos.

He llegado a esta bug conclusión haciendo una versión diferente de su programa que se ocupa del mismo escenario, pero mucho menos complicado.

Estoy usando tres propiedades de enteros nulos con almacenes de respaldo. Puse cada uno en 4 y luego ejecutar int? something2 = (A ?? B) ?? C;

(El código completo aquí )

Esto solo lee la A y nada más.

Esta declaración me parece que debería:

1. Comience entre corchetes, mire A, devuelva A y termine si A no es null.
2. Si A era nulo, evaluar B, terminar si B no es nulo
3. Si A y B eran nulos, evalúe C.{[18]]}

Entonces, como A no es null, solo mira A A y termina.

En su ejemplo, poner un punto de interrupción en el El primer caso muestra que x, y y z no son nulos y, por lo tanto, esperaría que fueran tratados igual que mi ejemplo menos complejo.... ¡pero me temo que soy demasiado novato en C# y he perdido el punto de esta pregunta por completo!