10 questions foundAn enum is a distinct value type representing a named set of constant integral values; by default, its members are backed by 'int', starting at 0 and auto-incrementing, unless you assign explicit values.public enum DayOfWeek {
Sunday, // 0
Monday, // 1
Tuesday // 2
}
DayOfWeek today = DayOfWeek.Monday;
Console.WriteLine((int)today); // 1Real-world example Representing a fixed set of order statuses, days of the week, or log severity levels with meaningful names.FundamentalsHow do you convert between an enum value and its underlying numeric value, and between an enum and its string name?
Beginner Cast directly with (int) to get the numeric value; use ToString() to get the member's name as a string, and Enum.Parse<T>() (or the safer Enum.TryParse<T>()) to convert a string back into the corresponding enum value.DayOfWeek day = DayOfWeek.Monday;
int numericValue = (int)day; // 1
string name = day.ToString(); // "Monday"
DayOfWeek parsed = Enum.Parse<DayOfWeek>("Tuesday"); // DayOfWeek.TuesdayReal-world example Converting a user-selected string from a dropdown into the corresponding enum value for use in business logic.String Handling & StringBuilderHow do you create a 'flags' enum that supports combining multiple values using bitwise operations?
Intermediate Mark the enum with [Flags] and assign each member a distinct POWER-OF-TWO value, letting you safely combine multiple flags into a single value with the bitwise OR operator and check for a specific flag's presence with bitwise AND.[Flags]
public enum Permissions {
None = 0,
Read = 1,
Write = 2,
Delete = 4,
All = Read | Write | Delete
}
Permissions userPerms = Permissions.Read | Permissions.Write;
bool canWrite = (userPerms & Permissions.Write) == Permissions.Write; // trueReal-world example Modeling a user's combined set of permissions (read/write/delete) compactly as a single stored enum value.Attributes & ReflectionHow does the [Flags] attribute change the output of ToString() on a combined flags enum value?
Intermediate Without [Flags], calling ToString() on a value that doesn't exactly match any single named member just returns the raw numeric value as a string; WITH [Flags], the runtime recognizes the value as a combination and formats it as a comma-separated list of the individual flag names that make it up.[Flags]
public enum Permissions { None = 0, Read = 1, Write = 2, Delete = 4 }
var combined = Permissions.Read | Permissions.Write;
Console.WriteLine(combined.ToString()); // "Read, Write" -- thanks to [Flags]
// Without [Flags], the same combined value would just print "3"Real-world example Displaying a human-readable summary of a user's combined permissions in a log message or admin dashboard.String Handling & StringBuilderWhat is the performance consideration when using Enum.HasFlag() versus a direct bitwise AND check?
Intermediate Enum.HasFlag() involves BOXING the enum value (converting it to an object) internally in older .NET versions, making it measurably slower than a direct bitwise AND comparison in performance-sensitive, high-frequency code — modern .NET has optimized this significantly, but the direct bitwise check remains marginally faster and avoids any boxing concern entirely.[Flags]
public enum Permissions { None = 0, Read = 1, Write = 2 }
var perms = Permissions.Read;
// Slightly slower historically (boxing), but more readable
bool hasRead1 = perms.HasFlag(Permissions.Read);
// Faster, no boxing, less readable
bool hasRead2 = (perms & Permissions.Read) == Permissions.Read;Real-world example Choosing the direct bitwise check over HasFlag() specifically in a tight, performance-critical loop checking permissions millions of times.Memory & Garbage CollectionHow would you write an extension method to safely add or remove a specific flag from a [Flags] enum value without manual bitwise operators scattered throughout your code?
Advanced Define generic (or type-specific) extension methods that encapsulate the bitwise OR (for adding) and AND-with-complement (for removing) operations, giving calling code a clean, readable API instead of repeating raw bitwise expressions everywhere.public static class PermissionsExtensions {
public static Permissions AddFlag(this Permissions value, Permissions flag) => value | flag;
public static Permissions RemoveFlag(this Permissions value, Permissions flag) => value & ~flag;
}
var perms = Permissions.Read;
perms = perms.AddFlag(Permissions.Write); // Read, Write
perms = perms.RemoveFlag(Permissions.Read); // WriteReal-world example Providing a clean, discoverable API for manipulating a permissions or feature-flags enum throughout a large codebase.Extension MethodsHow do you safely validate that an enum value received from external input (like deserialized JSON or a database) is actually a DEFINED member, given that enums don't enforce this by default?
Advanced Since C# enums are just named integers, a value like (Permissions)999 compiles and runs fine even though it doesn't correspond to any defined member (or valid flag combination) — use Enum.IsDefined() for simple enums, or a manual bitwise check against a computed 'all valid flags' mask for [Flags] enums, to validate untrusted input before trusting it.public enum Status { Active = 0, Inactive = 1 }
int rawValue = 99; // e.g., from untrusted deserialized JSON
var status = (Status)rawValue; // compiles and runs, but is INVALID
bool isValid = Enum.IsDefined(typeof(Status), status); // false -- correctly caughtReal-world example Validating a status or category field parsed from external API input before it's trusted and used in business logic.Exception HandlingHow would you use pattern matching (switch expressions) with an enum, including exhaustiveness warnings from the compiler?
Advanced A switch expression over an enum lets you handle each member concisely and return a value directly; the compiler emits a WARNING (not an error, unlike some other languages) if you don't handle every enum member and lack a discard pattern, helping catch forgotten cases when new members are added later.public enum OrderStatus { Pending, Shipped, Delivered, Cancelled }
string Describe(OrderStatus status) => status switch {
OrderStatus.Pending => "Waiting to ship",
OrderStatus.Shipped => "On its way",
OrderStatus.Delivered => "Arrived",
OrderStatus.Cancelled => "Order cancelled",
_ => throw new ArgumentOutOfRangeException(nameof(status)) // catches truly invalid/undefined values
};Real-world example Mapping an OrderStatus enum to a user-facing display string, with the compiler helping catch forgotten cases as the enum evolves.Records & Pattern MatchingHow do enums interact with generic constraints, and why has it historically been awkward to write generic, reusable flag-manipulation code?
Advanced Prior to more recent C# versions, you couldn't constrain a generic type parameter to 'must be an enum' cleanly enough to perform bitwise operations generically (the 'where T : struct, Enum' constraint exists, but bitwise operators aren't directly usable on a generic Enum-constrained parameter without casting through the underlying integral type) — this has led to workarounds using Convert.ToInt64() or reflection for fully generic flag utilities.public static bool HasFlagGeneric<T>(T value, T flag) where T : struct, Enum {
long valueAsLong = Convert.ToInt64(value);
long flagAsLong = Convert.ToInt64(flag);
return (valueAsLong & flagAsLong) == flagAsLong; // workaround: convert through long
}Real-world example Writing a single, reusable flag-checking utility that works generically across MULTIPLE different [Flags] enum types in a codebase.GenericsHow would you design an enum-based state machine using pattern matching to enforce valid state transitions at compile time or runtime?
Advanced Represent states as an enum, and define an explicit transition-validation method (often using a switch expression matching CURRENT state and DESIRED next state as a tuple) that only allows specific, intentional transitions — throwing or returning false for any transition not explicitly permitted, preventing invalid state changes from silently succeeding.public enum OrderState { Created, Paid, Shipped, Cancelled }
public bool CanTransition(OrderState from, OrderState to) => (from, to) switch {
(OrderState.Created, OrderState.Paid) => true,
(OrderState.Created, OrderState.Cancelled) => true,
(OrderState.Paid, OrderState.Shipped) => true,
(OrderState.Paid, OrderState.Cancelled) => true,
_ => false // every other transition is explicitly disallowed
};Real-world example Enforcing a valid order lifecycle (Created -> Paid -> Shipped) and rejecting invalid transitions like Shipped -> Created.Records & Pattern Matching