C# Enum Cheat Sheet
- • Complete examples: basic enums, Flags attribute, TryParse, extension methods
- • JSON serialization: JsonStringEnumConverter configuration
- • Naming conventions: PascalCase enum names and values
Team Code Review Checklist
✓ Design Standards
- • Enums use PascalCase naming (e.g., OrderStatus)
- • Use [Flags] attribute when bitwise combination is needed
- • Add [Description] or [Display] attributes to enum values
- • Avoid explicitly setting value to 0 unless there's special semantics
✓ Serialization
- • ASP.NET Core uses JsonStringEnumConverter
- • EF Core uses HasConversion to configure enum storage
- • Swagger/OpenAPI configures UseInlineDefinitionsForEnums
- • Use Enum.TryParse instead of direct conversion to avoid exceptions
✓ Best Practices
- • Use Enum.GetValues to iterate all enum values
- • Create extension methods to unify enum conversion handling
- • Unit tests cover business logic for all enum values
- • Document enum change history to avoid breaking API contracts
Naming and Design Anti-patterns
❌ Anti-pattern: Directly converting integer to enum
int value = GetUserInput();
OrderStatus status = (OrderStatus)value; // Unsafe!
Issue: If value is outside enum definition range, produces invalid enum
✅ Correct: Use Enum.IsDefined or TryParse
if (Enum.IsDefined(typeof(OrderStatus), value))
{
var status = (OrderStatus)value;
}
// Or use TryParse
if (Enum.TryParse(input, out var status))
{
// Safe to use
}
❌ Anti-pattern: Flags enum missing [Flags] attribute
public enum Permission // Missing [Flags]
{
None = 0,
Read = 1,
Write = 2,
Execute = 4
}
✅ Correct: Properly declare Flags enum
[Flags]
public enum Permission
{
None = 0,
Read = 1,
Write = 2,
Execute = 4,
All = Read | Write | Execute
}
ASP.NET Core Complete Configuration
Properly using enums in Web APIs:
// 1. Enum definition
using System.ComponentModel;
using System.Text.Json.Serialization;
[JsonConverter(typeof(JsonStringEnumConverter))]
public enum OrderStatus
{
[Description("Pending")]
Pending,
[Description("Processing")]
Processing,
[Description("Completed")]
Completed
}
// 2. Program.cs configuration
builder.Services.AddControllers()
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Converters.Add(
new JsonStringEnumConverter());
});
// 3. Swagger configuration
builder.Services.AddSwaggerGen(c =>
{
c.UseInlineDefinitionsForEnums();
c.SchemaFilter();
});
// 4. Custom Schema Filter
public class EnumSchemaFilter : ISchemaFilter
{
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (context.Type.IsEnum)
{
schema.Enum.Clear();
foreach (var name in Enum.GetNames(context.Type))
{
schema.Enum.Add(new OpenApiString(name));
}
}
}
}
Tip: JsonStringEnumConverter makes API return strings instead of numbers
xUnit Test Template
Ensure enums are correctly used across layers:
using Xunit;
using FluentAssertions;
public class OrderStatusTests
{
[Theory]
[InlineData("Pending", OrderStatus.Pending)]
[InlineData("Processing", OrderStatus.Processing)]
[InlineData("Completed", OrderStatus.Completed)]
public void TryParse_ShouldParseCorrectly(
string input, OrderStatus expected)
{
Enum.TryParse(input, out var result)
.Should().BeTrue();
result.Should().Be(expected);
}
[Fact]
public void AllEnumValues_ShouldHaveDescription()
{
foreach (OrderStatus status in Enum.GetValues())
{
var description = status.GetDescription();
description.Should().NotBeNullOrEmpty();
}
}
[Theory]
[MemberData(nameof(AllStatusValues))]
public void BusinessLogic_ShouldHandleAllStatuses(
OrderStatus status)
{
var result = OrderService.ProcessStatus(status);
result.Should().NotBeNull();
}
public static IEnumerable AllStatusValues()
{
return Enum.GetValues()
.Select(s => new object[] { s });
}
}
Tip: Use MemberData to automatically test all enum values
Practical Extension Methods Library
using System.ComponentModel;
using System.Reflection;
public static class EnumExtensions
{
public static string GetDescription(this Enum value)
{
var field = value.GetType().GetField(value.ToString());
var attribute = field?.GetCustomAttribute();
return attribute?.Description ?? value.ToString();
}
public static T? ParseOrDefault(this string value, T? defaultValue = default)
where T : struct, Enum
{
return Enum.TryParse(value, ignoreCase: true, out var result)
? result
: defaultValue;
}
public static IEnumerable GetFlags(this T value)
where T : struct, Enum
{
return Enum.GetValues()
.Where(v => value.HasFlag(v) && !v.Equals(default(T)));
}
public static List<(T Value, string Name, string Description)> ToList()
where T : struct, Enum
{
return Enum.GetValues()
.Select(v => (
Value: v,
Name: v.ToString(),
Description: v.GetDescription()
))
.ToList();
}
}
Tip: These extension methods can unify enum handling logic across the project