C# Enum Drapeaux De Comparaison

Donné les indicateurs suivants,

  [Flags]
    public enum Operations
    {
        add = 1,
        subtract = 2,
        multiply = 4,
        divide = 8,
        eval = 16,
    }

Comment pourrais-je mettre en œuvre un SI la condition d'exécution de chaque opération? Dans ma tentative, la première condition est vraie pour ajouter, eval, ce qui est correct. Cependant, la première condition est également vrai pour les soustraire, eval, ce qui est incorrect.

        public double Evaluate(double input)
    {
        if ((operation & (Operations.add & Operations.eval)) == (Operations.add & Operations.eval))
            currentResult += input;
        else if ((operation & (Operations.subtract & Operations.eval)) == (Operations.subtract & Operations.eval))
            currentResult -= input;
        else
            currentResult = input;

        operation = null;

        return currentResult;
    }

Je ne vois pas quel est le problème.

Est-ce juste moi qui pense [Drapeaux] pour l'opération indiquée n'est pas correcte? J'ai du mal à penser à un monde réel de l'échantillon où j'aurais des Drapeaux sur des opérations mathématiques montré...
Je suis d'accord Ensoleillé. Les drapeaux étaient censés représenter les états dans une calculatrice. Je ne sais pas pourquoi j'ai fait de cette façon. Rétrospectivement, je ne voudrais pas faire de cette façon maintenant des jours.
Double Possible de Comment faire pour Comparer les Drapeaux en C#?

InformationsquelleAutor destructo_gold | 2010-04-02

c#enums

Changer votre intérieur & à |:

if ((operation & (Operations.add | Operations.eval)) == (Operations.add | Operations.eval))

Ceci est équivalent à:

if( ((operation & Operations.add)==Operations.add) &&
    ((operation & Operations.eval)==Operations.eval))

qui peut être plus lisible. Vous pouvez également envisager une Extension comme ceci:

public static bool HasFlag(this Operations op, Operations checkflag)
{
    return (op & checkflag)==checkflag;
}

ensuite, vous pouvez faire ceci:

if(operation.HasFlag(Operations.add) && Operations.HasFlag(Operations.eval))

qui pourrait être encore plus lisible. Enfin, vous pourrez créer cette extension pour encore plus de plaisir:

public static bool HasAllFlags(this Operations op, params Operations[] checkflags)
{
    foreach(Operations checkflag in checkflags)
    {
        if((op & checkflag)!=checkflag)
            return false;
    }
    return true;
}

Alors votre expression pourrait se transformer en:

if(operation.HasAllFlags(Operations.add, Operations.eval))

+1 super réponse!
Suggestion initiale est le mal; la solution finale est correcte 😉
Sauf si vous trouvez cette illisible, vous avez besoin de séparer HasAllFlags, parce que vous pouvez utiliser HasFlag comme suit: if(operation.HasFlag(Operations.add | Operations.eval)).

InformationsquelleAutor Keltex

12

Wow, je ne peux pas croire toutes les mauvaises réponses..

Il est important de comprendre au niveau du bit de maths si vous travaillez avec des drapeaux. Dans votre cas, vous avez le suivant (pour la première condition):
```
1 in binary is  00001
16 in binary is 10000

  00001
& 10000
--------
  00000
```
Donc, disons que nous avons une Soustraction (2) comme le operation
```
2 in binary is     00010
previous result is 00000

  00010
& 00000
--------
  00000
```
Depuis le résultat précédent est 00000 rien ET avait avec elle sera de zéro. Si votre condition sera toujours évaluer à true depuis 0 == 0.

Si nous juste commutateur de cette de OU, puis nous avons les éléments suivants:
```
1 in binary is  00001
16 in binary is 10000

  00001
| 10000
--------
  10001 (17)
```
Maintenant, disons que nous avons Add (1) comme le operation
```
1 in binary is     00001
previous result is 10001 (17)

  00001
& 10001
--------
  00001
```
Donc, 1 & 17 => 1 et donc votre dernière condition est (1 & ( 1 | 16 ) ) == ( 1 | 16 ) => 1 & 17 == 17 => 1 == 17 => false (encore faux!)

Donc ce que vous voulez vraiment est:
```
((operation | Operations.add | Operations.eval) & (Operations.add | Operations.eval)) == (Operations.add | Operations.eval)
```
Cela devient ((1 | 1 | 16 ) & ( 1 | 16 )) == ( 1 | 16 ) => ( 17 & 17 ) == 17 => 17 == 17 == true

Ce n'est évidemment pas lisible, alors vous devriez opter pour l'extraction de ce dans une méthode (comme l'a suggéré). Mais il est encore important de comprendre pourquoi votre état est incorrect.

InformationsquelleAutor Ryan Emerle
4

Double:

Voir Comment Comparer les Drapeaux en C#?

C# 4 présente les Enum.HasFlags() méthode.

Cependant, voir Qu'est-ce qui fait que le protocole Enum.HasFlag-elle si lente? si la performance est un problème.

InformationsquelleAutor dan

La raison de votre opération est un échec parce que vous avez la mauvaise expression. (Operations.add & Operations.eval) est toujours zéro. À gauche et à droite de votre première comparaison sont à la fois toujours à zéro. Essayez plutôt ceci - je soupçonne que c'est ce que vous avez été au bout:

public double Evaluate(double input)
{
    if ((operation & (Operations.add | Operations.eval)) == (Operations.add | Operations.eval))
        currentResult += input;
    else if ((operation & (Operations.subtract | Operations.eval)) == (Operations.subtract | Operations.eval))
        currentResult -= input;
    else
        currentResult = input;

    operation = null;

    return currentResult;
}

InformationsquelleAutor Dan Puzey

Essayez ceci:

   public double Evaluate(double input)
{
    if ((operation & (Operations.add | Operations.eval)) == (Operations.add | Operations.eval))
        currentResult += input;
    else if ((operation & (Operations.subtract | Operations.eval)) == (Operations.subtract | Operations.eval))
        currentResult -= input;
    else
        currentResult = input;

    operation = null;

    return currentResult;
}

InformationsquelleAutor Andrey Tagaew

Vous devez vous connecter pour publier un commentaire.