TitanFx.AspNetCore.Mvc.Templating 1.0.0-alpha-1

TitanFx ASP.NET Core MVC Templating

TitanFx ASP.NET Core MVC Templating is an extension library for ASP.NET Core designed to make the creation of templates easier. Rather than only supporting display and editor templates through the use of a view, as is the case for ASP.NET Core, this project allows templates to be injected during the setup of MVC through the use of the ITemplate interface.

Get Started

To set up your project to use the custom templating system, during the ConfigureServices method of your Startup class, you will need to add the following line

services.AddMvcTemplating();

If you wish to preserve the default templates and type discovery rules, use

services.AddMvcTemplating(legacyMode: true);
services.AddDefaultMvcTemplates();

After this, you may add any amount of custom templates to your application as follows

services.AddMvcTemplate<MyCustomTemplate>(TemplatePurposes.Edit, "MyCustomModel");

Creating custom templates

To create a custom template you need to implement the ITemplate interface. For the majority of cases however, the simpliest approach will be to inherit from CodeTemplate as this provides a much more useful IHtmlHelper instance to work with.

class MyCustomTemplate : CodeTemplate 
{
    protected override IHtmlContent Render(ITemplateService templateService, IHtmlHelper htmlHelper)
    {
        if (htmlHelper.Model is MyCustomModel model)
        {
            var builder = new TagBuilder("div");
            builder.InnerHtml.SetContent(model.Name);
            return builder;
        }

        return HtmlString.Empty;
    }
}

Template naming

When deciding which template to use, the Templating Service will need to compute a list of possible template names. It does this by browsing the interfaces and inheritance of the type of the model being used. For legacyMode: true this is done with the same rules as MVC out of the box. The default method, however, is more exhaustive and is split into 2 sections: type discovery and type name generation, each is described below.

For each template name produced by either system, a view is first looked for in the folder corresponding to the given purpose with the name generated. If none is found, then a template is searched for in the list of loaded implementations of ITemplate. If no templates are found either,

Type discovery

1. Browse the type stack (ModelType, ModelType.BaseType, ModelType.BaseType.BaseType, ....) excluding ValueType and Object.
2. Browse the interface list, ranked by complexity and then alphabetical, with most complex first. Complexity is the number of interfaces an interface implements. E.g. complexity of IEnumerable is 0, but complexity of IDictionary is 2 (ICollection and IEnumerable).
3. Finally yield ValueType if appropriate, and Object.

Type naming

For each type discovered above, if the type is not a generic type, simply yield type.Name. For generic types, first yield a recursively generated name, and then the name of the type with the generic arguments. Both names for generics are of the form {typeName}({parameterNames}) with parameterNames being a comma delimited list of the names for each generic parameter of the type.

For example:

• int becomes ["Int32"]
• Guid becomes ["Guid"]
• Dictionary<int, string> becomes ["Dictionary(Int32,String)","Dictionary(TKey,TValue)"]
• Dictionary<object, Tuple<long, Task<string>> becomes ["Dictionary(Object,Tuple(Int64,Task(String)))","Dictionary(TKey,TValue)"]