How to add extension methods to Enums

Enums

Extension Methods

Programming Tips

Software Development

How to add extension methods to Enums

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions

C# & .NET

Introduction

In C#, enums are simple value types that define a set of named constants. On their own, they cannot contain methods. However, extension methods let you attach behavior to enum types without modifying their definitions. This is valuable because enums are often defined in libraries or shared code that you cannot or should not change, yet you frequently need to derive display text, perform validation, or apply business logic based on enum values.

Enum Basics

An enum in C# defines a set of named integer constants. By default, the underlying values start at 0 and increment:

csharp

1public enum DayOfWeek
2{
3    Sunday,    // 0
4    Monday,    // 1
5    Tuesday,   // 2
6    Wednesday, // 3
7    Thursday,  // 4
8    Friday,    // 5
9    Saturday   // 6
10}

You can use enums in switch statements and comparisons, but you cannot add methods directly to an enum definition. This is where extension methods come in.

Extension Method Syntax for Enums

An extension method is a static method in a static class, where the first parameter uses the this keyword followed by the type being extended. For enums, the type is your enum type:

csharp

1public static class DayOfWeekExtensions
2{
3    public static bool IsWeekend(this DayOfWeek day)
4    {
5        return day == DayOfWeek.Saturday || day == DayOfWeek.Sunday;
6    }
7
8    public static bool IsWeekday(this DayOfWeek day)
9    {
10        return !day.IsWeekend();
11    }
12}

Now you can call these methods directly on any DayOfWeek value:

csharp

1DayOfWeek today = DayOfWeek.Saturday;
2
3Console.WriteLine(today.IsWeekend());  // True
4Console.WriteLine(today.IsWeekday());  // False

The compiler rewrites today.IsWeekend() to DayOfWeekExtensions.IsWeekend(today) behind the scenes. The method appears as an instance method on the enum, but it is actually a static method call.

Practical Example: ToDescription with Attributes

A common pattern is pairing enums with [Description] attributes and using an extension method to retrieve the description text:

csharp

1using System.ComponentModel;
2using System.Reflection;
3
4public enum OrderStatus
5{
6    [Description("Waiting for payment")]
7    Pending,
8
9    [Description("Payment received, preparing shipment")]
10    Processing,
11
12    [Description("Package is on the way")]
13    Shipped,
14
15    [Description("Successfully delivered")]
16    Delivered,
17
18    [Description("Order was cancelled")]
19    Cancelled
20}
21
22public static class EnumExtensions
23{
24    public static string ToDescription(this Enum value)
25    {
26        FieldInfo field = value.GetType().GetField(value.ToString());
27
28        DescriptionAttribute attribute = field?
29            .GetCustomAttribute<DescriptionAttribute>();
30
31        return attribute?.Description ?? value.ToString();
32    }
33}

Usage:

csharp

1OrderStatus status = OrderStatus.Shipped;
2Console.WriteLine(status.ToDescription());
3// Output: "Package is on the way"
4
5// Falls back to enum name when no attribute is present
6Console.WriteLine(DayOfWeek.Monday.ToDescription());
7// Output: "Monday"

Notice that the extension method accepts Enum (the base type) rather than a specific enum. This makes it reusable across all enum types in your project.

Flag Enums and HasFlag

For enums decorated with [Flags], you can write extension methods that check for combined flags:

csharp

1[Flags]
2public enum Permissions
3{
4    None    = 0,
5    Read    = 1,
6    Write   = 2,
7    Execute = 4,
8    All     = Read | Write | Execute
9}
10
11public static class PermissionsExtensions
12{
13    public static bool CanRead(this Permissions p)
14    {
15        return p.HasFlag(Permissions.Read);
16    }
17
18    public static bool CanWrite(this Permissions p)
19    {
20        return p.HasFlag(Permissions.Write);
21    }
22
23    public static bool CanExecute(this Permissions p)
24    {
25        return p.HasFlag(Permissions.Execute);
26    }
27
28    public static Permissions Grant(this Permissions p, Permissions flag)
29    {
30        return p | flag;
31    }
32
33    public static Permissions Revoke(this Permissions p, Permissions flag)
34    {
35        return p & ~flag;
36    }
37}

Usage:

csharp

1Permissions userPerms = Permissions.Read | Permissions.Write;
2
3Console.WriteLine(userPerms.CanRead());     // True
4Console.WriteLine(userPerms.CanExecute());  // False
5
6userPerms = userPerms.Grant(Permissions.Execute);
7Console.WriteLine(userPerms.CanExecute());  // True
8
9userPerms = userPerms.Revoke(Permissions.Write);
10Console.WriteLine(userPerms.CanWrite());    // False

The built-in Enum.HasFlag() method handles the bitwise comparison internally. The extension methods here provide a more readable API on top of it.

Conversion and Validation Extensions

Extension methods are also useful for safe conversions and validation:

csharp

1public static class EnumExtensions
2{
3    public static T Next<T>(this T value) where T : Enum
4    {
5        T[] values = (T[])Enum.GetValues(typeof(T));
6        int index = Array.IndexOf(values, value);
7        return values[(index + 1) % values.Length];
8    }
9
10    public static bool IsDefined<T>(this T value) where T : Enum
11    {
12        return Enum.IsDefined(typeof(T), value);
13    }
14}

csharp

1DayOfWeek day = DayOfWeek.Friday;
2Console.WriteLine(day.Next());  // Saturday
3
4DayOfWeek invalid = (DayOfWeek)99;
5Console.WriteLine(invalid.IsDefined());  // False

Common Pitfalls

Forgetting to make both the class and the method static, which is required for extension methods
Defining the extension class in a namespace that the consuming code does not import via using
Using reflection-based approaches like ToDescription in tight loops without caching, which can hurt performance
Extending Enum (the base type) when you only intend the method for a specific enum, which makes it appear on all enums
Not handling undefined enum values (e.g., (DayOfWeek)99) which are valid in C# since enums are backed by integers
Forgetting that extension methods cannot access private state since they are syntactic sugar for static method calls

Summary

Extension methods let you add behavior to enums without modifying their definitions
Define them as static methods in a static class, using this EnumType value as the first parameter
Use [Description] attributes with a generic ToDescription() extension for display-friendly text
For [Flags] enums, write extension methods that wrap HasFlag for a cleaner API
Extend Enum (the base type) for utility methods that should work across all enum types
Extension methods are resolved at compile time, so the containing namespace must be imported with using

OOD Fundamentals

Master object-oriented design from first principles, SOLID, design patterns, and classic interview problems with hands-on coding.

View the course

Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions

How to add extension methods to Enums

Interview Questions practice on Codemia

Introduction

Enum Basics

Extension Method Syntax for Enums

Practical Example: ToDescription with Attributes

Flag Enums and HasFlag

Conversion and Validation Extensions

Common Pitfalls

Summary

Related reading

OOD Fundamentals

Track what you have practised

Interview Questions practice on Codemia