Disons que j'ai cette énumération:
[Flags]
enum Letters
{
A = 1,
B = 2,
C = 4,
AB = A | B,
All = A | B | C,
}
Pour vérifier si, par exemple, AB
est défini, je peux le faire:
if((letter & Letters.AB) == Letters.AB)
Existe-t-il un moyen plus simple de vérifier si l'un des indicateurs d'une constante d'indicateur combiné est défini que le suivant?
if((letter & Letters.A) == Letters.A || (letter & Letters.B) == Letters.B)
Pourriez-vous par exemple échanger le &
avec quelque chose?
Pas trop stable quand il s'agit de trucs binaires comme ça ...
Réponses:
Si vous voulez savoir si une lettre contient l'une des lettres AB, vous devez utiliser l' opérateur AND &. Quelque chose comme:
la source
letter & Letters.AB
. J'ai édité ça là-dedans.Letters.None
, je suppose que vous pourriez l'échanger avec le0
pour un look moins comparé au nombre magique?Dans .NET 4, vous pouvez utiliser la méthode Enum.HasFlag :
L'exemple affiche la sortie suivante:
la source
petsInFamily
si unPet.Dog || Pet.Cat
?J'utilise des méthodes d'extension pour écrire des choses comme ça:
Voici le code:
la source
where T : struct, IConvertible
. Excellent code sinon!IsFlagSet(this Enum value, Enum flag)
est suffisant.Il existe une méthode HasFlag dans .NET 4 ou supérieur.
la source
Si vous pouvez utiliser .NET 4 ou supérieur, utilisez la méthode HasFlag ()
exemples
pareil que
la source
bitwise OR
qu'il "les deux doivent être définis" et non aucun?bitwise OR
combinerait les valeurs, donc 1000 | 0010 devient 1010, ou les deux ensembleSi cela vous ennuie vraiment, vous pouvez écrire une fonction comme celle-ci:
la source
return (value & flag) == flag;
ne compile pas: "L'opérateur '&' ne peut pas être appliqué aux opérandes de type 'T' et 'T'" .Cela vérifie que les deux A et B sont définis, et ne tient pas si d'autres drapeaux sont ensemble.
Cela vérifie que soit A ou B est définie, et ne tient pas si d'autres indicateurs sont définis ou non.
Cela peut être simplifié en:
Voici le C pour les opérations binaires; il devrait être simple de l'appliquer à C #:
Incidemment, la dénomination de la variable dans l'exemple de la question est la «lettre» singulière, ce qui pourrait impliquer qu'elle ne représente qu'une seule lettre; L'exemple de code indique clairement qu'il s'agit d'un ensemble de lettres possibles et que plusieurs valeurs sont autorisées, alors pensez à renommer la variable «lettres».
la source
anything_and_a
,a_and_or_c_and_anything_else
etboth_ac_and_anything_else
sera toujours vrai? ou est-ce que je manque quelque chose ici?Que diriez-vous
?
la source
J'ai créé une méthode d'extension simple qui ne nécessite pas de vérification des
Enum
types:Cela fonctionne également sur les énumérations nullables. La
HasFlag
méthode standard ne le fait pas, j'ai donc créé une extension pour couvrir cela aussi.Un test simple:
Prendre plaisir!
la source
Il y a beaucoup de réponses ici mais je pense que la façon la plus idiomatique de le faire avec Flags serait Letters.AB.HasFlag (lettre) ou (Letters.A | Letters.B) .HasFlag (lettre) si vous ne l'avez pas fait ont déjà Letters.AB. letter.HasFlag (Letters.AB) ne fonctionne que s'il a les deux.
la source
Cela fonctionnerait-il pour vous?
Cordialement,
Sebastiaan
la source
Vous pouvez utiliser cette méthode d'extension sur enum, pour tout type d'énumérations:
la source
la source
Vous pouvez simplement vérifier si la valeur n'est pas zéro.
Mais je considérerais que c'est une meilleure solution d'introduire une nouvelle valeur d'énumération avec la valeur zéro et de comparer à nouveau cette valeur d'énumération (si possible, car vous devez pouvoir modifier l'énumération).
METTRE À JOUR
Mauvaise lecture de la question - correction de la première suggestion et ignorer simplement la deuxième suggestion.
la source
Il y a deux approches que je peux voir qui fonctionneraient pour vérifier n'importe quel bit en cours de définition.
Approche A
Cela fonctionne tant que cela ne vous dérange pas de vérifier tous les bits, y compris les bits non définis!
Approche B
Cela ne vérifie que les bits définis, tant que Letters.All représente tous les bits possibles.
Pour des bits spécifiques (un ou plusieurs ensembles), utilisez Aproach B en remplaçant Letters.Tous par les bits que vous souhaitez vérifier (voir ci-dessous).
la source
Désolé, mais je vais le montrer en VB :)
CntValue = 5 Donc l'énumération contient 1 + 4
la source