Multi-tenancy in ASP.NET MVC - Views

This is all very well and good as our requirements are quite clear, but the next step is making the above happen!

ASP.NET MVC provides the facility to override the View Engine, which is the component that determines how views are rendered.

This can be used to simply load views in from a different location, or even to allow completely bespoke mark-up to be transformed into HTML (Ala the Spark View Engine).

By default, the framework will use System.Web.Mvc.WebFormViewEngine, which is what loads the views from the View directory using the default convention and returns a ViewEngineResult containing a WebFormView which eventually ends up being used to render out the view.

The WebFormViewEngine class itself is extendable, and by inheriting from it we can change the search paths it uses to locate the views and partial views.

Naturally this is the first place we look to solve our problem, as writing less code is always preferable if we can get away with it.

The set-up of WebFormViewEngine is that in the constructor we  can give it a selection of search paths - which means for the life-time of WebFormViewEngine those search paths are set.

They can be modified per-request, but WebFormViewEngine inherits from VirtualPathProviderViewEngine which caches paths under which it has found files (or at least, reading the source it looks like it does!).

For performance purposes (per-configuration path caching), it would probably therefore be best implementing a ViewEngine from scratch, but as the main body of work is achieved through the return result of the  view engine methods, this is not as daunting an experience as we might think.

This is what IViewEngine looks like when we first create it:

    public class ModuleViewEngine : IViewEngine
    {
        public ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
        {
            throw new NotImplementedException();
        }

        public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
        {
            throw new NotImplementedException();
        }

        public void ReleaseView(ControllerContext controllerContext, IView view)
        {
            throw new NotImplementedException();
        }
    }

First things first, ReleaseView doesn't need to do anything unless the views you return implement IDisposable, and for that the following code can be used.

        public void ReleaseView(ControllerContext controllerContext, IView view)
        {
            IDisposable disposable = view as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }

The next thing of note is that the searching logic for locating the files is the same regardless of whether the engine is looking for a view or partial view, so we can create the following method and forget about it for now:

        private string ResolvePath(String requestedFile, ControllerContext controllerContext)
        {
            throw new NotImplementedException();
        }

FindPartialView and FindView both return the same type, and with similar values - I won't go into detail because the procedure is well documented elsewhere, but my methods in this example look like this:

        public ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
        {
            String foundFile = ResolvePath(string.Format("{0}.ascx", partialViewName), controllerContext);

            return new ViewEngineResult(
                new WebFormView(foundFile),
                this
            );       
        }

        public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
        {
            String foundFile = ResolvePath(string.Format("{0}.aspx", viewName), controllerContext);

            return new ViewEngineResult(
                 new WebFormView(
                     foundFile,
                     masterName),
                 this);
        }

Note: This example will not deal with absolute paths being specified, it will also not deal gracefully with the file not being found at all - this simply involves returning a list of the searched locations on failure and isn't worth discussing further here.

ResolvePath is entirely dependent on the logic you want to follow when searching for your per configuration module provided views, but a reference implementation might look like the following:

        private string ResolvePath(String requestedFile, ControllerContext controllerContext)
        {
            String result = string.Empty;

            // Reverse the module order so we search from most recently ordered first
            var searchModules = mConfigurationProvider
                .GetActiveConfiguration()
                .Modules
                .Reverse()
                .Select(m => m.Id);

            // Search through each module in turn
            foreach (String module in searchModules)
            {
                // Try the controller specific view folder first
                String controllerName = controllerContext.RouteData.Values["controller"] as string;
                result = GetFilename(requestedFile, controllerContext, module, controllerName);
                if (string.IsNullOrEmpty(result))
                {
                    result = GetFilename(requestedFile, controllerContext, module, "Shared");
                }
                if (!String.IsNullOrEmpty(result)) { return result; }
            }

            // Error!
            return null;
        }

        private string GetFilename(String requestedFile, ControllerContext controllerContext, String module, String controllerName)
        {
            String path = string.Format("~/Views/{0}/{1}/{2}/", module, controllerName, requestedFile);
            String filename = controllerContext.HttpContext.Server.MapPath(path);
            if (File.Exists(filename)) { return path; }
            return null;
        }