如何在C#中生成POCO类结构的哈希值以自动标记序列化状态快照失效

Great question! Since you're working with methodless POCO classes and need a hash that changes when properties are added, removed, or renamed (to auto-invalidate old snapshots), there are two solid approaches you can take—one using reflection (simple, runtime-based) and another using source generators (efficient, compile-time). Let's break them down:

Reflection lets you inspect the POCO's structure at runtime, generate a consistent string representation of its properties, and hash that string. This works great for most cases and requires no extra build setup.

Here's a reusable implementation:

using System;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;

public static class ClassStructureHasher
{
    public static string GenerateStructureHash(Type pocoType)
    {
        if (!IsValidPoco(pocoType))
        {
            throw new ArgumentException("Target type must be a non-abstract POCO class with no custom methods.", nameof(pocoType));
        }

        // Get public instance properties, sorted by name to avoid hash changes from property order
        var propertySignatures = pocoType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .OrderBy(prop => prop.Name)
            .Select(prop => $"{prop.Name}:{prop.PropertyType.FullName}");

        // Combine into a single string that uniquely represents the class structure
        var structureString = string.Join("|", propertySignatures);

        // Generate a SHA256 hash (more collision-resistant than GetHashCode())
        using var sha256 = SHA256.Create();
        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(structureString));

        // Convert hash to a lowercase hex string for easy storage
        return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
    }

    private static bool IsValidPoco(Type type)
    {
        if (!type.IsClass || type.IsAbstract) return false;
        
        // Ensure no custom methods exist (excluding inherited Object methods like ToString())
        var customMethods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
            .Where(method => method.DeclaringType != typeof(object));
        
        return !customMethods.Any();
    }
}

How to use it: #

// Example POCO
public class UserSnapshot
{
    public string UserId { get; set; }
    public string FullName { get; set; }
    public int Age { get; set; }
}

// Generate the structure hash
var hash = ClassStructureHasher.GenerateStructureHash(typeof(UserSnapshot));
Console.WriteLine(hash); // Outputs a unique string that changes if properties are modified

If you want to avoid runtime reflection overhead, a Roslyn source generator can compute the hash during compilation and inject it as a constant into your POCO class. This is ideal for performance-sensitive applications.

Here's a simplified generator implementation (requires .NET 5+):

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

[Generator]
public class PocoStructureHashGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context)
    {
        context.RegisterForSyntaxNotifications(() => new PocoSyntaxReceiver());
    }

    public void Execute(GeneratorExecutionContext context)
    {
        if (context.SyntaxReceiver is not PocoSyntaxReceiver receiver) return;

        foreach (var classDecl in receiver.PocoClasses)
        {
            var semanticModel = context.Compilation.GetSemanticModel(classDecl.SyntaxTree);
            if (semanticModel.GetDeclaredSymbol(classDecl) is not INamedTypeSymbol classSymbol) continue;

            // Get sorted public properties
            var propertySignatures = classSymbol.GetMembers()
                .OfType<IPropertySymbol>()
                .Where(prop => prop.DeclaredAccessibility == Accessibility.Public)
                .OrderBy(prop => prop.Name)
                .Select(prop => $"{prop.Name}:{prop.Type.ToDisplayString()}");

            var structureString = string.Join("|", propertySignatures);
            var hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(structureString));
            var hashString = BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();

            // Generate a partial class with the hash constant
            var sourceCode = $$"""
                namespace {{classSymbol.ContainingNamespace.ToDisplayString()}}
                {
                    public static partial class {{classSymbol.Name}}
                    {
                        /// <summary>
                        /// Hash of the class structure, changes when properties are added/removed/renamed
                        /// </summary>
                        public const string StructureHash = "{{hashString}}";
                    }
                }
                """;

            context.AddSource($"{classSymbol.Name}_StructureHash.g.cs", sourceCode);
        }
    }

    // Finds POCO classes (no custom methods except constructors)
    private class PocoSyntaxReceiver : ISyntaxReceiver
    {
        public List<ClassDeclarationSyntax> PocoClasses { get; } = new();

        public void OnVisitSyntaxNode(SyntaxNode node)
        {
            if (node is ClassDeclarationSyntax classDecl)
            {
                // Ignore classes with custom methods (allow constructors)
                var hasCustomMethods = classDecl.Members.Any(m => 
                    m is MethodDeclarationSyntax && !m.IsKind(SyntaxKind.ConstructorDeclaration));
                
                if (!hasCustomMethods)
                {
                    PocoClasses.Add(classDecl);
                }
            }
        }
    }
}

How to use it: #

1. Add the generator to your project as a separate class library or embedded in your project.
2. Make your POCO a partial class:

public partial class UserSnapshot
{
    public string UserId { get; set; }
    public string FullName { get; set; }
    public int Age { get; set; }
}

3. Access the hash directly at runtime:

Console.WriteLine(UserSnapshot.StructureHash);

• Property Order: Both approaches sort properties by name to ensure hash consistency even if property order in the class changes. If property order matters for your snapshot validity, remove the sorting step.
• Nested Types: If your POCO contains nested POCO types, you'll need to extend the logic to recursively include their structure hashes (critical if those nested types are serialized in your snapshots).
• Hash Algorithm: SHA256 is used here for collision resistance—avoid using GetHashCode() as it's not designed for long-term consistency.

内容的提问来源于stack exchange，提问作者Andy Hoyle