Perché sovraccaricare true e false invece di definire l'operatore bool?

Question

Ho letto di overloading true e false in C# e penso di capire la differenza fondamentale tra questo e definire un operatore bool. L'esempio che vedo in giro è qualcosa di simile:

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

Per me, questo è lo stesso che dire:

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

La differenza, per quanto posso dire, è che attraverso la definizione di vero e falso a parte, si può avere un oggetto che è allo stesso tempo vero e falso, o né vere né false:

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; } 

sono sicuro che c'è un motivo per cui questo è consentito, ma non riesco proprio a pensare a quello che è. Per me, se vuoi che un oggetto possa essere convertito in vero o falso, un singolo operatore bool ha più senso.

Qualcuno può darmi uno scenario in cui ha senso farlo in un altro modo?

Grazie

Answer 1

Come the docs dire, sovraccarico true e false è inteso per supportare (annullabili) tipi di database (Sì/No, Y/N, 0/1, ecc.).

E ovviamente è possibile definirli in modo incoerente, come con qualsiasi operatore. È tua responsabilità restituire qualcosa di sensato. Il compilatore non va oltre il richiedere né l'uno né l'altro.

Answer 2

seconda del sistema, vera può essere qualsiasi valore diverso da zero. In altri, può essere un qualsiasi valore positivo.

Altri sistemi non sono veramente booleani e consentono un terzo stato null o nill per i valori booleani, motivo per cui si potrebbe sovraccaricare vero e falso, rispetto a sovraccaricare un singolo operatore bool.

Answer 3

Ho visto persone sovraccaricare gli overload true e false per fare cose intelligenti come costruire espressioni in .NET 2.0, prima che Linq esistesse.

Ayende elaborato una sintassi come questo per costruire criteri di NHibernate query, utilizzando il suo progetto NHQG:

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

Answer 4

non avevo idea di questi operatori esistevano. Ciò significa che è possibile implementare il paradosso di auto-negazione:

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; 
    } 
} 

Così ora sappiamo che la vera soluzione a questo classico paradosso ... StackOverflowException.