À quoi sert le faux opérateur en C# ?
https://stackoverflow.com/questions/33265
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Il existe deux opérateurs étranges en C# :
Si je comprends bien, ces opérateurs peuvent être utilisés dans des types que je souhaite utiliser à la place d'une expression booléenne et pour lesquels je ne souhaite pas fournir de 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, pour tous les exemples ci-dessus, seul le vrai opérateur est exécuté.Alors, à quoi sert le faux opérateur en C# ?
Note:D'autres exemples peuvent être trouvés ici, ici et ici.
La solution
Vous pouvez l'utiliser pour remplacer le && et || les opérateurs.
Le && et || les opérateurs ne peuvent pas être remplacés, mais si vous remplacez |, &, true et false exactement de la bonne manière que le compilateur appellera | et & quand tu écris || et &&.
Par exemple, regardez ce code (de http://ayende.com/blog/1574/nhibernate-criteria-api-operator-overloading - où j'ai découvert cette astuce ; version archivée par @BiggsTRC) :
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;
}
Il s’agit évidemment d’un effet secondaire et non de la manière dont il est destiné à être utilisé, mais il est utile.
Autres conseils
Shog9 et Nir :merci pour vos réponses.Ces réponses m'ont indiqué Article de Steve Eichert et cela m'a indiqué 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.Alors, 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.
La page vers laquelle vous créez un lien http://msdn.microsoft.com/en-us/library/6x6y6z4d.aspx dit à quoi ils servaient, qui était un moyen de gérer les booléens nullables avant l'introduction des types de valeur nullables.
Je suppose que de nos jours, ils conviennent au même genre de choses qu'ArrayList - c'est-à-direabsolument rien.
AFAIK, il serait utilisé dans un test de faux, comme lorsque le && L’opérateur entre en jeu.Rappelez-vous, && courts-circuits, donc dans l'expression
if ( mFalse && mTrue)
{
// ... something
}
mFalse.false() est appelé, et à son 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 mettre en œuvre le & opérateur pour que cette expression soit compilée, car elle est utilisée si mFalse.false() Retour false.
Il ressort de l'article MSDN que vous avez lié qu'il a été fourni pour autoriser les types booléens nullables avant Nullable (c'est-à-direint?, bool?, etc.) étant introduit dans le langage en C#2.Ainsi, vous stockeriez une valeur interne indiquant si la valeur est vraie, fausse ou nulle, c'est-à-diredans votre exemple >0 pour vrai, <0 pour faux et ==0 pour nul, vous obtiendrez alors une sémantique nulle de style SQL.Vous devrez également implémenter une méthode ou une propriété .IsNull pour que la nullité puisse être vérifiée explicitement.
Par rapport à SQL, imaginez une table Table avec 3 lignes avec la valeur Foo définie sur true, 3 lignes avec la valeur Foo définie sur false et 3 lignes avec la valeur Foo définie sur null.
SELECT COUNT(*) FROM Table WHERE Foo = TRUE OR Foo = FALSE
6
Afin de compter toutes les lignes, vous devez procéder comme 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-à-dire3 valeurs égales à vrai, 3 valeurs égales à faux et 3 valeurs égales à nul.Dans ce cas, totalCount serait évalué à 6.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 lié sur l'opérateur false démontre une classe dans la BCL qui a exactement ce comportement.
En fait, la conclusion est que vous ne devriez pas l'utiliser à moins d'être complètement sûr de vouloir ce type de comportement, il est préférable d'utiliser simplement 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 crois que le faux opérateur alimente ces opérateurs logiques, c'est-à-direindiquant la vérité, la fausseté ou « autrement ».Comme indiqué dans un autre commentaire !x ne fonctionnera pas dès le départ ;il faut surcharger !.Étrangeté!
