• Nerdigy
  • \
  • Bitwise Operations with Enums

frontmatter.coverAlt

Bitwise Operations with Enums

Enums are a fundamental part of .NET, allowing developers to define a set of named constants for improved code readability and maintainability. However, in certain scenarios, a simple enumeration isn’t enough—we need a way to represent multiple values at once. For these use cases we can make use of bitwise operations and leverage the flags attribute.

The flags attribute, when applied to an enum, allows it to be treated as a bit field, enabling efficient storage and manipulation of multiple values using bitwise operations. This is particularly useful in cases where an entity can have multiple states or permissions simultaneously.

For example, consider a file system that defines access permissions such as Read, Write, and Execute. Instead of creating multiple boolean properties, we can use a bitwise enum to represent any combination of these permissions compactly.

Using flags, we can write code like this:

[Flags]
public enum FilePermissions
{
    Read = 1,
    Write = 2,
    Execute = 4
}

// Example Usage:
var permissions = FilePermissions.Read | FilePermissions.Write;
Console.WriteLine(permissions); // Output: Read, Write

As you can see, .NET automatically converts the bitwise combination into a human-readable format. This makes enums using flags an excellent choice for permission systems, feature toggles, and status indicators.

In this post, we’ll dive deep into how flags work and how to apply this powerful feature. Let’s get started 🚀

👨‍🎓 Understanding Enums in .NET

Before diving into the flags attribute, let’s first revisit how enums work in .NET.

An enum (short for enumeration) is a value type that allows you to define a set of named constants. It improves code readability by replacing magic numbers with meaningful names.

A simple example of an enum representing different user roles in a system could look like this:

public enum UserRole
{
    Guest = 1,
    User = 2,
    Moderator = 3,
    Admin = 4
}

Each enum member is assigned an integer value, either explicitly (as seen above) or implicitly (starting at 1 and incrementing by 1). This makes enums great for situations where only one value should be assigned at a time.

For instance, setting a user role would look like this:

UserRole role = UserRole.Moderator;
Console.WriteLine(role); // Output: Moderator

⚠️ Limitations of Regular Enums

While enums are useful for defining a fixed set of values, they fall short in scenarios where an entity needs to hold multiple values at the same time.

For example, consider a file access system where a user might have Read, Write, and Execute permissions. A standard enum would force us to choose only one permission at a time, making it difficult to represent combinations like Read & Write or Read, Write & Execute.

One possible workaround would be to define composite values manually:

public enum FilePermission
{
    Read = 1,
    Write = 2,
    ReadWrite = 3,  // Read (1) + Write (2) = 3
    Execute = 4
}

This approach works, but it doesn’t scale well as the number of combinations grows. Instead, we need a more flexible solution—bitwise flags—which allow us to combine multiple values efficiently. This is where the flags attribute shines.

🚩 Introduction to the Flags Attribute

The flags attribute in .NET is a special attribute that enhances the way enums are used, allowing them to represent a combination of values using bitwise operations. However, it is important to understand that flags itself does not change the behavior of an enum—it simply provides better formatting and improves code readability when working with bitwise operations.

🖐️ What Does the Flags Attribute Do?

When applied to an enum, the flags attribute enables the following benefits:

  • ✅ Human-Readable Output of Combined Flags (ex: ReadWrite)
  • ✅ Logical Representation of Multiple States (ex: Read | Write)
  • ✅ Simplifies Checking and Managing States

📓 Defining an Enum with Flags

To use flags, define an enum where each value is a power of two (1, 2, 4, 8, 16, …). This allows different values to be combined without conflicts. We’ll expand on why this is important in the next section.

Here’s an example of a file permission system using flags:

[Flags]
public enum FilePermissions
{
    Read = 1,      // 2^0
    Write = 2,     // 2^1
    Execute = 4,   // 2^2
    ReadWrite = Read | Write, // 3 (1 | 2)
    All = Read | Write | Execute // 7 (1 | 2 | 4)
}

Here’s how this setup benefits us:

FilePermissions permissions = FilePermissions.Read | FilePermissions.Write;
Console.WriteLine(permissions); // Output: ReadWrite

Without flags, the output would just be 3, which isn’t very helpful. But with the flags attribute, .NET understands that 3 represents Read, Write and prints it accordingly. Furthermore it uses the defined bitwise value on the output (instead of Read, Write we see ReadWrite).

🤔 Do Flags Change An Enums Behavior?

Annotating an enum with the flags attribute does not change how the enum behaves internally.

❌ It does NOT enable bitwise operations—enums always support bitwise logic.

✅ It DOES improve debugging, readability, and .ToString() output.

For example, even without flags, you can still perform bitwise operations:

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

However, without flags, the output of permissions.ToString() would just be “3” instead of “ReadWrite”. Flags enhance enums for a better developer experience as well as human-readable representations.

📝 Defining a Bitwise Enum with Flags

Now that we understand what the flags attribute does, let’s dive into some math and how to correctly define a bitwise enum. When defining a flags enum, it is crucial that each value corresponds to a power of two. This ensures that each flag has a unique bit position and can be combined without conflicts.

Let’s look at the following example:

[Flags]
public enum FilePermissions
{
    Read = 1,
    Write = 2,
    Execute = 4,
    ReadWrite = Read | Write,
    All = Read | Write | Execute
}

🔢 Understanding the Bitwise Representation

Each value in the above example corresponds to a unique bit in the binary system:

EnumValueBinary Representation
Read2^0 = 10001
Write2^1 = 20010
Execute2^2 = 40100
ReadWrite2^0 + 2^1 = 30011
All2^0 + 2^1 + 2^2 = 70111

✚ Using OR Operator To Combine Flags

By using the bitwise OR (|) operator, we can combine multiple values into a single variable.

FilePermissions permissions = FilePermissions.Read | FilePermissions.Write;
Console.WriteLine(permissions); // Output: ReadWrite

Here’s how it works at the binary level:

Read   = 0001 (1)
Write  = 0010 (2)
----------------
Result = 0011 (3) -> ReadWrite

🧩 Common Predefined Combinations

It’s a good practice to define common flag combinations within your enum to improve readability and reusability.

For example, we predefined:

ReadWrite = Read | Write; // 3 (0011)
All = Read | Write | Execute; // 7 (0111)

This allows us to easily assign multiple permissions in a meaningful way:

var fullAccess = FilePermissions.All;
Console.WriteLine(fullAccess); // Output: All

⚠️ What Happens If Values Are Not Powers of Two?

If an enum uses arbitrary values that are not powers of two, bitwise operations won’t work correctly.

❌ Incorrect Definition (BAD EXAMPLE)

[Flags]
public enum InvalidPermissions
{
    Read = 1,
    Write = 2,
    Custom = 3,  // ❌ Not a power of two
    ReadWrite = Read | Write
}

Since Custom is set to 3 (binary 0011) with overlaps with Read = 1 and Write = 2 we’ll get unexpected results.

InvalidPermissions permissions = InvalidPermissions.Custom;
Console.WriteLine(permissions); // Output: ReadWrite

🧮 Performing Bitwise Operations

Now that we have a properly defined flags enum, let’s explore how to work with it using bitwise operations. These operations allow us to efficiently set, check, and remove flags.

1️⃣ Setting Flags (Adding Permissions)

To add a flag to an existing set of flags, use the bitwise OR (|) operator.

FilePermissions permissions = FilePermissions.Read;
permissions |= FilePermissions.Write; // Add Write permission
Console.WriteLine(permissions); // Output: ReadWrite

How It Works (Binary Representation)

Read   = 0001 (1)
Write  = 0010 (2)
-----------------
Result = 0011 (3) -> ReadWrite

2️⃣ Checking Flags (Has a Permission?)

To check if a specific flag is set, use the bitwise AND (&) operator.

if ((permissions & FilePermissions.Write) == FilePermissions.Write)
{
    Console.WriteLine("User has Write permission.");
}

How It Works (Binary Representation)

permissions = 0011 (Read, Write)
Write       = 0010
-------------------
Result      = 0010 (Write) -> Match found ✅

Alternatively, you can use .HasFlag():

if (permissions.HasFlag(FilePermissions.Write))
{
    Console.WriteLine("User has Write permission.");
}

3️⃣ Removing Flags (Revoking Permissions)

To remove a flag, use the bitwise AND (&) operator combined with the bitwise NOT (~) operator.

permissions &= ~FilePermissions.Write; // Remove Write permission
Console.WriteLine(permissions); // Output: Read

How It Works (Binary Representation)

# Removes the Write permission
permissions = 0011 (Read, Write)
~Write      = 1101 (Inverted Write)
-------------------
Result      = 0001 (Read) -> Write removed ✅

4️⃣ Toggling Flags (Enable/Disable a Permission)

To toggle (enable if disabled, disable if enabled), use the bitwise XOR (^) operator.

permissions ^= FilePermissions.Write; // Toggle Write permission

How It Works (Binary Representation)

# Adds the Write permission
permissions = 0001 (Read)
Write       = 0010
-------------------
Result      = 0011 (Read, Write) -> Write was added ✅

# Removes the Write permission
permissions = 0011 (Read, Write)
Write       = 0010
-------------------
Result      = 0001 (Read) -> Write was removed ✅

🔗 Using Flags With LINQ Queries

Flags enums can alose be used in LINQ queries to filter collections based on multiple criteria. For example, let’s say we have a list of files and we want to filter them based on permissions. We can use LINQ to query files that have Write permission using the HasFlag method.

var files = new List<File>
{
    new("Document.txt", FilePermissions.Read),
    new("Script.sh", FilePermissions.ReadWrite),
    new("App.exe", FilePermissions.ReadWrite | FilePermissions.Execute)
};

var allowedFiles = files.Where(f => f.Permissions.HasFlag(FilePermissions.Write));

foreach (var file in allowedFiles)
{
    // Output: Script.sh, App.exe
    Console.WriteLine($"File: {file.FileName}");
}

public sealed record File(string FileName, FilePermissions Permissions);

[Flags]
public enum FilePermissions
{
    Read = 1,
    Write = 2,
    ReadWrite = 3,
    Execute = 4
}

Note: This also works in EntityFramework, but make sure you’re not storing flag enums as strings

📚 Further Reading & Resources

💡 Final Thoughts

Using enums with flags effectively can make your code cleaner, more efficient, and easier to maintain. Whether you’re managing permissions, feature toggles, or game states, bitwise enums provide a compact and powerful way to handle multiple values at once. Until next time, stay curious! 🚀