Flags attribute and bitwise enums in C Sharp (C#)

Introduction

The Flags attribute helps combine multiple options in one variable using bits. It makes checking and setting options easy and clear.

When you want to store multiple yes/no options in one variable.

When you need to check if certain options are set quickly.

When you want to combine settings like file permissions or user roles.

When you want to save memory by using one variable instead of many booleans.

Syntax

C Sharp (C#)

using System;

[Flags]
public enum Options
{
    None = 0,
    OptionA = 1 << 0,  // 1
    OptionB = 1 << 1,  // 2
    OptionC = 1 << 2,  // 4
    OptionD = 1 << 3   // 8
}

The [Flags] attribute tells C# to treat the enum as a set of bits.

Each option should be a power of two (1, 2, 4, 8, etc.) so they can combine without overlap.

Examples

Basic flags enum for file permissions.

C Sharp (C#)

[Flags]
public enum Permissions
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4
}

Example of no flags set (empty).

C Sharp (C#)

Permissions userPermissions = Permissions.None;
// Empty flags, no permissions set

Combining flags to set multiple options.

C Sharp (C#)

Permissions userPermissions = Permissions.Read | Permissions.Write;
// Combining two flags using bitwise OR

Check if a specific flag is set using bitwise AND.

C Sharp (C#)

bool canRead = (userPermissions & Permissions.Read) == Permissions.Read;
// Checking if a flag is set

Sample Program

This program shows how to add, check, and remove flags using bitwise operations with a Flags enum.

C Sharp (C#)

using System;

[Flags]
public enum AccessRights
{
    None = 0,
    Read = 1 << 0,   // 1
    Write = 1 << 1,  // 2
    Execute = 1 << 2 // 4
}

public class Program
{
    public static void Main()
    {
        AccessRights userRights = AccessRights.None;
        Console.WriteLine($"Initial rights: {userRights}");

        // Add Read and Write rights
        userRights |= AccessRights.Read | AccessRights.Write;
        Console.WriteLine($"After adding Read and Write: {userRights}");

        // Check if Execute right is set
        bool hasExecute = (userRights & AccessRights.Execute) == AccessRights.Execute;
        Console.WriteLine($"Has Execute right? {hasExecute}");

        // Remove Write right
        userRights &= ~AccessRights.Write;
        Console.WriteLine($"After removing Write: {userRights}");

        // Check if Write right is set
        bool hasWrite = (userRights & AccessRights.Write) == AccessRights.Write;
        Console.WriteLine($"Has Write right? {hasWrite}");
    }
}

Important Notes

Time complexity for checking, adding, or removing flags is O(1) because bitwise operations are very fast.

Space complexity is minimal since all flags are stored in one integer variable.

Common mistake: Not using powers of two for enum values causes flags to overlap and behave incorrectly.

Use Flags enums when you want to combine options efficiently; use regular enums when options are exclusive.

Summary

The [Flags] attribute allows combining multiple enum values using bits.

Use bitwise OR (|) to add flags, AND (&) to check flags, and AND with NOT (& ~) to remove flags.

Always assign enum values as powers of two to avoid overlap.

Practice

1. What is the main purpose of the [Flags] attribute in C# enums?

easy

A. To allow combining multiple enum values using bitwise operations

B. To make enum values readonly

C. To automatically assign sequential integer values

D. To restrict enum values to a single choice only

Solution

1. Step 1: Understand the role of [Flags]

   The [Flags] attribute marks an enum to be treated as a set of bit fields, allowing multiple values to be combined.

2. Step 2: Compare with other options

   Options B, C, and D describe unrelated enum behaviors. Only To allow combining multiple enum values using bitwise operations correctly describes the bitwise combination feature.

3. Final Answer:

   To allow combining multiple enum values using bitwise operations -> Option A

4. Quick Check:

   [Flags] enables bitwise combination [OK]

Hint: Remember: [Flags] means combine enum values with bits [OK]

Common Mistakes:

• Thinking [Flags] restricts enum to one value
• Confusing [Flags] with readonly or sequential enums
• Assuming [Flags] changes enum underlying type

2. Which of the following is the correct way to define a bitwise enum with the [Flags] attribute?

easy

A. [Flags]
public enum Colors { Red = 0, Green = 1, Blue = 2 }

B. [Flags]
public enum Colors { Red = 1, Green = 2, Blue = 4 }

C. public enum Colors { Red = 1, Green = 2, Blue = 3 }

D. [Flags]
public enum Colors { Red = 1, Green = 1, Blue = 2 }

Solution

1. Step 1: Check enum values for bitwise uniqueness

   Bitwise enums require values as powers of two (1, 2, 4, 8...) to avoid overlap.

2. Step 2: Validate each option

   [Flags] public enum Colors { Red = 1, Green = 2, Blue = 4 } uses 1, 2, 4 which are correct powers of two. [Flags] public enum Colors { Red = 0, Green = 1, Blue = 2 } starts with 0 which is valid for None but not typical for flags representing colors. public enum Colors { Red = 1, Green = 2, Blue = 3 } uses 3 which overlaps bits. [Flags] public enum Colors { Red = 1, Green = 1, Blue = 2 } repeats 1 twice, causing overlap.

3. Final Answer:

   [Flags] public enum Colors { Red = 1, Green = 2, Blue = 4 } -> Option B

4. Quick Check:

   Enum values must be powers of two [OK]

Hint: Use powers of two for flags enum values [OK]

Common Mistakes:

• Assigning zero to a flag value
• Using overlapping values like 3 or repeated numbers
• Forgetting the [Flags] attribute

3. Given the enum and code below, what is the output?

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

Permissions userPerms = Permissions.Read | Permissions.Execute;
bool canWrite = (userPerms & Permissions.Write) == Permissions.Write;
Console.WriteLine(canWrite);

medium

A. True

B. Compile-time error

C. Runtime exception

D. False

Solution

1. Step 1: Understand the combined flags

   The variable userPerms combines Read (1) and Execute (4) using bitwise OR, resulting in 5.

2. Step 2: Check if Write flag is set

   The expression (userPerms & Permissions.Write) checks if Write (2) is set in 5. Since 5 & 2 = 0, it is not set, so canWrite is false.

3. Final Answer:

   False -> Option D

4. Quick Check:

   5 & 2 == 0 means Write not set [OK]

Hint: Check flags with AND (&) and compare to flag value [OK]

Common Mistakes:

• Assuming OR sets all flags including Write
• Confusing bitwise AND with OR
• Expecting True because Write is in enum

4. Identify the error in the following code snippet using a [Flags] enum:

[Flags]
public enum Options { None = 0, First = 1, Second = 2, Third = 2 }

Options selected = Options.First | Options.Third;
Console.WriteLine(selected);

medium

A. Duplicate enum values cause overlapping flags

B. Missing [Flags] attribute

C. Bitwise OR operator is incorrect

D. Enum values must start from 1, not 0

Solution

1. Step 1: Check enum value assignments

   Both Second and Third are assigned the value 2, causing overlap in flags.

2. Step 2: Understand impact of duplicate values

   Duplicate values mean Options.Third is not unique, so bitwise operations may behave unexpectedly.

3. Final Answer:

   Duplicate enum values cause overlapping flags -> Option A

4. Quick Check:

   Enum values must be unique powers of two [OK]

Hint: Check for unique powers of two in enum values [OK]

Common Mistakes:

• Ignoring duplicate values in flags enums
• Thinking 0 is invalid for None
• Assuming bitwise OR is wrong syntax

5. You have the following [Flags] enum:

[Flags]
public enum Features { None = 0, FeatureA = 1, FeatureB = 2, FeatureC = 4, FeatureD = 8 }

How would you write code to remove FeatureB from a variable currentFeatures that may contain multiple features combined?

hard

A. currentFeatures ^= Features.FeatureB;

B. currentFeatures |= Features.FeatureB;

C. currentFeatures &= ~Features.FeatureB;

D. currentFeatures = Features.FeatureB;

Solution

1. Step 1: Understand how to remove a flag

   To remove a flag, use bitwise AND with the complement (NOT) of the flag.

2. Step 2: Apply the operation to remove FeatureB

   The expression currentFeatures &= ~Features.FeatureB; clears the FeatureB bit while keeping others intact.

3. Final Answer:

   currentFeatures &= ~Features.FeatureB; -> Option C

4. Quick Check:

   Remove flag with AND and NOT [OK]

Hint: Remove flags with AND and NOT (~) operator [OK]

Common Mistakes:

• Using OR (|) to remove flags instead of AND (&)
• Assigning flag directly, overwriting all others
• Using XOR (^) which toggles flags instead of removing