能否用C#源代码生成器根据常量参数生成ReadRaw的差异化代码？

完全可以通过C#源代码生成器实现需求，甚至能自动将带有常量参数的Bitpacker.ReadRaw调用替换为硬编码的高效实现，兼顾性能与可维护性，具体方案如下：

核心实现路径 #

• 识别可优化的调用：编写Roslyn分析器，扫描代码中所有Bitpacker.ReadRaw调用，检查startBit、bitLength、endianness是否为编译时常量。符合条件的调用标记为可优化目标。
• 生成硬编码逻辑：针对每个符合条件的调用，根据具体常量值生成无循环的位操作代码。比如：
  • 当startBit=0、bitLength=8、endianness=LSB_FIRST时，直接生成return src[0];；
  • 跨字节的场景，预计算位移量与掩码，生成直接的位拼接代码。
• 替换原调用：生成器可生成包含优化方法的静态类（如OptimizedBitpacker），再通过分析器提示替换原调用，或直接在编译阶段完成代码替换。

关键代码示例 #

Roslyn分析器核心片段 #

public override void Initialize(AnalysisContext context)
{
    context.EnableConcurrentExecution();
    context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
    context.RegisterSyntaxNodeAction(AnalyzeInvocation, SyntaxKind.InvocationExpression);
}

private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
{
    var invocation = (InvocationExpressionSyntax)context.Node;
    var methodSymbol = context.SemanticModel.GetSymbolInfo(invocation).Symbol as IMethodSymbol;
    
    if (methodSymbol == null 
        || methodSymbol.ContainingType.Name != "Bitpacker" 
        || methodSymbol.Name != "ReadRaw")
        return;

    // 检查参数是否为编译时常量
    var startBitArg = invocation.ArgumentList.Arguments[0];
    var bitLengthArg = invocation.ArgumentList.Arguments[1];
    var endiannessArg = invocation.ArgumentList.Arguments.Count > 2 
        ? invocation.ArgumentList.Arguments[2] 
        : null;

    if (!IsConstant(context.SemanticModel, startBitArg) 
        || !IsConstant(context.SemanticModel, bitLengthArg))
        return;

    // 上报诊断，提示替换为优化实现
    context.ReportDiagnostic(Diagnostic.Create(
        new DiagnosticDescriptor(
            id: "BITPACK001",
            title: "使用优化的位读取实现",
            messageFormat: "将ReadRaw调用替换为预生成的高效实现",
            category: "Performance",
            defaultSeverity: DiagnosticSeverity.Info,
            isEnabledByDefault: true),
        invocation.GetLocation()));
}

private bool IsConstant(SemanticModel semanticModel, ArgumentSyntax argument)
{
    var constantValue = semanticModel.GetConstantValue(argument.Expression);
    return constantValue.HasValue;
}

源代码生成器输出示例 #

生成器会为每个常量参数组合生成专属的优化方法：

public static class OptimizedBitpacker
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong ReadRaw_Start0_Length8_LSB(byte[] src)
    {
        return src[0];
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong ReadRaw_Start3_Length12_MSB(byte[] src)
    {
        return ((ulong)src[0] >> 3) | ((ulong)src[1] << 5);
    }
}

轻量化替代方案：泛型+常量表达式 #

如果不想编写完整的分析器+生成器，可利用C# 10+的[ConstantExpected]特性和激进内联，让JIT自动优化：

public static class Bitpacker<
    [ConstantExpected] int StartBit, 
    [ConstantExpected] int BitLength, 
    [ConstantExpected] Endianness Endian>
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong Read(byte[] src)
    {
        // 基于常量参数的位操作逻辑，JIT会自动编译为无循环的高效代码
        ulong result = 0;
        int startByte = StartBit / 8;
        int bitOffset = StartBit % 8;
        
        if (Endian == Endianness.MSB_FIRST)
        {
            // MSB优先的位操作逻辑
            result = (ulong)src[startByte] >> (8 - bitOffset - BitLength);
            if (BitLength > (8 - bitOffset))
            {
                int remainingBits = BitLength - (8 - bitOffset);
                result |= (ulong)src[startByte + 1] << (BitLength - remainingBits);
            }
        }
        else
        {
            // LSB优先的位操作逻辑
            result = (ulong)src[startByte] >> bitOffset;
            if (BitLength > (8 - bitOffset))
            {
                int remainingBits = BitLength - (8 - bitOffset);
                result |= (ulong)src[startByte + 1] << (8 - bitOffset);
            }
            result &= (1UL << BitLength) - 1;
        }
        return result;
    }
}

调用时使用Bitpacker<0, 8, Endianness.LSB_FIRST>.Read(src)，JIT会将这段代码优化为与手动硬编码等价的高效指令。

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