Qual è la tilde (~) nella definizione di enum?

Sono sempre sorpreso che anche dopo aver usato C # per tutto questo tempo, riesco ancora a trovare cose di cui non sapevo ...

Ho provato a cercare su Internet per questo, ma usando "~" in una ricerca non funziona così bene per me e non ho trovato nulla su MSDN (per non dire che non c'è)

Ho visto questo frammento di codice di recente, cosa significa 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
}

Sono stato un po 'sorpreso di vederlo, quindi ho provato a compilarlo, e ha funzionato ... ma non so ancora cosa significhi / faccia. Qualsiasi aiuto??

~ è l'operatore di complemento di uno unario - lancia i bit del suo operando.

~0 = 0xFFFFFFFF = -1

nell'aritmetica del complemento a due, ~x == -x-1

l'operatore ~ ​​può essere trovato praticamente in qualsiasi linguaggio che abbia preso in prestito la sintassi da C, incluso Objective-C / C ++ / C # / Java / Javascript.

Penso che:

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

Sarebbe un po 'più chiaro.

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

A causa di due complementi in C #, ~0 == -1il numero in cui tutti i bit sono 1 nella rappresentazione binaria.

È meglio del

All = Cash | Check | CreditCard

soluzione, perché se si aggiunge un altro metodo in un secondo momento, dire:

PayPal = 8 ,

avrai già finito con la tilde-All, ma dovrai cambiare la linea con l'altra. Quindi è meno soggetto a errori in seguito.

Saluti

Solo una nota a margine, quando si utilizza

All = Cash | Check | CreditCard

hai il vantaggio aggiunto che Cash | Check | CreditCardvaluterà Alle non ad un altro valore (-1) che non è uguale a tutti mentre contiene tutti i valori. Ad esempio, se si utilizzano tre caselle di controllo nell'interfaccia utente

[] Cash
[] Check
[] CreditCard

e sommare i loro valori, e l'utente li seleziona tutti, Allvedresti nell'enum risultante.

Per gli altri che hanno trovato questa domanda illuminante, ho un rapido ~esempio da condividere. Lo snippet seguente dall'implementazione di un metodo di pittura, come dettagliato in questa documentazione Mono , utilizza ~con grande efficacia:

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

Senza l' ~operatore, il codice sarebbe probabilmente simile a questo:

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

... perché l'enumerazione è simile alla seguente:

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
}

Notate la somiglianza di questo enum con la risposta di Sean Bright?

Penso che il take away più importante per me sia ~lo stesso operatore in un enum come in una normale riga di codice.

È un operatore di complemento, ecco un articolo a cui mi riferisco spesso per operatori bit a bit

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

Inoltre msdn lo usa nel loro articolo enums che lo dimostra usare meglio

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

L'alternativa che uso personalmente, che fa la stessa cosa della risposta di @Sean Bright ma mi sembra migliore, è questa:

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

Avviso come la natura binaria di questi numeri, che sono tutte le potenze di due, ha emesso la seguente asserzione vera: (a + b + c) == (a | b | c). E IMHO, +sembra migliore.

Ho fatto alcuni esperimenti con ~ e ho scoperto che potrebbe avere delle insidie. Considera questo snippet per LINQPad che mostra che il valore All enum non si comporta come previsto quando tutti i valori vengono ordinati insieme.

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 
}

Voglio solo aggiungere, se usi enum [Flags], potrebbe essere più comodo usare l'operatore di spostamento a sinistra bit a bit, in questo modo:

[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
}