Global helpers perf considerations

[lonix1]

Hi again @adams85.... I'd like to ask your opinion on a perf-related issue?

As I mentioned in #8, your solution for "global helpers", also implemented in this repo, is outstanding. As I noted in a comment there, I added a new feature request to the aspnetcore repo - maybe they'll change their mind and give us App_Code or something similar.

Until then we use your solution heavily. It works magnificently.

The problem is it's really complicated, so we treat it as a black box, which "just works". There are many snippets which we need all over the place, so instead of injecting the helpers class into various views, we decided to just keep it simple and inject it into _ViewImports.cshtml so it's available everywhere.

But that means exactly that - it's injected everwhere, in every view, in (almost) every partial.

Given that you know how it works, do you think that may be too "heavy"? I'm not asking for hard perf benchmarks, just a common-sensical opinion.

How do you typically do it?

[adams85]

Hi there,

GlobalRazorHelpers<> is a transient service, so an instance is created and the corresponding Razor view is looked up and activated each time a page injecting it is rendered. (ASP.NET uses a cache for lookup though.)

So it definitely doesn't come free, some garbage is produced, but without doing some profiling it's very hard to tell how much compared to the garbage produced by ASP.NET normally. I think it should be in the same ballpark as rendering partial views (since the steps required for that are very similar). So I don't think it's very heavy, but this is more like a guess.

Anyway, injecting GlobalRazorHelpers<> into _ViewImports.cshtml doesn't sound like a good idea (if only because it could lead to an endless recursion if _ViewImports.cshtml applies to the helper view) unless if it's actually used in the vast majority of your pages. In that case obviously there's little difference between injecting it into _ViewImports.cshtml and injecting it directly into the pages that use it.

[lonix1]

in the same ballpark as rendering partial views

I had the same thought... and we use lots of partials (especially due to HTMX).

The bit about recursion is an important gotcha which I didn't consider, but I suppose one could use @{ Layout = null; } in the global helpers file.

Another option is to inject into a custom PageModel, but that becomes messy (I plan to tinker with such a setup using Autofac so it can be done via property injection in an abstract base class).

Out of interest, is it possible to register IGlobalRazorHelpers as a singleton instead? Might be a silly question but as I mentioned I'm unsure how the beast works. My suspicion is no because it looks like a (open generic) wrapper for each globals file, so the Instance property would get clobbered. Just want to be sure.

[adams85]

Out of interest, is it possible to register IGlobalRazorHelpers as a singleton instead?

No, that would defeat its purpose. It's just a wrapper around the looked up and activated Razor view containing the helpers.

However, you can try something like:

public abstract class ExtendedPage : Page
{
    [RazorInject]
    public required IGlobalRazorHelpersFactory RazorHelpersFactory { get; init; }

    private IMyGlobalHelpers? _helpers;

    public IMyGlobalHelpers MyGlobalHelpers => _helpers ??= RazorHelpersFactory.Create<IMyGlobalHelpers>(ViewContext);
}

Then in your pages or _ViewImports.cshtml:

@inherits ExtendedPage

I haven't tested it but, in theory, this way the lookup and activation of the helpers' Razor view happens only when the helpers are actually accessed.

But again, the heavy part is still RazorHelpersFactory.Create...