The resulting rendering template for a requested content instance is selected based on page or partial renderers, tags and active display channels.
The examples are based on MVC.
A page or a block can have multiple associated templates; for example, one for a web channel and one for a mobile device. Pages can also have a **partial template** used when the page is displayed inside the content area of another page. See [Rendering](🔗) and [TemplateDescriptor and tags](🔗).
If you register multiple templates, the `
TemplateResolver` service selects the resulting rendering template using an algorithm based on content model, template types, rendering mode (page or partial rendering), tags, and inheritance. If needed, you can use _events_ to override the `
A default `
TemplateResolver` implementation selects templates based on the procedure below.
EPiServer.Web.TemplateResolver.TemplateResolving` **event** is raised. If an event handler selects a template, that template is used with no further handling.
All templates matching the desired **content type** are filtered according to the rendering mode**:** If t is a _page_, a suitable _controller_ is selected; if it is _partial rendering_, a suitable _partial controller_ or _partial view_ is selected. For partial templates, the list is filtered according to main template.
If the template is requested with a specific **tag**, the list is filtered on that tag. If no template matching the tag exists, all templates from 2 are taken into account.
If any **display channel** is active, and there are template tags matching that channel, templates are filtered for `
From remaining templates, the **shortest inheritance chain** to the `
TemplateModel` marked as **Default** and **not inherited,** is selected.
If no match from 5, the **shortest inheritance chain** to `
TemplateModel` that is marked as **Default,** is selected.
If no match from 6, the **shortest inheritance chain** to `
TemplateModel`, is selected.
EPiServer.Web.TemplateResolver.TemplateResolved` **event** is raised, providing a chance to replace the selected template.
The shortest inheritance chain means that a template that is registered **directly for the content model type** is preferred before a template registered for a base class or interface. For interfaces, the length of the inheritance chain is defined by following the inheritance chain upwards to see where the interface is implemented.
The following examples assume that you have a content model and are using multiple rendering templates for different display channels. See [Content](🔗), [Rendering](🔗), and [Display channels](🔗) for more information.
### Select page rendering
The template selected to render a content instance depends on the specific context such as channel and tagging. For a template to be automatically registered for rendering, it has to implement `
EPiServer.Web.IRenderTemplate<T>` (where T states which model it can render). If you use a **base class** like `
PageController<T>` or `
BlockComponent<T>` for your templates, you do not need to explicitly implement the interface. In addition, you can use the `
TemplateDescriptorAttribute` to specify more details about the template such as tags and inheritance. See [TemplateDescriptor and tags](🔗).
**Example:** A content type model is defined as shown below.
Given that there are templates defined as follows:
All of the above templates are registered as templates for **MyPage**. You can register a template for both a base type and an interface (`
MyFallbackController` and `
PageTeaser` in the code sample), which are registered for `
PageData`, not the specific type). If you want the template to be available for **all** subtypes, for example if you want to have a **fallback **template for content types without a specific template, set Inherited=true for the `
For the example above, a browser request for a page of the type _MyPage_ will result in the following:
If **no** `
DisplayChannel` is active, the _MyPageTemplate_ template is selected because no tag is active (disqualifies `
MyPageMobileTemplate`), and `
MyPageTemplate` has shorter inheritance chain than `
MyPageTeaser` and `
PageTeaser` are partial renderers and are filtered away.
If a `
DisplayChannel` named _Mobile_ is active, the _MyPageMobileTemplate_ template is selected, since templates that have a tag matching active channels are preferred.
### Select block rendering
Blocks can be either a property on a page, or a shared block instance in a content area. The selection of a template for a block is similar to the selection of a page template, except that blocks can only be rendered in the context of a page template. Rendering of blocks is done using partial views or view components. When rendering a block in a page template, you can use tags to define how the block should be rendered.
**Example:** Templates defined for a _MyBlock_ block type.
You can also use a **tag **to define rendering in a specific area such as a _Sidebar_ in a page template:
See [TemplateDescriptor and tags](🔗) for more information on how to apply tags.
### Block layout in a content area
If you specify a tag for a content area, then content added to that area will use a template matching that tag. You can use **display options** to let editors define the layout of a block in a content area, from edit view. See [Display options](🔗).