necesita el operador de sobrecarga <y la verificación nula

Question

Estoy sobrecargando el menor operador en C# y me pregunto si esto debe verificar si es nulo. A continuación puede encontrar un ejemplo:

public static bool operator <(MyClass x, MyClass y) 
{ 
    if (x == null && y == null) 
    { 
    return false; 
    } 
    if (x == null) 
    { 
    return true; //false? 
    } 
    if (y == null) 
    { 
    return false; //true? 
    } 
    return x.Value < y.Value; 
} 

o esto es correcto:

public static bool operator <(MyClass x, MyClass y) 
{ 
    return x.Value < y.Value; 
} 

que no encontramos ninguna instrucción sobre esto. Pero tal vez me perdí algo.

Answer 1

La respuesta depende del patrón de uso previsto. Si planea tener valores nulos en la combinación, y le gustaría considerar que los valores null son menores que los valores no nulos, entonces su implementación es correcta; si desea considerar que los valores null son mayores que los objetos que no son nulos, los valores de retorno comentado (false y true) deben usarse en su lugar. Si no planea permitir nulos en la mezcla, lanzar un ArgumentNullException o permitir NullReferenceException sería la opción correcta.

Answer 2

Un operador personalizado es poco más que un método estático. Además, los operadores en general no deberían lanzar excepciones. Lo que significa que necesita esos chequeos nulos si MyClass es un tipo de referencia.

Por cierto, es convencional que nulls sea menor que nulls, lo que hace que su implementación propuesta sea idiomática.

Answer 3

Personalmente me lanzo una ArgumentNullException si bien x o y son null, que debe ser una circunstancia excepcional.

Answer 4

Ambos enfoques son correctos (para diferentes valores de correcto).

Si x o y son nulos y tienen un significado válido en su caso, entonces vaya con el primer acercamiento.

Si es poco probable que x y y sean nulos, vaya con el segundo y deje que las excepciones se propaguen al código de llamada para su manejo.

Answer 5

1. que es una mala idea para los operadores de sobrecarga en las clases. Sin embargo, está bien para las estructuras.

2. Si decide sobrecargar un operador en una clase, tendrá que:
   a. Incluya la verificación nula en su lógica
   b. Lanzar excepciones cuando se pasa null en
   c. Hacer el registro no nulo y permitir NullReferenceExceptions (malo)

Básicamente, es una mala idea para sobrecargar un operador en una clase. Convertiría tu clase en una estructura, o simplemente implementaría una interfaz como IComparable<T>/IEquatable<T> que tiene directrices cuando se usan valores nulos en las comparaciones.