Quel est le tilde (~) dans la définition enum?

Je suis toujours surpris que même après avoir utilisé C # pendant tout ce temps maintenant, j'arrive toujours à trouver des choses que je ne savais pas ...

J'ai essayé de chercher sur Internet pour cela, mais utiliser le "~" dans une recherche ne fonctionne pas très bien pour moi et je n'ai rien trouvé sur MSDN non plus (pour ne pas dire qu'il n'y est pas)

J'ai vu cet extrait de code récemment, que signifie le tilde (~)?

/// <summary>
/// Enumerates the ways a customer may purchase goods.
/// </summary>
[Flags]
public enum PurchaseMethod
{   
    All = ~0,
    None =  0,
    Cash =  1,
    Check =  2,
    CreditCard =  4
}

J'ai été un peu surpris de le voir alors j'ai essayé de le compiler, et cela a fonctionné ... mais je ne sais toujours pas ce que cela signifie / fait. De l'aide??

~ est l'opérateur de complément à un unaire - il retourne les bits de son opérande.

~0 = 0xFFFFFFFF = -1

en arithmétique complémentaire à deux, ~x == -x-1

l'opérateur ~ peut être trouvé dans à peu près n'importe quel langage qui a emprunté la syntaxe de C, y compris Objective-C / C ++ / C # / Java / Javascript.

Je pense que:

[Flags]
public enum PurchaseMethod
{
    None = 0,
    Cash = 1,
    Check = 2,
    CreditCard = 4,
    All = Cash | Check | CreditCard
 }

Ce serait un peu plus clair.

public enum PurchaseMethod
{   
    All = ~0, // all bits of All are 1. the ~ operator just inverts bits
    None =  0,
    Cash =  1,
    Check =  2,
    CreditCard =  4
}

En raison de deux complément en C #, ~0 == -1le nombre où tous les bits sont 1 dans la représentation binaire.

C'est mieux que le

All = Cash | Check | CreditCard

solution, car si vous ajoutez une autre méthode plus tard, dites:

PayPal = 8 ,

vous en aurez déjà fini avec le tilde-All, mais vous devrez changer le all-line avec l'autre. Donc, c'est moins sujet aux erreurs plus tard.

Cordialement

Juste une note latérale, lorsque vous utilisez

All = Cash | Check | CreditCard

vous avez l'avantage supplémentaire qui Cash | Check | CreditCardserait évalué à Allet non à une autre valeur (-1) qui n'est pas égale à tout tout en contenant toutes les valeurs. Par exemple, si vous utilisez trois cases à cocher dans l'interface utilisateur

[] Cash
[] Check
[] CreditCard

et additionnez leurs valeurs, et l'utilisateur les sélectionne toutes, vous verriez Alldans l'énumération résultante.

Pour ceux qui ont trouvé cette question éclairante, j'ai un ~exemple rapide à partager. L'extrait suivant de l'implémentation d'une méthode de peinture, comme détaillé dans cette documentation Mono , utilise ~à bon escient:

PaintCells (clipBounds, 
    DataGridViewPaintParts.All & ~DataGridViewPaintParts.SelectionBackground);

Sans l' ~opérateur, le code ressemblerait probablement à ceci:

PaintCells (clipBounds, DataGridViewPaintParts.Background 
    | DataGridViewPaintParts.Border
    | DataGridViewPaintParts.ContentBackground
    | DataGridViewPaintParts.ContentForeground
    | DataGridViewPaintParts.ErrorIcon
    | DataGridViewPaintParts.Focus);

... parce que l'énumération ressemble à ceci:

public enum DataGridViewPaintParts
{
    None = 0,
    Background = 1,
    Border = 2,
    ContentBackground = 4,
    ContentForeground = 8,
    ErrorIcon = 16,
    Focus = 32,
    SelectionBackground = 64,
    All = 127 // which is equal to Background | Border | ... | Focus
}

Remarquez la similitude de cette énumération avec la réponse de Sean Bright?

Je pense que le plus important à retenir pour moi est que ~c'est le même opérateur dans une énumération que dans une ligne de code normale.

C'est un opérateur de complément, voici un article auquel je me réfère souvent pour les opérateurs bit à bit

http://www.blackwasp.co.uk/CSharpLogicalBitwiseOps.aspx

Aussi msdn l'utilise dans son article enums qui démontre qu'il utilise mieux

http://msdn.microsoft.com/en-us/library/cc138362.aspx

L'alternative que j'utilise personnellement, qui fait la même chose que la réponse de @Sean Bright mais me semble meilleure, est celle-ci:

[Flags]
public enum PurchaseMethod
{
    None = 0,
    Cash = 1,
    Check = 2,
    CreditCard = 4,
    PayPal = 8,
    BitCoin = 16,
    All = Cash + Check + CreditCard + PayPal + BitCoin
}

Remarquez comment la nature binaire de ces chiffres, qui sont tous les pouvoirs de deux, fait l'affirmation suivante vraie: (a + b + c) == (a | b | c). Et à mon humble avis, +semble mieux.

J'ai fait quelques expériences avec le ~ et je trouve qu'il pourrait avoir des pièges. Considérez cet extrait de code pour LINQPad qui montre que la valeur d'énumération All ne se comporte pas comme prévu lorsque toutes les valeurs sont regroupées.

void Main()
{
    StatusFilterEnum x = StatusFilterEnum.Standard | StatusFilterEnum.Saved;
    bool isAll = (x & StatusFilterEnum.All) == StatusFilterEnum.All;
    //isAll is false but the naive user would expect true
    isAll.Dump();
}
[Flags]
public enum StatusFilterEnum {
      Standard =0,
      Saved =1,   
      All = ~0 
}

Je veux juste ajouter, si vous utilisez [Flags] enum, alors il peut être plus pratique d'utiliser l'opérateur de décalage gauche au niveau du bit, comme ceci:

[Flags]
enum SampleEnum
{
    None   = 0,      // 0
    First  = 1 << 0, // 1b    = 1d
    Second = 1 << 1, // 10b   = 2d
    Third  = 1 << 2, // 100b  = 4d
    Fourth = 1 << 3, // 1000b = 8d
    All    = ~0      // 11111111b
}