Comment mettre tous les bits de l'enum drapeau

Je me demande une méthode générique pour la configuration de tous les bits de enum drapeau à 1.
J'aimerais juste avoir un enum qui renvoie pour toutes les comparaisons, indépendamment des autres énumérations.

Et ce code fonctionne;

[Flags]
public enum SomeRightEnum : uint
{
    CanDoNothing = 0,
    CanDoSomething = 1 << 0,
    CanDoSomethingElse = 1 << 1,
    CanDoYetAnotherThing = 1 << 2,
    ...
    DoEverything = 0xFFFFFFFF 
}

Mais dans le code ci-dessus, car il est uint nous avons fixé le nombre de "F"s, ça ne marcherait pas si c'était int.

Donc je vais apprécier d'une façon générique de l'établissement de tous les bits de enum drapeau à 1, quel que soit le type de données (int, int64, uint etc)

Hmmm. L'intention des énumérations est de décrire les options mutuellement exclusives. Vous semblez être de les utiliser comme raccourci pour un tas de masques de bits.
Vous êtes à l'aide de la [Drapeaux] l'attribut dans l'enum droit?
L' [Drapeaux] attribut sur l'enum est conçu à cet effet.
Blanc: L'attribut Flags est purement esthétique, vous POUVEZ utiliser des "drapeaux" sans elle.
bien sûr, j'ai édité, juste oublièrent de le copier
ideone.com/qkc8b
Le ToString représentation de la cosmétique. La sémantique et les comportements est identique avec ou sans le Flags attribut.

InformationsquelleAutor AFgone | 2011-09-19

c#enum-flags enums

56

Plus simple est probablement:
```
enum Foo
{
  blah = 1,
  ....
  all = ~0
}
```
Non signés, en fonction enum:
```
enum Foo : uint
{
  blah = 1,
  ....
  all = ~0u;
}
```
- quand j'ai essayer ce qu'il dit "Constante de la valeur '-1' ne peut pas être converti en 'uint' "
- Juste le jeter ensuite, par exemple, unchecked((uint)~0)
- Peut-int.MaxValue être utilisé?
- Certes, mais pourquoi? 😀
- regarde un peu moins de magie chiffre pour moi)
- int.MaxValue n'a pas mis le bit de signe (bit 31) sa valeur est la valeur hexadécimale 0x7FFFFFFF. Donc, seuls les bits 0 à 30 sont fixés. Vous pouvez utiliser -1 pour les types signés mais pas pour les types non signés. Toujours ~0 est le meilleur.
InformationsquelleAutor leppie
21
```
[Flags]
public enum MyEnum
{
    None   = 0,
    First  = 1 << 0,
    Second = 1 << 1,
    Third  = 1 << 2,
    Fourth = 1 << 3,
    All = ~(-1 << 4)
}
```
- J'aime bien cette option, même mieux que mon habitude -1 option. J'ai été en utilisant un enum pour garder une trace des tâches ont été demandées et la suppression de l'indicateur lorsque la tâche a été achevée. Mon plan était d'utiliser le résultat comme le code de sortie. Donc, ce qui contribue à la maintenance des tâches enum.
- Je préfère All = ~(~0 << 4) parce que c'est un peu plus clair. Pas tout le monde sait que -1 est tout 1s.
- None ne devrait pas être -1 ?!
InformationsquelleAutor realstrategos

internal static class Program
{
    private static void Main()
    {
        Console.WriteLine(Foo.Everything.HasFlag(Foo.None)); //False
        Console.WriteLine(Foo.Everything.HasFlag(Foo.Baz)); //True
        Console.WriteLine(Foo.Everything.HasFlag(Foo.Hello)); //True
    }
}

[Flags]
public enum Foo : uint
{
    None = 1 << 0,
    Bar = 1 << 1,
    Baz = 1 << 2,
    Qux = 1 << 3,
    Hello = 1 << 4,
    World = 1 << 5,
    Everything = Bar | Baz | Qux | Hello | World
}

Était-ce ce que vous vouliez?

mais ce n'est pas indépendamment des autres énumérations, lorsque je modifier ou supprimer les énumérations, je dois changer aussi "Tout"
C'est la bonne solution. ~0 n'est pas assez bon que vous ne pouvez pas tester pour elle. La combinaison de toutes les options n'est pas égal à ~0.

InformationsquelleAutor Scott

Au cas où quelqu'un se demande:
J'avais besoin de faire le même bâtiment un Bindable enumconverter pour WPF.

Car je ne sais pas ce que les valeurs moyennes dans la Réflexion, j'ai besoin d'manuellement été en mesure de changer les valeurs (les liant à une case à cocher p.e.)

Il y a un problème de réglage de la valeur d'un Pavillon enum à -1 pour définir tous les bits.

Si vous le réglez à -1, et vous démarquer de toutes les valeurs, il ne sera pas le résultat en 0 car tous les bits non utilisés ne sont pas décochée.
C'est le wat qui a le mieux fonctionné pour ma situation.

SomeRightEnum someRightEnum = SomeRightEnum.CanDoNothing;
Type enumType = someRightEnum.GetType();
int newValue = 0;
var enumValues = Enum.GetValues(enumType).Cast<int>().Where(e => e == 1 || e % 2 == 0);
foreach (var value in enumValues)
{
    newValue |= value;
}
Console.WriteLine(newValue);

Ou si vous voulez une méthode d'extension:

public static class FlagExtensions
{
    public static TEnum AllFlags<TEnum>(this TEnum @enum)
        where TEnum : struct
    {
        Type enumType = typeof(TEnum);
        long newValue = 0;
        var enumValues = Enum.GetValues(enumType);
        foreach (var value in enumValues)
        {
            long v = (long)Convert.ChangeType(value, TypeCode.Int64);
            if(v == 1 || v % 2 == 0)
            {
               newValue |= v; 
            }
        }
        return (TEnum)Enum.ToObject(enumType , newValue);
    }
}

en faire une méthode d'extension nommée AllFlags qui s'étend de la enum système de classe. ensuite, il pourrait être utilisé parfaitement enum.AllFlags(typeof(MyEnum)) pas ?
J'ai mis à jour ma réponse avec une extension générique qui renvoie le (immuable) de la valeur. J'ai aussi retiré un bug d'omettre non-valeurs d'indicateur.

InformationsquelleAutor Silvermind

Vous devez vous connecter pour publier un commentaire.