Program.cs

// Made by Benjamin Abt - https://github.com/BenjaminAbt

using System;
using System.Buffers;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Jobs;
using Microsoft.Extensions.ObjectPool;

#if DEBUG
Benchmark bench = new();
Console.WriteLine(bench.StringBuilder_Pool());
Console.WriteLine(bench.StringBuilder_Instance());
Console.WriteLine(bench.Linq());
Console.WriteLine(bench.Span());
Console.WriteLine(bench.Span2());
Console.WriteLine(bench.Span2Unsafe());
#else
BenchmarkDotNet.Running.BenchmarkRunner.Run<Benchmark>();
#endif

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net70)]
[SimpleJob(RuntimeMoniker.Net80)]
[SimpleJob(RuntimeMoniker.Net90, baseline: true)]
[HideColumns(Column.Job)]
public class Benchmark
{
    public const string Input = @"""
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        Hello\u0001World Hello\u0001World Hello\u0001World Hello\u0001World
        """;

    [Benchmark]
    public string StringBuilder_Pool()
        => Cleanups.UsingStringBuilderPool(Input);

    [Benchmark]
    public string StringBuilder_Instance()
        => Cleanups.UsingStringBuilderInstance(Input);

    [Benchmark]
    public string Linq()
        => Cleanups.UsingLinq(Input);

    [Benchmark]
    public string Span()
        => Cleanups.UsingSpan(Input);

    [Benchmark]
    public string Span1()
        => Cleanups.UseSpan1(Input);

    [Benchmark]
    public string Span2()
        => Cleanups.UseSpan2(Input);

    [Benchmark]
    public string Span2Unsafe()
        => Cleanups.UseSpan2Unsafe(Input);
}

public static class Cleanups
{
    public static string UsingStringBuilderPool(string source)
    {
        StringBuilder sb = StringBuilderPool.Get();
        try
        {
            foreach (char c in source)
            {
                if (char.IsControl(c) is false)
                {
                    sb.Append(c);
                }
            }

            return sb.ToString();
        }
        finally
        {
            StringBuilderPool.ReturnDirty(sb);
        }
    }

    public static string UsingStringBuilderInstance(string source)
    {
        StringBuilder sb = new();

        foreach (char c in source)
        {
            if (char.IsControl(c) is false)
            {
                sb.Append(c);
            }
        }

        return sb.ToString();
    }


    public static string UsingLinq(string source)
        => string.Concat(source.Where(c => char.IsControl(c) is false));

    public static string UsingSpan(string source)
    {
        int length = source.Length;
        char[] rentedFromPool = null;

        // allocate
        Span<char> buffer = length > 512 ?
            (rentedFromPool = ArrayPool<char>.Shared.Rent(length)) : (stackalloc char[512]);

        // filter
        int index = 0;
        foreach (char c in source)
        {
            if (char.IsControl(c) is false)
            {
                buffer[index] = c;
                index++;
            }
        }

        // only return the data that was written
        string data = buffer.Slice(0, index).ToString();

        // cleanup
        if (rentedFromPool is not null)
        {
            ArrayPool<char>.Shared.Return(rentedFromPool, clearArray: true);
        }

        return data;
    }

    [SkipLocalsInit]
    public static string UseSpan1(ReadOnlySpan<char> source)
    {
        int len = source.Length;
        char[] rentedFromPool = null;

        Span<char> buffer = len <= 512
            ? stackalloc char[512]
            : rentedFromPool = ArrayPool<char>.Shared.Rent(len);

        int idx = 0;
        foreach (char c in source)
        {
            if (!char.IsControl(c))
            {
                buffer[idx++] = c;
            }
        }

        buffer = buffer.Slice(0, idx);

        if (rentedFromPool is not null)
        {
            buffer.Clear();
            ArrayPool<char>.Shared.Return(rentedFromPool);
        }

        return buffer.ToString();
    }

    [SkipLocalsInit]
    public static string UseSpan2(ReadOnlySpan<char> source)
    {
        if (source.Length <= 512)
        {
            (string result, _) = Core(source, stackalloc char[512]);
            return result;
        }

        return UsePool(source);

        static (string, int) Core(ReadOnlySpan<char> source, Span<char> buffer)
        {
            int idx = 0;
            foreach (char c in source)
            {
                if (!char.IsControl(c))
                {
                    buffer[idx++] = c;
                }
            }

            string result = buffer.Slice(0, idx).ToString();
            return (result, idx);
        }

        static string UsePool(ReadOnlySpan<char> source)
        {
            char[] rentedFromPool = ArrayPool<char>.Shared.Rent(source.Length);

            (string result, int length) = Core(source, rentedFromPool);

            rentedFromPool.AsSpan(0, length).Clear();
            ArrayPool<char>.Shared.Return(rentedFromPool);

            return result;
        }
    }

    [SkipLocalsInit]
    public static string UseSpan2Unsafe(ReadOnlySpan<char> source)
    {
        if (source.Length <= 512)
        {
            (string result, _) = Core(source, stackalloc char[512]);
            return result;
        }

        return UsePool(source);

        static (string, int) Core(ReadOnlySpan<char> source, Span<char> buffer)
        {
            Debug.Assert(buffer.Length >= source.Length);

            ref char ptr = ref MemoryMarshal.GetReference(buffer);
            int idx = 0;

            foreach (char c in source)
            {
                if (!char.IsControl(c))
                {
                    Unsafe.Add(ref ptr, (uint)idx) = c;
                    idx++;
                }
            }

            string result = buffer.Slice(0, idx).ToString();
            return (result, idx);
        }

        static string UsePool(ReadOnlySpan<char> source)
        {
            char[] rentedFromPool = ArrayPool<char>.Shared.Rent(source.Length);

            (string result, int length) = Core(source, rentedFromPool);

            rentedFromPool.AsSpan(0, length).Clear();
            ArrayPool<char>.Shared.Return(rentedFromPool);

            return result;
        }
    }
}

public static class StringBuilderPool
{
    private static readonly ObjectPool<StringBuilder> s_pool
        = ObjectPool.Create<StringBuilder>();

    public static StringBuilder Get()
        => s_pool.Get();

    public static void Return(StringBuilder stringBuilder)
        => s_pool.Return(stringBuilder);

    public static void ReturnDirty(StringBuilder stringBuilder)
    {
        stringBuilder.Clear();
        Return(stringBuilder);
    }
}