Implémentation Tribool en C#

Question

J'essaye de mettre en œuvre un type Tribool en utilisant http://www.boost.org/doc/libs/1_41_0/doc/html/tribool.html comme référence. J'utilise une structure car c'est un type primitif et ne devrait pas être extensible. Je sais qu'il existe 3 types de Tribools --- True, False et Unknown, et le constructeur par défaut devrait fournir un False Tribool. Ma question est, quel type de données dois-je définir Vrai, Faux et Inconnu? En ce moment je:

struct Tribool 
{ 
    //True, False, and Unknown public constants 
    public static readonly Tribool TRUE, FALSE, UNKNOWN; 

    //Constructors 
    public Tribool() 
    { 
     Tribool = FALSE; //use ValueType instead? 
    } 

mais je ne suis pas sûr si cela est exact, car il semble que je suis juste un réglage Tribool à un autre Tribool. Dois-je utiliser ValueType à la place? Il a surgi quand je tapais VS, et cela semble raisonnable, mais je n'ai pas pu trouver beaucoup d'informations à partir de Google.

De plus, le Tribool doit être capable de fonctionner avec des bols réguliers, ce qui signifie que "vrai" et "faux" doivent être surchargés. Cela nécessiterait-il une surcharge de l'opérateur? Ou devrait-il juste être une méthode qui renvoie un bool?

Merci d'avance!

Edit: Désolé, j'aurais dû mentionner que c'était pour une affectation. Donc, je ne peux pas utiliser des bols, même si c'est beaucoup plus pratique que beaucoup d'entre vous l'ont souligné.

Answer 1

bool? 

fait. Ça fait quoi? En particulier, le compilateur C# fournira les opérateurs "levés" pour mapper à bool pour vous. Sans doute, cependant, il pourrait être légèrement plus grand qu'un bool ou un simple enum.

Remarque: ne pas utiliser ValueType, car il s'agirait d'une opération de boxe.

Si vous ne pouviez pas utiliser bool? (vous vouliez mettre en œuvre à partir de zéro) Je mapper à un enum (éventuellement un byte ENUM, mais je voudrais par défaut int comme normal):

public struct Tribool : IEquatable<Tribool> { 
    public static Tribool True { get { return new Tribool(true); } } 
    public static Tribool False { get { return new Tribool(false); } } 
    public static Tribool Unknown { get { return new Tribool(); } } 
    enum TriboolState { Unknown = 0, True = 1, False = 2 } 

    private readonly TriboolState state; 
    public Tribool(bool state) { 
     this.state = state ? TriboolState.True : TriboolState.False; 
    } 
    // default struct ctor handles unknown 
    public static bool operator true(Tribool value) { 
     return value.state == TriboolState.True; 
    } 
    public static bool operator false(Tribool value) { 
     return value.state == TriboolState.False; 
    } 
    public static bool operator ==(Tribool x, Tribool y) { 
     return x.state == y.state; 
    } 
    public static bool operator !=(Tribool x, Tribool y) { 
     return x.state != y.state; // note: which "unknown" logic do you want? 
            // i.e. does unknown == unknown? 
    } 
    public override string ToString() { 
     return state.ToString(); 
    } 
    public override bool Equals(object obj) { 
     return (obj != null && obj is Tribool) ? Equals((Tribool)obj) : false; 
    } 
    public bool Equals(Tribool value) { 
     return value == this; 
    } 
    public override int GetHashCode() { 
     return state.GetHashCode(); 
    } 
    public static implicit operator Tribool(bool value) { 
     return new Tribool(value); 
    } 
    public static explicit operator bool(Tribool value) { 
     switch (value.state) { 
      case TriboolState.True: return true; 
      case TriboolState.False: return false; 
      default: throw new InvalidCastException(); 
     } 
    } 
} 

Answer 2

Pourquoi ne pas simplement utiliser bool? qui est un booléen Nullable?

Answer 3

Quel est le problème avec Nullable<bool>?