{"id":106,"date":"2010-05-02T23:39:20","date_gmt":"2010-05-02T23:39:20","guid":{"rendered":"http:\/\/blog.joefield.co.uk\/?p=106"},"modified":"2010-05-04T09:05:04","modified_gmt":"2010-05-04T09:05:04","slug":"digging-around-fasttracktmodel-tvalue-in-asp-net-mvc-2","status":"publish","type":"post","link":"https:\/\/blog.joefield.co.uk\/?p=106","title":{"rendered":"Digging around: FastTrack in ASP.NET MVC 2"},"content":{"rendered":"

This is a second companion post to Scott Guthrie’s ASP.NET MVC 2: Strongly Typed Html Helpers<\/a>.<\/p>\n

In my previous post<\/a> I drilled down into the code executed when ASP.NET MVC 2 turned:<\/p>\n

<%= Html.TextBoxFor(model => model.ProductName) %><\/pre>\n
into:<\/p>\n
<input id="ProductName" name="ProductName" type="text" value="Aniseed Syrup" \/><\/pre>\n
We found that in order to do it ASP.NET MVC had performed two distinct operations:<\/p>\n
    \n
  1. parsed the expression tree produced by the compiler for model => model.ProductName<\/strong> to extract the name of the property ("ProductName") to use in the id and name attributes of the input element<\/li>\n
  2. compiled the expression and invoked the resulting delegate to produce the "Aniseed Syrup" value<\/li>\n<\/ol>\n
    Having examined the first case I started looking at how the expression was compiled into an executable delegate.<\/p>\n
    At this point we ran into this line of code:<\/p>\n
    return CachedExpressionCompiler.Process(expression)(container);<\/pre>\n
    The problem<\/h4>\n
    MVC is faced with a dilemma. It wants to use expression trees rather than delegates.<\/p>\n
    It likes to use the metadata obtained from the expression to, amongst other things, extract the property name.<\/p>\n
    But compiling expression trees is expensive.<\/strong><\/p>\n
    To get round this problem it maintains an in-process cache of compiled expressions.<\/em><\/strong><\/p>\n
    Disclaimer – this is a simple case<\/h4>\n
    We are only going to look at the simple property access case:<\/p>\n
    model => model.ProductName<\/pre>\n
    If we didn’t we would vanish into CachedExpressionCompiler for a long time. Many different types of expressions are compiled and cached, using different strategies.<\/p>\n
    By only looking at the property access case we will be able to visit the main classes, in particular FastTrack<TModel, TValue>.  We can look at the other caching strategies another time.<\/p>\n
    CachedExpressionCompiler.Process method<\/h4>\n
    Here’s the CachedExpressionCompiler.Process() method in full – the comment describes it way better than I just did:<\/p>\n
    \/\/ This is the entry point to the cached expression tree compiler. The processor will perform a series of checks \r\n\/\/ and optimizations in order to return a fully-compiled func as quickly as possible to the caller. If the \r\n\/\/ input expression is particularly obscure, the system will fall back to a slow but correct compilation step. \r\npublic static Func<TModel, TValue> Process<TModel, TValue>(Expression<Func<TModel, TValue>> lambdaExpression) { \r\n    return Processor<TModel, TValue>.GetFunc(lambdaExpression); \r\n} <\/pre>\n
    and here’s the beginning of Processor.GetFunc():<\/p>\n
    public static Func<TModel, TValue> GetFunc(Expression<Func<TModel, TValue>> lambdaExpression) { \r\n    \/\/ look for common patterns that don't need to be fingerprinted \r\n    Func<TModel, TValue> func = GetFuncFastTrack(lambdaExpression); \r\n    if (func != null) { \r\n        return func; \r\n    } \r\n... \r\n... \r\n... \r\n}<\/pre>\n
    We’ll talk about fingerprinting another day. Suffice it to say that the call to GetFuncFastTrack() succeeds for our expression and we need go no further.<\/p>\n
    Here’s the whole of Processor.GetFuncFastTrack():<\/p>\n
    private static Func<TModel, TValue> GetFuncFastTrack(Expression<Func<TModel, TValue>> lambdaExpression) { \r\n    ParameterExpression modelParameter = lambdaExpression.Parameters[0]; \r\n    Expression body = lambdaExpression.Body; \r\n\r\n    return FastTrack<TModel, TValue>.GetFunc(modelParameter, body); \r\n}<\/pre>\n
    The original expression has been split into its single parameter (our model) and its body and pased to the FastTrack class.<\/p>\n
    FastTrack<TModel, TValue>.GetFunc method<\/h4>\n
    And finally here’s the relevant portion of the FastTrack<TModel, TValue>.GetFunc() method.<\/p>\n
    public static Func GetFunc(ParameterExpression modelParameter, Expression body) { \r\n    ... \r\n    ... \r\n    ... \r\n    { \r\n        MemberExpression memberExpression = body as MemberExpression; \r\n        if (memberExpression != null) { \r\n            ... \r\n            ... \r\n            ... \r\n            else if (memberExpression.Expression == modelParameter) { \r\n                \/\/ model => model.Member \r\n                return GetModelMemberLookupFunc(memberExpression.Member, false \/* isStatic *\/); \r\n            } \r\n            ... \r\n            ... \r\n            ... \r\n        } \r\n    } \r\n    ... \r\n    ... \r\n    ... \r\n}<\/pre>\n
    As you can see the expression body has been successfully cast to a MemberExpression.  <\/p>\n
    A MemberExpression has two public properties:<\/p>\n
      \n
    • Expression – which represents the containing object (our "model")<\/li>\n
    • Member – which is the MemberInfo instance representing the access (our "ProductName")<\/li>\n<\/ul>\n
      MVC compares the Expression property to the ParameterExpression.  They are equal so it calls:<\/p>\n
      GetModelMemberLookupFunc(memberExpression.Member, false \/* isStatic *\/);<\/pre>\n
      which is just a wrapper for this:<\/p>\n
      return _modelMemberLookupCache.GetFunc(member, isStatic);<\/pre>\n
      I sense that we’re getting close to a cache…<\/p>\n
      ModelMemberLookupCache<\/h4>\n
      This _modelMemberLookupCache is a static member of type ModelMemberLookupCache.  ModelMemberLookupCache is derived from an abstract base class called ReaderWriteCache<TKey, TValue>.  It provides a creation function for the case when the cache lookup fails i.e. the first time.  Here’s the creation function:<\/p>\n
      private static Func<TModel, TValue> CreateFunc(MemberInfo member, bool isStatic) { \r\n    ParameterExpression modelParam = Expression.Parameter(typeof(TModel), "model"); \r\n    MemberExpression memberExpr = Expression.MakeMemberAccess((!isStatic) ? modelParam : null, member); \r\n    Expression<Func<TModel, TValue>> lambda = Expression.Lambda<Func<TModel, TValue>>(memberExpr, modelParam); \r\n    return lambda.Compile(); \r\n}<\/pre>\n
      In effect it recreates our original expression but "standardises" it by replacing the name of the parameter with "model".  This is then compiled into a delegate and stored in the cache with the MemberInfo instance as the key.<\/p>\n
      So the next time ASP.NET MVC encounters:<\/p>\n
      model => model.ProductName<\/pre>\n
      it will be able to return a pre-compiled delegate from the cache – a significant boost to performance.<\/p>\n
      Next I’ll look at the other cases FastTrack caters for, and dig around a bit more in ReaderWriterCache<TKey, TValue>.<\/p>\n","protected":false},"excerpt":{"rendered":"
      This is a second companion post to Scott Guthrie’s ASP.NET MVC 2: Strongly Typed Html Helpers. In my previous post I drilled down into the code executed when ASP.NET MVC 2 turned: <%= Html.TextBoxFor(model => model.ProductName) %> into: <input id="ProductName" name="ProductName" type="text" value="Aniseed Syrup" \/> We found that in order to do it ASP.NET MVC […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[6],"tags":[],"_links":{"self":[{"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/posts\/106"}],"collection":[{"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=106"}],"version-history":[{"count":8,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/posts\/106\/revisions"}],"predecessor-version":[{"id":115,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=\/wp\/v2\/posts\/106\/revisions\/115"}],"wp:attachment":[{"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=106"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=106"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.joefield.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=106"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}