Hidden template functionality in the MVC implementation

There is an alternative way of rendering content when using MVC. By implementing IRenderTemplate<T> and IView, the class will be registered as a render template for type (T).

Short before the RTM release of EPiServer 7, we found out that a block controller is very slow, and should be used carefully. We have, because of this, recommended partner developers to only use a view without a controller for blocks on their sites. The sad part of this is that it’s not possible to create view models of the blocks.

When you have patch 3 on your site, you can implement IView on a class, which automatically will register it as a render template, if the generic marker interface “IRenderTemplate” gets implemented by the same class. This makes it possible to create view models and use those instead of the actual “BlockData”. Because of a bug, the “IView” rendering template hasn’t worked before patch 3, so make sure to download patch 3 to your site.

Ok, so how does the “IVew” interface look like now again. Well, you get two parameters, “ViewContext” and a “TextWriter”. The view context should be used to render data on the text writer. Hm, not much help from EPiServer here it looks like.

I have created a base class, which looks pretty similar to a controller, that can be used. The class looks like this:

using EPiServer.Core;
using EPiServer.Web;
using EPiServer.Web.Routing;
using System;
using System.Globalization;
using System.IO;
using System.Web.Mvc;

namespace EPiServer.Samples.MvcTemplates.Controllers
{
    /// <summary>
    /// Base class for render template of type <see cref="IView"/>.
    /// </summary>
    /// <typeparam name="T">The <see cref="IContentData"/> this renderer should support.</typeparam>
    public abstract class ViewRenderTemplate<T> : IView, IRenderTemplate<T> where T : class, IContentData
    {
        /// <summary>
        /// Gets the default view name. "index" will be used when not overridden.
        /// </summary>
        protected virtual string DefaultViewName
        {
            get { return "index"; }
        }

        /// <summary>
        /// Gets the current view context
        /// </summary>
        protected ViewContext ViewContext { get; private set; }

        /// <summary>
        /// Gets the current writer
        /// </summary>
        protected TextWriter Writer { get; private set; }

        /// <summary>
        /// Called when the template will be executed
        /// </summary>
        /// <param name="viewContext">The current view context</param>
        /// <param name="writer">The current writer</param>
        public virtual void Render(ViewContext viewContext, TextWriter writer)
        {
            ViewContext = viewContext;
            Writer = writer;

            var currentContent = ViewContext.RequestContext.GetRoutedData<T>();
            if (currentContent == default(T))
            {
                currentContent = viewContext.RouteData.Values["currentContent"] as T;
            }

            ViewContext.RequestContext.SetController(currentContent.GetOriginalType().Name);
            Render(currentContent);
        }

        /// <summary>
        /// Called when the template will be executed
        /// </summary>
        /// <param name="currentContent">The current <see cref="IContentData"/></param>
        protected abstract void Render(T currentContent);

        /// <summary>
        /// Calls the default view with the <param name="model">view model</param>.
        /// </summary>
        /// <param name="model">The view model</param>
        protected virtual void RenderView(object model)
        {
            RenderView(DefaultViewName, model);
        }

        /// <summary>
        /// Calls the <param name="viewName">view</param> view with the <param name="model">view model</param>.
        /// </summary>
        /// <param name="viewName">The view name</param>
        /// <param name="model">The view model</param>
        protected virtual void RenderView(string viewName, object model)
        {
            RenderView(viewName, null, model);
        }

        /// <summary>
        /// Calls the <param name="viewName">view</param> view with the <param name="model">view model</param>.
        /// </summary>
        /// <param name="viewName">The view name</param>
        /// <param name="masterName">The master name. Default master will be used when set to 'null'.</param>
        /// <param name="model">The view model</param>
        protected virtual void RenderView(string viewName, string masterName, object model)
        {
            var result = GetViewEngineResult(viewName, masterName);
            RenderView(model, result, viewName);
        }

        /// <summary>
        /// Calls the default partial view with the <param name="model">view model</param>.
        /// </summary>
        /// <param name="model">The view model</param>
        protected virtual void RenderPartialView(object model)
        {
            RenderPartialView(DefaultViewName, model);
        }

        /// <summary>
        /// Calls the <param name="viewName">partial view</param> view with the <param name="model">view model</param>.
        /// </summary>
        /// <param name="viewName">The view name</param>
        /// <param name="model">The view model</param>
        protected virtual void RenderPartialView(string viewName, object model)
        {
            var result = GetPartialViewEngineResult(viewName);
            RenderView(model, result, viewName);
        }

        private void RenderView(object model, ViewEngineResult result, string viewName)
        {
            if (result.View == null)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "The view '{0}' or its master was not found or no view engine supports the searched locations.", viewName));
            }

            ViewContext.ViewData.Model = model;
            result.View.Render(ViewContext, Writer);
        }

        private ViewEngineResult GetPartialViewEngineResult(string viewName)
        {
            return ViewEngines.Engines.FindPartialView(ViewContext, viewName);
        }

        private ViewEngineResult GetViewEngineResult(string viewName, string masterName)
        {
            return ViewEngines.Engines.FindView(ViewContext, viewName, masterName);
        }
    }
}

Now, we can simple use this base class like this:

using EPiServer.Framework.DataAnnotations;
using EPiServer.Templates.Alloy.Models.Blocks;

namespace EPiServer.Samples
{
    [TemplateDescriptor(Default = true, Tags = new[]{"myTag"}, AvailableWithoutTag = true)]
    public class TestBlockDemoController : ViewRenderTemplate<TestBlock>
    {
        protected override void Render(TestBlock currentContent)
        {
            RenderPartialView(currentContent);
        }
    }
}