Three years ago (wow, time flies) I wrote a generic Cache Repository that has become one of my more popular open source projects. It is 2016, so was definitely time to create an async version of that cache repository! This new implementation has all of the same features as the original, only now it is completely async from top to bottom.
Enjoy,
Tom
MVC has a lot of great built in tooling, including the ability to stream very large file results straight from disk without having to load the whole file stream into memory.
What about the scenario where you want to stream a large file from one web server to another?
For example, I have an ASP.NET MVC application that needs to expose a download for a file hosted on another server, but I can not just redirect my users directly to the other URL. For that, we need to create a custom ActionResult type!
Here is a simple of example of what your controller might look like:
public class FileController : Controller
{
public ActionResult LocalFile()
{
return new FilePathResult(@"c:\files\otherfile.zip", "application/zip");
}
public ActionResult RemoteFile()
{
return new WebRequestFileResult("http://otherserver/otherfile.zip");
}
}
I have talked before about BundleTransformer, and how you can use it to compile your LESS on a per request basis. Did you know that it supports TypeScript too?
BundleTransformer is an add on for Microsoft's System.Web.Optimization frame work bundling and minification of web resources. It allows you to convert your compiled languages on the server on request instead of need to create and maintain complied versions of resource files. Best of all BundleTransformer uses a JavaScript engine to compile LESS and TypeScript in with native compiler, ensuring that you will never lag behind the latest version.
The BundleTransfomer will bring in System.Web.Optimization, but then you need to specify a JavaScriptEngineSwitcher for the framework to run on, as well as a minifier to use on the final scripts when in release.
After including these packages you need only make three more updates...
Thank you to Isaac Abraham for bringing this solution to my attention!
Do not extend DefaultDependencyResolver
How do you practice inversion of control with SignalR? The official SignalR documentation suggests that you extend the DefaultDependencyResolver base class, and then register that as SignalRs dependency resolver.
This however, can have some nasty side effects! In my case, the ConnectionManager.GetHubContext method was not properly resolving my contexts, and thus I was unable to broadcast messages to my hubs clients.
So then, what is a less obtrusive way to inject your dependencies into your hubs?
Instead register an IHubActivator with the DependencyResolver
A simpler solution is just to register a custom HubActivator with the already existing DependencyResolver. This means that instead of completely replacing the SignalR resolver you are instead adding to it.
The HubActivator is only used when trying to resolve a hub; thus the activator can wrap your container of choice and use it to resolve your hub with its dependencies, while leaving the rest of the SignalR pipeline intact.
SignalR Startup with MVC DepenencyResolver
What does this all mean? It means that once you have your dependency injection setup for MVC, you can then create hubs with dependencies using the same container! This MvcHubActivator will use the default System.Web.Mvc.DependencyResolver to resolve its Hubs:
Until Twitter Bootstrap v3, I would have recommend that you use dotLess to compile and bundle your LESS files. However, it is now a known issue that the current build of dotLess does not support Bootstrap 3, or more specifically that it does not support LESS 1.4; and worse yet, there is no fix in sight.
So, how can you use Bootstrap LESS with MVC?
I recommend using BundleTransformer. It is an amazingly feature rich set of extensions for System.Web.Optimization. The BundleTransformer.Less extension provides easy to use LESS transformations (already up to LESS 1.5) and bundling support that wires up straight into your pre-existing BundleCollection configuration. For more information about everything that BundleTransformer has to offer, check out this article.
Now here is how you setup Bootstrap 3 and BundleTransformer for ASP.NET:
The Microsoft ASP.NET Web Optimization Framework is a great bundling and minification solution for your web applications. Simply grab the Microsoft.AspNet.Web.Optimization NuGet package, register your bundles, render them with a single line of code, and your environment will automatically resolve your dependencies based on whether or not the web server is running in debug mode.
But how can you debug minified styles and scripts in production?
Normally that is a difficult proposition, but here is a simple solution: JUST DON'T MINIFY THEM! With the little code snippets below you can add a simple query string parameter to disable minification for specific sessions or requests.
Adding this functionality to your website is extremely easy and requires no additional dependencies. Web Optimizations already has an internal AssetManager class that supports this functionality, we just need to access it via reflection.
Simply apply the following two steps and you will be ready to debug in production:
@using System.Web.Optimization
@{
Layout = "~/Views/Shared/_Layout.cshtml";
Html.TrySetOptimizationEnabled();
}
public static class HtmlHelperExtensions
{
public const string Key = "OptimizationEnabled";
public static bool TrySetOptimizationEnabled(this HtmlHelper html)
{
var queryString = html.ViewContext.HttpContext.Request.QueryString;
var session = html.ViewContext.HttpContext.Session;
// Check the query string first, then the session.
return TryQueryString(queryString, session) || TrySession(session);
}
private static bool TryQueryString(
NameValueCollection queryString,
HttpSessionStateBase session)
{
// Does the query string contain the key?
if (queryString.AllKeys.Contains(
Key,
StringComparer.InvariantCultureIgnoreCase))
{
// Is the value a boolean?
bool boolValue;
var stringValue = queryString[Key];
if (bool.TryParse(stringValue, out boolValue))
{
// Set the OptimizationEnabled flag
// and then store that value in session.
SetOptimizationEnabled(boolValue);
session[Key] = boolValue;
return true;
}
}
return false;
}
private static bool TrySession(HttpSessionStateBase session)
{
if (session != null)
{
var value = session[Key] as bool?;
if (value.HasValue)
{
// Use the session value to set the OptimizationEnabled flag.
SetOptimizationEnabled(value.Value);
return true;
}
}
return false;
}
private static void SetOptimizationEnabled(bool value)
{
// Use reflection to set the internal AssetManager.OptimizationEnabled
// flag for this request specific.
var instance = ManagerProperty.GetValue(null, null);
OptimizationEnabledProperty.SetValue(instance, value);
}
private static readonly PropertyInfo ManagerProperty = typeof(Scripts)
.GetProperty("Manager", BindingFlags.Static | BindingFlags.NonPublic);
private static readonly PropertyInfo OptimizationEnabledProperty = Assembly
.GetAssembly(typeof(Scripts))
.GetType("System.Web.Optimization.AssetManager")
.GetProperty(
"OptimizationEnabled",
BindingFlags.Instance | BindingFlags.NonPublic);
}
Enjoy,
Tom
First and foremost, the CacheRepository is NOT web specific!
The CacheRepository library contains the abstract CacheRepositoryBase class, which can be implemented by any caching system that you choose. The CacheRepository.Web NuGet package includes a WebCacheRepository implementation that leverages System.Web.Caching.Cache
Get all of the source code, unit tests, and a complete MVC4 sample application (preconfigured to include dependency injection with Unity) from GitHub. Or to just jump in and start using it, grab the CacheRepository.Web package from NuGet.
The ICacheRepository interface has all the standard Get, Set, Remove and Clear methods. Additionally, these methods have been expanded to include enum parameters to group manage cache expiration.
Best of all, it includes GetOrSet methods. These methods will try to get the value of the specified key, and when it can not find that value it will then be loaded via the passed in Func. A key feature here is the fact that the setter of the GetOrSet will lock on load to prevent redundant data loads. (More details about this below.)
public interface ICacheRepository
{
object Get(string key);
T Get<T>(string key);
T GetOrSet<T>(string key, Func<T> loader);
T GetOrSet<T>(string key, Func<T> loader, DateTime expiration);
T GetOrSet<T>(string key, Func<T> loader, TimeSpan sliding);
T GetOrSet<T>(string key, Func<T> loader, CacheExpiration expiration);
T GetOrSet<T>(string key, Func<T> loader, CacheSliding sliding);
void Set<T>(string key, T value);
void Set<T>(string key, T value, DateTime expiration);
void Set<T>(string key, T value, TimeSpan sliding);
void Set<T>(string key, T value, CacheExpiration expiration);
void Set<T>(string key, T value, CacheSliding sliding);
void Remove(string key);
void ClearAll();
}
As any good cache should, the CacheRepository is thread safe and can be treated as a singleton.
Even better, the GetOrSet methods lock on set. This means that 10 threads could be trying to load the same cache value simultaneously, but only one will actually trigger a load and set. This helps redundant resource loads and database calls and keep your application running optimally.
private T GetOrSet<T>(string key, Func<T> loader,
DateTime? expiration, TimeSpan? sliding)
{
// Get It
T value;
var success = TryGet(key, out value);
// Got It or No Loader
if (loader == null || success)
return value;
// Load It
return LockedInvoke(key, () =>
{
// Get It (Again)
success = TryGet(key, out value);
if (!success)
{
// Load It (For Real)
value = loader();
// Set It
if (value != null)
Set(key, value, expiration, sliding);
}
return value;
});
}
Instead of being forced to set each of your cache expirations separately, you now have the option to use an enum value to group your cache expirations. Enums are available for both absolute expiration and sliding expiration.
You may override the duration of each cache key in your app config; this is really useful for when you want to uniformly modify your cache expirations in your QA or testing environments. Additionally, you may override the CacheRepositoryBase.GetConfigurationValue method to pull this configuration for anywhere you want, not just the ConfigurationManager.
public enum CacheExpiration
{
VeryShort = 10, // Ten Seconds
Short = 60, // One Minute
Medium = 300, // Five Minutes
Long = 3600, // One Hour
VeryLong = 86400 // One Day
}
<configuration>
<appSettings>
<add key="CacheExpiration.VeryShort" value="15" />
<add key="CacheExpiration.Short" value="90" />
Transparent cache key management is offered through a series of ICacheRepository extension methods. This makes caching even easier, as you don't need to worry about cache key collisions.
Using these extension methods, you many cache a Cat object with an Id of 1 and a Dog object with an Id of 1 in the same manner. The extension methods will create a key prefix based on the type and then use the specified identified as the suffix.
[Fact]
public void SameKeyDifferentType()
{
var setCat = new Cat { Name = "Linq" };
CacheRepository.SetByType(1, setCat);
var setDog = new Dog { Name = "Taboo" };
CacheRepository.SetByType(1, setDog);
var getCat = CacheRepository.GetByType<Cat>(1);
Assert.Equal(setCat.Name, getCat.Name);
var getDog = CacheRepository.GetByType<Dog>(1);
Assert.Equal(setDog.Name, getDog.Name);
}
The CacheRepository.Web NuGet package includes a WebCacheRepository implementation that leverages System.Web.Caching.Cache. This is a very simple, but very effective, production ready implementation of the CacheRepositoryBase.
It should also be noted that this implementation is not only useful in ASP.NET, the System.Web.Caching.Cache is located in the System.Web library, but it still available outside of a web context. This means that this implementation can be used in other applications, including but not limited to Windows Services.
public class WebCacheRepository : CacheRepositoryBase
{
private readonly Cache _cache;
public WebCacheRepository()
{
_cache = HttpContext.Current == null
? HttpRuntime.Cache
: HttpContext.Current.Cache;
}
Wiring the cache repository to be injected into your controllers via Unity is also very easy. Just register the WebCacheRepository for the ICacheRepository interface, and be sure to provide a ContainerControlledLifetimeManager for optimal performance.
To use the implementation below, you will need to include the Unity.MVC3 NuGet Package to gain access to the UnityDependencyResolver.
public static void Initialise()
{
var container = BuildUnityContainer();
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}
private static IUnityContainer BuildUnityContainer()
{
var container = new UnityContainer();
container.RegisterType<ICacheRepository, WebCacheRepository>(
new ContainerControlledLifetimeManager());
return container;
}
If you missed the links above, here they are again:
Enjoy,
Tom
MvcBundleConfig is now available on NuGet!
MvcBundleConfig is a very simple project that adds configuration and debugging features to MVC 4's bundling framework. Once you create a new MVC4 web application and install the MvcBundleConfig NuGet Package, then you need only update our layout to use the new bundle extension methods, and you are ready to go!
Please note that the System.Web.Optimization NuGet package is still in beta, and thus that dependency is not included in the current version of the NuGet package. However, if you have created a new MVC4 project then that assembly should already be included.
Sample Installation Steps
Enjoy,
Tom
We write a lot of JavaScript.
Thus the bundling, compression, and minification of JavaScript is important to the speed and performance of modern websites. This is why I love and have been a big advocate of tools like Combres, and also why I was so excited to hear that such features were (finally) coming built in to ASP.NET MVC 4.
Introducing MvcBundleConfig
MvcBundleConfig is a very simple minimalist project I wrote to add configuration and debugging features to MVC 4's bundling framework, and achieves all 6 six of the goals listed below. It requires only MVC4 to run, and you need only add one config file to your project, one line of code to your application start, and you are off and running.
NuGet Package: https://nuget.org/packages/MvcBundleConfig/
Source on GitHub: https://github.com/tdupont750/MvcBundleConfig
Before we get to the demonstration at the bottom, let's review the needs and wants of a good minification framework.
What I NEED in a minification tool:
What I WANT in a minification tool:
MvcBundleConfig Examples
Bundles.config
<?xml version="1.0"?>
<bundleConfig ignoreIfDebug="true" ignoreIfLocal="true">
<cssBundles>
<add bundlePath="~/css/shared">
<directories>
<add directoryPath="~/content/" searchPattern="*.css" />
</directories>
</add>
</cssBundles>
<jsBundles>
<add bundlePath="~/js/shared" minify="false">
<files>
<add filePath="~/scripts/jscript1.js" />
<add filePath="~/scripts/jscript2.js" />
</files>
</add>
</jsBundles>
</bundleConfig>
Global.asax.cs
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
BundleTable.Bundles.RegisterTemplateBundles();
// Only code required for MvcBundleConfig wire up
BundleTable.Bundles.RegisterConfigurationBundles();
}
_Layout.cshtml
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
<title>@ViewBag.Title</title>
@* Call bundle helpers from MvcBundleConfig *@
@Html.CssBundle("~/css/shared")
@Html.JsBundle("~/js/shared")
</head>
<body>
@RenderBody()
</body>
</html>
In the Browser
NuGet Package: https://nuget.org/packages/MvcBundleConfig/
Source on GitHub: https://github.com/tdupont750/MvcBundleConfig
Enjoy,
Tom
ASP.NET MVC is even more configurable than you think!
Routes are registered in the Application Start of an MVC application, but there is no reason that they have to be hard coded in the Global.asax. By simply reading routes out of the Web.config you provide a way to control routing without having to redeploy code, allowing you to enable or disable website functionality on the fly.
I can't take credit for this idea, my implementation is an enhancement of Fredrik Normén's MvcRouteHandler that adds a few things that were missing:
Download MvcRouteConfig.zip for the project and a sample application.
Example Global.asax
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
var routeConfigManager = new RouteManager();
routeConfigManager.RegisterRoutes(routes);
}
Example Web.config
<configuration>
<configSections>
<section name="routeTable" type="MvcRouteConfig.RouteSection" />
</configSections>
<routeTable>
<routes>
<add name="Default" url="{controller}/{action}/{id}">
<defaults controller="Home" action="Index" id="Optional" />
<constraints>
<add name="custom"
type="MvcApplication.CustomConstraint, MvcApplication">
<params value="Hello world!" />
</add>
</constraints>
</add>
</routes>
</routeTable>
Thanks Fredrik!
~Tom
Update 2/16/2013 - I have added this source to GitHub and created a NuGet Package.
Recently I was having a conversation with a friend where I was able to articulate my thoughts on dependency injection more eloquently than I ever had before. In fact, I may have phrased this better than any nerd in the history of programming. That's a bold statement, so you be the judge:
"I didn't just swallow the inversion of control kool-aid, I went on the I.V. drip."
Unity.Mvc3
I recently starting working on a new project where they wanted to use Microsoft's Unity for their DI framework. It's not the exact flavor of IOC container would have chosen, but I am all for best practices regardless of specific implementation.
Important side note about MVC3: There is a new way to wire up for dependency injection. MVC now natively exposes a System.Web.MVC.DependencyResolver that you can set to use your container. This means that you no longer need to create a custom MVC controller factory to inject your dependencies.
While researching how best to implement Unity in my MVC 3 project, I came across Unity.Mvc3 by DevTrends. (Here is a little overview.) It's a great project for all the right reasons:
Note that last point. There are a lot of wrappers out there, and a lot of simple copy paste code snippets, but I really appreciate when someone goes out of their way to do more than just write their own version of something. To be specific, unlike many of the alternatives Unity.Mvc3 works with IDisposable dependencies, and that just happens to be a requirement of the project that I am working on.
Also, DevTrends get's additional bonus points for deploying their solution as a NuGet package!
Disposing Singletons with Application_End
I did find two small problems with Unity.Mvc3:
First and foremost, singleton dependencies (anything registered with ContainerControlledLifetimeManager) were not being disposed. This was easy enough to fix however, I just wired up a dispose call to my Bootstrapper in the MvcApplication's Application_End method.
Second, the NuGet package's initialize method was spelled wrong. I actually view this is actually a good thing, because it means that I am not the only person who makes spelling errors in code that they opensource! HA HA HA!
Bootstrapper Example
public static class Bootstrapper
{
private static IUnityContainer _container;
public static void Initialize()
{
_container = BuildUnityContainer();
var resolver = new UnityDependencyResolver(_container);
DependencyResolver.SetResolver(resolver);
}
public static void Dispose()
{
if (_container != null)
_container.Dispose();
}
private static IUnityContainer BuildUnityContainer()
{
var container = new UnityContainer();
// TODO Register Types Here
container.RegisterControllers();
return container;
}
}
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
Bootstrapper.Initialize();
}
protected void Application_End()
{
Bootstrapper.Dispose();
}
Enjoy,
Tom
Let me start off on a modest note: I am not an expert on dependency injection.
I am, however, certain of the value that it provides.
TDD
After having engaged in the same conversation time and time again, I have become convinced that there is indeed "one simple way to get any developer to write better code." That is because every developer, Junior or Senior, C# or Java, can always engage in more Test Driven Development with Dependency Injection. These are best practices that we can all agree on and that will always result in better and more maintainable code.
If you are already doing TDD with Dependency Injection, keep it up and help spread the word! If you are not, it's time to start. On the plus side, thanks to tools like NuGet, it has never been easier to get started with all of these new fun techniques. :)
Dependency Injection
Dependency Injection is a universally accepted best practice for a number or reasons, not the least of which is how easy it makes unit testing. You should be able to test one section of code without having to rely on the other 99% of your application. By injecting dependencies you are able to control what code is being tested with pin point precision.
A little ant can't move a lake, nor should it want to. However with a little help from a good surface tension framework, it can easily move a drop of water.
MVC
The MVC architecture provides you with a consistent entry point into your code: controller actions. All requests come in and get processed the same way, always passing through a consistent set of action filters and model binders. Right out of the box the MVC model binders are already injecting models straight into your controllers, so why not take it one more step forward and inject your services too?
My controller actions almost always need two things: 1) a model and 2) a service to process that model. So let the MVC model binder manage the RequestContext and inject your model, and let a DI framework manage the logic by injecting your service.
NuGet
To get started (after having installed NuGet) you need look no farther than Tools -> Library Package Manager -> Manage NuGet Packages. If you search for Ninject, a MVC3 specific package will come up that can install itself straight into your MVC3 project and get you going in mere seconds.
Ninject is just one choice of Dependency Injection framework, and it has great documentation. If you would prefer something else then just pick your flavor of choice and keep on moving.
Example
Create your controllers, models and services like normal, and update your controller to take in a service dependency through it's constructor.
public class CalculatorController : Controller
{
public ICalculatorService CalculatorService {get; private set;}
public CalculatorController(ICalculatorService calculatorService)
{
CalculatorService = calculatorService;
}
Then all that you have left to do is create a model that binds the service type to it's interface...
public class MvcExampleModule : NinjectModule
{
public override void Load()
{
Bind<ICalculatorService>().To<CalculatorService>();
}
}
...and load that in the static RegisterServices method.
public static class NinjectMVC3
{
private static void RegisterServices(IKernel kernel)
{
var module = new MvcExampleModule();
kernel.Load(module);
}
That's it. That is all that you have to do to start using Dependency Injection.
Want proof? Download the sample application.
Enjoy!
Tom
OAuth 1.0 was one complicated beast. The OAuth 2.0 spec greatly simplified things, but that also had the wonderful side effect of rending all of our old OAuth 1.0 code obsolete. They say that "the only thing a pioneer gets is an arrow in the back," I disagree, I say "the thing that only a pioneer gets to have is an adventure."
For example, I got to help write this wonderful, cutting edge, open source, OAuth 2.0 implementation for MVC!
OAuth 2.0 Overview
OAuth is all about tokens. You start by getting a Request Token from the server, and then using that to secure your login information. When you have successfully logged in you will be given a role/permission specific Access Token, you will then submit this token with all of your future requests. You will also get a Refresh Token with your Access Token. Once your Access Token has expired, you can then submit your Refresh Token to get a new pair of Access and Request Tokens.
Two Legged vs Three Legged
A two legged implementation is rather straight forward, you log into the server you are trying to access. A three legged implementation allows you to gain access to a resource by authentication with a third party server. For the time being this project only supports two legged authentication.
Implementation
You must implement four classes to use this library:
The first three are very small classes, requiring only a few short lines of code. The Service is the work horse where most of your code will go, but even then it only requires the implementation of four methods.
public abstract class OAuthServiceBase : ProviderBase, IOAuthService
{
public static IOAuthService Instance { get; set; }
public abstract OAuthResponse RequestToken();
public abstract OAuthResponse AccessToken(string requestToken,
string grantType, string userName, string password, bool persistent);
public abstract OAuthResponse RefreshToken(string refreshToken);
public abstract bool UnauthorizeToken(string token);
}
Then of course you will need to update your Web.config:
<configuration>
<configSections>
<section name="oauth" type="OAuth2.Mvc.Configuration.OAuthSection, OAuth2.Mvc, Version=1.0.0.0, Culture=neutral"/>
</configSections>
<oauth defaultProvider="DemoProvider" defaultService="DemoService">
<providers>
<add name="DemoProvider" type="OAuth2.Demo.OAuth.DemoProvider, OAuth2.Demo" />
</providers>
<services>
<add name="DemoService" type="OAuth2.Demo.OAuth.DemoService, OAuth2.Demo" />
</services>
</oauth>
<system.web>
<httpModules>
<add name="OAuthAuthentication" type="OAuth2.Mvc.Module.OAuthAuthenticationModule, OAuth2.Mvc, Version=1.0.0.0, Culture=neutral"/>
</httpModules>
</system.web>
</configuration>
Securing Your Pages
That's the easy part, just add the MVC Authorize Attribute to any actions or controllers that you want to secure.
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
[Authorize]
public ActionResult Secure()
{
return View();
}
}
The Demo API in Action
Additional Resources
Happy authenticating!
~ Tom
So, what else is new in MVC 3?
MVC 3 now has a GlobalFilterCollection that is automatically populated with a HandleErrorAttribute. This default FilterAttribute brings with it a new way of handling errors in your web applications. In short, you can now handle errors inside of the MVC pipeline.
What does that mean?
This gives you direct programmatic control over handling your 500 errors in the same way that ASP.NET and CustomErrors give you configurable control of handling your HTTP error codes.
How does that work out?
Think of it as a routing table specifically for your Exceptions, it's pretty sweet!
The new Global.asax file now has a RegisterGlobalFilters method that is used to add filters to the new GlobalFilterCollection, statically located at System.Web.Mvc.GlobalFilter.Filters. By default this method adds one filter, the HandleErrorAttribute.
public class MvcApplication : System.Web.HttpApplication
{
public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
filters.Add(new HandleErrorAttribute());
}The HandleErrorAttribute is pretty simple in concept: MVC has already adjusted us to using Filter attributes for our AcceptVerbs and RequiresAuthorization, now we are going to use them for (as the name implies) error handling, and we are going to do so on a (also as the name implies) global scale.
The HandleErrorAttribute has properties for ExceptionType, View, and Master. The ExceptionType allows you to specify what exception that attribute should handle. The View allows you to specify which error view (page) you want it to redirect to. Last but not least, the Master allows you to control which master page (or as Razor refers to them, Layout) you want to render with, even if that means overriding the default layout specified in the view itself.
public class MvcApplication : System.Web.HttpApplication
{
public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
filters.Add(new HandleErrorAttribute
{
ExceptionType = typeof(DbException),
// DbError.cshtml is a view in the Shared folder.
View = "DbError",
Order = 2
});
filters.Add(new HandleErrorAttribute());
}All of your views still work like they did in the previous version of MVC (except of course that they can now use the Razor engine). However, a view that is used to render an error can not have a specified model! This is because they already have a model, and that is System.Web.Mvc.HandleErrorInfo
@model System.Web.Mvc.HandleErrorInfo
@{
ViewBag.Title = "DbError";
}
<h2>A Database Error Has Occurred</h2>
@if (Model != null)
{
<p>@Model.Exception.GetType().Name<br />
thrown in @Model.ControllerName @Model.ActionName</p>
}The HandleErrorAttribute will only handle errors that happen inside of the MVC pipeline, better known as 500 errors. Errors outside of the MVC pipeline are still handled the way they have always been with ASP.NET. You turn on custom errors, specify error codes and paths to error pages, etc.
It is important to remember that these will happen for anything and everything outside of what the HandleErrorAttribute handles. Also, these will happen whenever an error is not handled with the HandleErrorAttribute from inside of the pipeline.
<system.web>
<customErrors mode="On" defaultRedirect="~/error">
<error statusCode="404" redirect="~/error/notfound"></error>
</customErrors>public class ExampleController : Controller
{
public ActionResult Exception()
{
throw new ArgumentNullException();
}
public ActionResult Db()
{
// Inherits from DbException
throw new MyDbException();
}
}
public class ErrorController : Controller
{
public ActionResult Index()
{
return View();
}
public ActionResult NotFound()
{
return View();
}
}If we have all the code above included in our MVC 3 project, here is how the following scenario's will play out:
But don't take my word for it, download the sample project and try it yourself.
For the most part this is all pretty straight forward, but there are a few gotcha's that you should remember to watch out for:
1) Error views have models, but they must be of type HandleErrorInfo.
It is confusing at first to think that you can't control the M in an MVC page, but it's for a good reason. Errors can come from any action in any controller, and no redirect is taking place, so the view engine is just going to render an error view with the only data it has: The HandleError Info model. Do not try to set the model on your error page or pass in a different object through a controller action, it will just blow up and cause a second exception after your first exception!
2) When the HandleErrorAttribute renders a page, it does not pass through a controller or an action.
The standard web.config CustomErrors literally redirect a failed request to a new page. The HandleErrorAttribute is just rendering a view, so it is not going to pass through a controller action. But that's ok! Remember, a controller's job is to get the model for a view, but an error already has a model ready to give to the view, thus there is no need to pass through a controller.
That being said, the normal ASP.NET custom errors still need to route through controllers. So if you want to share an error page between the HandleErrorAttribute and your web.config redirects, you will need to create a controller action and route for it. But then when you render that error view from your action, you can only use the HandlerErrorInfo model or ViewData dictionary to populate your page.
3) The HandleErrorAttribute obeys if CustomErrors are on or off, but does not use their redirects.
If you turn CustomErrors off in your web.config, the HandleErrorAttributes will stop handling errors. However, that is the only configuration these two mechanisms share. The HandleErrorAttribute will not use your defaultRedirect property, or any other errors registered with customer errors.
The HandleErrorAttribute is for displaying 500 errors that were caused by exceptions inside of the MVC pipeline. The custom errors are for redirecting from error pages caused by other HTTP codes.
Also, if you are going to be handling all these errors, why not report them too?
In MVC3 a GlobalFilterCollection has been added to the Application_Start. This allows you to register filters that will be applied to all controller actions in a single location. Also, MVC3 web applications now add an instance of HandleErrorAttribute to these GlobalFilters by default. This means that errors in the MVC pipeline will now be automatically handled by these attributes and never fire the HttpApplication's OnError event.
This is nice because it is another step away from the old ASP.NET way of doing things, and a step toward the newer cleaner MVC way of doing things. However, it did throw us a slight curve ball when updating CodeSmith Insight's HttpModule.
Side Note: The CodeSmith Insight MVC3 client assembly will be released next week (the week of 2/21/11).
Our old HttpModule wired up to the HttpApplication's OnError event and used that to log unhandled exceptions in web applications. It didn't care if the error happened in or out of the MVC pipeline, either way it was going to bubble up and get caught in the module.
public virtual void Init(HttpApplication context)
{
InsightManager.Current.Register();
InsightManager.Current.Configuration.IncludePrivateInformation = true;
context.Error += OnError;
}
private void OnError(object sender, EventArgs e)
{
var context = HttpContext.Current;
if (context == null)
return;
Exception exception = context.Server.GetLastError();
if (exception == null)
return;
var abstractContext = new HttpContextWrapper(context);
InsightManager.Current.SubmitUnhandledException(exception, abstractContext);
}However, now the MVC HandleErrorAttribute may handle exceptions right inside of the MVC pipeline, meaning that they will never reach the HttpApplication and the OnError will never be fired. What to do, what to do...
Now we need to work with both the attributes and the HttpApplication, ensuring that we will catch errors from both inside and outside of the MVC pipeline. This means that we need to find and wrap any instances of HandleErrorAttribute in the GlobalFilters, and still register our model to receive notifications from the HttpApplications OnError event.
The first thing we had to do was create a new HandleErrorAttribute. Please note that this example is simplified and only overrides the OnException method. If you want to do this "right", you'll have to override and wrap all of the virtual methods in HandleErrorAttribute.
public class HandleErrorAndReportToInsightAttribute : HandleErrorAttribute
{
public bool HasWrappedHandler
{
get { return WrappedHandler != null; }
}
public HandleErrorAttribute WrappedHandler { get; set; }
public override void OnException(ExceptionContext filterContext)
{
if (HasWrappedHandler)
WrappedHandler.OnException(filterContext);
else
base.OnException(filterContext);
if (filterContext.ExceptionHandled)
InsightManager.Current.SubmitUnhandledException(filterContext.Exception, filterContext.HttpContext);
}
}Next we needed to update our HttpModule to find, wrap, and replace any instances of HandleErrorAttribute in the GlobalFilters.
public virtual void Init(HttpApplication context)
{
InsightManager.Current.Register();
InsightManager.Current.Configuration.IncludePrivateInformation = true;
context.Error += OnError;
ReplaceErrorHandler();
}
private void ReplaceErrorHandler()
{
var filter = GlobalFilters.Filters.FirstOrDefault(f => f.Instance is HandleErrorAttribute);
var handler = new HandleErrorAndReportToInsightAttribute();
if (filter != null)
{
GlobalFilters.Filters.Remove(filter.Instance);
handler.WrappedHandler = (HandleErrorAttribute) filter.Instance;
}
GlobalFilters.Filters.Add(handler);
}Now when we register the InsightModule in our web.config, we will start capturing all unhandled exceptions again.
<configuration>
<configSections>
<section name="codesmith.insight" type="CodeSmith.Insight.Client.Configuration.InsightSection, CodeSmith.Insight.Client.Mvc3" />
</configSections>
<codesmith.insight apiKey="XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" serverUrl="http://app.codesmithinsight.com/" />
<system.web>
<customErrors mode="On" />
<httpModules>
<add name="InsightModule" type="CodeSmith.Insight.Client.Web.InsightModule, CodeSmith.Insight.Client.Mvc3"/>
</httpModules>
</system.web>
</configuration>
I love how testable ASP.NET MVC is, I also love MVC2's model validation. However when trying to unit test a controller method that used the ModelState, I quickly learned that the ModelState is not populated when just newing up a Controller and calling one of its public methods. As usual, I think this is best narrated by example:
Example Model and Controller
public class PersonModel
{
[Required]
public string Name { get; set; }
}
public class PersonController : Controller
{
[AcceptVerbs(HttpVerbs.Get)]
public ViewResult Register(Person person)
{
return View(new PersonModel());
}
[AcceptVerbs(HttpVerbs.Post)]
public ViewResult Register(Person person)
{
if (!ModelState.IsValid)
return View(model);
PersonService.Register(person);
return View("success");
}
}
Example of the Problem
[Test]
public void RegisterTest()
{
var model = new PersonModel { Name = String.Empty }; // This is model is invalid.
var controller = new PersonController();
var result = controller.Register(model);
// This fails because the ModelState was valid, although the passed in model was not.
Assert.AreNotEqual("success", result.ViewName);
}
Solution
Other solutions I have come across were adding the errors to the model state manually, or mocking the ControllerContext as to enable the Controller's private ValidateModel method. I didn't like the former because it felt like I wasn't actually testing the model validation, and I didn't like the latter because it seemed like a lot of work to both mocking things and then still have to manually expose a private method.
My solution is (I feel) pretty simple: Add an extension method to the ModelStateDictionary that allows you to pass in a model, and it will then validate that model and add it's errors to the dictionary.
public static void AddValidationErrors(this ModelStateDictionary modelState, object model)
{
var context = new ValidationContext(model, null, null);
var results = new List<ValidationResult>();
Validator.TryValidateObject(model, context, results, true);
foreach (var result in results)
{
var name = result.MemberNames.First();
modelState.AddModelError(name, result.ErrorMessage);
}
}
Example of the Solution
[Test]
public void RegisterTest()
{
var model = new PersonModel { Name = String.Empty }; // This is model is invalid.
var controller = new PersonController();
// This populates the ModelState errors, causing the Register method to fail and the unit test to pass.
controller.ModelState.AddValidationErrors(model);
var result = controller.Register(model);
Assert.AreNotEqual("success", result.ViewName);
}
One of the most exciting new features in MVC 2 is "Enhanced Model Validation support across both server and client". The new enhanced support allows for client side validation to be dynamically generated into a view quickly and easily using DataAnnotations attributes on models. This means that by simply dressing up your model properties with attributes, your web pages can instantly have dynamic client side validation; all generated and maintained for you by the MVC framework!
MVC 2 enhanced model validation really is a terrific new feature...so, what's the problem? Microsoft uses JQuery, we use ExtJS.
We here at CodeSmith absolutely love MVC, but many of features are designed to use JQuery, and we (for several different reasons) prefer to use the ExtJS Framework. This means that (as it stands) to use both we must reference both, and no one wants to download two complete AJAX frameworks just to view one webpage.
Good news, we fixed that!
Introducing: Ext.ux.MvcFormValidator
The MVC client side form validator dynamically generates a small blob of configuration for each form, and stores them in window.mvcClientValidationMetadata. Once the page loads up, the client side validator framework loads all these configs, and then starts monitoring the specified forms for validation.
What we have done is created an alternative form validation context (modeled after Sys.Mvc.FormContext) that loads the validation configuration, and requires no changes in the MVC generated code, but uses ExtJS as it's back end. This means that the only thing you have to do is reference Ext.ux.MvcFormValidator.js, and it will enable you to use the ExtJS Core for form validation instead of having to import MicrosoftMvcValidation and the other Microsoft AJAX libraries.
Features
Downloads
Ext.ux.MvcFormValidator.js: http://codesmith.googlecode.com/files/Ext.ux.MvcFormValidator.js
Demo Solution: http://codesmith.googlecode.com/files/ExtUxMvcFormValidationDemo.zip
Example
Model
public class ValidationDemoModel
{
[Required]
[StringLength(10)]
public string Name { get; set; }
[Range(10000, 99999)]
public string ZipCode { get; set; }
[RegularExpression (@"\d{3}[-]?\d{3}[-]?\d{4}", ErrorMessage="The field Phone must be valid phone number.")]
public string Phone { get; set; }
[AcceptBox]
public bool Accept { get; set; }
}
Site.Master
<script src="/Scripts/ext-core.js" type="text/javascript"></script>
<script src="/Scripts/Ext.ux.MvcFormValidator.js" type="text/javascript"></script>
<script src="/Scripts/CustomValidators.js" type="text/javascript"></script>
View
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
<h2>Validation Demo</h2>
<% Html.EnableClientValidation(); %>
<% using (Html.BeginForm()) { %>
<%= Html.LabelFor(m => m.Name) %>:
<%= Html.TextBoxFor(m => m.Name)%>
<%= Html.ValidationMessageFor(m => m.Name)%>
<br />
<%= Html.LabelFor(m => m.Phone) %>:
<%= Html.TextBoxFor(m => m.Phone)%>
<%= Html.ValidationMessageFor(m => m.Phone)%>
<br />
<%= Html.LabelFor(m => m.ZipCode) %>:
<%= Html.TextBoxFor(m => m.ZipCode)%>
<%= Html.ValidationMessageFor(m => m.ZipCode)%>
<br />
<%= Html.LabelFor(m => m.Accept) %>:
<%= Html.CheckBoxFor(m => m.Accept)%>
<%= Html.ValidationMessageFor(m => m.Accept)%>
<br />
<input type="submit" value="Submit" />
<% } %>
</asp:Content>
Controller Action
[HttpGet]
public ActionResult ValidationDemo()
{
var model = new ValidationDemoModel();
return View(model);
}
Custom Validator
Ext.Mvc.ValidatorRegistry.validators["acceptbox"] = function (rule) {
return function (value, context) {
return context.fieldContext.elements[0].checked === true;
};
};
Here it is folks: the Ultimate Ultimate* ASP.NET MVC JSON Model Binder!
Moving complex data structures from client to server used to be difficult, but not anymore! Just add the JsonBinder attribute to your action parameters, and this Custom ModelBinder will automatically detect the type and parameter name, and deserialize your complex JSON object to the data structure of your choice.
No configuration required, it works every time, it's PFM!**
* Yes, I said Ultimate twice.
** Pure Friendly Magic
JsonBinderAttribute
public class JsonBinderAttribute : CustomModelBinderAttribute
{
public override IModelBinder GetBinder()
{
return new JsonModelBinder();
}
public class JsonModelBinder : IModelBinder
{
public object BindModel(
ControllerContext controllerContext,
ModelBindingContext bindingContext)
{
try
{
var json = controllerContext.HttpContext.Request
.Params[bindingContext.ModelName];
if (String.IsNullOrWhitespace(json))
return null;
// Swap this out with whichever Json deserializer you prefer.
return Newtonsoft.Json.JsonConvert
.DeserializeObject(json, bindingContext.ModelType);
}
catch
{
return null;
}
}
}
}
Controller Action
public class PersonController : Controller
{
// Note: The JsonBinder attribute has been added to the person parameter.
[HttpPost]
public ActionResult Update([JsonBinder]Person person)
{
// Both the person and its internal pet object have been populated!
ViewData["PetName"] = person.Pet.Name;
return View();
}
}
Sample Models
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
// Note: This property is not a primitive!
public DomesticAnimal Pet { get; set; }
}
public class DomesticAnimal
{
public string Name { get; set; }
public int Age { get; set; }
public string Species { get; set; }
}
jQuery Method
function sendToServer() {
var person = {
Name : 'Tom',
Age : 27,
Pet : {
Name : 'Taboo',
Age : 2,
Species : 'Shiba Inu'
}
};
// {"Name":"Tom","Age":27,Pet:{"Name":"Taboo",Age:2,Species:"Shiba Inu"}}
var personJson = JSON.stringify(person);
$.ajax({
url: 'Person/Update',
type: 'POST',
data: {
person: personJson
}
});
}
Enjoy,
Tom
