Enforce Enums to have explicit int value

I would like to enforce that all enums in my codebase to have explicit values assigned. Many Enums are stored at-rest using their int value (in a DB or file or queue) so adding a new value in the middle reorders the following values and makes for a very sad time.

I'm not opposed to writing a roslyn analyser to get this done, I considered a unit test, but I don't think the reflection APIs will tell me if there is an implicit or explicit value assigned to the enum.

Another approach could be an approval/snapshot test using something like Verify where the values are reflected and explicitly listed in a test file and if you add a new enum or enum value the test fails until you approve it.

The snapshot test seems heavy-handed, so a roslyn analyser would give better feedback to the dev working at the time.

Bad:

public enum ImplictValuedEnum
{
    Zero,
    One,
    Two,
    Three
}

Good:

public enum ExplictValuedEnum
{
    Zero = 0,
    One = 1,
    Two = 2,
    Three = 3
}

Microsoft do provide a basic template/sample for roylsn code analysers/fixers. https://github.com/dotnet/samples/tree/main/csharp/roslyn-sdk/Tutorials

Here's a simplified roslyn analyser of what I came up with to address this.

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class ExplicitEnumValueAnalyzer : DiagnosticAnalyzer
{
    public const string DiagnosticId = "ExplicitEnumValue";

    public const string Title = "Enum Members must have an explicit value set";
    public const string MessageFormat = "{0}.{1} must have an explicit value";

    public const string Description =
        "Enum values can be serialized as integer values and stored at rest. If members are added or removed from the enum existing implicit values may change, corrupting the at-rest data.";

    public const string Category = "Usage";

    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
        DiagnosticId,
        Title,
        MessageFormat,
        Category,
        DiagnosticSeverity.Error,
        isEnabledByDefault: true,
        description: Description);

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);

    public override void Initialize(AnalysisContext context)
    {
        // See https://github.com/dotnet/roslyn/blob/main/docs/analyzers/Analyzer%20Actions%20Semantics.md for more information
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();
        context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.EnumMemberDeclaration);
    }

    private void AnalyzeNode(SyntaxNodeAnalysisContext context)
    {
        if (!(context.Node is EnumMemberDeclarationSyntax enumNode))
            return;

        //has equals sign, so has an explicit value
        if (!(enumNode.EqualsValue is null))
            return;

        var enumDeclaration = enumNode.Parent as EnumDeclarationSyntax;
        var enumName = enumDeclaration?.Identifier.Text ?? "UnknownEnum";
        var enumMember = enumNode.Identifier.Text;

        context.ReportDiagnostic(
            Diagnostic.Create(
                Rule,
                context.Node.GetLocation(),
                //the following arguments are used in the MessageFormat string above
                enumName,
                enumMember));
    }
}