sencillos - sobrecarga de operadores c# binarios

¿Por qué sobrecargar verdadero y falso en lugar de definir el operador bool?

Question

He estado leyendo sobre la sobrecarga de verdadero y falso en C #, y creo que entiendo la diferencia básica entre esto y la definición de un operador bool. El ejemplo que veo alrededor es algo como:

public static bool operator true(Foo foo) {
  return (foo.PropA > 0);
}
public static bool operator false(Foo foo) {
  return (foo.PropA <= 0);
}

Para mí, esto es lo mismo que decir:

public static implicit operator bool(Foo foo) {
  return (foo.PropA > 0);
}

La diferencia, por lo que puedo decir, es que al definir verdadero y falso por separado, puede tener un objeto que sea verdadero y falso, o ni verdadero ni falso:

public static bool operator true(Foo foo) { return true; }
public static bool operator false(Foo foo) { return true; }
//or
public static bool operator true(Foo foo) { return false; }
public static bool operator false(Foo foo) { return false; }

Estoy seguro de que hay una razón para que esto esté permitido, pero simplemente no puedo pensar en lo que es. Para mí, si desea que un objeto se pueda convertir en verdadero o falso, un solo operador bool tiene más sentido.

¿Alguien me puede dar un escenario donde tenga sentido hacerlo de otra manera?

Gracias

Answer 1

Como dicen los documentos , la sobrecarga de true y false está pensada para admitir tipos de base de datos (que admiten nulos) (Sí / No, S / N, 0/1, etc.).

Y, por supuesto, puede definirlos de manera inconsistente, como con cualquier operador. Es su responsabilidad devolver algo sensato. El compilador no va más allá de requerir ninguno o ambos.

Answer 2

Dependiendo del sistema, verdadero puede ser cualquier valor distinto de cero. En otros, puede ser cualquier valor positivo.

Otros sistemas no son realmente booleanos, y permiten un tercer estado nulo o nulo para los valores booleanos, por lo que puede sobrecargar verdadero y falso, en lugar de sobrecargar un solo operador bool.

Answer 3

He visto a personas sobrecargar las sobrecargas true y false para hacer cosas inteligentes como construir expresiones en .NET 2.0, antes de que existiera Linq.

Ayende desarrolló una sintaxis como esta para construir consultas de criterios NHibernate, utilizando su proyecto NHQG:

return Repository.FindAll(
    (Where.Publisher.Name == name) &&
    (Where.Publisher.City == city));

Answer 4

No tenía idea de que existieran estos operadores. Eso significa que puedes implementar la paradoja de la autonegación:

public class ThisClassIsFalse
{
    public static bool operator true(ThisClassIsFalse statement)
    {
        return statement ? false : true;
    }

    public static bool operator false(ThisClassIsFalse statement)
    {
        return statement ? true : false;
    }
}

Así que ahora sabemos la verdadera solución a esta paradoja clásica ... Exception.