首页 > 资讯 > 后端开发 > ASP.NET >.NET性能优化ValueStringBuilder拼接字符串使用实例

262

分享到

.NET性能优化ValueStringBuilder拼接字符串使用实例

2024-04-02 19:04:59 262人浏览泡泡鱼

摘要

目录前言ValueStringBuilder源码解析适用场景需要注意的场景总结前言这一次要和大家分享的一个Tips是在字符串拼接场景使用的，我们经常会遇到有很多短小的字符串需要拼接

前言

这一次要和大家分享的一个Tips是在字符串拼接场景使用的，我们经常会遇到有很多短小的字符串需要拼接的场景，在这种场景下及其的不推荐使用String.Concat也就是使用+=运算符。
目前来说官方最推荐的方案就是使用StringBuilder来构建这些字符串，那么有什么更快内存占用更低的方式吗？那就是今天要和大家介绍的ValueStringBuilder。

ValueStringBuilder

ValueStringBuilder不是一个公开的api，但是它被大量用于.net的基础类库中，由于它是值类型的，所以它本身不会在堆上分配，不会有GC的压力。
微软提供的ValueStringBuilder有两种使用方式，一种是自己已经有了一块内存空间可供字符串构建使用。这意味着你可以使用栈空间，也可以使用堆空间甚至非托管堆的空间，这对于GC来说是非常友好的，在高并发情况下能大大降低GC压力。

// 构造函数：传入一个Span的Buffer数组
public ValueStringBuilder(Span<char> initialBuffer);
// 使用方式：
// 栈空间
var vsb = new ValueStringBuilder(stackalloc char[512]);
// 普通数租
var vsb = new ValueStringBuilder(new char[512]);
// 使用非托管堆
var length = 512;
var ptr = NativeMemory.Alloc((nuint)(512 * Unsafe.SizeOf<char>()));
var span = new Span<char>(ptr, length);
var vsb = new ValueStringBuilder(span);
.....
NativeMemory.Free(ptr); // 非托管堆用完一定要Free

另外一种方式是指定一个容量，它会从默认的ArrayPool的char对象池中获取缓冲空间，因为使用的是对象池，所以对于GC来说也是比较友好的，千万需要注意，池中的对象一定要记得归还。

// 传入预计的容量
public ValueStringBuilder(int initialCapacity)  
{  
    // 从对象池中获取缓冲区
    _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);  
    ......
}

那么我们就来比较一下使用+=、StringBuilder和ValueStringBuilder这几种方式的性能吧。

// 一个简单的类
public class SomeClass  
{  
    public int Value1; public int Value2; public float Value3;  
    public double Value4; public string? Value5; public decimal Value6;  
    public DateTime Value7; public TimeOnly Value8; public DateOnly Value9;  
    public int[]? Value10;  
}
// Benchmark类
[MemoryDiagnoser]  
[htmlExporter]  
[Orderer(SummaryOrderPolicy.FastestToSlowest)]  
public class StringBuilderBenchmark  
{  
    private static readonly SomeClass Data;  
    static StringBuilderBenchmark()  
    {  
        var baseTime = DateTime.Now;  
        Data = new SomeClass  
        {  
            Value1 = 100, Value2 = 200, Value3 = 333,  
            Value4 = 400, Value5 = string.Join('-', Enumerable.Range(0, 10000).Select(i => i.ToString())),  
            Value6 = 655, Value7 = baseTime.AddHours(12),  
            Value8 = TimeOnly.MinValue, Value9 = DateOnly.MaxValue,  
            Value10 = Enumerable.Range(0, 5).ToArray()  
        };  
    }
    // 使用我们熟悉的StringBuilder
    [Benchmark(Baseline = true)]  
    public string StringBuilder()  
    {  
        var data = Data;  
        var sb = new StringBuilder();  
        sb.Append("Value1:"); sb.Append(data.Value1);  
        if (data.Value2 > 10)  
        {  
            sb.Append(" ,Value2:"); sb.Append(data.Value2);  
        }  
        sb.Append(" ,Value3:"); sb.Append(data.Value3);  
        sb.Append(" ,Value4:"); sb.Append(data.Value4);  
        sb.Append(" ,Value5:"); sb.Append(data.Value5);  
        if (data.Value6 > 20)  
        {  
            sb.Append(" ,Value6:"); sb.AppendFORMat("{0:F2}", data.Value6);  
        }  
        sb.Append(" ,Value7:"); sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss}", data.Value7);  
        sb.Append(" ,Value8:"); sb.AppendFormat("{0:HH:mm:ss}", data.Value8);  
        sb.Append(" ,Value9:"); sb.AppendFormat("{0:yyyy-MM-dd}", data.Value9);  
        sb.Append(" ,Value10:");  
        if (data.Value10 is null or {Length: 0}) return sb.ToString();  
        for (int i = 0; i < data.Value10.Length; i++)  
        {  
            sb.Append(data.Value10[i]);  
        }  
        return sb.ToString();  
    }
    // StringBuilder使用Capacity
    [Benchmark]  
    public string StringBuilderCapacity()  
    {  
        var data = Data;  
        var sb = new StringBuilder(20480);  
        sb.Append("Value1:"); sb.Append(data.Value1);  
        if (data.Value2 > 10)  
        {  
            sb.Append(" ,Value2:"); sb.Append(data.Value2);  
        }  
        sb.Append(" ,Value3:"); sb.Append(data.Value3);  
        sb.Append(" ,Value4:"); sb.Append(data.Value4);  
        sb.Append(" ,Value5:"); sb.Append(data.Value5);  
        if (data.Value6 > 20)  
        {  
            sb.Append(" ,Value6:"); sb.AppendFormat("{0:F2}", data.Value6);  
        }  
        sb.Append(" ,Value7:"); sb.AppendFormat("{0:yyyy-MM-dd HH:mm:ss}", data.Value7);  
        sb.Append(" ,Value8:"); sb.AppendFormat("{0:HH:mm:ss}", data.Value8);  
        sb.Append(" ,Value9:"); sb.AppendFormat("{0:yyyy-MM-dd}", data.Value9);  
        sb.Append(" ,Value10:");  
        if (data.Value10 is null or {Length: 0}) return sb.ToString();  
        for (int i = 0; i < data.Value10.Length; i++)  
        {  
            sb.Append(data.Value10[i]);  
        }  
        return sb.ToString();  
    }  
    // 直接使用+=拼接字符串
    [Benchmark]  
    public string StringConcat()  
    {  
        var str = "";  
        var data = Data;  
        str += ("Value1:"); str += (data.Value1);  
        if (data.Value2 > 10)  
        {  
            str += " ,Value2:"; str += data.Value2;  
        }  
        str += " ,Value3:"; str += (data.Value3);  
        str += " ,Value4:"; str += (data.Value4);  
        str += " ,Value5:"; str += (data.Value5);  
        if (data.Value6 > 20)  
        {  
            str += " ,Value6:"; str += data.Value6.ToString("F2");  
        }  
        str += " ,Value7:"; str += data.Value7.ToString("yyyy-MM-dd HH:mm:ss");  
        str += " ,Value8:"; str += data.Value8.ToString("HH:mm:ss");  
        str += " ,Value9:"; str += data.Value9.ToString("yyyy-MM-dd");  
        str += " ,Value10:";  
        if (data.Value10 is not null && data.Value10.Length > 0)  
        {  
            for (int i = 0; i < data.Value10.Length; i++)  
            {  
                str += (data.Value10[i]);  
            }     
        }  
        return str;  
    }  
    // 使用栈上分配的ValueStringBuilder
    [Benchmark]  
    public string ValueStringBuilderOnStack()  
    {  
        var data = Data;  
        Span<char> buffer = stackalloc char[20480];  
        var sb = new ValueStringBuilder(buffer);  
        sb.Append("Value1:"); sb.AppendSpanFormattable(data.Value1);  
        if (data.Value2 > 10)  
        {  
            sb.Append(" ,Value2:"); sb.AppendSpanFormattable(data.Value2);  
        }  
        sb.Append(" ,Value3:"); sb.AppendSpanFormattable(data.Value3);  
        sb.Append(" ,Value4:"); sb.AppendSpanFormattable(data.Value4);  
        sb.Append(" ,Value5:"); sb.Append(data.Value5);  
        if (data.Value6 > 20)  
        {  
            sb.Append(" ,Value6:"); sb.AppendSpanFormattable(data.Value6, "F2");  
        }  
        sb.Append(" ,Value7:"); sb.AppendSpanFormattable(data.Value7, "yyyy-MM-dd HH:mm:ss");  
        sb.Append(" ,Value8:"); sb.AppendSpanFormattable(data.Value8, "HH:mm:ss");  
        sb.Append(" ,Value9:"); sb.AppendSpanFormattable(data.Value9, "yyyy-MM-dd");  
        sb.Append(" ,Value10:");  
        if (data.Value10 is not null && data.Value10.Length > 0)  
        {  
            for (int i = 0; i < data.Value10.Length; i++)  
            {  
                sb.AppendSpanFormattable(data.Value10[i]);  
            }     
        }  
        return sb.ToString();  
    }
    // 使用ArrayPool 堆上分配的StringBuilder
    [Benchmark]  
    public string ValueStringBuilderOnHeap()  
    {  
        var data = Data;  
        var sb = new ValueStringBuilder(20480);  
        sb.Append("Value1:"); sb.AppendSpanFormattable(data.Value1);  
        if (data.Value2 > 10)  
        {  
            sb.Append(" ,Value2:"); sb.AppendSpanFormattable(data.Value2);  
        }  
        sb.Append(" ,Value3:"); sb.AppendSpanFormattable(data.Value3);  
        sb.Append(" ,Value4:"); sb.AppendSpanFormattable(data.Value4);  
        sb.Append(" ,Value5:"); sb.Append(data.Value5);  
        if (data.Value6 > 20)  
        {  
            sb.Append(" ,Value6:"); sb.AppendSpanFormattable(data.Value6, "F2");  
        }  
        sb.Append(" ,Value7:"); sb.AppendSpanFormattable(data.Value7, "yyyy-MM-dd HH:mm:ss");  
        sb.Append(" ,Value8:"); sb.AppendSpanFormattable(data.Value8, "HH:mm:ss");  
        sb.Append(" ,Value9:"); sb.AppendSpanFormattable(data.Value9, "yyyy-MM-dd");  
        sb.Append(" ,Value10:");  
        if (data.Value10 is not null && data.Value10.Length > 0)  
        {  
            for (int i = 0; i < data.Value10.Length; i++)  
            {  
                sb.AppendSpanFormattable(data.Value10[i]);  
            }     
        }
        return sb.ToString();  
    }
}

结果如下所示。

从上图的结果中，我们可以得出如下的结论。

使用StringConcat是最慢的，这种方式是无论如何都不推荐的。
使用StringBuilder要比使用StringConcat快6.5倍，这是推荐的方法。
设置了初始容量的StringBuilder要比直接使用StringBuilder快25%，正如我在你应该为集合类型设置初始大小一样，设置初始大小绝对是相当推荐的做法。
栈上分配的ValueStringBuilder比StringBuilder要快50%，比设置了初始容量的StringBuilder还快25%，另外它的GC次数是最低的。
堆上分配的ValueStringBuilder比StringBuilder要快55%，他的GC次数稍高与栈上分配。
从上面的结论中，我们可以发现ValueStringBuilder的性能非常好，就算是在栈上分配缓冲区，性能也比StringBuilder快25%。

源码解析

ValueStringBuilder的源码不长，我们挑几个重要的方法给大家分享一下，部分源码如下。

// 使用 ref struct 该对象只能在栈上分配
public ref struct ValueStringBuilder
{
    // 如果从ArrayPool里分配buffer 那么需要存储一下
    // 以便在Dispose时归还
    private char[]? _arrayToReturnToPool;
    // 暂存外部传入的buffer
    private Span<char> _chars;
    // 当前字符串长度
    private int _pos;
    // 外部传入buffer
    public ValueStringBuilder(Span<char> initialBuffer)
    {
        // 使用外部传入的buffer就不使用从pool里面读取的了
        _arrayToReturnToPool = null;
        _chars = initialBuffer;
        _pos = 0;
    }
    public ValueStringBuilder(int initialCapacity)
    {
        // 如果外部传入了capacity 那么从ArrayPool里面获取
        _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
        _chars = _arrayToReturnToPool;
        _pos = 0;
    }
    // 返回字符串的Length 由于Length可读可写
    // 所以重复使用ValueStringBuilder只需将Length设置为0
    public int Length
    {
        get => _pos;
        set
        {
            Debug.Assert(value >= 0);
            Debug.Assert(value <= _chars.Length);
            _pos = value;
        }
    }
    ......
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Append(char c)
    {
        // 添加字符非常高效 直接设置到对应Span位置即可
        int pos = _pos;
        if ((uint) pos < (uint) _chars.Length)
        {
            _chars[pos] = c;
            _pos = pos + 1;
        }
        else
        {
            // 如果buffer空间不足，那么会走
            GrowAndAppend(c);
        }
    }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Append(string? s)
    {
        if (s == null)
        {
            return;
        }
        // 追加字符串也是一样的高效
        int pos = _pos;
        // 如果字符串长度为1 那么可以直接像追加字符一样
        if (s.Length == 1 && (uint) pos < (uint) _chars .Length)
        {
            _chars[pos] = s[0];
            _pos = pos + 1;
        }
        else
        {
            // 如果是多个字符 那么使用较慢的方法
            AppendSlow(s);
        }
    }
    private void AppendSlow(string s)
    {
        // 追加字符串 空间不够先扩容
        // 然后使用Span复制 相当高效
        int pos = _pos;
        if (pos > _chars.Length - s.Length)
        {
            Grow(s.Length);
        }
        s
#if !netcoreAPP
                .AsSpan()
#endif
            .CopyTo(_chars.Slice(pos));
        _pos += s.Length;
    }
    // 对于需要格式化的对象特殊处理
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void AppendSpanFormattable<T>(T value, string? format = null, IFormatProvider? provider = null)
        where T : ISpanFormattable
    {
        // ISpanFormattable非常高效
        if (value.TryFormat(_chars.Slice(_pos), out int charsWritten, format, provider))
        {
            _pos += charsWritten;
        }
        else
        {
            Append(value.ToString(format, provider));
        }
    }
    [MethodImpl(MethodImplOptions.NoInlining)]
    private void GrowAndAppend(char c)
    {
        // 单个字符扩容在添加
        Grow(1);
        Append(c);
    }
    // 扩容方法
    [MethodImpl(MethodImplOptions.NoInlining)]
    private void Grow(int additionalCapacityBeyondPos)
    {
        Debug.Assert(additionalCapacityBeyondPos > 0);
        Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos,
            "Grow called incorrectly, no resize is needed.");
        // 同样也是2倍扩容，默认从对象池中获取buffer
        char[] poolArray = ArrayPool<char>.Shared.Rent((int) Math.Max((uint) (_pos + additionalCapacityBeyondPos),
            (uint) _chars.Length * 2));
        _chars.Slice(0, _pos).CopyTo(poolArray);
        char[]? toReturn = _arrayToReturnToPool;
        _chars = _arrayToReturnToPool = poolArray;
        if (toReturn != null)
        {
            // 如果原本就是使用的对象池 那么必须归还
            ArrayPool<char>.Shared.Return(toReturn);
        }
    }
    // 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Dispose()
    {
        char[]? toReturn = _arrayToReturnToPool;
        this = default; // 为了安全，在释放时置空当前对象
        if (toReturn != null)
        {
            // 一定要记得归还对象池
            ArrayPool<char>.Shared.Return(toReturn);
        }
    }
}

从上面的源码我们可以总结出ValueStringBuilder的几个特征：

比起StringBuilder来说，实现方式非常简单。
一切都是为了高性能，比如各种Span的用法，各种内联参数，以及使用对象池等等。
内存占用非常低，它本身就是结构体类型，另外它是ref struct，意味着不会被装箱，不会在堆上分配。

适用场景

ValueStringBuilder是一种高性能的字符串创建方式，针对于不同的场景，可以有不同的使用方式。

1.非常高频次的字符串拼接的场景，并且字符串长度较小，此时可以使用栈上分配的ValueStringBuilder。

大家都知道现在ASP.net core性能非常好，在其依赖的内部库UrlBuilder中，就使用栈上分配，因为栈上分配在当前方法结束后内存就会回收，所以不会造成任何GC压力。

2.非常高频次的字符串拼接场景，但是字符串长度不可控，此时使用ArrayPool指定容量的ValueStringBuilder。比如在.NET BCL库中有很多场景使用，比如动态方法的ToString实现。从池中分配虽然没有栈上分配那么高效，但是一样的能降低内存占用和GC压力。

3. 非常高频次的字符串拼接场景，但是字符串长度可控，此时可以栈上分配和ArrayPool分配联合使用，比如正则表达式解析类中，如果字符串长度较小那么使用栈空间，较大那么使用ArrayPool。

需要注意的场景

1.在async\await中无法使用ValueStringBuilder。原因大家也都知道，因为ValueStringBuilder是ref struct，它只能在栈上分配，async\await会编译成状态机拆分await前后的方法，所以ValueStringBuilder不好在方法内传递，不过编译器也会警告。

2.无法将ValueStringBuilder作为返回值返回，因为在当前栈上分配，方法结束后它会被释放，返回它将指向未知的地址。这个编译器也会警告。

3.如果要将ValueStringBuilder传递给其它方法，那么必须使用ref传递，否则发生值拷贝会存在多个实例。这个编译器不会警告，但是你必须非常注意。

4. 如果使用栈上分配，那么Buffer大小控制在5KB内比较稳妥，至于为什么需要这样，后面有机会在讲一讲。

总结

今天和大家分享了一下高性能几乎无内存占用的字符串拼接结构体ValueStringBuilder，在大多数的场景还是推荐大家使用。但是要非常注意上面提到的的几个场景，如果不符合条件，那么大家还是可以使用高效的StringBuilder来进行字符串拼接。

源码链接点击

以上就是.NET性能优化ValueStringBuilder拼接字符串使用实例的详细内容，更多关于.NET ValueStringBuilder拼接字符串的资料请关注编程网其它相关文章！

--结束END--

本文标题: .NET性能优化ValueStringBuilder拼接字符串使用实例

本文链接: https://lsjlt.com/news/151175.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

.NET性能优化ValueStringBuilder拼接字符串使用实例

目录

前言

ValueStringBuilder

源码解析

适用场景

需要注意的场景

总结

.NET性能优化ValueStringBuilder拼接字符串使用实例

.NET性能优化ValueStringBuilder拼接字符串如何使用

Golong字符串拼接性能优化及原理介绍

GoLang中拼接字符串性能优化方法详解

优化Go语言字符串拼接性能的技巧

MySQL字符串拼接与分组拼接字符串实例代码

Golong字符串拼接性能优化方法及原理是什么

Shell 字符串拼接的实现示例

Java字符串拼接的优雅方式实例详解

Python字符串拼接的4种方法实例

pandas中拼接字符串cat()方法的使用示例

Java中list.foreach不能使用字符串拼接的问题

MyBatis中正则使用foreach拼接字符串

使用Go语言拼接字符串的最佳实践

怎么在JavaScript中使用join拼接字符串

Golang 技术性能优化中如何优化字符串操作？

java实战小技巧之优雅的实现字符串拼接

Mysql性能优化：如何给字符串加索引？

mysql字符串拼接并设置null值的实例方法

R语言中字符串的拼接操作实例讲解

[红色]一次性下载远程页面上的所有内容284815分享

通过数组给您的文件排序284815解决

[紫色]利用ASP发送和接收XML数据的处理方法284815实例

ASP动态include文件284815分享

用asp自动解析网页中的图片地址284627(思路详解)

AspJpeg V1.5.0 破解版使用方法284587问题及解决

ASP动态include文件284587过程讲解

用asp自动解析网页中的图片地址284567处理办法

[紫色]利用ASP发送和接收XML数据的处理方法284567过程讲解

Session对象失效的客户端解决方法284567详解