C# 最快的整数字符串生成器追加

将整数追加到StringBuilder，分配量最小。有没有更快的办法

    public static void AppendInvariant(this StringBuilder builder, int value)
    {
        // Deal with negative numbers
        if (value < 0)
        {
            builder.Append('-');
            uint uint_value = uint.MaxValue - ((uint)value) + 1; //< This is to deal with Int32.MinValue
            AppendInvariant(builder, uint_value);
        }
        else
        {
            AppendInvariant(builder, (uint)value);
        }
    }

    public static void AppendInvariant(this StringBuilder builder, uint value)
    {
        if (value == 0)
        {
            builder.Append('0');
            return;
        }

        // Pad out space for writing.
        int length = UintLength(value);
        builder.Append('0', length);
        length = builder.Length;

        uint tmp_value;
        do
        {
            tmp_value = value;
            value /= 10;
            builder[--length] = (char)('0' + (tmp_value - value * 10));
        } while (value > 0);
    }

    private static int UintLength(uint i)
    {
        if (i < 100000)
        {
            if (i < 10) return 1;
            if (i < 100) return 2;
            if (i < 1000) return 3;
            if (i < 10000) return 4;
            return 5;
        }
        else
        {
            if (i < 1000000) return 6;
            if (i < 10000000) return 7;
            if (i < 100000000) return 8;
            if (i < 1000000000) return 9;
            return 10;
        }
    }

public static void AppendInvariant（此StringBuilder，int值）
{
//处理负数
如果（值<0）
{
builder.Append（'-'）；
uint uint_value=uint.MaxValue-（（uint）value）+1；//<这是为了处理Int32.MinValue
附加不变量（生成器，uint_值）；
}
其他的
{
附录（生成器，（uint）值）；
}
}
公共静态无效（此StringBuilder，uint值）
{
如果（值==0）
{
builder.Append（'0'）；
返回；
}
//为书写留出空间。
int length=UintLength（值）；
builder.Append（'0'，长度）；
长度=builder.length；
uint tmp_值；
做
{
tmp_值=值；
数值/=10；
生成器[--length]=（char）（'0'+（tmp_值-值*10））；
}而（值>0）；
}
专用静态输入长度（uint i）
{
如果（i<100000）
{
如果（i<10）返回1；
如果（i<100）返回2；
如果（i<1000）返回3；
如果（i<10000）返回4；
返回5；
}
其他的
{
如果（i<1000000）返回6；
如果（i<10000000）返回7；
如果（i<100000000）返回8；
如果（i<100000000）返回9；
返回10；
}
}

以下实现大约快2倍

它通过使用一个小的100元素预分配字符串表来最小化

StringBuilder

调用来实现这一点

private static readonly string[] UIntPairStrings =
    Enumerable.Range(0, 100).Select(n => n.ToString("00")).ToArray();

而且，通过从高到低处理2位数对的输入值（以补偿存储不足），还可以最大限度地减少分区数。这样，操作执行的追加调用不超过5次

private static readonly uint[] UIntPairScales = { 100000000, 1000000, 10000, 100 };

public static void AppendInvariant(this StringBuilder builder, uint value)
{
    bool next = false;
    foreach (var scale in UIntPairScales)
    {
        if (value >= scale)
        {
            uint pair = value / scale;
            if (!next && pair < 10)
                builder.Append((char)('0' + pair));
            else
                builder.Append(UIntPairStrings[pair]);
            value -= pair * scale;
            next = true;
        }
        else if (next)
        {
            builder.Append("00");
        }
    }
    if (!next && value < 10)
        builder.Append((char)('0' + value));
    else
        builder.Append(UIntPairStrings[value]);
}

private static readonly uint[]UIntPairScales={100000000,1000000,100}；
公共静态无效（此StringBuilder，uint值）
{
bool-next=false；
foreach（UIntPairScales中的var刻度）
{
如果（值>=刻度）
{
uint对=值/刻度；
如果（！下一个和对<10）
追加（（字符）（'0'+对））；
其他的
Append（uintPairString[pair]）；
值-=成对*刻度；
next=真；
}
否则，如果（下一个）
{
建造商。附加（“00”）；
}
}
如果（！next&&值<10）
追加（（字符）（'0'+值））；
其他的
Append（uintPairString[value]）；
}

builder[--length]=（char）（'0'+（tmp_值-value*10））没有分配，你说？：）@john是的，您是对的，将有StringBuilder缓冲区分配，但我接受：）