C# Bitwise Operators : A Tutorial

Bitwise operators in C# are used to perform operations on individual bits of integers. These operators work with binary representations of numbers and are useful in low-level programming, bit masking, and performance optimization.

This tutorial will cover:

• List of Bitwise Operators in C#
• Understanding Binary Representation
• Using Bitwise Operators with Examples
• Bitwise Shift Operators
• Practical Applications of Bitwise Operators
• Best Practices for Using Bitwise Operators

1. List of Bitwise Operators in C#

C# provides the following operators, which manipulate bits in an integer.

2. Understanding Binary Representation

To understand bitwise operations, it is important to understand binary representation.

Example: Binary Representation of Numbers

Binary representation consists of 0s and 1s. Bitwise operations are performed on these binary digits.

3. Using Bitwise Operators with Examples

Bitwise AND (&)

The & (AND) operator compares each bit of two numbers. It returns 1 only if both bits are 1.

Example:

int a = 5; // Binary: 00000101
int b = 3; // Binary: 00000011
int result = a & b; // Binary: 00000001 (Decimal: 1)

Console.WriteLine(result); // Output: 1

Bitwise OR (|)

The | (OR) operator compares each bit and returns 1 if either bit is 1.

Example:

int a = 5; // Binary: 00000101
int b = 3; // Binary: 00000011
int result = a | b; // Binary: 00000111 (Decimal: 7)

Console.WriteLine(result); // Output: 7

Bitwise XOR (^)

The ^ (XOR) operator returns 1 if the bits are different, otherwise 0.

Example:

int a = 5; // Binary: 00000101
int b = 3; // Binary: 00000011
int result = a ^ b; // Binary: 00000110 (Decimal: 6)

Console.WriteLine(result); // Output: 6

Bitwise NOT (~)

The ~ (NOT) operator inverts each bit, changing 0s to 1s and vice versa.

Example:

int a = 5;  // Binary: 00000101
int result = ~a; // Binary: 11111010 (Two’s complement: -6)

Console.WriteLine(result); // Output: -6

• In C#, bitwise NOT uses two’s complement representation, so ~5 results in -6.

4. Bitwise Shift Operators

Bitwise shift operators move bits left or right, filling empty positions with 0.

Left Shift (<<)

Shifts bits to the left by a specified number of positions, multiplying the number by powers of 2.

Example:

int a = 5;  // Binary: 00000101
int result = a << 2; // Shift left by 2 (Binary: 00010100)

Console.WriteLine(result); // Output: 20

• a << 2 shifts 5 (00000101) left by 2 places, making it 20 (00010100).

Right Shift (>>)

Shifts bits to the right, dividing the number by powers of 2.

Example:

int a = 20; // Binary: 00010100
int result = a >> 2; // Shift right by 2 (Binary: 00000101)

Console.WriteLine(result); // Output: 5

• a >> 2 shifts 20 (00010100) right by 2 places, making it 5 (00000101).

5. Practical Applications

Checking if a Number is Even or Odd

int num = 7;

if ((num & 1) == 0)
{
    Console.WriteLine("Even");
}
else
{
    Console.WriteLine("Odd");
}

• The least significant bit of even numbers is always 0, and for odd numbers, it is 1.

Using Bitwise OR (|) for Flags

Bitwise OR is often used to combine multiple flags.

const int Read = 1;   // 0001
const int Write = 2;  // 0010
const int Execute = 4; // 0100

int permissions = Read | Write; // 0011 (3)
Console.WriteLine(permissions); // Output: 3

Using Bitwise AND (&) for Permission Checks

if ((permissions & Read) != 0)
{
    Console.WriteLine("Read permission granted.");
}

• This checks if Read permission is set.

Using Bitwise XOR (^) for Swapping Numbers

int x = 10, y = 5;
x = x ^ y;
y = x ^ y;
x = x ^ y;

Console.WriteLine($"x: {x}, y: {y}"); // Output: x: 5, y: 10

• This swaps two numbers without using a temporary variable.

6. Best Practices

Performance Optimization

• Bitwise operations are faster than arithmetic operations.

int result = number << 1; // Faster than multiplying by 2

Use Constants for Readability

const int Admin = 1;
const int Editor = 2;
const int Viewer = 4;

• Using constants makes code readable when using bitwise operations.

Be Cautious with Signed Integers in Right Shifts

• Right shifting negative numbers depends on the implementation.

int a = -10;
int result = a >> 1; // May not always behave as expected

Use Parentheses for Clarity

int result = (a & b) | (c ^ d);

• This ensures proper evaluation order.

Conclusion

• Bitwise operators manipulate individual bits in integers.
• Bitwise AND (&), OR (|), XOR (^), NOT (~) are used for binary comparisons.
• Shift operators (<<, >>) move bits left or right, affecting values efficiently.
• Practical applications include permission handling, performance optimizations, and algorithm improvements.
• Understanding binary operations helps in writing efficient and optimized C# code.