Qual é o til (~) na definição de enum?

Fico sempre surpreso que, mesmo depois de usar o C # por todo esse tempo, ainda consigo encontrar coisas que não sabia ...

Tentei pesquisar na Internet, mas usar o "~" em uma pesquisa não está funcionando tão bem para mim e também não encontrei nada no MSDN (para não dizer que não está lá)

Eu vi esse trecho de código recentemente, o que significa o til (~)?

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

Fiquei um pouco surpreso ao vê-lo, então tentei compilá-lo e funcionou ... mas ainda não sei o que isso significa / faz. Qualquer ajuda??

~ é o operador complementar do unário - ele inverte os bits do seu operando.

~0 = 0xFFFFFFFF = -1

na aritmética do complemento de dois, ~x == -x-1

o operador ~ pode ser encontrado em praticamente qualquer linguagem que emprestou sintaxe de C, incluindo Objective-C / C ++ / C # / Java / Javascript.

Eu pensaria que:

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

Seria um pouco mais claro.

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

Por causa de dois complementos em C #, ~0 == -1o número em que todos os bits são 1 na representação binária.

É melhor que o

All = Cash | Check | CreditCard

solução, porque se você adicionar outro método posteriormente, diga:

PayPal = 8 ,

você já estará pronto com o til-All, mas precisará alterar o all-line com o outro. Portanto, é menos propenso a erros mais tarde.

Saudações

Apenas uma nota lateral, quando você usa

All = Cash | Check | CreditCard

você tem o benefício adicional que Cash | Check | CreditCardseria avaliado Alle não com outro valor (-1) que não é igual a todos e contém todos os valores. Por exemplo, se você usar três caixas de seleção na interface do usuário

[] Cash
[] Check
[] CreditCard

e some seus valores, e o usuário seleciona todos eles, você verá Allna enumeração resultante.

Para outros que acharam essa pergunta esclarecedora, tenho um ~exemplo rápido para compartilhar. O seguinte trecho da implementação de um método de pintura, conforme detalhado nesta documentação Mono , usa ~com grande efeito:

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

Sem o ~operador, o código provavelmente seria algo como isto:

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

... porque a enumeração se parece com isso:

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
}

Notou a semelhança desse enum com a resposta de Sean Bright?

Eu acho que a coisa mais importante para mim é que ~é o mesmo operador em uma enumeração e em uma linha de código normal.

É um operador de complemento. Aqui está um artigo ao qual frequentemente me refiro para operadores de bits

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

O msdn também o usa em seu artigo de enumerações, o que demonstra que ele usa melhor

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

A alternativa que eu pessoalmente uso, que faz a mesma coisa que a resposta de @Sean Bright, mas parece melhor para mim, é esta:

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

Observe como a natureza binária desses números, que são todas as potências de dois, faz a seguinte afirmação verdadeira: (a + b + c) == (a | b | c). E IMHO, +parece melhor.

Fiz algumas experiências com o ~ e achei que poderia ter armadilhas. Considere esse trecho para LINQPad, que mostra que o valor All enum não se comporta conforme o esperado quando todos os valores são ored juntos.

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 
}

Só quero adicionar, se você usar [Flags] enum, pode ser mais conveniente usar o operador de deslocamento à esquerda bit a bit, assim:

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