C# - Bitwise Operators

---

---

C# bitwise operators allow operations at the binary level. These operators are primarily used for performance optimization, low-level programming, encryption, networking, and system programming.

What Are Bitwise Operators in C#?

C# bitwise operators manipulate individual bits of numbers. These operators are commonly used for efficient computations, flag operations, and hardware interactions.

List of C# Bitwise Operators

The Bitwise operators supported by C# are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Understanding Bitwise Operations with Examples

Example 1: Bitwise AND (&)

Bitwise AND sets each bit to 1 only if both operands have 1 in that position.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 3;  // Binary: a = 0101, b = 0011
        int result = a & b; // 0101 & 0011 = 0001 (1)

        Console.WriteLine("Bitwise AND: " + result);
    }
}

When the above code is compiled and executed, it produces the following result −

Bitwise AND: 1

Example 2: Bitwise OR (|)

Bitwise OR sets each bit to 1 if either operand has 1.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 3;  // Binary: a = 0101, b = 0011
        int result = a | b; // 0101 | 0011 = 0111 (7)

        Console.WriteLine("Bitwise OR: " + result);
    }
}

When the above code is compiled and executed, it produces the following result −

Bitwise OR: 7

Example 3: Bitwise XOR (^)

Bitwise XOR sets each bit to 1 if the corresponding bits are different.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 3;  // Binary: a = 0101, b = 0011
        int result = a ^ b; // 0101 ^ 0011 = 0110 (6)

        Console.WriteLine("Bitwise XOR: " + result);
    }
}

When the above code is compiled and executed, it produces the following result −

Bitwise XOR: 6

Example 4: Bitwise NOT (~)

Bitwise NOT inverts each bit (turns 1 into 0 and vice versa).

using System;

class Program
{
    static void Main()
    {
        int a = 5;         // Binary: 00000101
        int result = ~a;   // NOT 00000101 = 11111010 (Twos Complement)

        Console.WriteLine("Bitwise NOT: " + result);
    }
}

When the above code is compiled and executed, it produces the following result −

Bitwise NOT: -6

Example 5: Left Shift (<<)

Left shift (<<) moves bits left, multiplying the number by 2^n.

using System;

class Program
{
    static void Main()
    {
        int a = 5;        // Binary: 00000101
        int result = a 
When the above code is compiled and executed, it produces the following result −
Left Shift: 20

Example 6: Right Shift (>>)
Right shift (>>) moves bits right, dividing the number by 2^n.

using System;

class Program
{
    static void Main()
    {
        int a = 20;       // Binary: 00010100
        int result = a >> 2; // Right Shift by 2: 00000101 (5)

        Console.WriteLine("Right Shift: " + result);
    }
}
When the above code is compiled and executed, it produces the following result −
Right Shift: 5
Real-World Applications of Bitwise Operators
Example 7: Checking If a Number Is Even or Odd
You can use bitwise AND to determine if a number is even or odd.
using System;

class Program
{
    static void Main()
    {
        int number = 10;

        if ((number & 1) == 0)
            Console.WriteLine("Even");
        else
            Console.WriteLine("Odd");
    }
}
When the above code is compiled and executed, it produces the following result −
Even

Example 8: Swapping Two Numbers Without Using a Temporary Variable
You can use bitwise XOR bitwise operator to swap two numbers without extra memory.
using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 10;

        a = a ^ b;
        b = a ^ b;
        a = a ^ b;

        Console.WriteLine("After Swap: a = " + a + ", b = " + b);
    }
}
When the above code is compiled and executed, it produces the following result −
After Swap: a = 10, b = 5

Common Mistakes & How to Avoid Them

    

        
Mistake
        
Issue
        
Solution
    
    

        
a << -1
        
Negative shift count
        
Use a << 0 or a >> 0
    
    

        
a = a & 0;
        
Always sets a to 0
        
Ensure a & mask where mask is properly set
    
    

        
b = ~b;
        
Unexpected negative value
        
Understand twos complement representation
    


Best Practices for Using Bitwise Operators in C#

• Use bitwise AND (&) for flag operations and bit masking.
• Use XOR (^) for swapping values efficiently.
• Use shift operators (<< and >>) for fast multiplication and division by powers of 2.
• Understand how negative numbers are represented in twos complement format.