À quoi sert l'opérateur false en C# ?

Question

Il existe deux opérateurs bizarres en C# :

• le site véritable opérateur
• le site faux opérateur

Si je comprends bien, ces opérateurs peuvent être utilisés dans des types que je veux utiliser à la place d'une expression booléenne et où je ne veux pas fournir une conversion implicite en bool.

Disons que j'ai une classe suivante :

    public class MyType
    {
        public readonly int Value;

        public MyType(int value)
        {
            Value = value;
        }

        public static bool operator true (MyType mt)
        {
            return  mt.Value > 0;
        }

        public static bool operator false (MyType mt)
        {
            return  mt.Value < 0;
        }

    }

Je peux donc écrire le code suivant :

    MyType mTrue = new MyType(100);
    MyType mFalse = new MyType(-100);
    MyType mDontKnow = new MyType(0);

    if (mTrue)
    {
         // Do something.
    }

    while (mFalse)
    {
        // Do something else.
    }

    do
    {
        // Another code comes here.
    } while (mDontKnow)

Cependant, dans tous les exemples ci-dessus, seul l'opérateur true est exécuté. Alors à quoi sert l'opérateur false en C# ?

_Note : D'autres exemples peuvent être trouvés aquí , aquí et aquí ._

Answer 1

Vous pouvez l'utiliser pour remplacer le && et || les opérateurs.

Le && et || les opérateurs peuvent pas être remplacés, mais si vous remplacez |, &, le vrai et le faux, exactement de la bonne façon, le compilateur va appeler | et & lorsque vous écrivez || et &&

par exemple, regardez ce code (à partir de http://www.ayende.com/Blog/archive/2006/08/04/7381.aspx - où j'ai découvert ce truc):

EDIT: L'URL a été brisé. Voici un lien vers l'archive de cette URL: http://web.archive.org/web/20080613013350/http://www.ayende.com/Blog/archive/2006/08/04/7381.aspx

public static AbstractCriterion operator &(AbstractCriterion lhs, AbstractCriterion rhs)
{
       return new AndExpression(lhs, rhs);
}

public static AbstractCriterion operator |(AbstractCriterion lhs, AbstractCriterion rhs)
{
       return new OrExpression(lhs, rhs);
}

public static bool operator false(AbstractCriterion criteria)
{
       return false;
}
public static bool operator true(AbstractCriterion criteria)
{
       return false;
}

C'est évidemment un effet secondaire et non pas la façon dont il est destiné à être utilisé, mais il est utile.

Answer 2

Shog9 et Nir : merci pour vos réponses. Ces réponses m'ont orienté vers Article de Steve Eichert et cela m'a conduit à msdn :

L'opération x && y est évaluée comme T.false(x) ? x : T.&(x, y), où T.false(x) est une invocation de l'opérateur false déclaré dans T, et T.&(x, y) est une invocation de l'opérateur sélectionné &. En d'autres termes, x est d'abord évalué et l'opérateur false est invoqué sur le résultat pour déterminer si x est définitivement faux. Ensuite, si x est définitivement faux, le résultat de l'opération est la valeur précédemment calculée pour x. Sinon, y est évalué, et l'opérateur sélectionné & est invoqué sur la valeur précédemment calculée pour x et la valeur calculée pour y pour produire le résultat de l'opération.

Answer 3

La page vers laquelle vous vous dirigez http://msdn.microsoft.com/en-us/library/6x6y6z4d.aspx dit à quoi ils servaient, c'est-à-dire une façon de gérer les bools nullables avant l'introduction des types de valeurs nullables.

Je pense qu'aujourd'hui ils sont bons pour le même genre de choses que ArrayList - c'est-à-dire absolument rien.

Answer 4

AFAIK, il serait utilisé dans un test pour faux, comme quand le && opérateur entre en jeu. Rappelez-vous, && court-circuite, donc dans l'expression

if ( mFalse && mTrue) 
{
   // ... something
}

mFalse.false() est appelé, et au retour true l'expression est réduite à un appel à 'mFalse.true()' (qui devrait alors renvoyer false ou les choses vont devenir bizarres).

Notez que vous devez implémenter l'option & pour que cette expression soit compilée, puisqu'il est utilisé si mFalse.false() renvoie à false .

Answer 5

D'après l'article MSDN auquel vous avez accédé, il semble qu'il ait été fourni pour permettre les types booléens annulables avant que le type Nullable (c'est-à-dire int ?, bool ?, etc.) ne soit introduit dans le langage en C#2. Ainsi, vous stockez une valeur interne indiquant si la valeur est vraie, fausse ou nulle, c'est-à-dire, dans votre exemple, >0 pour vrai, <0 pour faux et ==0 pour nul, et vous obtenez une sémantique nulle de type SQL. Vous devriez également implémenter une méthode ou une propriété .IsNull afin que la nullité puisse être vérifiée explicitement.

Par rapport à SQL, imaginez une table Table contenant 3 lignes avec la valeur Foo définie comme vraie, 3 lignes avec la valeur Foo définie comme fausse et 3 lignes avec la valeur Foo définie comme nulle.

SELECT COUNT(*) FROM Table WHERE Foo = TRUE OR Foo = FALSE
6

Pour compter toutes les lignes, il faut faire ce qui suit:-.

SELECT COUNT(*) FROM Table WHERE Foo = TRUE OR Foo = FALSE OR Foo IS NULL
9

Cette syntaxe "IS NULL" aurait un code équivalent dans votre classe comme .IsNull().

LINQ rend la comparaison avec C# encore plus claire:-

int totalCount = (from s in MyTypeEnumerable
                 where s || !s
                 select s).Count();

Imaginons que MyTypeEnumberable ait exactement le même contenu que la base de données, c'est-à-dire 3 valeurs égales à true, 3 valeurs égales à false et 3 valeurs égales à null. Dans ce cas, totalCount serait évalué à 6 dans ce cas. Cependant, si nous réécrivons le code comme suit :-.

int totalCount = (from s in MyTypeEnumerable
                 where s || !s || s.IsNull()
                 select s).Count();

Alors totalCount serait évalué à 9.

L'exemple DBNull donné dans l'article MSDN sur l'opérateur false montre une classe de la BCL qui a exactement ce comportement.

En effet, la conclusion est que vous ne devriez pas utiliser cette fonction à moins d'être complètement sûr de vouloir ce type de comportement, il est préférable d'utiliser la syntaxe nullable, beaucoup plus simple !

Mise à jour : Je viens de remarquer que vous devez remplacer manuellement les opérateurs logiques !, || et && pour que cela fonctionne correctement. Je pense que l'opérateur false alimente ces opérateurs logiques, c'est-à-dire qu'il indique la vérité, la fausseté ou le "sinon". Comme indiqué dans un autre commentaire, !x ne fonctionnera pas d'emblée ; vous devez surcharger !. Bizarrerie !