Glavs Blog

ScriptHelper now a Nuget package, and managing your Javascript

Glav — Sat, 21 Jan 2012 03:45:54 GMT

For a while now I have been looking at different ways of managing javascript inclusion in web pages, and also managing the dependencies that each script inclusion requires. Furthermore, working with ASP.NET MVC and partial views, working with the ever increasing number of dependencies as well as ensuring that each partial view has the script it requires, can be a little challenging. At the very least messy and tedious.

Ideally, I’d like every page or partial view to be able to express what scripts it requires and let the framework care about removing duplication, minification etc.

So, after looking at the needs of our application, as well as the needs of others I developed the ScriptHelper component which is now available as a Nuget package. I had released an initial version some time ago, details are here.

This latest version has the following features:

Support for RequiresScriptsDeferred and RenderDeferred methods to allow you to specify script requirements as many times as you like, where ever you like and to have these requirements only rendered to the page when the RenderDeferred method is called. This makes it easy to include the RenderDeferred at the bottom of your master page so all deferred scripts are rendered then. These scripts can be minified and combined at this time as well.

So you can do:

@ScriptDependencyExtension.ScriptHelper.RequiresScriptsDeferred("jQuery")

and maybe somewhere else in the page or in another partial view

@ScriptDependencyExtension.ScriptHelper.RequiresScriptsDeferred("jQuery-validate-unobtrusive")

@ScriptDependencyExtension.ScriptHelper.RequiresScriptsDeferred("SomeOtherScripts")

Then when the:

@ScriptDependencyExtension.ScriptHelper.RenderDeferredScripts()

is called, all the previously deferred scripts are combined, minified and rendered as one single file inclusion

Support for .Less so you can have variables and functions in your CSS. No need to use a .less extension as .Less is automatically invoked if it is enabled for the first time it is required.

Note: Although the project source is titled as an MVC script helper, it can also be used within Webforms without issue as it is a simple static method with no reliance on anything from MVC. I just happened to start coding it with an MVC project in mind.

Additionally, the helper fully supports CSS and .less CSS semantics and syntax.

There are other frameworks that do similar things but I created this one for a few reasons:

The code is pretty small and simple. Very easy to modify and extend to suit your own purposes. It currently uses the Microsoft Ajax minifier. If you dont like it, implement the “IScriptProcessingFilter” and replace the current minifier component with your own.
I liked the ability to express dependencies explicitly. The number of JS libraries to use grows every day and it can get tricky in large apps to easily see what is required and needed.
I didn’t find one that easily implemented the deferred loading scenario, took care of duplicates, and minification, and .less support. Maybe there is now, but I got started on it anyway. Or maybe there is one, but the implementation looked ugly. Either way, I wasn’t satisfied with the current offerings.
I like coding stuff

Download the Nuget package from here.

Download the source from here.

For full documentation on ScriptHelper (minus the new features here), see this post.

A ReadMe.txt file is included in the package with all configuration details.

But .Net 4.5 will include a bundling facility to address some this. Why would I use this?

See Scott Gu’s blog post for more info on this feature.

Well of course you don't have to and if you were happy with the default way bundling works, it is probably worth sticking with that. I mean, you don’t want to include extra libraries if you don’t have to.

However the bundling supports expressing dependencies programmatically in code. it is ok, but I prefer the XML file. Easier to read and define IMO. Sure the code isn’t that hard to read, but it could be anywhere and takes a bit more analysis to see all of the dependencies any one component may need.

There is no support for .less files out of the box. I am sure this wont be far off as adding .less support is pretty trivial. However it is not in there by default.

Bundling will include what you tell it to when you tell it to. This is good, but I love the idea of views or pages being able to express their dependencies without worry of script duplication. The deferred script loading feature of the ScriptHelper was one of my main reasons for developing this. If you don’t use deferred script loading/inclusion, then ScriptHelper will assume you know what you are doing and include the script file immediately as per bundling.

The bundling feature will use .Net 4.5. If you are bound to lower versions of the framework, this is a blocker. ScriptHelper is compiled against .Net 4, however there is nothing that really relies on .Net 4 specifics. If you were targeting .Net 1, it could prove a little tricky as generics are used and a few other features, but migrating/compiling against lower versions should not be very hard.

Managing your Javascript

So how does this help manage your javascript in your projects?

PartialViews

Normally partial views, other pages either rely on a knowledge of what is included via the master page and what is also included on the content page itself in terms of scripts. A partial view may include its own scripts, provided that script is not included elsewhere to prevent duplicate script files being loaded.

Using ScriptHelper and DeferredScripts your partial view can include anything all its dependencies. So the partial view can use the “RequiresScriptsDeferred” method to express its dependencies. At some point in time, typically at the bottom of your master page/layout, you will call the “RenderDeferredScripts” where all the required scripts are rendered. Typically this is also used with script combination and minification so that only 1 include is rendered. All duplicate inclusions are ignored, all files are combined, minified, and .less filter is run over it if required. A single script include is generated and your done. If the master page/layout has already expressed dependencies (such as jQuery for example) and the partial view also expresses this dependencies, it is ignored.

This means each partial view, component or page can express all its dependencies that it requires without fear of duplication.

Script Dependencies

The way ScriptHelper works is by using a friendly name to group one or more script files together in the ScriptDependencies.xml file. The way this is all grouped is up to you. You can group by component (jQuery, validation, etc…) or even by page or anything else. There only needs to be 1 reference to the explicit name of your script, everything else is by friendly name so when a version number of a script changes, potentially changing the name of the script file, you only need to change the name of the file in one place.

In addition, the dependencies for scripts in the XML file are listed explicitly. There is no guesswork as to what script require what in terms of dependencies since it is listed for easy identification.

Finally, if you like having version identifiers on your query strings to assist with browser caching, this can also be expressed in the ScriptDependencies.xml file. This means you can have a script with http://host/script.js?v=123 where the v=123 is the version identifier. The ‘v’ and the ‘123’ are all declared in the XML file which is easily updated manually or via a build script.

So if you find yourself in Javascript inclusion and dependency hell, give this library a shot, it may help.

My Code Kata–A Solution Kata

Glav — Sun, 13 Nov 2011 03:53:56 GMT

There are many developers and coders out there who like to do code Kata’s to keep their coding ability up to scratch and to practice their skills. I think it is a good idea.

While I like the concept, I find them dead boring and of minimal purpose. Yes, they serve to hone your skills but that’s about it. They are often quite abstract, in that they usually focus on a small problem set requiring specific solutions. It is fair enough as that is how they are designed but again, I find them quite boring.

What I personally like to do is go for something a little larger and a little more fun. It takes a little more time and is not as easily executed as a kata though, but it services the same purposes from a practice perspective and allows me to continue to solve some problems that are not directly part of the initial goal. This means I can cover a broader learning range and have a bit more fun. If I am lucky, sometimes they even end up being useful tools.

With that in mind, I thought I’d share my current ‘kata’. It is not really a code kata as it is too big. I prefer to think of it as a ‘solution kata’.

The code is on bitbucket here.

What I wanted to do was create a kind of simplistic virtual world where I can create a player, or a class, stuff it into the world, and see if it survives, and can navigate its way to the exit.

Requirements were pretty simple:

Must be able to define a map to describe the world using simple X,Y co-ordinates. Z co-ordinates as well if you feel like getting clever.
Should have the concept of entrances, exists, solid blocks, and potentially other materials (again if you want to get clever).
A coder should be able to easily write a class which will act as an inhabitant of the world.
An inhabitant will receive stimulus from the world in the form of surrounding environment and be able to make a decision on action which it passes back to the ‘world’ for processing.
At a minimum, an inhabitant will have sight and speed characteristics which determine how far they can ‘see’ in the world, and how fast they can move.
Coders who write a really bad ‘inhabitant’ should not adversely affect the rest of world.
Should allow multiple inhabitants in the world.

So that was the solution I set out to act as a practice solution and a little bit of fun. It had some interesting problems to solve and I figured, if it turned out ok, I could potentially use this as a ‘developer test’ for interviews. Ask a potential coder to write a class for an inhabitant. Show the coder the map they will navigate, but also mention that we will use their code to navigate a map they have not yet seen and a little more complex.

I have been playing with solution for a short time now and have it working in basic concepts. Below is a screen shot using a very basic console visualiser that shows the map, boundaries, blocks, entrance, exit and players/inhabitants.

The yellow asterisks ‘*’ are the players, green ‘O’ the entrance, purple ‘^’ the exit, maroon/browny ‘#’ are solid blocks.

The players can move around at different speeds, knock into each others, and make directional movement decisions based on what they see and who is around them. It has been quite fun to write and it is also quite fun to develop different players to inject into the world.

The code below shows a really simple implementation of an inhabitant that can work out what to do based on stimulus from the world. It is pretty simple and just tries to move in some direction if there is nothing blocking the path.

public class TestPlayer:LivingEntity
{
    public TestPlayer()
    {
        Name = "Beta Boy";
        LifeKey = Guid.NewGuid();
    }
    public override ActionResult DecideActionToPerform(EcoDev.Core.Common.Actions.ActionContext actionContext)
    {
        try
        {
            var action = new MovementAction();

            // move forward if we can
            if (actionContext.Position.ForwardFacingPositions.Length > 0)
            {
                if (CheckAccessibilityOfMapBlock(actionContext.Position.ForwardFacingPositions[0]))
                {
                    action.DirectionToMove = MovementDirection.Forward;
                    return action;
                }
            }
            if (actionContext.Position.LeftFacingPositions.Length > 0)
            {
                if (CheckAccessibilityOfMapBlock(actionContext.Position.LeftFacingPositions[0]))
                {
                    action.DirectionToMove = MovementDirection.Left;
                    return action;
                }
            }
            if (actionContext.Position.RearFacingPositions.Length > 0)
            {
                if (CheckAccessibilityOfMapBlock(actionContext.Position.RearFacingPositions[0]))
                {
                    action.DirectionToMove = MovementDirection.Back;
                    return action;
                }
            }
            if (actionContext.Position.RightFacingPositions.Length > 0)
            {
                if (CheckAccessibilityOfMapBlock(actionContext.Position.RightFacingPositions[0]))
                {
                    action.DirectionToMove = MovementDirection.Right;
                    return action;
                }
            }

            return action;
        }
        catch (Exception ex)
        {
            World.WriteDebugInformation("Player: "+ Name, string.Format("Player Generated exception: {0}",ex.Message));
            throw ex;
        }
    }

    private bool CheckAccessibilityOfMapBlock(MapBlock block)
    {
        if (block == null || block.Accessibility == MapBlockAccessibility.AllowEntry || block.Accessibility == MapBlockAccessibility.AllowExit || block.Accessibility == MapBlockAccessibility.AllowPotentialEntry)
        {
            return true;
        }
        return false;
    }

}

It is simple and it seems to work well. The world implementation itself decides the stimulus context that is passed to he inhabitant to make an action decision. All movement is carried out on separate threads and timed appropriately to be as fair as possible and to cater for additional skills such as speed, and eventually maybe stamina, strength, with actions like fighting. It is pretty fun to make up random maps and see how your inhabitant does.

You can download the code from here.

Along the way I have played with parallel extensions to make the compute intensive stuff spread across all cores, had to heavily factor in visibility of methods and properties so design of classes was paramount, work out movement algorithms that play fairly in the world and properly favour the players with higher abilities, as well as a host of other issues.

So that is my ‘solution kata’.

If I keep going with it, I may develop a web interface for it where people can upload assemblies and watch their player within a web browser visualiser and maybe even a map designer.

What do you do to keep the fires burning?

Updates to the CacheAdapter Package

Glav — Sun, 21 Aug 2011 03:12:52 GMT

Note: This post was originally going to detail the changes from 2.0 to 2.1, however in between the time of release and this post, I released 2.2 so this post will detail all the changes up to 2.2.

In the last update to my CacheAdapter library (you can view it here), I mentioned the support for memcached cache engine. That brought the version to 2.0.

As previously mentioned, you can get this package from here.

I have recently updated the version of the library to ~~2.1~~ 2.2 which now includes the following changes:

The ability provide specific configuration data to a particular cache engine without introducing a bunch of specific configuration tags that are only relevant to a particular cache mechanism.
- Addition of a CacheSpecificData configuration element.
The addition of 2 new simpler API methods to get data from the cache.
- T Get<T>(DateTime absoluteExpiryDate, Func<T> getData)
- T Get<T>(TimeSpan slidingExpiryWindow, Func<T> getData)

Notice that there is no cache key required to be specified. It is auto generated from the Func<T> delegate. (Thanks to Corneliu for this great idea). So you can write really simple code to get data from the cache like so:

var myData = cacheProvider.Get<SomeData>(DateTime.Now.AddSeconds(2), () =>
                                                                          {
                                                                             var somedata = new SomeData();
                                                                             // populate data from somewhere (db, code etc..)
                                                                             return somedata;
                                                                          });

Simplification of the interface
- Replacing the GetDataToCacheDelegate<T>() delegate with a Func<T>
- Removal of the bool addToPerRequestCache = false parameter from the Get<T> methods.

So why the new configuration element? Well, previous versions of this library supported Windows Azure AppFabric however it was only in a non Azure scenario. When Windows AppFabric is used within Azure, a security mode and authentication key is required. This is easily achieved with config, but I wanted a way that did not introduce redundant elements that were not applicable to other cache mechanisms AND that may be useful for other cache mechanisms if they require it. Basically, a generic way of providing configuration data to cache mechanisms, that could be used by any cache mechanism and not pollute the configuration with lots of items specific to only 1 method.

To that end, this release has introduced a “CacheSpecificData” configuration element as shown below:

<setting name="CacheSpecificData" serializeAs="String">
  <value>UseSsl=false;SecurityMode=Message;MessageSecurityAuthorizationInfo=your_secure_key_from_azure_dashboard</value>
</setting>

Currently, this element is only of use to AppFabric cache mechanism, but as support for more cache types grow, this item will be used more and more.

This element is a simple series of key/value pairs that are separated by a semi-colon. In the example above, the following values are defined:

UseSsl = false

SecurityMode = Message

MessageSecurityAuthorizationInfo = your_secure_key_from_azure_dashboard

This equates to the following configuration for Windows AppFabric in Azure (Specifically the <SecurityProperties> element):

<dataCacheClients>
  <dataCacheClient name="default">
    <hosts>
      <host name="somehost.com" cachePort="22233" />
    </hosts>
    <securityProperties mode="Message">
      <messageSecurity authorizationInfo="your_authorisation_key"></messageSecurity>
    </securityProperties>
  </dataCacheClient>
</dataCacheClients>

There are also a few bug fixes and code cleanup in there. Thanks to Corneliu Tusnea (creator of OneSaas) for submitting some really useful changes and bug fixes.

Hope you enjoy the new features.

Go get the Nuget package from here.

Or download the source code from here.

CacheAdapter–V2 Now with memcached support

Glav — Mon, 04 Jul 2011 04:00:34 GMT

Previously I blogged about my CacheAdapter project that is available as a Nuget package and allows you to program against a single interface implementation, but have support for using Memory, ASP.NET Web or Windows AppFabric cache mechanisms via configuration.

I am happy to announce that my CacheAdapter now has support for memcached. Version 2 of the Nuget package is available here. Alternatively, all the source code is available here.

What this now means is you can write one line of code to get or store an item in the cache, and that code can automatically support using Windows AppFabric, memcached, MemoryCache or ASP.NET web cache. No code change required.

I am particularly happy about having memcached support as it means a few things:

Free / Open Source: It is a free, well established open source caching engine that is widely used in many applications.
Easy: It is easy to setup.
Simple and Cheap: It provides an alternative to using Windows AppFabric. AppFabric can be a little tricky to setup sometimes. If you are using Windows Azure, AppFabric is a simple checkbox BUT you need to pay extra for the privilege of using it based on how much you use the cache service. By contrast, memcached can be installed easily on Azure and requires no extra cost whatsoever.
Auto fail over support: In addition, Windows AppFabric has some limitations for a relatively small cache farm. AppFabric utilises a “lead host” to co-ordinate small cache farms of 3 or less cache servers. If the lead host goes down, they all go down. The memcached implementation has no reliance on any single point of failure so if one memcached node fails, requests will automatically be redirected to the nodes that are alive. If the dead node comes back alive again, it is re-introduced to the cache pool after about 1 minute or so. At worst, it results in a few cache misses.

Note: This release contains a few namespace changes that may break older versions if you are using the objects directly. Namely AppFabric object support has been moved from the Glav.CacheAdapter.Distributed namespace to the Glav.CacheAdapter.Distributed.AppFabric namespace. This is to allow differentiation from AppFabric and memcached within the distributed namespace.

In addition, at the request of some users, I have added a simple ‘Add’ method to the ICacheProvider interface for ease of use. The interface now looks like this:

public interface ICacheProvider
{
    T Get<T>(string cacheKey, DateTime absoluteExpiryDate, GetDataToCacheDelegate<T> getData, bool addToPerRequestCache = false) where T : class;
    T Get<T>(string cacheKey, TimeSpan slidingExpiryWindow, GetDataToCacheDelegate<T> getData, bool addToPerRequestCache = false) where T : class;
    void InvalidateCacheItem(string cacheKey);
    void Add(string cacheKey, DateTime absoluteExpiryDate, object dataToAdd);
    void Add(string cacheKey, TimeSpan slidingExpiryWindow, object dataToAdd);
    void AddToPerRequestCache(string cacheKey, object dataToAdd);
}

So that is it. I hope you enjoy using memcached support within the CacheAdapter.

Converting from Webforms view engine to Razor–Some Tips

Glav — Sun, 05 Jun 2011 22:16:55 GMT

Recently, I have had to perform a lot of conversion in an MVC application from using the webforms view engine to the Razor view engine.

I say “had to” but we didn’t really have to, more wanted to. We wanted the cleaner syntax that razor allows. Since we were going to embark on a bunch of new features involving new pages, we wanted to do this conversion earlier rather than later to prevent excessive rework.

This post simply summarises most of the issues and tips that were experienced along the way and how we overcame them, so that others can get a clear picture of what is involved should they embark on such an undertaking, and be prepared for any issues.

Preparation

First off, there are some things you should do prior to starting the conversion to make the process as smooth as possible, and to allow easy resolution of any issues.

Take a copy of your entire source tree and keep it separate to allow for comparison along the way. If you are using HG or GIT, clone your repository to another location. Sure you could look at source control history if you wanted, but its easier to have this code at hand to do side by side comparisons.More importantly though, you can run the backup version to compare HTML output to make sure your conversions are good.
In your solution, turn on MVC compiled views. This will tell the compiler to compile your views and you will catch any errors whenever you compile. Very handy and saves sometime. Unfortunately, it does add some time to the build process. If you have a lot of views, this could be lengthy, so you may want to disable this after the conversion is complete. To enable compiled views:

<MvcBuildViews>false</MvcBuildViews>

and change it to

<MvcBuildViews>true</MvcBuildViews>

Save the file. Then right click on the project again and select ‘Reload Project’
Now when you compile, your views will also be compiled.

Download the aspx2razor conversion tool from Telerik which does a reasonable job of converting your ASPX views into razor views. It probably wont do it all for you,but it removes a good deal of work.

Performing the actual conversion

This is the easy part. Simply run the conversion tool over your project. You can do this by running the tool against your base views directory and have it recursively convert all files it founds in all directories to their razor counterparts. Something like this:

aspx2razor.exe c:\MyProject\MyViews\*.cshtml MyOutputDirectory -r

You will then need to copy the files from the output directory into your solution and ensure they are included in the project. Make sure you delete all the existing ASPX files as having both of these file types present can cause problems.

So that’s it. Job done right?

Testing and Fixing

Now the fun begins. The conversion tool works reasonably well, but it has its problems. Here are some of the issues you will find.

The conversion tool does not support master pages, so don’t expect them to be converted. Roll up your sleeves and do those manually. Even though the tool does not support master pages, it will blindly convert anything you tell it to so it will attempt to convert a master page if one exists in the set of input files. Don’t be tempted to use a partially converted master page if there is one as it will usually not convert properly, putting in an incorrect ‘@inherits’ directive which just causes more confusion. Start from scratch and do the master pages manually.
Sometimes the conversion tool completely misses the server side tags, particularly when embedded in script tags like this:

<script type="text/javascript" language="javascript" src="<%: Url.Content("~/Content/Scripts/jQuery/jshashtable.js") %>"></script>

Embedded server tags can get completely messed up when converting to razor. As an example, the following snippet:

class="item <%: isParentDate ? "" : "child-date " %>
<%: item.IsReconciled ? "reconciled " : "" %>">

gets converted to the following razor equivalent:

class="item @isParentDate ? "" : "child-date "@item.IsReconciled ? "reconciled " : """>

which is obviously incorrect and results in simple text being output to the HTML, not the expected class names. Ideally, this should be refactored into amore explicit code block, something like this:
@{ 
  var divClass = string.Format("item {0}{1}", isParentDate ? string.Empty : "child-date ", item.IsReconciled ? "reconciled " : "");
}
class="@divClass"

“Tight” concatenation of server tags like this:

<input type="hidden" id="itemAmount<%: Model.BankFeed.Id %>" />

get converted to this:

<input type="hidden" id="itemAmount@Model.BankFeed.Id" />

which is not right and just renders the text. Again, something more explicit is required such as:

@{ 
  var controlId = string.Format("itemAmount{0}", Model.Id);
}
    <input type="hidden" id="@controlId" />

One last tip. Use the “original” copy of your site and run it up in a browser, do the same with the converted site. For each view that is converted, it is worth doing a “source view” of original and converted page from the browser to ensure you are getting the same output. This is particularly important for scripts and CSS.

That is about it for most of the issues I came across. You will no doubt experience some variations from the examples above, but the set of issues presented here should at least allow you to be prepared for what the actual conversion effort is going to be.

Hopefully, this article helps you to efficiently convert your projects into the wonderful world of razor

CacheAdapter–Now a Nuget package

Glav — Tue, 31 May 2011 06:12:05 GMT

Note: Link to Wiki is here

A while ago, I blogged about a personal project around caching that allowed you to abstract away the underlying cache mechanism, and use whatever cache you wanted. Through simple configuration, you can choose to use either the memory cache provided by System.Runtime.Caching in .Net 4, the traditional ASP.NET web cache, or you can use the Windows AppFabric caching to taker advantage of distributed caching.

Well, its now a package on Nuget that you can easily install and use immediately. You can grab it from here.

Update: This package uses the Microsoft Public Licence (MS-PL).

Just as a recap, you can use this cache adapter like this:

var data1 = cacheProvider.Get<SomeData>("cache-key", DateTime.Now.AddSeconds(3), () =>
{
    // This is the anonymous function which gets called if the data is not in the cache.
    // This method is executed and whatever is returned, is added to the cache with the
    // passed in expiry time.
    Console.WriteLine("... => Adding data to the cache... 1st call");
    var someData = new SomeData() { SomeText = "cache example1", SomeNumber = 1 };
    return someData;
});

(Note: You will get a small example .cs file included in your project that contains this example usage when you install the package)

You can see in the example, that you can request the data, and provide a lambda that retrieves that data if its not in the cache. The data gets added to the cache once the lambda has been executed to retrieve the data from the source. Also, the data that is returned is strongly typed. It is not a generic object that you then need to cast.

Additionally, you can set the type of cache used by one line of configuration:

<setting name="CacheToUse" serializeAs="String">
    <value>Memory</value>
</setting>

If I wanted to use the ASP.NET Web cache, I could simply set the config item like so:

<setting name="CacheToUse" serializeAs="String">
    <value>Web</value>
</setting>

And if I wanted to use the AppFabric distributed cache (assuming it has been installed on the system), then I can simply set the config like so:

<setting name="CacheToUse" serializeAs="String">
    <value>AppFabric</value>
</setting>

The package references the required AppFabric client assemblies for you. This means you can write a web application today using this package and use the traditional ASP.NET cache. Then we you are ready, install AppFabric, setup a cache cluster, change the configuration to enable AppFabric and you are away. No code changes to your app.

Using AppFabric

To use AppFabric, there are a few extra things to do by way of Infrastructure. Obviously, you need to download and install it. Then you need to setup your cache cluster via the wizard when you install it (or via powershell if you choose). During this process you will be creating some cache nodes and you need to create a named cache for your application. This can be done via powershell using the

New-Cache {cachename}

powershell command. In addition, you will need to ensure that the user that will be accessing the cache has access to it. Again, this can be done from powershell via the:

Grant-CacheAllowedClientAccount {account}

There is some additional config you will need to do as well. In the application config file you will need to change the following entries to match your configured infrastructure:

<setting name="DistributedCacheServers" serializeAs="String">
    <value>localhost:22223</value>
</setting>
<setting name="DistributedCacheName" serializeAs="String">
    <value>MyCache</value>
</setting>

The “DistributedCacheServers” setting can be a comma separated list of servers and ports that the cache client (ie. your app) will communicate with. This can be one or as many comma separated entries as you like and depends on your cache cluster config.

The “DistributedCacheName” is the name of the cache you have setup in the cache cluster for your app. (Detailed above)

Final Notes

Before I published this package, I cleaned it up a bit as I have been using it on a current project and I didn’t like a number of ways I implemented things initially. Instead of multiple assemblies, everything is in the one assembly.

Also, I removed the use of Unity as a mechanism for dependency injection and implemented a very very simple method which uses no particular dependency injection implementation. I did this because everyone wants to do DI (Dependency Injection) using their favourite implementation whether this be Unity, Autofac, Ninject, Castle Windsor etc. etc. So I opted for something that does the job, it is not what a purist would be happy with, but is dead simple to rip out and change which is what I expect most people would do.

Finally, because all cache access is via an interface, it allows for easy testability.

So go grab it. Or you can download the source code form here and change it to your hearts content. Its actually a relatively simple implementation and it would be easy to plug in any underlying cache implementation should you wish.

Diskeeper–a short review

Glav — Sun, 15 May 2011 22:23:40 GMT

I have been lucky enough to be ASP.NET MVP for a number of years now. One of the perks of that is you get access to free licences of software such as Diskeeper. This piece of software keeps your disks running as smooth as they possibly can.

I have been using Diskeeper for around 2 months now and am pretty impressed. It silently does its thing in the background without you having to touch anything. One of the newest and also one of my favourite features is the automatic defrag capability.You don’t have to launch a defrag application and have it run on your system or schedule it to run periodically, as Diskeeper performs this operation all the time, in the background for all disk operations. Basically, you just use your system like normal, and it just magically gets defragmented, all the time. Nice.

I have 2 disks in my system. A SSD (Solid State Drive) as my primary ( C: ) drive, and a 5200rpm 320Gb hard disk as my secondary data drive ( D: ). After installing Diskeeper, I have noticed a significant difference in the performance of the secondary drive in particular. I imagine because it is the slowest disk and because it stands to benefit the most. The SSD is fast anyway, so it is much harder to notice any difference. I have noticed a small difference, but it’s only slight compared to the secondary ( spinning rust ) drive.

I should mention that in order for Diskeeper to work with SSD hardware, you need a special edition of Diskeeper with an add-on called Hyper-fast that takes into account the SSD unit and has special algorithms that are designed to optimise SSD operation.

For those interested in the actual metrics, Diskeeper provides an easy to use management console that displays your current system improvements. The initial display is shown below.

The management console offers a number of ways to look at what has been done to your disks and how it has been performing. I find the history view particularly interesting as it proves a look at how the disk is being used and optimised over time.

So would I recommend it? Yes, and this is not simply because I have been given a free licence and feel obligated to do so. It is particularly useful if you have standard hard disks regardless of how fast they spin. You will notice a much smoother and responsive system as a result. For SSD owners, it is still worthwhile but the benefits are less because of the inherent speed in SSD units. For a system with a mix of SSD and hard disks, it works beautifully.

Entity Framework and the PreApplicationStartMethod attribute

Glav — Fri, 06 May 2011 03:09:05 GMT

Recently, while implementing an EntityFramework data model into a new application, I thought I’d add some caching functionality early, to establish a framework going forward. I added the DBML (generated from a database), and added in my funky caching layer (which will be distributed as a Nuget package soon) that allows caching to be configurable switching between in memory, ASP.NET cache and AppFabric caching.

Anyway, I added some repository methods to grab data from the database. All good. I added my caching layer to that so that a bunch of reference data was cached, again all good.

Now this application is a .NET 4/ASP.NET MVC 3 application and I was using the PreApplicationStartMethod attribute to specify a class method that is executed before anything else in the application. Something like this:-

In the AssemblyInfo.cs file I had this attribute declaration:

[assembly: PreApplicationStartMethod(typeof(WebAppStart), "PreStartInitialise")]

And in the WebAppStart.cs file I had this:

public static class WebAppStart
{
    public static void PreStartInitialise()
    {
        RegisterWebDependencies();
    }
}

This all worked well. Then I thought, well rather than let the first user of the application cause the cache to get primed/filled, I would simply make a call to a method I had already to prefill the cache:

public static void PreStartInitialise()
{
    RegisterWebDependencies();
    PrimeCache();
}

Seems ok so far, but alas no. Apparently, you cannot use the EntityFramework from within a method invoked by the PreApplicationStartMethod attribute. What you will get is an exception message like this:

The solution was easy enough for me, I just moved the PrimeCache method to the Application_Start event within the Global.asax.cs file. However, what made this error, let’s say “interesting” is that I was developing an azure application. What then happens is you get an error that seemingly has nothing to do with the root cause. So when developing running in debug mode for an azure application you get the following exception:

It seems to point to some issue with the connection string which is absolute rubbish and leads you to nowhere. If you happen to try and run this without attaching a debugger, then you simply get an exception dialog stating that the windows azure web role has stopped working.

Nice.

So, the moral to this story. Don’t use EntityFramework within a method defined using the PreApplicationStartMethod attribute. If developing an azure app and you get this error, do not believe what you are told. Move the EntityFramework code to somewhere later in the lifecycle and you will be good.

Mix11–Day 2 Sessions

Glav — Wed, 13 Apr 2011 20:49:42 GMT

I blogged here about my Mix11 bootcamp sessions, and here about my Mix11 day 1 keynote and sessions. To continue the theme, here are some thoughts and opinions around Day 2.

Keynote #2

This keynote started a little slow with some apologies and explanations around delays in Windows Phone 7 updates coming. Necessary but unexciting. After that though, things moved along well. Lots of great new features coming to Windows Phones in the form of the “mango” update to come soon. Things like better much performance, SQL databases on the phone, better multitasking. You can read about all the features here. One thing that I personally liked was the fact that IE9 will be the browser on Windows Phone and replace the current klunky browser version. This means I can target Windows Phone 7 with HTML 5 apps like I can with iPhone and Android. Nice.

All the new features that will come with the Mango update will really make WP7 a much more polished device.

The developer tools update for Windows Phone 7 look just fantastic. Really polished and it will be a real big gain. Being able to emulate titling your phone, gestures such as shaking the phone, and other smaller items such as placing breakpoints on bindings in XAML markup will make development so much nicer. Microsoft have done a huge amount of work here and it shows.

Silverlight 5 was announced and the beta is available for download from here. There are a huge number of improvements in this new release and it looks really nice.

Kinect played a big part in this keynote with some awesome example of what the community has done with the Kinect. In particular, a fully mobile lounge chair, controlled via hand gestures and the Kinect. Also, the Microsoft Telescope demo using the Kinect was excellent. All attendees were also given a free Kinect which was fantastic and obviously made everyone happy.

A great keynote overall.

Here are some thoughts on the sessions I have attended.

Douglass Crockford: ECMAScript 5: The New Parts

Its Douglass Crockford. End of story. If Javascript is your thing, then you really can’t go past this to get some insight into where the language is going, from the man himself.

Back To Square One

This talk was presented by Nishant Kothary and it held almost no technical content. A little but not much. You might think that this is a negative thing but that is not the case. I found this talk exceptional and provided many insights into why and how we think like we do. It looked at why some projects have failed, and why some succeeded. In addition, there was some really interesting material around left vs right hemisphere brain function and how that relates to developers and designers.

It was a really interesting presentation and I found it one of the best and most refreshing of Mix. Entertaining, engaging and informative. Highly recommended.

Go download or stream the content from here.

Mix 11–Bootcamp Day

Glav — Mon, 11 Apr 2011 22:40:51 GMT

I have been lucky enough to get to the Mix11 event this year (many thanks to my awesome company Saasu) and have been attending the bootcamps here at Mix.

First one was Design, Content, Code: Start to Finish with Roman Blagovirnyy, Anthony Franco, Cindy Vanover Tony Walt and Chad Bakeman of effective ui.

It presented an overview of the start to finish process of a rich interactive site, utilising a hybrid approach of HTML 5 and Silverlight. Traditional ASP.NET webforms was chosen over MVC with the reason cited as the extra complexity of MVC was unnecessary and provided no benefit.

This session was a good session for a few reasons.

It presented a project from start to finish and described the challenges involved.
Talked a good deal about the design process for such a rich and interactive site. While this team had a number of designers and UX savvy people, the concepts, processes and more importantly, the risks could be utilised and taken into account in any sized team or project.
- For example, the use of nodes to build high level navigation concepts, then further drilling into these nodes in an intuitive way to build out the rest of the navigational elements of the site, which was finally formed into a set of wireframes.
Talked a lot about the technology used, including such elements as Silverlight, 3D rendering (think depth of field, particle systems, lens flares etc,…). Items such as considerations when combining and synchronising multiple videos, usage of HTML 5 video functionality is not as easy as its “standardised inclusion” is meant to be, compression and bit rate considerations amongst others.
Provided insight into how other company and people do things. This is probably the most valuable as everyone does things their own way, even if they follow a specific process or methodology, it is usually tailored in some way to meet the needs of the business, company and client. It is extremely valuable to gain this insight as it is experience based and this what is often hard to get without going through some pain first. The pain points were not too dissimilar from most peoples, client issues (although the client was the navy/military so presented extra challenges), integrating all the media into the site in a usable and intuitive way, tight deadlines,unforseen technical issues, as well as a few others.

All in all a good session with lots to learn.

Sydney Architecture User Group - It has come to an end

Glav — Tue, 22 Mar 2011 03:57:00 GMT

Unfortunately, the Sydney Architecture User Group that Omar Besiso and myself run in Sydney, is closing its doors.

It has been running for around 2 years now and we have had some great sessions, however there are a number of factors that have caused us to make this decision.

Primarily, we lost our funding. Datacom (the company I used to work for and where Omar still works) were originally kind enough to foot the bill for the venue and food (which was substantial), however Datacom Software Solutions are undergoing their own financial issues and as such, had to stop funding. While Microsoft also provides some funding, it was not enough to cater for the current venue and we did not have another venue to go to. Now that I work for the awesome Saasu.com, its a little hard for me to try and push this issue.
Secondly, it was getting harder to organise speakers. Presenting takes time and effort, and the availability of speakers was getting low. The last few months meant that Omar and myself would often have to juggle presenting.
Lastly, interest in the group was slowly declining. We have seen this a lot lately where some user groups are either closed down, or become part of a larger group in order to survive. I think this may be indicative of the community in general. There are a lot of user groups locally in Australia. Probably too much. The ones that survive seem to specialise in certain areas. In addition, the amount of online technical learning content available means a user group has to offer something different to be effective.

So, we close our doors. However, we are looking at re-inventing a new learning mechanism soon. Something that differs to a user group and can offer value that traditional user groups and online content cannot provide.

Stay tuned...

My Mix11 Proposal

Glav — Wed, 26 Jan 2011 20:51:30 GMT

I only submitted one session for consideration to present at Mix this year. Unfortunately it was not shortlisted and is consequently not open to voting currently on the site.

However, I thought I might post it here to gain some feedback from others as to how I might refine or change it. Maybe it is just something people are not interested in and I have taken a wrong direction. Perhaps you might be interested in me presenting this at your user group?

At any rate, the session abstract is below and would love your feedback.

Title: There is no Web: HTML5 Offline capabilities

Abstract:

HTML 5 offers many new capabilities to the standardised web space. The majority of this session will focus on a few capabilities geared towards allowing your web applications to function when the web is not available or otherwise pre-occupied. For a lot of developers, this has not been too much of a consideration because of the limited ability to deal with it, but with HTML 5 this can all change. We will look at how HTML 5 makes it easier to detect your offline/online status and also look at a way to to construct your application to take this into account and provide a seamless experience for your users. We will look at constructing components to provide a better network detection status, offline storage approaches, integration with ASP.NET MVC, and to top it all off, will utilise the RavenDB (NoSQL) document storage engine just for some fun. If you want to see some of the techniques and pitfalls of HTML 5 offline capabilities, combined with ASP.NET MVC and NoSQL, then this talk is for you.

ScriptHelper–For MVC and WebForms projects

Glav — Thu, 18 Nov 2010 06:38:30 GMT

This issue might seem minor but I always forget the names (exact naming) or number of script files I need to get some features working in MVC or Webforms. In addition, in my applications that require a specific client side feature, I might need a series of dependent scripts to make it work. Failing to include all of them often gives ambiguous errors or the functionality or feature just doesn't work.

To that end, I have created a ScriptHelper to allow me to express those dependencies as a singular name and have all the script dependencies (or CSS) emitted for me.

The library is currently hosted on bitbucket here http://bitbucket.org/glav/mvc-script-dependency-extension

The idea is that you can express your Javascript and CSS dependencies into a separate file and pretty much call it what you want. Then, in your pages, simply the reference the dependencies by name and everything you need is pulled in for you.

The ScriptHelper I have written is a little raw, but you can define an XML file that expresses script names and its dependencies. The script helper then allows you to provide that single name and all dependent scripts are emitted in the page.

For example, in the page you can do:

<%= ScriptHelper.RequiresScript(ScriptName.jqueryValidateUnobtrusive) %>

<%= ScriptHelper.RequiresScript(“jQuery-validate-unobtrusive”) %>

And you would get

<script type='text/javascript' src='/Scripts/jquery-1.4.1.js'></script>
<script type='text/javascript' src='/Scripts/jquery.validate.js'></script>
<script type='text/javascript' src='/Scripts/jquery.validate.unobtrusive.js'></script>

Additionally, you could do:

<%= ScriptHelper.RequiresScript("All") %>

And you would get the following emitted into your page:

<script type='text/javascript' src='/Scripts/jquery-1.4.1.js'></script>
<script type='text/javascript' src='/Scripts/MicrosoftAjax.js'></script>
<script type='text/javascript' src='/Scripts/MicrosoftMvcAjax.js'></script>
<script type='text/javascript' src='/Scripts/jquery.validate.js'></script>
<script type='text/javascript' src='/Scripts/jquery.validate.unobtrusive.js'></script>
<script type='text/javascript' src='/Scripts/MicrosoftMvcValidation.js'></script>

The dependency file looks something like:

<?xml version="1.0" encoding="utf-8" ?>
<Dependencies ReleaseSuffix="min" DebugSuffix="debug">
  <Dependency Name="jQuery-validate-unobtrusive" Type="js">
    <ScriptFile>~/Scripts/jquery.validate.unobtrusive.js</ScriptFile>
    <RequiredDependencies>
      <Name>jquery</Name>
      <Name>jQuery-validate</Name>
    </RequiredDependencies>
  </Dependency>

  <Dependency Name="jQuery-validate" Type="js">
    <ScriptFile>~/Scripts/jquery.validate.js</ScriptFile>
    <RequiredDependencies>
      <Name>jquery</Name>
    </RequiredDependencies>
  </Dependency>

  <Dependency Name="jQuery" Type="js">
    <ScriptFile>~/Scripts/jquery-1.4.1.js</ScriptFile>
  </Dependency>

<!— rest of dependencies …. -->

The ReleaseSuffix and DebugSuffix also act to rename a dependency file that is output to the page. These are not mandatory but it is not uncommon to host debug versions of your scripts when doing development and release/minified versions of your scripts in production. So for example, if we have a script file dependency defined as Something.js, then it will be renamed to Something.min.js in release mode and Something.debug.js in debug mode when output to the page. If not specified, the emitted dependency is left as is.

Finally, you can also specify multiple dependencies on the same line like so:

<%= ScriptHelper.RequiresScript("Microsoft-Mvc-Validation", "jQuery") %>

And all dependent scripts will be included for you without duplicating anything. Obviously the script names must be the same as what is defined in the script dependency file. I have used a static class to hold these constants and you could easily substitute your own as its just strings.

It also supports expressing CSS dependencies. For example, with the following dependency definitions:

<Dependency Name="SiteWideStyle" Type="css">
    <ScriptFile>~/Content/Site.css</ScriptFile>
  </Dependency>

  <Dependency Name="HomeStyle" Type="css">
    <ScriptFile>~/Content/Home.css</ScriptFile>
    <RequiredDependencies>
      <Name>SiteWideStyle</Name>
    </RequiredDependencies>
  </Dependency>

You can then include the following in your <head> section of your pages

<%= ScriptHelper.RequiresScript("HomeStyle") %>

And you would get

<link href='/Content/Site.css' rel='stylesheet' type='text/css' />
<link href='/Content/Home.css' rel='stylesheet' type='text/css' />

Currently, the ScriptHelper I have written supports resolving the dependency file in a few local locations, but I plan on extending it support remote locations via HTTP.

This type of thing could reduce multiple script include to a single line in a web page or view. In addition, you could have dependency files centrally located on a remote server either in the cloud or internal to your organisation, so that dependencies are always resolved via this file which can be maintained and updated as new dependencies and/or later versions of the scripts are available or required.

There is also nothing stopping you from naming your dependencies more component oriented in nature. For example you might name a dependency “AjaxGrid”, and that may load in jQuery core script, jQuery UI custom scripts, as well as some of your own custom scripts required to get this component working.

I have been using this library primarily with ASP.NET MVC projects, but it is just a set of static methods that could also be used within an ASP.NET Webforms application as well.

Feel free to leave comments/issues on the hosting site here http://bitbucket.org/glav/mvc-script-dependency-extension

Caching Architecture–Testability, Dependency Injection and Multiple Providers

Glav — Wed, 13 Oct 2010 10:52:00 GMT

Note: Link to Wiki is here

Note: This article assumes familiarity with caching in .Net and dependency injection.

Update: Fixed broken links and updated some text based on feedback.

One of the things I have always stated is that caching is important to every applications performance. In many of the applications I design and work on, I like to introduce a caching layer from the outset, and ensure it is part of the vertical slice that I typically provide as an application blueprint.

Obviously we want to ensure that all this caching magic does not introduce hard dependencies to the underlying caching mechanism. For example, the ASP.NET caching engine is fantastic at what it does, however if you are writing components that make use of it, then they become hard to test as you need to introduce lots of HttpContext references which are time consuming and hard to mock out for testing purposes.

In order to prevent this, I like to define an ICache interface that defines our contract for working with a cache.

Something like this:

  1: public interface ICache 
  2: { 
  3:    void Add<T>(string cacheKey, DateTime expiry, T dataToAdd) where T : class; 
  4:    T Get<T>(string cacheKey) where T : class; 
  5:    void Add(string cacheKey, DateTime expiry, object dataToAdd); 
  6:    object Get(string cacheKey); 
  7:    void InvalidateCacheItem(string cacheKey); 
  8: }

With that, I can write a simple pass through CacheAdapter that implements this interface, but passes all the calls through to the ASP.NET Cache. Any components can then work with the CacheAdapter rather than the ASP.NET cache directly. This means we can mock it out easily by mocking the interface. Testing then becomes much easier and our code is loosely coupled. The CacheAdapter may look something like this:

  1: public class WebCacheAdapter : ICache
  2: {
  3:    private System.Web.Caching.Cache _cache;
  4:    public WebCacheAdapter()
  5:    {
  6:       if (System.Web.HttpContext.Current != null)
  7:          _cache = System.Web.HttpContext.Current.Cache;
  8:       else
  9:          throw new ArgumentNullException("Not in a web context, unable to use the web cache.");
 10:    }
 11: 
 12: public void Add<T>(string cacheKey, DateTime expiry, T dataToAdd) where T : class
 13: {
 14:    if (dataToAdd != null)
 15:       _cache.Add(cacheKey, dataToAdd, null, expiry, Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
 16: }
 17: 
 18: public void Add(string cacheKey, DateTime expiry, object dataToAdd)
 19: {
 20:    Add<object>(cacheKey, expiry, dataToAdd);
 21: }
 22: 
 23: // rest of code omitted for brevity

So that’s all well and good. Even though I am primarily a web guy, I often design and work with desktop applications which cannot use the ASP.NET cache. In addition, I may also want to use the awesome power of Windows AppFabric Cache for distributed caching. Furthermore, in a few scenarios it has been unclear whether distributed caching was an option due to infrastructure concerns. So I would have liked to use AppFabric caching, but may not be able to, and I would not have known this till later in the project. Finally, I do this kind of code a lot, and I did not want to write it for each scenario and have to specialise it for each project.

It would be nice if I could have all the caching options I may need, already abstracted out for me, easily selectable via configuration, and utilise interfaces with dependency injection for easy testing and loosely coupled applications (what a mouthful).

With that in mind, I have developed a simple caching architecture that I can introduce into all new projects and has the following features:

Provides an ICache interface and associated cache adapter class through which all cache engines are accessed. This includes the .Net 4 MemoryCache, ASP.NET Web cache, and Windows AppFabric cache.

Provides an enhanced CacheProvider class (which implements ICacheProvider) that allows strongly typed cache access and a simple easy to use consistent API.

Allows selection of which cache engine to use via configuration.
- The currently supported cache mechanisms are
  - Memory
  - Web
  - AppFabric

Fully supports dependency injection with everything already wired up. My current organisation standardises on Microsoft's Unity for Dependency Injection so that is what this library uses.
- Container.Resolve<ICacheProvider>();

is all you need to do to access the cache mechanism.

Provides simple logging diagnostics (again via dependency injection so its easy to change) so that you can track whats going on.

Before I dive into the details, here is some example code to use this library and caching.

  1: var cacheProvider = AppServices.Resolve<ICacheProvider>();
  2: 
  3: Console.WriteLine("Getting Some Data.");
  4: var data = cacheProvider.Get<SomeData>("cache-key", DateTime.Now.AddSeconds(5), () =>
  5: {
  6:    Console.WriteLine("... => Adding data to the cache... ");
  7:    var someData = new SomeData() { SomeText = "cache example1", SomeNumber = 1 };
  8:    return someData;
  9: });

The preceding code sample first resolves our cache provider using the Unity container. Note that this is not an ICache instance (which we could also resolve and use directly), but rather a higher level ICacheProvider instance. This provides a more advanced and easy to use API for caching.

Then we simply try and retrieve the item (of type SomeData) from the cache passing in a cache key, the expiry time of the cached data, and an anonymous function as the last argument.

The anonymous function is only called if the data is not present in the cache. The return data of the anonymous function is placed into the cache using the cache key and expiry date/time, then returned to the caller.

The library comes with some simple example code to allow you to get up and running very quickly. If you want to use it, you can download it from here.

For those who are interested in more detail, then read on.

The design of the library is fairly simple.

The solution itself consists of 4 projects as shown below:

Glav.CacheAdapter.Core contains all the necessary interfaces and an implementation of the MemoryCache (which implements ICache). There are multiple cache adapters (memory, web and AppFabric) which implement ICache. The ICache interface has basic Get/Remove methods to manipulate the cache. To facilitate a higher level API with easier usage and without introducing extra these methods into ICache (thus forcing each ICache adapter implementation to have to implement these methods), there is also a ICacheProvider interface which has the enhanced methods for retrieving items from the cache and automatically inserting them if the data items do not exist in the cache. Methods such as

  1: Get<T>(string cacheKey, DateTime expiryTime, GetDataToCacheDelete)

Both Glav.CacheAdapter.Web and Glav.CacheAdapter.Distributed contain implementations of the ICache interface for ASP.NET and Windows AppFabric respectively.

Obviously, in order to use Windows AppFabric caching, you must have that installed on the machines that will utilise it. The library contains 2 core assemblies from Windows AppFabric that allow it to compile and reference the required functionality. If you enable AppFabric in the configuration of the library without it being installed and try to utilise caching, this will obviously fail.

Finally, to glue all this together a project called the Glav.CacheAdapter.CacheBootstrap will register the correct cache implementation into the service container based on the supplied configuration. The .Net 4 MemoryCache is the default if no configuration or an unrecognised configuration is supplied.

So that’s it. Download it and give it a try if you want a nicely abstracted and pre-packaged cache solution. I would welcome any feedback.

ASP.NET MVC 3 and Custom Extensions

Glav — Sun, 08 Aug 2010 04:03:24 GMT

When playing with the latest ASP.NET MVC 3 Preview 1 bits, some people have mentioned their dislike of the .cshtml extension used for the “razor” view engine that comes with ASP.NET MVC 3 and also WebMatrix. Well there are a number of ways you can change this. For the purposes of learning and tinkering, I decided to try and register a new view engine using the new Dependency Injection support within ASP.NET MVC 3.

So, in the Global.asax.cs file I did this:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    IUnityContainer container = new UnityContainer();
 
    container.RegisterInstance<IControllerFactory>(new UnityControllerFactory(container));
    container.RegisterType<IViewEngine, TestViewEngine>();
    
    UnityMvcServiceLocator svcLocator = new UnityMvcServiceLocator(container);
    MvcServiceLocator.SetCurrent(svcLocator);
 
    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
}

Note: Previously (and this options is still available), you would register your custom view engine by adding it to the existing Engines collections like so:

ViewEngines.Engines.Add(new TestViewEngine());

My Custom view engine looked like this:

public class TestViewEngine : VirtualPathProviderViewEngine
{
    public TestViewEngine()
    {
        base.AreaViewLocationFormats = new string[] { "~/Areas/{2}/Views/{1}/{0}.glav", "~/Areas/{2}/Views/Shared/{0}.glav" };
        base.AreaMasterLocationFormats = new string[] { "~/Areas/{2}/Views/{1}/{0}.glav", "~/Areas/{2}/Views/Shared/{0}.glav" };
        base.AreaPartialViewLocationFormats = new string[] { "~/Areas/{2}/Views/{1}/{0}.glav", "~/Areas/{2}/Views/Shared/{0}.glav" };
        base.ViewLocationFormats = new string[] { "~/Views/{1}/{0}.glav", "~/Views/Shared/{0}.glav" };
        base.MasterLocationFormats = new string[] { "~/Views/{1}/{0}.glav", "~/Views/Shared/{0}.glav" };
        base.PartialViewLocationFormats = new string[] { "~/Views/{1}/{0}.glav", "~/Views/Shared/{0}.glav" };
 
    }
    protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
    {
        return new CshtmlView(partialPath, "");
    }
 
    protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
    {
        return new CshtmlView(viewPath, masterPath);
    }
}

This view engine implementation looked for a view extension of ‘.glav’ and invokes the “razor” view to parse the document/page (CshtmlView)

ASP.NET MVC 3 will use the MvcServiceLocator that we have supplied, and call the ‘GetAllInstances’ method when determining what classes implement IViewEngine so that it can invoke the correct view engine.

By default, ASP.NET MVC 3 has the System.Web.Mvc.WebFormViewEngine and the System.Web.Mvc.CshtmlViewEngine registered. We are adding a new custom view engine to the mix by registering it with the service locator that ASP.NET MVC uses ( MvcServiceLocator ). When ASP.NET MVC goes looking for a view engine it will use the MvcServiceLocator to get all instances of IViewEngine (via a call to ‘GetAllInstances’ ) in order to try and satisfy the request to process/render a particular view.

Now all this theory is good and well, and I thought it would work however it didn’t. One of the issues with Unity (and thats what I was basing my testing on since that was the example provided with ASP.NET MVC 3) is the the ' MvcServiceLocator.GetAllInstances ‘ method, calls the ResolveAll method of the UnityContainer. Now this *only* returns all instances if they have been registered by name, so I had to change one line of my code in the Global.asax.cs from:

container.RegisterType<IViewEngine, TestViewEngine>();

container.RegisterType<IViewEngine, TestViewEngine>("test");

and it all worked and my new engine was invoked. Apparently this is known behaviour with Unity and may be changed in future versions, but for now, this is how it works.

Note: There are a few other ways of registering custom view engines and also associating file extensions with a particular view engine. This is just one way of doing it.