Creating a plain non-component class using a razor file - razor

Question

Is it possible to create a plain non-component class using a razor file? The idea is to take advantage of the simplified syntax for generating RenderFragments, from a class that is not intended to be a component or a page. e.g.
#inherits object
#code {
// some other stuff
public RenderFragment Foo => #<span class="foo"></span>;
public RenderFragment Render(string? name) => __builder =>
{
// some other stuff
<text>#name</text>
};
}
where the resulting class should be equivalent to:
public class Whatever /*: object*/
{
public RenderFragment Foo => __builder =>
{
__builder.OpenElement(0, "span");
// etc
};
public RenderFragment Render(string? name) => __builder =>
{
__builder.AddContent(0, name); // or whatever
};
}
Trying exactly the above results in the generated code reporting an error:
Whatever.BuildRenderTree(RenderTreeBuilder): no suitable method to override
which is not entirely surprising, since the generated code includes an override for that method, which of course does not exist in a plain class.
I was hoping that by not including anything outside of #code the compiler would not attempt to override that method, but sadly that does not appear to be the case. Is there some other trick that can make this work?

Answer 1

Revised Answer
Yes you can. You can create a minimum requirement class that the Razor compiler will accept.
It doesn't need to implement IComponent as there is no intention of using it as a component.
It needs a virtual BuildRenderTree(RenderTreeBuilder builder) method for the Razor compiler to override: it's where it compiles all the markup in the main block.
public abstract class MinRazor
{
protected virtual void BuildRenderTree(RenderTreeBuilder builder) {}
}
You're Razor file then inherits from it.
RenderStuff.razor
#inherits MinRazor
#code {
public string Message { get; set; } = "No one set me!";
public RenderFragment GiveMeADiv => __builder =>
{
<div class="p-2 m-2 bg-light">
<div class="p-2 m-2 bg-primary text-white">
#Message
</div>
</div>
};
}
The only baggage that the compiled code has is a blank BuildRenderTree(RenderTreeBuilder builder).
Here's the output file the compiler produces:
public partial class RenderStuff : MinRazor
{
protected override void BuildRenderTree(Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder __builder)
{
}
public string Message { get; set; } = "No one set me!";
public RenderFragment GiveMeADiv => __builder =>
{
__builder.OpenElement(0, "div");
__builder.AddAttribute(1, "class", "p-2 m-2 bg-light");
__builder.OpenElement(2, "div");
__builder.AddAttribute(3, "class", "p-2 m-2 bg-primary text-white");
__builder.AddContent(4, Message);
__builder.CloseElement();
__builder.CloseElement();
};
}

Answer 2

Your problem comes form #inherits object.
That does indeed make a "non-component class", but why?
Just leave that out and make your helpers static:
Whatever.razor
#inherits ComponentBase
#code {
// some other stuff
internal static RenderFragment Foo => #<span class="foo"></span>;
internal static RenderFragment Render(string? name) => __builder =>
{
// some other stuff
<text>#name</text>
};
}
And then you can use it like any static function:
#Whatever.Render("J Doe")

Answer 3

It appears that this is (currently at least) not possible; the closest working approach seems to be to implement it as a component anyway, but indicate that it is not intended to be used as such:
#code {
protected override void OnInitialized()
{
throw new NotSupportedException();
}
// some other stuff
public RenderFragment Foo => #<span class="foo"></span>;
public RenderFragment Render(string? name) => __builder =>
{
// some other stuff
<text>#name</text>
};
}
This unfortunately stills means that it will carry around some extra state baggage from inheriting ComponentBase, and it can't inherit any other (non-component) base class.
Making the render methods static and simply calling them from the "real" class as Henk Holterman suggests is probably the best compromise, although it would still need something like the OnInitialized override to discourage misuse.
Ideally you'd mark the static methods component as #internal too, to further reduce the scope of possible mis-use, but sadly that's not implemented yet.