Zu den bitweisen Operatoren und Schiebeoperatoren zählen das unäre bitweise Komplement, die binäre Links- und Rechtsverschiebung, die vorzeichenlose Rechtsverschiebung sowie die binären logischen AND-, OR- und XOR-Operatoren. Diese Operanden verwenden Operanden der integralen numerischen Typen oder des char-Typs.

Mit dem Operator ~ wird ein bitweises Komplement seines Operanden erzeugt, indem jedes Bit umgekehrt wird:

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Console.WriteLine(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

Zu den bitweisen Operatoren und Schiebeoperatoren zählen das unäre bitweise Komplement, die binäre Links- und Rechtsverschiebung, die vorzeichenlose Rechtsverschiebung sowie die binären logischen AND-, OR- und XOR-Operatoren. Diese Operanden verwenden Operanden der integralen numerischen Typen oder des char-Typs.

Mit dem Operator ~ wird ein bitweises Komplement seines Operanden erzeugt, indem jedes Bit umgekehrt wird:

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Console.WriteLine(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

Mit dem Operator « wird der linke Operand um die Anzahl von Bits nach links verschoben, die durch den rechten Operanden angegeben wird. Bei der Operation zum Verschieben nach links werden die hohen Bits, die außerhalb des Bereichs des Ergebnistyps liegen, verworfen, und die niedrigen leeren Bitpositionen werden auf null festgelegt. Dies ist im folgenden Beispiel dargestellt:

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2)}");
 
uint y = x << 4;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

Da die Verschiebeoperatoren nur für die Typen int, uint, long und ulong definiert werden, enthält das Ergebnis einer Operation immer mindestens 32 Bit. Wenn der linke Operand einen abweichenden integralen Typ aufweist (sbyte, byte, short, ushort oder char), wird sein Wert in den Typ int konvertiert. Dies ist im folgenden Beispiel dargestellt:

byte a = 0b_1111_0001;
var b = a << 8;
Console.WriteLine(b.GetType());
Console.WriteLine($"Shifted byte: {Convert.ToString(b, toBase: 2)}");
// Output:
// System.Int32
// Shifted byte: 1111000100000000

Mit dem Operator » wird der linke Operand um die Anzahl von Bits nach rechts verschoben, die durch den rechten Operanden angegeben wird.

Bei der Operation zum Verschieben nach rechts werden die niedrigen Bits verworfen. Dies ist im folgenden Beispiel dargestellt:

uint x = 0b_1001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2), 4}");
 
uint y = x >> 2;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2).PadLeft(4, '0'), 4}");
// Output:
// Before: 1001
// After:  0010

Die höheren leeren Bitpositionen werden basierend auf dem Typ des linken Operanden wie folgt festgelegt:

Wenn der linke Operand vom Typ int oder long ist, führt der Operator zur Rechtsverschiebung eine arithmetische Verschiebung durch: Der Wert des Bits mit dem höchsten Stellenwert (MSB, „most significant bit“) des linken Operanden wird auf die hohen leeren Bitpositionen übertragen. Die hohen leeren Bitpositionen werden daher auf 0 festgelegt, wenn der linke Operand nicht negativ ist, bzw. auf 1, wenn der linke Operand negativ ist.

int a = int.MinValue;
Console.WriteLine($"Before: {Convert.ToString(a, toBase: 2)}");
 
int b = a >> 3;
Console.WriteLine($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

Wenn der linke Operand vom Typ uint oder ulong ist, führt der Operator zur Rechtsverschiebung eine logische Verschiebung durch: Die hohen leeren Bitpositionen werden immer auf 0 (null) festgelegt.

uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Console.WriteLine($"Before: {Convert.ToString(c, toBase: 2), 32}");
 
uint d = c >> 3;
Console.WriteLine($"After:  {Convert.ToString(d, toBase: 2).PadLeft(32, '0'), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:  00010000000000000000000000000000

Mit dem in C# 11 und höher verfügbaren Operator »> wird der linke Operand um die Anzahl von Bits nach rechts verschoben, die durch den rechten Operanden angegeben wird.

Der »>-Operator führt immer eine logische Verschiebung durch. Das heißt, die höherwertigen leeren Bitpositionen werden unabhängig vom Typ des linken Operanden immer auf 0 festgelegt.

Das folgende Beispiel veranschaulicht den Unterschied zwischen den Operatoren » und »> für einen negativen linken Operanden:

int x = -8;
Console.WriteLine($"Before:    {x,11}, hex: {x,8:x}, binary: {Convert.ToString(x, toBase: 2), 32}");
 
int y = x >> 2;
Console.WriteLine($"After  >>: {y,11}, hex: {y,8:x}, binary: {Convert.ToString(y, toBase: 2), 32}");
 
int z = x >>> 2;
Console.WriteLine($"After >>>: {z,11}, hex: {z,8:x}, binary: {Convert.ToString(z, toBase: 2).PadLeft(32, '0'), 32}");
// Output:
// Before:             -8, hex: fffffff8, binary: 11111111111111111111111111111000
// After  >>:          -2, hex: fffffffe, binary: 11111111111111111111111111111110
// After >>>:  1073741822, hex: 3ffffffe, binary: 00111111111111111111111111111110

Mit dem Operator & wird „bitweises logisches UND“ für die ganzzahligen Operanden berechnet:

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

Für bool-Operanden berechnet der &-Operator das logische UND für die Operanden.

Mit dem Operator ^ wird „bitweises logisches exklusives ODER“, auch als „bitweises logisches XOR“ bezeichnet, seiner ganzzahligen Operanden berechnet:

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

Für bool-Operanden berechnet der ^-Operator das logische exklusive ODER für die Operanden.

Mit dem Operator | wird „bitweises logisches ODER“ der ganzzahligen Operanden berechnet:

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

Für bool-Operanden berechnet der |-Operator das logische ODER für die Operanden.

Bei einem binären Operator op entspricht ein Verbundzuweisungsausdruck der Form

x op= y

für die folgende Syntax:

x = x op y

Im folgenden Beispiel wird die Verwendung von Verbundzuweisungen mit bitweisen und Schiebeoperatoren veranschaulicht:

uint INITIAL_VALUE = 0b_1111_1000;
 
uint a = INITIAL_VALUE;
a &= 0b_1001_1101; 
Display(a);  // output: 10011000
 
a = INITIAL_VALUE;
a |= 0b_0011_0001; 
Display(a);  // output: 11111001
 
a = INITIAL_VALUE;
a ^= 0b_1000_0000;
Display(a);  // output: 01111000
 
a = INITIAL_VALUE;
a <<= 2;
Display(a);  // output: 1111100000
 
a = INITIAL_VALUE;
a >>= 4;
Display(a);  // output: 00001111
 
a = INITIAL_VALUE;
a >>>= 4;
Display(a);  // output: 00001111
 
void Display(uint x) => Console.WriteLine($"{Convert.ToString(x, toBase: 2).PadLeft(8, '0'), 8}");