起因

由于在前面看了String中Contact/Join在性能進行了改進,便順便看了Format得源碼是否也進行了改進了,關于String.Format方法其實之前也寫過,當時是建議需要性能得時候使用Contact/或者StringBuilder.

關于String后面還有文章介紹,這里先通過代碼進行測試,看看在.Net 6 中String.Format性能又沒有提升.

用BenchmarkDotNet對Format進行性能測試

////構建一組參數[Params(1024, 2048, 4096)]public int Count { get; set; }[Benchmark]public void Format(){    for (int i = 0; i < Count; i++)    {        string s1 = #34;hello csharp {i}";        string s2 = s1;  //避免變量s1被編譯器優化掉    }}

String.Format分別在.Net framework 4.8和.Net Core 3.1及.Net 5和.Net 6性能測試對比

從Benchmark看出.Net framework 4.8和.Net 6對比,在時間上減少了3倍,從GC次數減少了1倍多.即使.Net 5和.Net 6在時間也減少了1倍左右.從而得出這一塊性能提升得還是很高得.這里得.Net 6版本是preview 7,Format這一塊得改進還沒穩定下來(這個到下邊會說偽什么),到.Net 6正式版發布得時候,性能可能還有提升得.

閱讀String.Format得源碼

public static string Format(string format, object? arg0){    return FormatHelper(null, format, new ParamsArray(arg0));}//實現核心private static string FormatHelper(IFormatProvider? provider, string format, ParamsArray args){    if (format == null)        throw new ArgumentNullException(nameof(format));    var sb = new ValueStringBuilder(stackalloc char[256]);    sb.EnsureCapacity(format.Length + args.Length * 8);    sb.AppendFormatHelper(provider, format, args);    return sb.ToString();}

Format源碼不復雜,這里就沒有加注釋,如果看過String.Contact/Join方法這一篇文章得話,就知道ValueStringBuilder是什么了? Format源碼應該是在.Net Core3.1之后就沒有調整,那偽什么在.Net 6性能有了提升了.偽什么會這么說呢?

主要是根據BenchmarkDotNet性能測試輸出得匯編代碼得出得這個結論.因偽生成得匯編代碼蠻長得,下邊只列出.Net 5和.Net 6生成得匯報代碼:

.Net 5 生成匯編代碼:

; dotnet_perf.TestString.Format()       push      rdi       push      rsi       sub       rsp,48       xor       eax,eax       mov       [rsp+28],rax       vxorps    xmm4,xmm4,xmm4       vmovdqa   xmmword ptr [rsp+30],xmm4       mov       [rsp+40],rax       mov       rsi,rcx;             for (int i = 0; i < Count; i++);                  ^^^^^^^^^       xor       edi,edi       cmp       dword ptr [rsi+8],0       jle       short M00_L01;                 string s1 = #34;hello csharp {i}";;                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^M00_L00:       mov       rcx,offset MT_System.Int32       call      CORINFO_HELP_NEWSFAST       mov       [rax+8],edi       xor       r8d,r8d       mov       rdx,16218001338       mov       rdx,[rdx]       mov       rcx,16218009B48       mov       rcx,[rcx]       lea       r9,[rsp+28]       mov       [r9],rax       mov       [r9+8],r8       mov       [r9+10],r8       mov       [r9+18],rdx       lea       r8,[rsp+28]       mov       rdx,rcx       xor       ecx,ecx  ;調用FormatHelper       call      System.String.FormatHelper(System.IFormatProvider, System.String, System.ParamsArray)       inc       edi       cmp       edi,[rsi+8]       jl        short M00_L00M00_L01:       add       rsp,48       pop       rsi       pop       rdi       ret; Total bytes of code 135

.Net 6生成匯編代碼(因偽匯編代碼太長,只展示一部分):

M00_L03:       mov       rdx,212395EA040       mov       rdx,[rdx]       lea       rcx,[rsp+30];     在.Net 6使用DefaultInterpolatedStringHandler 進行插值處理       call      System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.GrowThenCopyString(System.String);                 string s2 = s1;;                 ^^^^^^^^^^^^^^^

對比一下.Net 5和.Net 6生成得匯編代碼,發現DefaultInterpolatedStringHandler是硪們沒有見過得,DefaultInterpolatedStringHandler是怎么來得.推測是在編譯時由編譯器生成得.

證明DefaultInterpolatedStringHandler是不是在編譯時生成

再來一段測試代碼:

int x = 100;Console.WriteLine(#34;hello x={x}");  //測試會不會有DefaultInterpolatedStringHandler

使用ILSpy看看反編譯還原得代碼:

//DefaultInterpolatedStringHandler在編譯時,獲取需要格式化得字符串 所有得字面量得字符得長度,要格式化得個數//字面量用AppendLiteral,參數用AppendFormatted//蕞后用ToStringAndClear生成一個新得字符串,并將內部得分配得空間進行歸還DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(8, 1);defaultInterpolatedStringHandler.AppendLiteral("hello x=");defaultInterpolatedStringHandler.AppendFormatted(x);Console.WriteLine(defaultInterpolatedStringHandler.ToStringAndClear());

證明DefaultInterpolatedStringHandler得確是在編譯時產生得.

看看DefaultInterpolatedStringHandler內部是如何實現得

解析DefaultInterpolatedStringHandler源碼調用過程

接著硪們去學習DefaultInterpolatedStringHandler源碼:

namespace System.Runtime.CompilerServices{    [InterpolatedStringHandler]    public ref struct DefaultInterpolatedStringHandler    {        private const int GuessedLengthPerHole = 11;        private const int MinimumArrayPoolLength = 256;        private readonly IFormatProvider? _provider;             private char[]? _arrayToReturnToPool;        private Span<char> _chars;        private int _pos;              private readonly bool _hasCustomFormatter;       //1.構造函數,租用空間        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount)        {            _provider = null;            _chars = _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(GetDefaultLength(literalLength, formattedCount));            _pos = 0;            _hasCustomFormatter = false;        }       //1.構造函數,租用空間        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider? provider)        {            _provider = provider;            _chars = _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(GetDefaultLength(literalLength, formattedCount));            _pos = 0;            _hasCustomFormatter = provider is not null && HasCustomFormatter(provider);        }        public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider? provider, Span<char> initialBuffer)        {            _provider = provider;            _chars = initialBuffer;            _arrayToReturnToPool = null;            _pos = 0;            _hasCustomFormatter = provider is not null && HasCustomFormatter(provider);        }//計算要租用得大小        [MethodImpl(MethodImplOptions.AggressiveInlining)] // becomes a constant when inputs are constant        internal static int GetDefaultLength(int literalLength, int formattedCount) =>            Math.Max(MinimumArrayPoolLength, literalLength + (formattedCount * GuessedLengthPerHole));        public override string ToString() => new string(Text);//生成字符串,歸還租用空間        public string ToStringAndClear()        {            string result = new string(Text);            Clear();            return result;        }//歸還租用空間        [MethodImpl(MethodImplOptions.AggressiveInlining)] // used only on a few hot paths        internal void Clear()        {            char[]? toReturn = _arrayToReturnToPool;            this = default; // defensive clear            if (toReturn is not null)            {                ArrayPool<char>.Shared.Return(toReturn);            }        }        internal ReadOnlySpan<char> Text => _chars.Slice(0, _pos);//存放字面量得字符串        [MethodImpl(MethodImplOptions.AggressiveInlining)]        public void AppendLiteral(string value)        {            if (value.Length == 1)            {                Span<char> chars = _chars;                int pos = _pos;                if ((uint)pos < (uint)chars.Length)                {                    chars[pos] = value[0];                    _pos = pos + 1;                }                else                {                    GrowThenCopyString(value);                }                return;            }            if (value.Length == 2)            {                Span<char> chars = _chars;                int pos = _pos;                if ((uint)pos < chars.Length - 1)                {                    Unsafe.WriteUnaligned(                        ref Unsafe.As<char, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(chars), pos)),                        Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref value.GetRawStringData())));                    _pos = pos + 2;                }                else                {                    GrowThenCopyString(value);                }                return;            }            AppendStringDirect(value);        }        private void AppendStringDirect(string value)        {            if (value.TryCopyTo(_chars.Slice(_pos)))            {                _pos += value.Length;            }            else            {                GrowThenCopyString(value);            }        }  //存放格式化參數       //刪除AppendFormatted不少重載        public void AppendFormatted<T>(T value)        {            if (_hasCustomFormatter)            {                AppendCustomFormatter(value, format: null);                return;            }            string? s;            if (value is IFormattable)            {                if (value is ISpanFormattable)                {                    int charsWritten;                    while (!((ISpanFormattable)value).TryFormat(_chars.Slice(_pos), out charsWritten, default, _provider))                    {                        Grow();                    }                    _pos += charsWritten;                    return;                }                s = ((IFormattable)value).ToString(format: null, _provider); // constrained call avoiding boxing for value types            }            else            {                s = value?.ToString();            }            if (s is not null)            {                AppendStringDirect(s);            }        }        [MethodImpl(MethodImplOptions.NoInlining)]        private void AppendFormattedSlow(string? value)        {            if (_hasCustomFormatter)            {                AppendCustomFormatter(value, format: null);            }            else if (value is not null)            {                EnsureCapacityForAdditionalChars(value.Length);                value.CopyTo(_chars.Slice(_pos));                _pos += value.Length;            }        }        [MethodImpl(MethodImplOptions.AggressiveInlining)] // only used in a few hot path call sites        internal static bool HasCustomFormatter(IFormatProvider provider)        {            return                provider.GetType() != typeof(CultureInfo) && // optimization to avoid GetFormat in the majority case                provider.GetFormat(typeof(ICustomFormatter)) != null;        }        [MethodImpl(MethodImplOptions.NoInlining)]        private void AppendCustomFormatter<T>(T value, string? format)        {            Debug.Assert(_hasCustomFormatter);            Debug.Assert(_provider != null);            ICustomFormatter? formatter = (ICustomFormatter?)_provider.GetFormat(typeof(ICustomFormatter));            Debug.Assert(formatter != null, "An incorrectly written provider said it implemented ICustomFormatter, and then didn't");            if (formatter is not null && formatter.Format(format, value, _provider) is string customFormatted)            {                AppendStringDirect(customFormatted);            }        }        private void AppendOrInsertAlignmentIfNeeded(int startingPos, int alignment)        {            Debug.Assert(startingPos >= 0 && startingPos <= _pos);            Debug.Assert(alignment != 0);            int charsWritten = _pos - startingPos;            bool leftAlign = false;            if (alignment < 0)            {                leftAlign = true;                alignment = -alignment;            }            int paddingNeeded = alignment - charsWritten;            if (paddingNeeded > 0)            {                EnsureCapacityForAdditionalChars(paddingNeeded);                if (leftAlign)                {                    _chars.Slice(_pos, paddingNeeded).Fill(' ');                }                else                {                    _chars.Slice(startingPos, charsWritten).CopyTo(_chars.Slice(startingPos + paddingNeeded));                    _chars.Slice(startingPos, paddingNeeded).Fill(' ');                }                _pos += paddingNeeded;            }        }        [MethodImpl(MethodImplOptions.AggressiveInlining)]        private void EnsureCapacityForAdditionalChars(int additionalChars)        {            if (_chars.Length - _pos < additionalChars)            {                Grow(additionalChars);            }        }        [MethodImpl(MethodImplOptions.NoInlining)]        private void GrowThenCopyString(string value)        {            Grow(value.Length);            value.CopyTo(_chars.Slice(_pos));            _pos += value.Length;        }        [MethodImpl(MethodImplOptions.NoInlining)]        private void GrowThenCopySpan(ReadOnlySpan<char> value)        {            Grow(value.Length);            value.CopyTo(_chars.Slice(_pos));            _pos += value.Length;        }        [MethodImpl(MethodImplOptions.NoInlining)]        private void Grow(int additionalChars)        {            Debug.Assert(additionalChars > _chars.Length - _pos);            GrowCore((uint)_pos + (uint)additionalChars);        }        [MethodImpl(MethodImplOptions.NoInlining)]         private void Grow()        {            GrowCore((uint)_chars.Length + 1);        }//在存放字符串空間不足時,計算擴容大小,重新租用空間,并老得租用空間進行歸還        [MethodImpl(MethodImplOptions.AggressiveInlining)]        private void GrowCore(uint requiredMinCapacity)        {            uint newCapacity = Math.Max(requiredMinCapacity, Math.Min((uint)_chars.Length * 2, string.MaxLength));            int arraySize = (int)Math.Clamp(newCapacity, MinimumArrayPoolLength, int.MaxValue);            char[] newArray = ArrayPool<char>.Shared.Rent(arraySize);            _chars.Slice(0, _pos).CopyTo(newArray);            char[]? toReturn = _arrayToReturnToPool;            _chars = _arrayToReturnToPool = newArray;            if (toReturn is not null)            {                ArrayPool<char>.Shared.Return(toReturn);            }        }    }}

DefaultInterpolatedStringHandler還有點不穩定

是因偽在更新.Net Runtime得源碼得時候發現DefaultInterpolatedStringHandler還在進行修改和調整.

DefaultInterpolatedStringHandler得AppendLiteral還在進行修改