Patch to implement Html.PartialAsync

[kobruleht]

Using @Html.PartialAsync in template causes error.

Add partial support using code like

  protected async Task<IHtmlstring> PartialAsync<T>(string viewName, T model)
        {
            // http://stackoverflow.com/questions/483091/render-a-view-as-a-string
            ViewData.Model = model;
            using (var sw = new StringWriter())
            {
                var viewResult = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
                var viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
                viewResult.View.Render(viewContext, sw);
                viewResult.ViewEngine.ReleaseView(ControllerContext, viewResult.View);
                return new Htmlstring  (sw.GetStringBuilder().ToString());
            }
        }

[adoconnection]

@kobruleht what kind of app you are building right now? (to understand your needs better)
the code you provided has is more about MVC rather the RazorEngine itself.

[kobruleht]

I'm building ASP.NET 5 MVC Shopping cart + ERP application.

RazorEngineCore.Extension is used to inject Razor code from database into application razor views:

        public async Task<string> RenderAsync<TModel>(string template, TModel model, ITempDataDictionary tempData) 
        {
            int templateHashCode = template.GetHashCode();
            if (!templateCache.TryGetValue(templateHashCode, out object vaart))
            {
                vaart = await CompileTempate<TModel>(template);
                templateCache.TryAdd(templateHashCode, vaart);
            }

            var compiledTemplate = (IRazorEngineCompiledTemplate<MyRazorEngineCorePageModel<TModel>>) vaart;
                return await compiledTemplate.RunAsync(instance =>
                {
                    instance.Model = model;
                    instance.TempData = tempData;
                    instance.HttpContext = httpContextAccessor.HttpContext;
                });
        }

        async Task<IRazorEngineCompiledTemplate<MyRazorEngineCorePageModel<TModel2>>> CompileTempate<TModel2>(string template)
        {
            var razorEngine = new RazorEngine();
                var compiledTemplateLocal = await razorEngine.CompileAsync<MyRazorEngineCorePageModel<TModel2>>(template, builder =>
                {
                    builder.AddAssemblyReference(typeof(RazorEngineCorePageModel));
                    builder.AddAssemblyReference(typeof(ITempDataDictionary));
                    builder.AddAssemblyReference(typeof(MyScaffoldContext));
                    builder.AddAssemblyReference(typeof(DbContext));
                });
                return compiledTemplateLocal;
        }

    public abstract class MyRazorEngineCorePageModel<T> : RazorEngineCorePageModel, IRazorEngineTemplate
    {
        public ITempDataDictionary TempData;
        public HttpContext HttpContext;
    }

[adoconnection]

Why dont you use Razor that comes together with MVC?

[kobruleht]

MVC does not allow to use templates from database. Those templates are created buy application users and needs rendered runtime, for example to create new shipping methods in shopping cart.

[wdcossey]

As per my comment here, I'll have a look and see what I can do 😃

[kobruleht]

Thank you. It should be async version, @Html.PartialAsync since sync version causes locks and will removed from .NET 6

[wdcossey]

I would have no issues adding asynchronous support but there will need to be changes added to the base project, template writing currently only supports synchronous writing (see here).

I will make the changes and raise a PR.

[kobruleht]

I posted it in adoconnection/RazorEngineCore#48

[wdcossey]

@kobruleht

I have implemented the following:

@Html.Partial("Partial", new { Name = "Partial Template"})

@(await Html.PartialAsync("Partial", new { Name = "Partial Template"}))

/* Note that the second parameter (model) is optional and will pass through the parent model if not specified */
@(await Html.PartialAsync("Partial"))

I originally had plans for Html.PartialAsync(Func<string> func, ...), unfortunately Func<> is not supported :/

I have added a basic PartialViewsManager (it's the name I came up with at the time) to manage the Partial views used by the extensions.
PartialViewsManager is a static class that implements a ConcurrentDictionary<string, Lazy<...>>, you can define your partials views before using .RunAsync(...)

In a nutshell, you can so the following.

// setup
PartialViewsManager.TryAdd("Body", SampleApp.Content.BodyContent);
PartialViewsManager.TryAdd("Partial", SampleApp.Content.PartialContent);

Primary template:

<!DOCTYPE html>
<html lang="en">
<body>
    @(await Html.PartialAsync("Body"), new { Name = "Body"})
</body>
</html>

Body template:

<div>
    <main>
        Hello <b>@Model.Name</b>
        @(await Html.PartialAsync("Partial", new { Name = "Partial Template"}))
    </main>
</div>

Additional template:

Hello <b>@Model.Name</b>

This will render:

<!DOCTYPE html>
<html lang="en">
<body>
<div>
    <main>
        Hello <b>Body</b>
        Hello <b>Partial Template</b>
    </main>
</div>
</body>
</html>

[kobruleht]

Will it allow to use existing, pre-compiled views in applicaton, without using PartialViewsManager ?

@await Html.ParialAsync("_PartialName")

should find view in Views/Shared directory without additional settings required. In .NET 4 Antalis RazoreEngine does not have view manager. Not sure is view manager required.

[wdcossey]

@kobruleht

I am still looking into this, I will get to it later this evening (UK time here).
I did forget about pre-compiled partials/views but will ensure they work as expected.

It's worth noting that RazorEngineCore is NOT AspNetCore so things do behave differently (as I am sure you are aware), there's no mechanism to find templates as you would have in AspNetCore.
It's possible to implement some rudimentary finder/lookup mechanism if you are going to use .cshtml templates from a Content resource (rather than strings) which would be better IMHO.

Making changes to the main repo owned by adoconnection would be simpler but I think he's against the whole Partial views thing (in his project), I have to make workarounds here to compensate for what I think is lacking (hence why this project exists).
I am limited in options when it comes to extending RazorEngineCore w/o forking the entire project and creating another package (which there's a bunch [of broken ones] already on NuGet).

That all said, I will happily get something working and you are most welcome to add input, make requests and/or raise PRs for anything you need.

[kobruleht]

Code and SO link which I posted in this issue finds pre-compiled views by name and renders it as string:

var viewResult = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
var viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
 viewResult.View.Render(viewContext, sw);
viewResult.ViewEngine.ReleaseView(ControllerContext, viewResult.View);
return new Htmlstring  (sw.GetStringBuilder().ToString());

HtmlPartialAsync should run this code and return result string.

If application is published, there are no .cshtml files. Only compiled assemblies are published.
Builtin views contain @inject commands which are not supported in RazorEngineExtensions. So those cannot compiled.
Since compiled code can used there is no reason to add cshtml files as resources.

Maybe it is possible to leave RazorEngineCore without MVC and dependency injection like author prefers and implement MVC specific thinga like Html.PartialAsync and @inject in your project using template base class.
In this case using MVC application willl require two packages included.

[wdcossey]

I am implementing the following.

RazorEngineCoreCompiler.MSBuild.Tasks (this replaces the old RazorEngineCore.Precompiler which never really worked)

• This is a build task that will run when building your project.
• It will scan the Pages directory where your .csproj file is located, get all the .cshtml files and compile them.
• These (pre)compiled templates will then be added as an embedded resource (to the project and thus output assembly).

To use the embedded templates should be as simple as.

var resourceTemplate = await PrecompiledTemplate.LoadAsync("Template", Assembly.GetExecutingAssembly());
await resourceTemplate.RunAsync(model: model);

These precompiled templates can have @Html.PartialAsync() (or @Html.Partial()), scanning for precompiled templates will be against the EntryAssembly (for now).

There's a bunch of things that still need to be optimised but here's a basic benchmark (Runtime vs Precompiled) of rendering templates

Results of 10 runs |
        Runtime    | total: 00:00:01.0446029; average: 00:00:00.1044602
        Precompile | total: 00:00:00.2078749; average: 00:00:00.0207874