Csharp Lambda Actions 或 AggressiveInlining 以避免判断复杂字符串并将其传递给单独的静态类

首先，使用适当的基准工具--如BenchmarkDotNet.

我提出了以下基准:

namespace CS_Console_Test_05
{
    static public class Logger
    {
        public static bool MenuItems = false;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void MenuWrite(string msg)
        {
            if (MenuItems)
            {
                Console.WriteLine(msg);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void MenuWriteFormattableString(FormattableString msg)
        {
            if (MenuItems)
            {
                Console.WriteLine(msg);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void MenuWriteFunc(Func<string> msg)
        {
            if (MenuItems)
            {
                Console.WriteLine(msg());
            }
        }
    }
}

[MemoryDiagnoser]
public class LoggerWrapperBench
{
    public static string Value = "TestVal";
    private const int Iterations = 1000;

    [Benchmark]
    public void LoopMessagesInline()
    {
        for (int i = 0; i < Iterations; i++)
        {
            if (Logger.MenuItems)
            {
                Console.WriteLine($"Counting Down to the time {Value}");
            }
        }
    }

    [Benchmark]
    public void LoopMessagesInlineFormatableString()
    {
        for (int i = 0; i < Iterations; i++)
        {
            Logger.MenuWriteFormattableString($"Counting Down to the time {Value}");
        }
    }
    
    [Benchmark]
    public void LoopMessagesInlineFunc()
    {
        for (int i = 0; i < Iterations; i++)
        {
            Logger.MenuWriteFunc(() => $"Counting Down to the time {Value}");
        }
    }

    [Benchmark]
    public void LoopMessagesCall()
    {
        for (int i = 0; i < Iterations; i++)
        {
            Logger.MenuWrite($"Counting Down to the time {Value}");
        }
    }
}

它在我的机器上提供了:

使惰性函数方法最接近内联方法(尽管我有点奇怪它为什么没有分配任何东西).

请注意，内联在MenuWrite和MenuWriteFormattableString的情况下对字符串计算没有太大影响，因为:

var s = DoSomething(); // like build string
if(...)
{
    Console.WriteLine(s);
}

和

if(...)
{
    Console.WriteLine(DoSomething());
}

在一般情况下(由于函数调用的可能副作用)，它们在功能上不是等价的，所以内联不应该改变程序的正确性，所以调用字符串格式化(至少这是我关于这个主题的理论).

UPD个

还有一种方法值得一提的是(尽管我不能让它执行得更快，在有多个内插元素的情况下，它甚至可以更慢地预成型)-从.NET 6开始，您可以创建一个custom interpolated string handler:

[InterpolatedStringHandler]
public readonly ref struct LogInterpolatedStringHandler
{
    readonly StringBuilder? _builder;

    public LogInterpolatedStringHandler(int literalLength, int formattedCount)
    {
        if (Logger.MenuItems)
        {
            _builder = new StringBuilder(literalLength);
        }
    }

    public void AppendLiteral(string s) => _builder?.Append(s);

    public void AppendFormatted<T>(T t) => _builder?.Append(t?.ToString());

    internal string GetFormattedText()
    {
        if (_builder is not null)
        {
            var format = _builder.ToString();
            Console.WriteLine(format);
            return format;
        }

        return string.Empty;
    }
}

和 usage:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void MenuWriteInterpolatedStringHandler(ref LogInterpolatedStringHandler msg)
{
    if(MenuItems) msg.GetFormattedText();
}

[Benchmark]
public void LoopMenuWriteInterpolatedStringHandler()
{
    for (int i = 0; i < Iterations; i++)
    {
        Logger.MenuWriteInterpolatedStringHandler($"Counting Down to the time {Value}");
    }
}

它在我的机器上提供了: