ASP.NET

Find/Replace on Render

Noah — Mon, 01 Mar 2010 17:10:28 GMT

This post is a follow up to to 2 posts: Find/Replace on Render – an MVC alternative to Response Filters and Response.Flush and the crimes against Page Caching.

In the first post I explored a way to parse special tags before rendering a page. I’m working on a CMS that accepts special tags inside content. Those tags are then replaced on render. For example, an author might place a tag like:

        1: <CustomAmazonBestSellers Count=”5” />

to display the 5 best selling products on Amazon (we don’t support this but you get the point).

I came up with a solution but quickly ran into an issue with caching. In fact, the solution caused Page Caching to be effectively disabled which is very, very bad.

There are a number of solutions to this issue. I’ll run through 2 of them and explain why I chose to implement the one I did.

First, the solution I did not implement:

Override Page Render

The issue with Page Caching was caused by the way I was parsing through the page’s output. Inside the Render method of my custom IView, I had a routine that flushed the Response to a MemoryStream, parsed through that, and then wrote the result back to Response. This is what caused the Page Cache issue but it’s also what allowed me to do the parsing in one shot.

A single request can mean rendering a half dozen pages. You might have a Master and a Nested Master page (that makes 2). You might have your main page (which makes 3) that has a bunch of RenderPartial and/or RenderAction calls (which can add 1 or more per call).

Overriding Page Render would mean that each time any of these is rendered I would first render to string, then parse out the tags, then add the result to the Response. However, that would mean that every one of my pages would have to Inherit from MySpecialViewPage instead of System.Web.Mvc.ViewPage. This creates a bit of a tooling issue since Visual Studio automatically creates Views that inherit from System.Web.Mvc.ViewPage. Another reason I didn’t like this approach was that it felt a little dirty requiring each page to be responsible for rendering its own custom tags.

Back to Response Filters

There is a built in way of manipulating output in ASP.NET. It’s called Response Filters. A Response Filter is just a Stream that wraps the Response Output so that you can manipulate the data before sending it downstream. Our original solution used Response Filters to render these special tags. The reason I wanted a different solution in the first place was because we were outputting HTML from the Response Filter Stream (in code, using an HtmlTextWriter!) which is very ugly and unwieldy. It was very painful to create a new tag or change an existing one!

The solution I came up with is the best of both worlds. I’m using most of the code from my original IView-based solution (first link above), but instead of parsing the output on Render (which created the Page Caching issue), I do it inside a Response Filter (which was created expressly for this purpose). And when I encounter a custom tag? I have an ASPX page designed to handle just that tag and I use Server.Execute to let the ASP.NET runtime render that “template” page. BTW, Rick Strahl has a terrific write-up on Server.Execute on his blog.

And now for the code :)

The Reponse Filter (look at the RenderCustomTags method. I removed some logging and other misc stuff):

       1: /// <summary>

       2: /// This is a generic class that is used to parse all CustomTags

       3: /// It will search for all CustomTagsin the output of an ASPX

       4: /// page and, if there is a Template defined in the TagParsers

       5: /// it renders that template (passing the parameters in the QueryString)

       6: /// it makes MAX_PASSES passes over the HTML to account for

       7: /// CustomTags that output other CustomTags

       8: /// </summary>

       9: class CustomTagParser : Stream

{

    const int MAX_PASSES = 20;

    private Stream _OutputStream;

    private MemoryStream _BufferStream;

    public CustomTagParser(Stream outputStream)

    {

        _OutputStream = outputStream;

        _BufferStream = new MemoryStream();

    }

    public override bool CanRead

    {

        get { return false;  }

    }

  

    public override bool CanSeek

    {

        get { return false; }

    }

  

    public override bool CanWrite

    {

        get { return true; }

    }

  

    public override void Flush()

    {

        string html;

        _BufferStream.Position = 0;

        using (StreamReader reader = new StreamReader(_BufferStream, ASCIIEncoding.UTF8))

        {

            html = reader.ReadToEnd();

        }

        html = RenderCustomTags(html);

        byte[] utf8Bytes = ASCIIEncoding.UTF8.GetBytes(html);

        _OutputStream.Write(utf8Bytes, 0, utf8Bytes.Length);

        _OutputStream.Flush();

    }

  

    private static Dictionary<string, string> GetTagParameters(string tag)

    {

        Dictionary<string, string> paramDictionary = new Dictionary<string, string>();

        // Get param/value pairs

        Regex parameterRegex = new Regex("([a-z0-9]+)=\"([\\w\\s#|]*)\"", RegexOptions.IgnoreCase);

        foreach (Match paramMatch in parameterRegex.Matches(tag))

        {

            string paramName = paramMatch.Groups[1].Value;

            string paramValue = paramMatch.Groups[2].Value;

            paramDictionary.Add(paramName.ToLower(), paramValue);

        }

        // Get params with no value pair (e.g. "notable" in <zifftag notable>)

        Regex novalueRegex = new Regex("\\s\\b([a-z0-9]+)\\b(?!=)", RegexOptions.IgnoreCase);

        foreach (Match paramMatch in novalueRegex.Matches(tag))

        {

            string paramName = paramMatch.Groups[1].Value;

            paramDictionary.Add(paramName.ToLower(), null);

        }

        return paramDictionary;

    }

  

    private static string GetPageAndQueryString(string templateLocation, string innerText, Dictionary<string, string> parameters)

    {

        StringBuilder pageAndQueryString = new StringBuilder();

        pageAndQueryString.Append(templateLocation);

        pageAndQueryString.Append("?innerText=");

        pageAndQueryString.Append(HttpUtility.UrlEncode(innerText));

        foreach (var param in parameters)

        {

            pageAndQueryString.Append("&");

            pageAndQueryString.Append(HttpUtility.UrlEncode(param.Key));

            pageAndQueryString.Append("=");

            pageAndQueryString.Append(HttpUtility.UrlEncode(param.Value));

        }

        return pageAndQueryString.ToString();

    }

    private string RenderCustomTags(string html)

    {

        StringWriter writer = null;

        Regex customTagRegex = new Regex("<(CUSTOM[A-Z0-9]*)([^>]*)>((.*?)</\\1>)?", RegexOptions.IgnoreCase);

        for (int i = 0; i <= MAX_PASSES; i++)

        {

            int currentOffset = 0;

            writer = new StringWriter();

            MatchCollection customTagMatches = customTagRegex.Matches(html);

            if (customTagMatches.Count == 0)

                break; // no need to keep going

            foreach (Match match in customTagMatches)

            {

                // Get tag info

                string fullTag = match.Value;

                string tagName = match.Groups[1].Value;

                string innerText = string.Empty;

                string parameterString = match.Groups[2].Value;

                if (match.Groups.Count == 5 /* has closing tag */)

                    innerText = match.Groups[4].Value;

  

                // Get template location

                string templateLocation;

                if (!TagParsers.TryGetValue(tagName, out templateLocation))

                    continue; // No template defined for this tag

  

                // Write text before this tag

                writer.Write(html.Substring(currentOffset, match.Index - currentOffset));

  

                Dictionary<string, string> parameters = GetTagParameters(parameterString);

                

                string pageAndQueryString = GetPageAndQueryString(templateLocation, innerText, parameters);

                try

                {

                    HttpContext.Current.Server.Execute(pageAndQueryString.ToString(), writer);

                }

                catch (Exception ex)

                {

                    // Some logging

                }

                finally

                {

                    // Update current offset before next pass

                    currentOffset = match.Index + match.Length;

                }

            }

            // Write remainder of html to writer

            writer.Write(html.Substring(currentOffset));

            html = writer.ToString();

        }

        return html;

    }

    public override long Length

    {

        get { return _BufferStream.Length; }

    }

  

    public override long Position

    {

        get

        {

            throw new NotImplementedException();

        }

        set

        {

            throw new NotImplementedException();

        }

    }

  

    public override int Read(byte[] buffer, int offset, int count)

    {

        throw new NotImplementedException();

    }

  

    public override long Seek(long offset, SeekOrigin origin)

    {

        throw new NotImplementedException();

    }

  

    public override void SetLength(long value)

    {

        throw new NotImplementedException();

    }

  

    public override void Write(byte[] buffer, int offset, int count)

    {

        _BufferStream.Write(buffer, offset, count);

    }

}

I created a static class called TagParsers that basically acts as a case-insensitive dictionary (so that tags are found regardless of cASe):

       1: public static class TagParsers

       2: {

       3:     private static IDictionary<string, string> _TagParsers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

       4:  

       5:     #region IDictionary<string,string> Members

       6:  

       7:     public static void Add(string tagName, string relativeTemplateLocation)

       8:     {

       9:         _TagParsers.Add(tagName, relativeTemplateLocation);

    }

  

    public static bool ContainsKey(string tagName)

    {

        return _TagParsers.ContainsKey(tagName);

    }

  

    public static ICollection<string> Keys

    {

        get { return _TagParsers.Keys; }

    }

  

    public static bool Remove(string tagName)

    {

        return _TagParsers.Remove(tagName);

    }

  

    public static bool TryGetValue(string tagName, out string relativeTemplateLocation)

    {

        return _TagParsers.TryGetValue(tagName, out relativeTemplateLocation);

    }

  

    public static ICollection<string> Values

    {

        get { return _TagParsers.Values; }

    }

  

    #endregion

  

}

And the last piece of the puzzle was adding all of my custom tags to my TagParsers dictionary (inside Global.asax):

       1: TagParsers.Add("CustomAmazonBestSellers", "~/CustomTagTemplates/AmazonBestSellers.aspx");

The AmazonBestSellers.aspx page has code-behind that just interprets the QueryString parameters (in the fictional Amazon best-selling case above, “count=5”)

And just for the sake of completion, attaching the Response Filter goes something like this (don’t forget to add the HttpModule it to the Web.Config):

       1: class CustomTagParserHttpModule : System.Web.IHttpModule

       2: {

       3: ...

       4:     void System.Web.IHttpModule.Init(System.Web.HttpApplication context)

       5:     {

       6:         context.PostRequestHandlerExecute += new EventHandler(context_PostRequestHandlerExecute);

       7:     }

       8:     void context_PostRequestHandlerExecute(object sender, EventArgs e)

       9:     {

      10:         HttpApplication application = (HttpApplication)sender;   

      11:         application.Response.Filter = new  CustomTagParser(application.Response.Filter);

      12:     }

      13: }

Help me build a great software development course

Noah — Tue, 09 Feb 2010 17:17:45 GMT

It looks like I might be giving a course on Beginning .NET Development to non developers with IT backgrounds. I'm putting together my lectures and it's really hard. I want to make sure that I explain things so others can understand them.

Even though this is a .NET course (with a web-based slant), I really see it as a fundamental software development (crash) course. You can’t become a great developer without understanding what’s going on behind the scenes. If you have any thoughts or advice on any of the topics at hand (am I missing a topic? are they poorly ordered? do you have a great analogy for something?) or just some general thoughts or advice, I'd be grateful if you would pass them along.

Here's what I have in regards to topics for the course:

Principals in software engineering

What are numbers (decimal, binary, hex)
Memory & microprocessors (rundown on how code gets executed)

Into to OOP

What's assembly language
C and low level languages
Beginning OOP (concepts relevant to OOP)

Microsoft .NET Platform

Native executable vs intermediate language (history, how it works)
Basic types & operators
Pass by Value vs reference
Using Visual Studio

Principals of web architecture

What's the internet?
State vs stateless

Fundamentals of ASP.NET

What is ViewState?
Configuration

Proficiency in C#

Basic structure
Flow control, ifs, fors, whiles, methods
OOP (classes, interfaces, polymorphism)
Generics*
Lambda expressions & functional programming*

* These topics might have to be left for the next, more advanced course depending on time contraints

ASP.NET MVC & State Pattern: Choose your view

Noah — Fri, 08 Jan 2010 19:10:56 GMT

Problem

I have a model that uses the State pattern. Some States allow read/write access to the Model’s properties and some are read-only. I wanted a good way to separate the logic for this from my Views; the View shouldn’t have to decide whether properties are displayed as TextBoxes or inside Divs.

First Thought

At first I was going to create a custom ViewEngine. That ViewEngine would be responsible for choosing the right View – that is, if the View was called “Edit” but the model was in a readonly state, it would change the View to “ReadOnly”. However, that just didn’t sound right – why was that responsibility falling on the ViewEngine? Plus, it’s kind of inflexible – what if some editable Views are called “Edit” but some are called “Details”.

Solution

I ended up with a mixture of a custom ActionFilter and a base Controller class. Before I show you the code, let me show you the usage:

        1: [AcceptVerbs(HttpVerbs.Get)]

       2: [StateItemEditView("ReadOnly")]

       3: public ActionResult Edit(int id)

       4: {

       5:     var module = _Repository.GetByID(id);

       6:     return View(module);

       7: }

Notice Line 2 – this specifies that:

The current action has editable content
The ReadOnly View name is called “ReadOnly”

The code for the controller, which I use as a base class for my controllers that act upon StateItems:

       1: public class StateItemController : Controller

       2: {

       3:     protected override ViewResult View(string viewName, string masterName, object model)

       4:     {

       5:         object readOnlyViewName;

       6:         if (ControllerContext.Controller.TempData

       7:             .TryGetValue(StateItemEditViewAttribute.key_ReadOnlyView, out readOnlyViewName))

       8:         {

       9:             var stateItem = model as IStateItem;

      10:             if (workflowItem != null && stateItem.CurrentState.IsReadOnly)

      11:                 viewName = readOnlyViewName as string;

      12:         }

      13:         return base.View(viewName, masterName, model);

      14:     }

      15: }

Before returning the View, which has a ViewName string, we want to make sure the ViewName is correct. We check the Controller’s TempData for a predefined key. If that key exists, the value will be the name of the View to display for ReadOnly states. We then check if the Model exists and is a StateItem, and if it’s ReadOnly we change the ViewName before returning the View.

The StateItemEditViewAttribute is just responsible for setting the TempData key:

       1: public class StateItemEditViewAttribute : ActionFilterAttribute

       2: {

       3:     public StateItemEditViewAttribute(string readOnlyView)

       4:     {

       5:         _ReadOnlyView = readOnlyView;

       6:     }

       7:     private string _ReadOnlyView;

       8:     public const string key_ReadOnlyView = "ReadOnlyView";

       9:     public override void OnActionExecuting(ActionExecutingContext filterContext)

      10:     {

      11:         filterContext.Controller.TempData.Add(key_ReadOnlyView, _ReadOnlyView);

      12:     }

      13: }

I’m using this for a binary dicision – Edit/ReadOnly – but this could be used for a lot of other purposes too.

Find/Replace on Render – an MVC alternative to Response Filters

Noah — Mon, 16 Nov 2009 22:55:28 GMT

UPDATE 02/03/2010: You might NOT want to use this method as it screws up Page Caching: http://blog.statichippo.com/archive/2010/02/03/response.flush-and-the-crimes-against-page-caching.aspx

This post is sort of in response to another post of mine entitled Rendering ViewPage to random stream (or not). Back then I was looking for this solution. Now I found it!

If you’re not familiar with Response Filters, read the MSDN article and this quick example at aspnetlibrary.com. Basically, Reponse Filters are used to filter output before it gets sent downstream. This is useful if you want to, say, replace certain special characters.

Background & the existing Response Filter solution

I’m working on a Content Management System that does just this. Let’s say you want to create a page break in your page, you might have a <PAGEBREAK /> tag inside the content. This is a simple example, but there are more complex examples too, such as displaying Commerce info based on information in content.

The way this was done before was via Response Filters, but I wanted these special tags to be handled as each Page/Partial was rendered. There were a few reasons for this:

Using response filters meant storing the HTML to render outside of an ASPX page. I have seen people render ASPX pages for this kind of thing, but considering the logic for rendering a special tag in a Controller “felt” right, I didn’t want to go this route
The existing solution was using a separate filter for each tag. What that meant was that before the Response was sent downstream, it was converted into a String numerous times in order to do a Find/Replace (one time for each tag filter). Keep in mind that one tag might render another tag, so there is a bit of recursive goodness going on here too. Now this could also have been refactored so that a single Filter would do the Find and hand over the Replace to other classes, but, again, I wanted these tags to be rendered through a Controller in-pipeline with the pages that contain them.

IView, in-pipeline rendering solution

At first I thought it would be a pretty simple fix. I’d just create an IView that renders to a string and then do a find/replace. That’s basically what I did, however, this is harder than it sounds.

        1: public class MyView : WebFormView

       2: {

       3:     string _Masterpath;

       4:     string _ViewPath;

       5:  

       6:     public MyView(string viewPath)

       7:         : this(viewPath, null)

       8:     {

       9:     }

      10:     public MyView(string viewPath, string masterpath)

      11:         : base(viewPath, masterpath)

      12:     {

      13:         _Masterpath = masterpath;

      14:         _ViewPath = viewPath;

      15:     }

      16:     

      17:     public override void Render(ViewContext viewContext, System.IO.TextWriter writer)

      18:     {

      19:         string response = RenderToString(viewContext, writer);

      20:     

      21:         // WebFormView doesn't care about the writer arg

      22:         var outputTextWriter = viewContext.HttpContext.Response.Output; 

      23:         MyTagParser.RenderTags(response, viewContext, outputTextWriter);

      24:     }

      25: }

I created a class called MyView that inherits from WebFormView, since that’s the default we’re using anyway. You’ll notice the above code is missing the RenderToString() method. That’s what I had the hardest time on.

After some failed attempts, I did a quick google search and found this post on stackoverflow. The question was how to render a View to a String and Tim Scott had a great idea, which I ended up using. I just wish I thought of it!

The idea is basically to create a new MemoryStream and use it as your Response Filter. Render your View the normal way, but now it will be rendered to the MemoryStream instead of the Response. Now you can create a StreamReader to read the contents of the MemoryStream into a string.

Here’s that method:

       1: private string RenderToString(ViewContext viewContext, TextWriter writer)

       2:     {

       3:         string responseString = null;

       4:         var response = viewContext.HttpContext.Response;

       5:         response.Flush();

       6:         var oldFilter = response.Filter;           

       7:         Stream filter = null;

       8:         try

       9:         {

      10:             filter = new MemoryStream();

      11:             response.Filter = filter;

      12:             

      13:             base.Render(viewContext, writer);

      14:             response.Flush();

      15:             filter.Position = 0;

      16:             var reader = new StreamReader(filter, response.ContentEncoding);

      17:             responseString = reader.ReadToEnd();

      18:         }

      19:         finally

      20:         {

      21:             if (filter != null)

      22:                 filter.Dispose();

      23:  

      24:             response.Filter = oldFilter;

      25:         }

      26:         return responseString;

      27:     }

So, now that the I’m getting a string, it’s time for the Find/Replace code. That’s in the MyTagParser class with its helper methods (but missing the main, RenderTags method, below):

       1: public class MyTagParser

       2:     {

       3:         public static IDictionary<string, ITagParser> TagParsers = 

       4:             new Dictionary<string, ITagParser>(StringComparer.CurrentCultureIgnoreCase);

       5:         const int MAX_RECURSION = 50;

       6:         private const string k_RECURSION_COUNT = "tag_parser_recursion_count";

       7:  

       8:         private static Dictionary<string, string> GetTagParameters(string tag)

       9:         {

            Dictionary<string, string> paramDictionary = new Dictionary<string, string>();

            // Get param/value pairs

            Regex parameterRegex = new Regex("([a-z0-9]+)=\"([\\w\\s#|]*)\"", 

                    RegexOptions.IgnoreCase);

            foreach (Match paramMatch in parameterRegex.Matches(tag))

            {

                string paramName = paramMatch.Groups[1].Value;

                string paramValue = paramMatch.Groups[2].Value;

                paramDictionary.Add(paramName.ToLower(), paramValue);

            }

            // Get params with no value pair (e.g. "notable" in <zifftag notable>)

            Regex novalueRegex = new Regex("\\s\\b([a-z0-9]+)\\b(?!=)", 

                    RegexOptions.IgnoreCase);

            foreach (Match paramMatch in novalueRegex.Matches(tag))

            {

                string paramName = paramMatch.Groups[1].Value;

                paramDictionary.Add(paramName.ToLower(), null);

            }

            return paramDictionary;

        }

  

        private static ITagParser FindCorrespondingTag(string tagName)

        {

            ITagParser ziffTag = null;

            if (TagParsers.ContainsKey(tagName))

                return TagParsers[tagName];

            return null;

        }

        private static int IncrementRecursionCount(ViewContext viewContext)

        {

            IDictionary httpItems = viewContext.HttpContext.Items;

            if (!httpItems.Contains(k_RECURSION_COUNT))

                httpItems[k_RECURSION_COUNT] = 0;

            int recursionCount = (int)httpItems[k_RECURSION_COUNT];

            httpItems[k_RECURSION_COUNT] = ++recursionCount;

            return recursionCount;

        }

        private static void WriteTextToOutput(string origString, TextWriter writer, 

                int startOffset, int endOffset)

        {

            int length = endOffset - startOffset;

            string str = origString.Substring(startOffset, length);

            writer.Write(str);

        }

        // RenderMyTags() method below

    }

Since these tags can be nested, we don’t want infinite loops. I have a key that’s stored in the HttpContext Items to prevent this – if our count gets beyond MAX_RECURSION, we won’t process any more tags. Just an explanation of some of the regex:

Our tags aren’t HTML and can look like any of these examples:

And finally, the RenderMyTags method does all the manly work:

       1: public static void RenderMyTags(string origString, ViewContext viewContext, 

       2:     TextWriter writer)

       3:  {

       4:      if (string.IsNullOrEmpty(origString))

       5:          return;

       6:      int recursionCount = IncrementRecursionCount(viewContext);

       7:      int renderOffset = 0;

       8:  

       9:      Regex specialTagRegex = new Regex("<(SPECIAL[A-Z0-9]*)[^>]*>((.*?)</\\1>)?", 

        RegexOptions.IgnoreCase);

     MatchCollection specialTagMatches = specialTagRegex.Matches(origString);

  

     foreach (Match match in specialTagMatches)

     {

         // Write the text before this tag

         WriteTextToOutput(origString, writer, renderOffset, match.Index);

  

         if (recursionCount <= MAX_RECURSION)

         {

             string fullTag = match.Value;

             string tagName = match.Groups[1].Value;

             string innerText = string.Empty;

             if (match.Groups.Count == 4 /* has closing tag */)

                 innerText = match.Groups[3].Value;

             int trueMatchIndex = match.Index + renderOffset;

  

             ITagParser tagParser  = FindCorrespondingTag(tagName);

             if (tagParser != null)

             {

                 Dictionary<string, string> parameters = GetTagParameters(fullTag);

                 tagParser.RenderTag(viewContext, fullTag, innerText, parameters);

             }

         }

         renderOffset = match.Index + match.Length;

     }

  

     // Write the remaining text

     WriteTextToOutput(origString, writer, renderOffset, origString.Length);

     

 }

Regex blows up with NULL strings, so line 4 just checks for that. Line 7 keeps renderOffset – this helps us keep track of where we are in the string we’re processing. Imagine the following string:

SOME TEXT <SPECIALTAG> SOME MORE TEXT

We want to write out the SOME TEXT, then render the SPECIALTAG, then again write the SOME MORE TEXT.

The rest is pretty self explanatory.

LINQ to SQL Entities and DDD

Noah — Mon, 09 Nov 2009 03:06:36 GMT

We’re using LINQ-to-SQL (L2S from here on in) for a new project. L2S has a number of drawbacks, and those are especially underscored when working with a very old and severely ‘lagacy’ database.

L2S has a 1:1 relationship between tables and objects and a 1:1 relationship between columns and properties. That doesn’t work very well if your database doesn’t map to the business objects you wish you had ;). L2S also has a very tight relationship with your business entities which will make any sort of move away from L2S near impossible the larger your app gets.

But requirements are requirements and ours use L2S, so we had to make do. However, I feared for the life of our project when I noticed L2S objects were scattered all over our BLL. Since these L2S entities mimic our database 1:1, they are extremely far removed from the business logic we want to implement and there were methods being created to do get information used to bridge gaps and weird stuff like that.

I tried out a solution and I’m glad to say it worked (meaning the CTO wants to remove all references to other implementations – I’m extremely happy) -- that’s why I’m finally publishing this post.

Here’s how it works:

1) I’ve created an interfaces that mimics our Domain – not our database.

2) I created wrappers for all the L2S entities (sometimes more than 1 wrapper, I’ll get into that in a bit*) that wrap the logic required to rewire the L2S entities (basically the DB schema) to the interfaces.

3) I created Repositories that abstract away the L2S DataContexts

Now in order to change object relational mappers (say, if we want to use NHibernate in the future), we will only need to create new objects that implement the interfaces and new repositories to access the data. Yay!

Multiple Wrappers

* The reason for the multiple wrappers is that sometimes you have an object that has some self references (for instance, a category might have a parent category with a parent category etc). Eg:

        1: public class Category

       2: {

       3:     public string Name { get; }

       4:     public Category Category { get; }

       5: }

In these cases, you might not need all the information on the parent object, but with the way L2S works you’d be forced to do a full SELECT statement (meaning it includes all the columns) for the parent and parent’s parent etc. and there might be lots of waste there.

So if you have a table (A) you could have 2 L2S entities, one called FullA with all the columns from A and one called ParentA with just a few columns from the A table. By creating a relationship between FullA and ParentA and a self reference between ParentA and itself, you bypass this issue. Then you would have a FullA wrapper which fully implements the interface and a ParentA wrapper which does not. But since both FullA and ParentA implement IAInterface, you leave yourself open at a later date for using a different (better) Object Relational Mapper.

MVC RenderAction or RenderPartial graceful exception handling

Noah — Mon, 09 Nov 2009 02:20:33 GMT

We recently had a little dilemma that I’m sure others have had. We have a lot of areas of our pages that are rendered using RenderPartial or RenderAction (part of MVC Futures) and we want graceful handling of exceptions. Of course exceptions shouldn’t happen, but sometimes they do (if only everyone practiced TDD…), and with 1M hits a day we would like to be able to at least show as much content (and ads ;) as we can – even if something does go wrong.

ViewEngine & IView

So I was approached about this issue and my solution was very simple:

We created a custom ViewEngine that returns a custom IView (just inherits from the default WebFormView) that wraps its base.Render() call in a try/catch.

Very simple and works like a charm!

Rendering ViewPage to random stream (or not)

Noah — Wed, 16 Sep 2009 21:50:00 GMT

Update - I actually seem to have gotten a working solution to this (one I’m comfortable with). I blogged about it here.

I had this crazy idea.

My company has some Response Filters that replace tokens in the outputted HTML into some other data. Now that we're moving over to MVC I figured hey -- maybe I can do a better job with these. You see, these Filters have inline HTML -- that is, they use a StringBuilder to create the necessary HTML to replace the token. That's no fun -- first of all it's not too pretty, but also, what happens when the designer wants to make a change?

My crazy idea was to call an Action from within the Filter. I figured this would have a couple benefits:

Decouple UI from the data (that's what MVC's all about right?)
Provide 1 stop for this information (so now the same method can be called from within the web app, without the need for a token, and the same method will be called from the filter to replace the token)

I figured the process would go something like this:

Create a StreamWriter that points to a MemoryStream
Create a faux Response object that uses this StreamWriter
Have the ControllerFactory.Current create the controller
Invoke the Action on the Controller using the in-memory Response
Since the output will be sent to MemoryStream, just read it from there and replace the token

Sound simple, right? It's not!

First of all, HttpContext is a magical, super-inter-dependent beast.

        1: IControllerFactory factory = ControllerBuilder.Current.GetControllerFactory();

       2: // I need an HttpRequest    

       3: HttpRequest httpRequest = new HttpRequest(HttpContext.Current.Request.FilePath, 

       4:     HttpContext.Current.Request.Url.AbsoluteUri, string.Empty);

       5: // Here's the stream I'm going to put the response into

       6: MemoryStream memStream = new MemoryStream();

       7: // I need a Response to hold the stream

       8: HttpResponse response = new HttpResponse(new StreamWriter(memStream));

       9: // I need an HttpContextBase, which wraps the HttpContext

      10: // which requires the Request & Response

      11: HttpContextBase httpContext = new HttpContextWrapper(

      12:     new HttpContext(httpRequest, response));

      13: // I need a RequestContext to feed into the Execute method on my Controller

      14: RequestContext requestContext = new RequestContext(httpContext, new RouteData()

      15:     {

      16:         Values = { { "controller", "Home" }, 

      17:         { "action", "SomeAction" } }

      18:     });

      19: IController controller = factory.CreateController(requestContext, "Home");

      20: controller.Execute(requestContext);

Man, that was a lot of work! And you know what? It doesn’t even work!

That’s right, get used to it because this post is all about things not working. If you’re looking for a quick fix, you might want to visit google because you won’t find it in this post. The above code generates the following Exception on line 16:

The SessionStateTempDataProvider requires SessionState to be enabled.

And a quick peek at Reflector tells me this is because the HttpContext (that I’m passing in) has a Session object that’s null.

Ok, so I came up with another, simpler and more elegant way of accomplishing this, if not a little more dependent:

       1: // Queue up all my HttpContext dependencies

       2: HttpRequest httpRequest = new HttpRequest(HttpContext.Current.Request.FilePath, 

       3:     HttpContext.Current.Request.Url.AbsoluteUri, string.Empty);

       4: MemoryStream memStream = new MemoryStream();

       5: HttpResponse response = new HttpResponse(new StreamWriter(memStream));

       6: HttpContextBase httpContext = new HttpContextWrapper(

       7:     new HttpContext(httpRequest, response));

       8:  

       9: // In reality I'd use reflection for this, 

      10: // but as you'll see the code won't work anyway so why bother?

      11: HomeController homeController = new HomeController();

      12: ControllerContext controllerContext = new ControllerContext(httpContext, new RouteData(){

      13:     Values = {{ "controller", "Home"}, 

      14:     { "action", "SomeAction"}}

      15: }, homeController);

      16:  

      17: // Again, I would use reflection but it's a waste of time

      18: ActionResult result = homeController.SomeAction();

      19: result.ExecuteResult(controllerContext);

Looks pretty good, right? What I’m doing is creating the Controller (in a non proof-of-concept I’d use reflection to queue that up) and then calling the necessary Action which returns an ActionResult. I’m then running the ExecuteResult method on said ActionResult passing in my ControllerContext which has a reference to my HttpContext which in turn writes data to my MemoryStream.

However, this also doesn’t work as (I) expected. What ends up happening is that the MemoryStream length remains 0 but the output from the ActionResult ends up on the calling page – at the top of the page.

I debugged against the MVC source code and you want to see the culprit? ViewPage.cs, line 110:

       1: public virtual void RenderView(ViewContext viewContext) {

       2:     ViewContext = viewContext;

       3:     InitHelpers();

       4:     // Tracing requires Page IDs to be unique.

       5:     ID = Guid.NewGuid().ToString();

       6:     ProcessRequest(HttpContext.Current);

       7:  

       8: }

Notice the last line there:

ProcessRequest(HttpContext.Current);

So, no matter what you do, you’ll still be passing the HttpContext.Current (with its StreamWriter) back to the Page to get rendered. Damn!

So what are the options here?

I could inherit from ViewPage and override the RenderView. That might work, but could cause other bugs because HttpContext is still super duper dependent and to debug I’ll have to head on over to the .NET Framework code (which, luckily, is available). I’ll also probably want to create a new class for my Controllers (which we already have, actually) to inherit from Controller so that I can create some sort of View method that will return my special inherited ViewPage that calls this overridden RenderView.

This no longer strikes me as quite the elegant solution I first assumed it would be.

I’m not quite sure the direction I’m going to take this now.

UriModelBinder for ASP.NET MVC RTM

Noah — Mon, 23 Mar 2009 14:59:00 GMT

I blogged a while ago about creating a UriModelBinder to bind a url string to a Uri object (see http://blog.statichippo.com/archive/0001/01/01/uri-modelbinders-and-updatemodel.aspx) but things have changed since then (I think that was RC1, but I don't recall).

Anyway, here's the same gist updated for the MVC RTM release:

        1: public class UriModelBinder : IModelBinder

       2: {

       3:     #region IModelBinder Members

       4:     public object BindModel(ControllerContext controllerContext, 

       5:             ModelBindingContext bindingContext)

       6:     {

       7:         ValueProviderResult result;

       8:         Uri url = null;

       9:         bindingContext.ValueProvider.TryGetValue(bindingContext.ModelName, 

      10:             out result);

      11:         if (result != null && string.IsNullOrEmpty(result.AttemptedValue))

      12:         {

      13:             if (Uri.TryCreate(result.AttemptedValue, UriKind.RelativeOrAbsolute, 

      14:                 out url))

      15:             return url;

      16:         }

      17:         return null;

      18:     }

      19:     #endregion

      20: }

As you can see, the code is pretty simple. I'm returning a NULL Uri if the Url is not valid. I'm also accepting Relative OR Absolute Uris. This might not be what you want to do. But as you can see, custom model binders are pretty easy.

---------

A friend asked me how this works, so I'm gonna post it here:

Take a look at this line:

       1: bindingContext.ValueProvider.TryGetValue(bindingContext.ModelName, out result);

What we're doing here is attempting to get a ValueProviderResult based on the the bindingContext.ModelName. Keep in mind that the ValueProvider is a way of getting a value and in our website is most likely in the form of a FormCollection.

Now I'm using the bindingContext.ModelName to pull the value because a Uri is made up of only a single field -- i.e. I have a website with textbox called website url that takes an entire string like "http://www.google.com" . So if we're traversing an object tree and one of the properties that we're binding is called "WebsiteUrl", we'll expect that a field called "WebsiteUrl" is posted with the rest of the data and that's the bindingContext.ModelName. Now this might change if we were building a more complex object or an object that's based on multiple fields.

Uri, ModelBinders, and UpdateModel()

Noah — Fri, 07 Nov 2008 14:55:00 GMT

So you're developing an application using ASP.NET MVC and you got a Person class with properties:

        1: string FirstName;

       2: string LastName;

       3: string Email;

       4: Uri Webpage;

And of course you have a form that collects these 4 pieces of information. And you build an Action in your PersonController called Create like so:

       1: public ActionResult Create(FormCollection form)

       2: {

       3:     Person p = new Person();

       4:     UpdateModel(p, form);

       5: }

and you run it thinking you're done and ready to go home and.... get an Exception on the line UpdateModel(p, form). Why?

The answer has to do with ModelBinders and the IModelBinder interface and how UpdateModel() works. That was something I couldn't find too much information about so I thought I would write this post.

Basically, the MVC framework provides you with a cool method called UpdateModel that will take all the data from an IValueProvider (not gonna get into this right now) and update the model you send it with that data. If the model is a complex type, it will iterate over all the properties and try to set them automagically. But it isn't actually magic. The reason why your UpdateModel(p, form) line is crapping out is because the ModelBinder doesn't know how to transform a string (e.g. "http://www.google.com") into an object of type Uri.

The nice thing is that you can add your own custom binders by extending IModelBinder. Here's the code I used for UriModelBinder:

       1: internal class UriModelBinder : IModelBinder

       2: {

       3:     public ModelBinderResult BindModel(ModelBindingContext bindingContext)

       4:     {

       5:         ValueProviderResult valueProviderResult = bindingContext.ValueProvider

       6:             .GetValue(bindingContext.ModelName);

       7:         if (valueProviderResult != null && !string

       8:             .IsNullOrEmpty(valueProviderResult.AttemptedValue))

       9:         {

      10:             Uri url = new Uri(valueProviderResult.AttemptedValue);

      11:             return new ModelBinderResult(url);

      12:         }

      13:         return new ModelBinderResult(null);

      14:     }

      15: }

* keep in mind that this will throw an error if the url is not formatted properly (because that's what happens when you try instantiating a new Uri with an improperly formatted url) but will set the Uri to null if the string representing it is blank. This is intentional, but not necessarily what YOU want.

Very simple here. Just get the string value that we will use to set the property value and check if it's null or empty. If so, just return null. If not, create a new Uri using the attempted value and return that.

Now to get this to work we just need one more thing -- an entry in the Global.asax to register this Binder (otherwise it just sits there and nobody knows about it):

       1: ModelBinders.Binders.Add(typeof(Uri), new UriModelBinder());

that means -- "use this UriModelBinder to convert values to type Uri".

Pretty cool. You could also create a binder for the entire Person object using this same basic idea. Google that and you'll see numerous examples.

Here's a free one -- I also built a binder for DateTime? (that's Nullable DateTime):

       1: internal class NullableDateTimeModelBinder : IModelBinder 

       2: { 

       3:     public ModelBinderResult BindModel(ModelBindingContext bindingContext) 

       4:     { 

       5:         ValueProviderResult valueProviderResult = bindingContext.ValueProvider

       6:             .GetValue(bindingContext.ModelName); 

       7:         if (valueProviderResult != null 

       8:                 && !string.IsNullOrEmpty(valueProviderResult.AttemptedValue)) 

       9:         { 

      10:             DateTime date = DateTime.Parse(valueProviderResult.AttemptedValue); 

      11:             return new ModelBinderResult(date); 

      12:         } 

      13:         return new ModelBinderResult(null); 

      14:     } 

      15: }

Pretty simple, huh?

ASP.NET MVC Captcha

Noah — Tue, 28 Oct 2008 21:53:00 GMT

I was looking for an ASP.NET MVC Captcha control and stumbled upon Nick Berardi's (http://www.coderjournal.com/2008/06/mvc-captcha-for-preview-release-3/).

First of all I'm using IIS7 and had trouble getting the HttpHandler to register properly. I ended up with the following steps to get it to work:

Add <add verb="GET" path="captcha.ashx" validate="false" type="ManagedFusion.Web.Handlers.CaptchaImageHandler, ManagedFusion.Web.Captcha" /> to <httpHandlers> in Web.config
Add <add name="CaptchaImageHandler" verb="GET" path="captcha.ashx" type="ManagedFusion.Web.Handlers.CaptchaImageHandler, ManagedFusion.Web.Captcha" /> to the <handlers> section within <system.webserver> in Web.config
Add routes.IgnoreRoute("{handler}.ashx"); to Global.asax

So that got it working, but there were a few pieces of functionality I felt were missing:

1) I wanted the ability to style the CaptchaTextBox

The site I'm working with is pretty design intensive and I needed a way to inject CSS information into the CaptchaTextBox Html Helper. I reworked the CaptchaHelper and modified the CaptchaTextBox as well as added some overloads:

        1: public static string CaptchaTextBox(this HtmlHelper helper, string name)         

       2: {             

       3:     return helper.CaptchaTextBox(name, null);         

       4: }

       5: public static string CaptchaTextBox(this HtmlHelper helper, string name, 

       6:     Object htmlAttributes)

       7: {

       8:     return helper.CaptchaTextBox(name, 

       9:         ((IDictionary<string, object>)new RouteValueDictionary(htmlAttributes)));         

}         

public static string CaptchaTextBox(this HtmlHelper helper, string name,

 IDictionary<String, Object> htmlAttributes)         

{             

    ModelState state;             

    TagBuilder builder = new TagBuilder("input");             

    builder.MergeAttributes<string, object>(htmlAttributes);             

    builder.MergeAttribute("type", "text");             

    builder.MergeAttribute("name", name);             

    builder.MergeAttribute("id", name);             

    builder.MergeAttribute("value", "");             

    builder.MergeAttribute("maxlength", 

        ManagedFusion.Web.Controls.CaptchaImage.TextLength.ToString());             

    builder.MergeAttribute("autocomplete", "off");             

    

    if (helper.ViewData.ModelState.TryGetValue(name, out state) 

        && (state.Errors.Count > 0))             

    {                

        builder.AddCssClass("input-validation-error");             

    }             

    return builder.ToString(TagRenderMode.SelfClosing);         

}

I got the TagBuilder idea from checking out the Reflector on System.Web.MVC. Pretty cool stuff there. So now I can use the CaptchaTextBox like so:

<%= Html.CaptchaTextBox("captcha", new { @class = "field" })%>

2) I wanted the CaptchaValidationAttribute to invalidate my Model if the captcha isn't valid

(instead of inject a captchaValid with a value of false into my routedata which is what it does off the shelf)

For this I modified the CaptchaValidationAttribute class. The first thing I did was make add an ErrorMessage string property. Then I modified the OnActionExecutingContext method to look like this:

       1: public override void OnActionExecuting(ActionExecutingContext filterContext)         

       2: {             

       3:     // get the guid from the post back             

       4:     string guid = filterContext.HttpContext.Request.Form["captcha-guid"];             

       5:     // check for the guid because it is required from the 

       6: //rest of the opperation             

       7:     if (String.IsNullOrEmpty(guid))            

       8:     {                 

       9:         filterContext.Controller.ViewData.ModelState

      10:             .AddModelError(Field, ErrorMessage);                 

      11:         return;             

      12:     }            

      13:     // get values             

      14:     CaptchaImage image = CaptchaImage.GetCachedCaptcha(guid);             

      15:     string actualValue = filterContext.HttpContext.Request.Form[Field];             

      16:     string expectedValue = image == null ? String.Empty : image.Text;            

      17:     // removes the captch from cache so it cannot be used again             

      18:     filterContext.HttpContext.Cache.Remove(guid);            

      19:     // validate the captch             

      20:     if (String.IsNullOrEmpty(actualValue) 

      21:         || String.IsNullOrEmpty(expectedValue) 

      22:         || !String.Equals(actualValue, expectedValue, 

      23:                 StringComparison.OrdinalIgnoreCase))             

      24:     {                 

      25:         filterContext.Controller.ViewData.ModelState

      26:             .AddModelError(Field, ErrorMessage);                 

      27:         return;             

      28:     }         

      29: }

Now I can use the CaptchaValidationAttribute like this:

       1: [CaptchaValidationAttribute()]

       2: public ActionResult Register(FormCollection form)         

       3: {

       4:     // INCREDIBLY OVER-SIMPLIFIED BUT YOU GET THE IDEA             

       5:     if (!ViewData.ModelState.IsValid)             

       6:     {             

       7:     return View();

       8:     }         

       9: }