This is a second post in a series of articles about Masonry starter kit. Please refer to this article in order to get more information about Masonry:
Masonry starter kit was designed with extensibility in mind from the very beginning. There are several out-of-box blocks that greatly reduce learning curve and efforts required to extend main navigation elements like sidebar and header bar, provide custom content and routing, integrate into help or search system or messaging pipeline.
Masonry is also shipped with a project template for Visual Studio 2012 that turns the process of extension library creation into a several mouse-click procedure.
Part 1 of this article will give a high-level overview of supported extensibility features as well as developer tools shipped with version 1.0
Part 2 will dwell on technical details of extension discovery, processing and mapping of dynamic/static content and UI composition.
Extensions in Masonry are based on Areas that are compiled into a single-assembly libraries and deployed to Masonry-based web application by means of xcopy. For more details on Areas in ASP.NET MVC please refer to the following articles:
Every Masonry extension depends on the following assemblies:
- Masonry.Core.dll (required); contains low-level infrastructure required by Masonry and 3rd party extensions in order to function.
- Masonry.Extensibility.dll (required); contains shared blocks that may be used by all or any 3rd party extension. For the moment of writing this article it consists mainly of UI-relacted contracts.
- Masonry.Resources.dll (optional); contains default localized content that may be reused within extensions
Masonry does not require extra efforts in order to enable extensibility support for a web application, referencing “Masonry.Core” is usually enough to automatically enable underlying infrastructure.
There are two different modes supported by Masonry out-of-box: automatic (or convention-based) and controlled (or configuration-based) extension discovery.
Automatic extension discovery
This is the default mode and requires zero coding efforts besides referencing “Masonry.Core” assembly from within your Masonry-based web application.
Prior to web application startup the following workflow is executed automatically:
- Underlying extensibility engine is initialized and started
- All assemblies are discovered by “*.Extension.dll” mask and loaded
- Custom ASP.NET MVC view and content providers (Masonry-specific) are initialized and wired with the extension libraries if loaded with previous step
With automatic discovery mode every 3rd party extension library must follow the following predefined conventions in order to allow resulting assembly to be discovered and loaded:
- Extension assembly file name should end with “.Extension.dll“
- Default root namespace for the extension assembly should not end with “Extension” word
The process of configuring assembly file name and namespace for a new extension project is pretty simple. For example in order to configure a “Dummy” extension developer may need performing the following steps:
- Create a .NET class library project named “Dummy” and navigate to project properties pane
- Ensure “Default namespace” property is set to “Dummy”
- Change “Assembly name” property from “Dummy” to “Dummy.Extension”
Note: steps above can be omitted when using “Masonry Extension” project template for Visual Studio 2012 shipped with Masonry kit out-of-box. More details regarding project template will be given further in this article.
Controlled extension discovery
Due to security, performance, additional level of extension management and review, or any other reasons it is possible switching off automatic discovery for 3rd party extensions and defining them explicitly within configuration file (web.config) instead.
The following picture demonstrates registration of “Dummy” widget within configuration file:
In this case the following workflow will be executed prior to web application startup:
- Underlying extensibility engine is initialized and started
- All assemblies from configuration file are discovered and loaded
- Custom ASP.NET MVC view and content providers (Masonry-specific) are initialized and wired with the extension libraries loaded during previous step
The are no file and namespace naming conventions for configuration-based mode (as it is possible defining corresponding values within configuration file as well).
Extension project template
In order to greatly simplify development process and reduce amount of efforts and time needed to create and configure a new extension library Masonry is shipped with a special project template for Visual Studio 2012.
Important note: for version 1.0 the resulting project should reside within “Extensions” subfolder of the project like displayed on the picture. This is required in order to automate configuration of assembly references and Nuget packages for a newly created project.
Project template handles and automates development process by executing the following operations:
- Creates new class library within “Extensions” subfolder
- Configures all Masonry-related assembly references, wires project with required and/or optional Nuget packages
- Enables Razor support for newly created project (code highlighting, intellisense, compilation, etc.)
- Creates initial file structure that conforms to common ASP.NET MVC Areas design
- Generates “Area Registration” settings for the given project including default route registration
- Generates set of files that address basic extensibility scenarios, for example sidebar and header bar extensions, grouping, default “main content” and “about” pages, etc.
- All generated files and automated settings take into account name of project
So upon creating a new project with this template you get a working Masonry Extension library that is ready to be instantly compiled and deployed to main web application.
By default Masonry also provides and embedded demo extension called “Dummy” that reuses most of the extensibility features:
The file structure of the project when using Masonry Extension project template will be nearly the same except the name of the area registration class, all code namespaces and all UI labels/names will be reflecting the name of the project you have defined at the creation stage. This means that multiple extensions created from the same template won’t conflict.
Here’s for example the content of the Area Registration file that was automatically generated for the “MyExtension1” project:
And image below provides a quick example on a sidebar extension element generated automatically and aligned with your project name and settings:
Needless to say that resulting project can be tuned in any way. Visual Studio template just takes care of the most frequent, repetitive and so time-consuming tasks.
Compiling and deploying extensions
Every class library created with “Masonry Extension” project template can be instantly compiled and deployed to a Masonry-based web application without any modifications.
As a result of successful compilation you will be getting a single assembly file with all the features and content required by extension.
Besides changing build action to “Embedded Resource” developers need performing no actions. Picture below demonstrates the default set of files delivered by Masonry Extension project template as embedded resources:
Deploying compiled extensions has no special requirements or prerequisites. Resulting “.dll” file can be copied into the binaries folder of the target Masonry-based web application. Optionally you can drop debugging information (.pdb files) to enable debugging of deployed extensions and stepping through the code:
Note: when using “controlled discovery mode” you may need defining a new configuration entry upon deploying your extension to the target web application.
Upon execution and extension discovery Masonry will automatically populate sidebar, header bar and other extensible UI areas with corresponding elements. Every action (link) will point to custom extension-provided content.
This is the end of basic overview of extensibility in Masonry. In the second part I will be giving more information about areas that support extensibility in Masonry, classes and contracts that may be utilized when writing custom extensions, technical details on embedded resources and the process of mapping them at run time, and a lot more…