Performance benchmark references

[MikeAlhayek]

This discussion is for performance benchmark tip. Anytime a helpful benchmark is generated, I like to log it here for future references. Feel free to comment with more benchmark results.

@Piedone @sebastienros @Skrypt @hishamco @agriffard

[MikeAlhayek]

Use IEnumerable when possible and avoid having to convert with .ToList() or .ToArray() if possible.

Using List is faster but comes at the cost of allocation more as you expected. I'll modify the code to no use the list.

[Piedone]

Do you mean AsEnumerable()? BTW see this, a bit related: https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1859.

[MikeAlhayek]

No. What I mean here is that when we already have IEnumerable<> we should use it without having to cast it "unless casing is needed". If other words, we should not convert existing IEnumerable to a collection just because we can. We should cast to list if we want to add items to it or remove items.... But If all we need it to iterate over it, we should just iterate over it without casting it at all to reduce the amount of allocation necessary. In case where we are optimizing for speed over memory allocation, then we should use case the IEnumerable .ToArray() which will provide better speed during iteration. Of course, if we already paid the price of have a list or array, we'll just iterate over it and will be faster.

I am guessing the speed advantage in negligible in most case. So if we use the IEnumerable object we reduce allocation.

[Piedone]

Yeah, that's natural, I just thought "UseEnumerable" was d supposed to be some LINQ method, but now I see that's just the line header :).

[MikeAlhayek]

Use .ToArray() over .ToList() when possible

As you can see from the benchmark below, .ToArray() is slightly faster that .ToList() with slightly less allocations.

@sebastienros we had the opposite in mind.

[Piedone]

Similar conclusion: https://www.meziantou.net/copying-a-collection-tolist-vs-toarray.htm And: https://olegkarasik.wordpress.com/2019/07/23/what-is-the-difference-between-toarray-and-tolist/

[MikeAlhayek]

Sweet, glad someone else did similar performance test!

[MikeAlhayek]

Creating the same object very often can be costly.

In places like INavigationProvider where we call the handler on every single request, creating the same object over and over can be expensive.

As simple as one constant variable saves 12 mb in memory allocation over 100k requests.

For example, the below AdminMenu class, we store the RouteValues in a const variable which is created only one during the entire life of the app. This object will be used by every single request (from any tenant). This small change will reduce lots of allocations over the life of the app. Make sure you do not store client specific data in a const variable!

public class AdminMenu : INavigationProvider
{
    private static readonly RouteValueDictionary _routeValues = new()
    {
        { "area", "OrchardCore.Settings" },
        { "groupId", AdminSiteSettingsDisplayDriver.GroupId },
    };

    protected readonly IStringLocalizer S;

    public AdminMenu(IStringLocalizer<AdminMenu> stringLocalizer)
    {
        S = stringLocalizer;
    }

    public Task BuildNavigationAsync(string name, NavigationBuilder builder)
    {
        if (!NavigationHelper.IsAdminMenu(name))
        {
            return Task.CompletedTask;
        }

        builder
            .Add(S["Configuration"], configuration => configuration
                .Add(S["Settings"], settings => settings
                    .Add(S["Admin"], S["Admin"].PrefixPosition(), admin => admin
                        .AddClass("admin")
                        .Id("admin")
                        .Action("Index", "Admin", _routeValues)
                        .Permission(PermissionsAdminSettings.ManageAdminSettings)
                        .LocalNav()
                    )
                )
            );

        return Task.CompletedTask;
    }
}

[MikeAlhayek]

Use string interpolation when concatenation few strings.

A benchmark on a medium size string

That output of the following benchmark

[MemoryDiagnoser]
public class MediumStringConcatenationBenchmarks
{
    private const string Phrase1 = "In the vast expanse of the cosmos, stars dance in celestial choreography";
    private const string Phrase2 = "weaving tales of cosmic marvels, while on Earth, the tapestry of life unfolds";
    private const string Phrase3 = "intertwining moments of joy, sorrow, and discovery, echoing the symphony of existence itself.";
    private const string Separator = ", ";

    [Benchmark(Baseline = true)]
    public string StringConcatenation()
    {
        var result = string.Empty;

        result += Phrase1;
        result += Separator;
        result += Phrase2;
        result += Separator;
        result += Phrase3;

        return result;
    }

    [Benchmark]
    public string StringConcatenationOneLine()
    {
        var result = Phrase1 + Separator + Phrase2 + Separator + Phrase3;

        return result;
    }

    [Benchmark]
    public string StringInterpolation()
    {
        var result = $"{Phrase1}{Separator}{Phrase2}{Separator}{Phrase3}";

        return result;
    }

    [Benchmark]
    public string StringBuilder()
    {
        var builder = new StringBuilder();
        builder.Append(Phrase1);
        builder.Append(Separator);
        builder.Append(Phrase2);
        builder.Append(Separator);
        builder.Append(Phrase3);

        return builder.ToString();
    }
}

But, when we are doing many concatenations, the results are not as good.

Here is the benchmark I used

[MemoryDiagnoser]
public class SmallStringConcatenationBenchmarks
{
    private const string Phrase1 = "One";
    private const string Phrase2 = "Two";
    private const string Phrase3 = "Three";
    private const string Phrase4 = "Four";
    private const string Phrase5 = "Five";
    private const string Phrase6 = "Six";
    private const string Phrase7 = "Seven";
    private const string Phrase8 = "Eight";
    private const string Phrase9 = "Nine";
    private const string Phrase10 = "Ten";
    private const char Separator = ' ';

    [Benchmark(Baseline = true)]
    public string StringConcatenation()
    {
        var result = string.Empty;

        result += Phrase1;
        result += Separator;
        result += Phrase2;
        result += Separator;
        result += Phrase3;
        result += Separator;
        result += Phrase4;
        result += Separator;
        result += Phrase5;
        result += Separator;
        result += Phrase6;
        result += Separator;
        result += Phrase7;
        result += Separator;
        result += Phrase8;
        result += Separator;
        result += Phrase9;
        result += Separator;
        result += Phrase10;

        return result;
    }

    [Benchmark]
    public string StringConcatenationOneLine()
    {
        var result = Phrase1 + Separator
            + Phrase2 + Separator
            + Phrase3 + Separator
            + Phrase3 + Separator
            + Phrase4 + Separator
            + Phrase5 + Separator
            + Phrase6 + Separator
            + Phrase7 + Separator
            + Phrase8 + Separator
            + Phrase9 + Separator
            + Phrase10;

        return result;
    }

    [Benchmark]
    public string StringInterpolation()
    {
        var result = $"{Phrase1}{Separator}{Phrase2}{Separator}{Phrase3}{Separator}{Phrase4}{Separator}{Phrase5}{Separator}{Phrase6}{Separator}{Phrase7}{Separator}{Phrase8}{Separator}{Phrase9}{Separator}{Phrase10}";

        return result;
    }

    [Benchmark]
    public string StringBuilder()
    {
        var builder = new StringBuilder();
        builder.Append(Phrase1);
        builder.Append(Separator);
        builder.Append(Phrase2);
        builder.Append(Separator);
        builder.Append(Phrase3);
        builder.Append(Separator);
        builder.Append(Phrase4);
        builder.Append(Separator);
        builder.Append(Phrase5);
        builder.Append(Separator);
        builder.Append(Phrase6);
        builder.Append(Separator);
        builder.Append(Phrase7);
        builder.Append(Separator);
        builder.Append(Phrase8);
        builder.Append(Separator);
        builder.Append(Phrase9);
        builder.Append(Separator);
        builder.Append(Phrase10);

        return builder.ToString();
    }
}

[Piedone]

These would be great on a docs page BTW.

[MikeAlhayek]

maybe. I though a discussion would be nice so people can replay to each topic separately. These are all graph blog topics too :)

For now, I just want a single place where we can archive these performance benchmark so we can always visit them, search them and add to them. If someone used .ToList() for no good reason we can always say use .ToArray() instead and reference this discussion for more insights.

[Piedone]

For now, definitely, and good idea to have a discussion with threads. But to make them recommendations, I think eventually it should be part of the docs.