Interested readers may view a dynamically sortable table of the complete list of top 1000 most visited sites on the web which also has APV added (Warning: on slow computers it may take a while to load or crash your browser since it’s a long list that requires Javascript processing).

I used it to gather the following data for sites in the News category.

News & Current Events

This category includes sites with an online and television presence, covering current and breaking news.

• BBC (#43) with 45 million UU and 56 APV, the highest in the overall News category
• ifeng.com (#55) in Chinese/Mandarin
• CNN (#64) with 34 million UU and 38 APV
• Digg (#252) is also impressive given that its a community driven news aggregator that runs automatically
• FoxNews (#279) with 11 million UU and 8 APV

Newspapers

This category includes the traditional print newspapers complemented by an online presence

• NYTimes (#83) takes the top spot with 26 million UU and 23 APV
• Yomiuri (#213) with 20 APV
• Daily Mail (#236) with 22 APV
• WSJ (#277) with 15 APV
• Mainichi (#287) with 7 APV
• Guardian (#310) with 16 APV

Business News

• CE.CN (#500) with 7.4 million UU and 5 APV giving it 34 million monthly PV
• Forbes (#633) with 6.1 million UU and 18 APV giving it 110 million monthly PV

Local News

This category includes online news sites which focus on national coverage

• iG.com.br (#477) out of Brazil
• zjol.com.cn (#746) out of China

Social Networks

Of the top 1000 sites, the ones with the highest APV are comprised primarily of social networking sites along with a few classifieds and shopping sites. This makes sense because people spend a lot of time on social networking sites viewing a lot of pages.

Page Views

Facebook is the grand daddy of all websites. Not only does it have the highest number of UU at 540 million, its PV count gets even more impressive with an APV count of 1056. Facebook gets a total of 570 billion page views per month which is more than all the next 30 websites combined! Yahoo web portal is a paltry second with 70 billion page views from it’s 490 million unique users.

Building large scale systems like The Express Tribune news portal and turning it around in 6 months requires a team of determined masochists and some really quick thinking. One has to think about scalability, performance, security, architecture and pliability of the product. One also has to think about usability, information architecture and layouts. About user interactivity, community engagement and publication workflows. Integration with television and print and a coherent new media strategy.

But it’s here and it’s far from over. Going in, I was confident that we would easily come out ahead of the competition (whom I have written about here and here) but I never thought I would have so much fun doing it.

The Express Tribune website uses some existing platforms and our developer toolkit is quite powerful, but to get to where we wanted to go, we got neck deep in every aspect of the system.

Beyond being just a pretty website, it has some behind the scenes features where it really shines out. This is where the competition has a lot of catching up to do. For example, assigning headlines and stories to sections or updating the page layout happens directly from the section itself, rather than going in to some specialized administrative screen. The image management and carousels are first class features and not just an after thought. The News in Pictures and slide shows can be done in under 5 minutes. The pages load blazingly fast, because we optimized not only the caching mechanisms but also the web server, database server, application server and even the operating system.

The user interface follows some hard principles. For example, the comment preview feature is painstakingly simple and dynamic so users know exactly how their words will appear. The submit button is below the comment preview by design, so the user is forced to preview on his way to the submit button. The design follows a horizontal rhythm using grid-based layouts. The weather widget updates the weather without having to refresh the page and on the back end we do some very specific caching so we can handle thousands of users, yet provide the latest weather updates or auto updating stock charts. The alerts ticker is directly linked to the Express 24/7 television station which requires some trickery on the part of both, the television platform as well as the web platform.

The interesting bits about strategy are something I cannot talk about other than to say that if the website works well for you and you find yourself interacting more and more, it’s because we put the user first. And in the short and long term both, our strategy will allow us to surpass the competition and out-pace them so we maintain the lead.

With internet penetration growing the way it is, I have no doubt that The Express Tribune portal will provide common ground for a lot of avid readers and have interesting side effects.

Why Use Abstract Classes?

An Abstract class provides concrete base functions as well as abstract functions that must be implemented by concrete child classes—binding them into a contract so to speak, if they wish to make use of the base functionality.

This is a subtle but important point and this is where abstract classes really shine. They can call abstract functions from within base concrete functions. Jumping straight to an example is the clearest way to explain this.

abstract class Animal {
  function greeting() {
    $sound = $this->sound();      // exists in child class by contract
    return strtoupper($sound);
  }
  abstract function sound();      // this is the contract
}

class Dog extends Animal {
  function sound() {              // concrete implementation is mandatory
    return "Woof!";
  }
}

$dog = new Dog();
echo $dog->greeting();            // WOOF!

This opens up a whole lot of interesting possibilities. For example, you can write a drive() function that calls $this->start(); $this->accelerate(); in an abstract class. Then create a motorcycle class that defines its own start() and accelerate() functions that may be different from those in the car class. In turn, the motorcycle and car can both be driven by just calling drive() without having to implement it locally.

Characteristics of Abstract Classes

Make a note of these characteristics to lock down your understanding of abstract classes:

1. Single inheritance. Child classes can extend only one class at a time.
2. Abstract classes cannot be instantiated — no new Animal();
3. Abstract classes can define class variables of type const only.
4. Abstract class A can be extended by another abstract class B. Abstract class B can implement none or any of the abstract functions in A.
5. In the previous case, a child class C which extends abstract class B must implement all abstract functions in B as well as the abstract functions in A which have not already been implemented in B.
6. The signature of the concrete functions and abstract functions must be the same. However, if an abstract function is defined as abstract function speak($greeting); then it is okay to implement it as function speak($greeting, $shout = FALSE) but not function speak($greeting, $shout).
7. The visibility of functions in the child classes must be the same or less restrictive than the parent class. Thus, a protected abstract function can be implemented as either protected or public but not private.
8. Declaring functions as static abstract throws a strict warning in PHP 5.2 or earlier, however, as of PHP 5.3 this is allowed.

The website is a big hoarding with no less than 20 advertisements on the front page while at the same time carries less than 100 words of actual news. And it looks really ugly.

This is what happens when you just don’t care about the readers. This is what happens when designers develop, developers design, business units dictate the roadmap and talent in general lacks. This is also what happens when you just don’t understand interaction design, information architecture, usability or have been oblivious to the paradigm shifts in online advertising and technological trends. This screen capture of the Jang News website clearly highlights all this.

The actual news content is highlighted in green boxes while the rest of the page is mostly advertisements. All ad slots highlighted in red are available for sale while unsold ad space is used for in-house products. The advertising tariffs section of the website indicates the type of ads available for sale on Jang News Online which includes video and expandable ads at a premium. The annoying expandable ads block access to the news until readers close them (shown in the screen capture) while video ads block the rest of the page because they take so long to load (Pakistan has very low broadband penetration in any case).

Jang News Online gets a considerable amount of traffic because the Jang News Group has entrenched itself as the face of news over the past 70 years that it has been around–a time during which it enjoyed little or no competition which helps explain their complacency.

Now, I am not even sure why an advertiser would want to publish one ad amongst 20 when it’s well known that users develop banner blindness and moreover the website’s ad space is extremely diluted and the screen interface is so cluttered.

The page reminds me of the days popup ads ran rampant until readers expressed rage and all major browsers (Internet Explorer, Firefox, Safari, et al) reacted by featuring popup blockers to put an end to it all. Unfortunately, in Jang’s case it’s not easy to block the spam. The website’s front page is practically an online hoarding which seems to take it’s cue from the million dollar homepage (whose sole purpose is to show advertisements) rather than a news site. One may easily pass this off as spam in its current state.

There are some valuable lessons in this for all budding web developers and web entrepreneurs.

Download PowerPoint: Online Strategy and Development in a Nutshell.

In a seemingly abrupt move, tr.im recently announced the decision to shut down at the end of this year blaming the bit.ly and Twitter partnership for driving them out of business. I have not used either service other than for test driving so I don’t have a bias either way but it makes sense for Twitter to go with best of the breed so it is unclear why tr.im needs to place the blame with either bit.ly or Twitter. The situation was pareto efficient and one or the other had to lose out. It makes sense for Twitter to partner with or acquire such a service because it is complimentary to their business (tiny posts with tiny URLs).

Soon after announcing their intent to go out of business, tr.im reversed their position and Eric Woodward offered to bear the costs of operations out of his own pocket if donations fell short–a move that is even worse than going out of business.

Revenue Model

The revenue model suggests that for the most part, such a service is very difficult to sustain. The revenue model for URL shortening services would depend either on showing disruptive advertisements or tracking user patterns and selling intelligence.

In the former case, users would probably stop using the service if they saw an ad before being redirect to long URL. In the latter case, tr.im would need considerable market share to track behavioural data.

Tr.im shot itself in the foot by claiming it will simply go belly up because the business is bad. There goes their chance of getting acquired for a good price.

All this is offset by the fact that it allowed tr.im to receive a lot of media attention and might drive up usage but smart users will shy away from a service that’s on life support and business continuity is of utmost importance. The smarter strategy was to get acquired much like bit.ly did.

Why go open?

The technical challenge of converting long URLs to short ones is trivial so the value-proposition to the community is not that great but let’s assume that since it’s free it’s good. The problem then again is that it will encourage users to create their own competing services to bit.ly and since the revenue model for the most part does not have a compelling monetization strategy, these services will eventually go out of business and intensify the link-rot problem.

The primary motivation for going open seems to be the move toward donations where the community would donate code as well as money to keep the servers running for the millions of links that will accumulate over time. This works well for Wikipedia because it is a natural monopoly and can fall back on ads if needed. And again, Wikipedia has completely different dynamics compared to tr.im which functions simply to shorten the length of links with equal or better services already available that pose a lesser risk of going bust.

A Nasty Time Bomb

When Eric Woodward proposes that he will fund this from his own pocket if donations fall short, the community should be concerned. What is something happens to Eric? Does he leave behind a trust fund? Not only that but the costs are ever-increasing because all links will need to be supported for all of time or thousands if not millions of links will break.

The longer the service stays in operation, the greater the risk it poses. If it goes out of business 2 years from now it might end taking out a couple million URLs with it which will be even worse than if it went out of business today.

So the costs will be ever-increasing, the risks will also be ever-increasing and there is no good revenue model to sustain the service. In fact if it becomes community owned, all data will be free so tr.im cannot depend on behavioural tracking data as a revenue strategy. Tr.im will continue to be a burden on the community and not only that, but if other unsustainable services come up replicating its code, the link rot problem will get compounded. And all those people who make donations will see their money go to waste when they realize the tr.im will need piles of cash, month after month with no other source of cash flow.

I hope I am wrong about this.

JavaScriptSerializer

The JavaScriptSerializer lives in the System.Web.Script.Serialization namespace and the usage is fairly straight forward for serialization:

JavaScriptSerializer serializer = new JavaScriptSerializer();
String json = serializer.Serialize(data);

For deserialization however, there is a minor annoyance in that the deserializer accepts a generic type along with the content:

serializer.Deserialize<T>(String s)

which can be a problem if the type T is not known at compile time and needs to be dynamic. The work around is a bit ugly as I learnt because it uses reflection to create a generic method but it works:

var result = typeof(JavaScriptSerializer).GetMethod("Deserialize")
             .MakeGenericMethod(JsonDataType)
             .Invoke(serializer, new object[] { inputContent });

The JavaScriptSerializer is excellent for general purpose serialization and deserialization, however, one downside is that it cannot handle circular references.

A useful feature of the JavaScriptSerializer is that you can also implement a custom JavaScriptConverter and pass that in to JavaScriptSerializer for fine-grained control over the serialization/deserialization. However, for it to be really useful you need to know the types at compile time and have references to those types. This really limits the usefulness of this feature because by referencing those classes your code becomes tightly coupled so you cannot easily use it in something like an MVC filter.

The JavaScriptSerializer includes all public fields and properties for serialization by default which makes it useful when working with auto-generated classes or if you don’t have access to the source. This is different from how DataContractJsonSerializer works.

DataContractJsonSerializer

The DataContractJsonSerializer lives in the System.Runtime.Serialization.Json namespace. Unlike the JavaScriptSerializer, the DataContractJsonSerializer is a contract-based serializer so classes or members need to have the [DataContract], [DataMember] or the [Serializable] attribute.

[Serializable]
class Person {
    public String Name;
    public Int32 Age;
}

...

String json;
using (var stream = new MemoryStream()) {
    DataContractJsonSerializer serializer =
       new DataContractJsonSerializer(data.GetType());
    serializer.WriteObject(stream, data);
    json = Encoding.UTF8.GetString(stream.ToArray());
}

And for deserialization:

using(var stream = new MemoryStream(Encoding.Unicode.GetBytes(json)) {
    Object data = serializer.ReadObject(stream);
}

Since DataContractJsonSerializer is contract based and relies on attributes, it is not particularly suitable for auto-generated classes (unless they have these attributes) or when source is not accessible because the relevant attributes cannot be added at runtime as far as I know. However, for other situations attributes are an easy way to control the serialization aspects.

The most compelling feature of the DataContractJsonSerializer is that it can handle complex object graphs with circular references. This makes it particularly useful with the Entity Framework 4.0 which now support T4 templates allowing required [Serializable] or [DataMember] attributes to be added to auto-generated classes.

Update: In .NET 3.5 SP1, DataContractSerializer added support for classes without attributes (or POCO objects).

Json in MVC

The System.Web.Mvc namespace contains the Json function intended for use within ASP.NET MVC. There is no real reason to use it outside of ASP.NET MVC when JavaScriptSerializer and DataContractJsonSerializer are available. This function makes it extremely easy to serialize objects to a JSON string. It is not intended for deserialization, however, serialization is just one call:

String content = Json(data);

POCO Support

If you are not up to date on POCO, quickly read up on POCO and Persistence Ignorance first. Entity Framework 4.0 has full support for POCO or Plain Old CLR Objects.

If you have a class called Person with name, address and phone number then that’s how it will stay. It will not have EntityKey or some other such properties. It does not need to implement any interface specific to Entity Framework nor does it need to add any special attributes on properties and methods.

You can pass this plain object around much more cleanly and your domain logic is not polluted with any persistence code. This is also useful for Test Driven Development (TDD)  or migrating out of EF to another framework down the line.

Entity Model Designer Improvements

Previously you had to design the database schema in SQL Server and then import that into the Entity Designer. With 4.0 you can build the model first in the Entity Designer and generate your database and classes from there.  Alternately a lot of DDD (Domain Driven Design) folks prefer to hand code their model classes. Since those classes end up being POCO and EF has full support for POCO, it works out quite well for everyone.

T4 templates

Currently the Entity Designer generates classes from models by using EntityClassGenerator which provides little to no control over the generated classes. In 4.0 you will have T4 templates which provide for greater control over the generated classes with richer functionality like adding attributes to properties or having the generated classes implement a custom interface.

T4 templates are used not only to generate classes but also to generate tables if you choose to start off by building the models first. For example, by default the mapping is table-per-type which can be overridden through T4 templates to produce a table-per-hierarchy schema. You can also add prefixes to the generated table names and so on.

Self Tracking Entities and N-Tier applications

Self tracking entities are a very cool feature of the Entity Framework that allow for N-tier applications. Currently when you have entities on which you wish to track changes, the object context does that for you. However, the object context only exists in the current tier and if you decide to pass that object around to other tiers where the context is not present, you cannot track the entities any more. For example, if you pass the Person object to the UI layer which presents it to the user for modification, those modifications are not being tracked because the object context is not available in the UI tier. N-tier support can now handle this scenario quite elegantly.

One way to do this is to generate self-tracking entities as these entities have logic to track changes within. If the UI modifies the Person object’s address, the Person object will now contain information on how it’s been modified because it is self-tracking. When you pass the Person object back to the data tier, the object can easily relay what’s changed and the context can use this to persist the object.

Of course, this means that the object is not POCO any more because it has logic to track changes within itself so there is yet another approach. You can pass the POCO object back to the Entity Framework and attach it to the context which can then do a diff on the object and the original object to determine what’s changed. This requires more processing obviously.

Proxy Tracking

Besides diff’ing the POCO entities or using self-tracking entities for change detection, another approach is provided by the Entity Framework 4.0 which is proxy tracking. It provides the benefits of POCO without the performance implications of doing a diff (to check what’s changed each time the POCO object is re-attached to the context) albiet it cannot be used in an n-tier scenario.

If using proxies to track changes, EF sets up proxy classes to communicate with your POCO classes. These proxy classes inherit from the POCO classes and any property getter/setter calls are still made to the POCO class but through the proxy class. This allows the Entity Framework to stay in sync with entities at all times. You do however need to be a bit careful if you are going to serialize these objects because the resulting output could be a proxy object (though easily remedied by calling something like EFPocoAdapter’s ProxiesToPoco() equivalent in EF 4.0).

Conclusion

This is going to be a big release for EF to bring it in line with the other major ORMs out there. The MVC community right now favors Linq to SQL but hopefully we’ll see more ASP.NET MVC + Entity Framework projects coming out.

1. Persistence Ignorance
2. Single Responsibility Principle
3. Domain Driven Design
4. An Interim Solution

I previously published a JSON / POX Filter for MVC developers working with RESTful services. It works really well in that it allows a Controller Action to speak two additional languages (JSON and XML) other than View rendition without requiring any extra modifications. Everything was fine until I pulled out Linq to SQL and plugged in Entity Framework and got an education on a variety of issues with the framework.

Persistence Ignorance

Serializing objects within the Entity Framework is a common enough scenario that I expected to work around it farily easily. More so because the serialized objects only contained some additional undesirable key/value pairs that I did not expect. This is when I first got introduced to Persistence Ignorance.

In the Entity Framework an object generated from the Persons table for example contains not only the properties and relationships of that table (such as Age and Name) but also has additional properties used for tracking changes to the object (such as EntityState). In my scenario, serializing the entity object ought to have resulted in a plain object representation (JSON format shown):

// Plain Old CLR Object
{"Id":1, "Name":"John"}

But instead I saw this:

// Entity Object
{"Id":1, "Name":"John",
 "EntityState":2, "EntityKey": {"EntitySetName":"Persons",
    "EntityContainerName":"PersonEntities","EntityKeyValues":
     [{"Key":"Id","Value":1}],"IsTemporary":false}}

In laymen’s terms Persistence Ignorance is a design principle which suggests that the underlying object hide the details of how it is persisted so you can ignore it and work with a simple object. The term “ignorance” suggests that this behaviour be encapsulated which is a tenet of Object Oriented design.

Single Responsibility Principle

Instead, the Entity Object has additional properties used by the Entity Framework for managing data persistence. An object that plainly represents the Person table and does not contain any additional service-level properties and functions is called a Plain Old CLR Object or POCO. The Entity Object violates the Single Responsibility Principle because other than representing a Person it takes on the additional responsibility of managing data persistence.

Albeit, this makes it very convenient for the Entity Framework to persist the object in the database if, for example, you make modifications to the Person object and save it back to the database. Because the state information is stored within the object itself, the Entity Framework easily knows if the object has changed (by looking at the EntityState property) and what changes were made. It can then update the appropriate fields in the database. Even though this makes things easy for the Entity Framework, it is clearly a big second responsibility tacked on to what should be a plain old Person object. Besides, developers need not be confused by nor concerned with lower level implementation details of state and persistence. Consequently, the Entity Framework recognizes and intends to fix this in Version 2 which will support POCO and Persistence Ignorance.

Domain Driven Design

Lack of POCO objects means that developers are left dealing with an Entity Object and while for me this started off with a naive problem of serializing a Person object, the actual issue has further implications. My over simplified understanding of Domain Driven Design is that domain objects should be Plain Old CLR Objects and should encapsulate only domain logic. So for example, if you are building a warehousing application, the objects used to represent the warehouse domain should only encapsulate functionality within the warehouse (such as orders, storage and delivery). Anything more in the objects (such as database persistence) and the application breaks the Domain Driven Design model. It gets much harder to manage or extend, and Separation of Concerns is lost. For further discussion Ian Cooper’s article on Entity Framework and Domain Drive Design provides an interesting and insightful background on this issue.

An Interim Solution

The EFPocoAdapater is just what the name suggests — a POCO adapter for the Entity Framework which solves the issues outlined above. The EFPocoAdapter currently serves as a sort of staging platform for supporting these scenarios until they become available in version 2 of the Entity Framework, at which time EFPocoAdapter will be made obsolete.

1. JSON and XML Action Filter Code
2. Usage Example
3. Sample Output

So I just hopped on the ASP.NET MVC bandwagon. As my first task, I undertook custom Action Filters for returning either JSON or XML as determined by the HTTP Request. Fortunately Omar AL Zabir did most of the work for creating a RESTful API with ASP.NET MVC.

JSON and XML Action Filter Code

The following is a filter which makes the whole thing much cleaner. The filter looks for Content-Type headers in the HTTP request. If it matches text/xml then Plain Old XML (POX) is returned and if it matches application/json the output is JSON. This eliminates the need to write separate actions for JSON/XML and Views.

using System;
using System.Web;
using System.Web.Mvc;
using System.IO;
using System.Xml;
using System.Text;
using System.Collections.Generic;
using System.Web.Script.Serialization;
using System.Runtime.Serialization;
using System.Reflection;
using System.Reflection.Emit;

namespace AleemBawany.ActionFilters
{
  public class JsonPox : ActionFilterAttribute
  {
    private String[] _actionParams;

    // for deserialization
    public JsonPox(params String[] parameters)
    {
      this._actionParams = parameters;
    }

    // SERIALIZE
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
      if (!(filterContext.Result is ViewResult)) return;

      // SETUP
      UTF8Encoding utf8 = new UTF8Encoding(false);
      HttpRequestBase request = filterContext.RequestContext.HttpContext.Request;
      String contentType = request.ContentType ?? string.Empty;
      ViewResult view = (ViewResult)(filterContext.Result);
      var data = view.ViewData.Model;

      // JSON
      if (contentType.Contains("application/json") || request.IsAjaxRequest())
      {
        using (var stream = new MemoryStream())
        {
          JavaScriptSerializer js = new JavaScriptSerializer();

          String content = js.Serialize(data);
          filterContext.Result = new ContentResult
          {
            ContentType = "application/json",
            Content = content,
            ContentEncoding = utf8
          };
        }

      }

      // POX
      else if (contentType.Contains("text/xml"))
      {
        // MemoryStream to encapsulate as UTF-8 (default UTF-16)
        // http://stackoverflow.com/questions/427725/
        //
        // MemoryStream also used for atomicity but not here
        // http://stackoverflow.com/questions/486843/
        using (MemoryStream stream = new MemoryStream(500))
        {
          using (var xmlWriter =
            XmlTextWriter.Create(stream,
              new XmlWriterSettings()
              {
                OmitXmlDeclaration = true,
                Encoding = utf8,
                Indent = true
              }))
          {

            new DataContractSerializer(
              data.GetType(),
              null, // knownTypes
              65536, // maxItemsInObjectGraph
              false, // ignoreExtensionDataObject
              true, // preserveObjectReference - overcomes cyclical reference issues
              null // dataContractSurrogate
              ).WriteObject(stream, data);
          }

          filterContext.Result = new ContentResult
          {
            ContentType = "text/xml",
            Content = utf8.GetString(stream.ToArray()),
            ContentEncoding = utf8
          };
        }
      }
    }

    // DESERIALIZE
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {

      if (_actionParams == null || _actionParams.Length == 0) return;

      HttpRequestBase request = filterContext.RequestContext.HttpContext.Request;
      String contentType = request.ContentType ?? string.Empty;
      Boolean isJson = contentType.Contains("application/json");

      if (!isJson) return;
      //@@todo Deserialize POX

      // JavascriptSerialier expects a single type to deserialize
      // so if the response contains multiple disparate objects to deserialize
      // we dynamically build a new wrapper class with fields representing those
      // object types, deserialize and then unwrap
      ParameterDescriptor[] paramDescriptors =
          filterContext.ActionDescriptor.GetParameters();
      Boolean complexType = paramDescriptors.Length > 1;

      Type wrapperClass;
      if (complexType)
      {
        Dictionary parameterInfo = new Dictionary();
        foreach (ParameterDescriptor p in paramDescriptors)
        {
          parameterInfo.Add(p.ParameterName, p.ParameterType);
        }
        wrapperClass = BuildWrapperClass(parameterInfo);
      }
      else
      {
        wrapperClass = paramDescriptors[0].ParameterType;
      }

      String json;
      using (var sr = new StreamReader(request.InputStream))
      {
        json = sr.ReadToEnd();
      }

      // then deserialize json as instance of dynamically created wrapper class
      JavaScriptSerializer serializer = new JavaScriptSerializer();
      var result = typeof(JavaScriptSerializer)
              .GetMethod("Deserialize")
              .MakeGenericMethod(wrapperClass)
              .Invoke(serializer, new object[] { json });

      // then get fields from wrapper class assign the values back to the action params
      if (complexType)
      {
        for (Int32 i = 0; i < paramDescriptors.Length; i++)
        {
          ParameterDescriptor pd = paramDescriptors[i];
          filterContext.ActionParameters[pd.ParameterName] =
              wrapperClass.GetField(pd.ParameterName).GetValue(result);

        }
      }
      else
      {
        ParameterDescriptor pd = paramDescriptors[0];
        filterContext.ActionParameters[pd.ParameterName] = result;
      }
    }

    private Type BuildWrapperClass(Dictionary parameterInfo)
    {
      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "DynamicAssembly";
      AppDomain appDomain = AppDomain.CurrentDomain;
      AssemblyBuilder assemblyBuilder =
          appDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      ModuleBuilder moduleBuilder =
          assemblyBuilder.DefineDynamicModule("DynamicModule");
      TypeBuilder typeBuilder =
          moduleBuilder.DefineType("DynamicClass",
          TypeAttributes.Public | TypeAttributes.Class);

      foreach (KeyValuePair entry in parameterInfo)
      {
        String paramName = entry.Key;
        Type paramType = entry.Value;
        FieldBuilder field = typeBuilder.DefineField(paramName,
                    paramType, FieldAttributes.Public);
      }

      Type generatedType = typeBuilder.CreateType();
      // object generatedObject = Activator.CreateInstance(generatedType);

      return generatedType;
    }

  }
}

Last Updated: 28 March, 2010

Usage Example

To use this code in your Controller Action, you simply need to decorate it with the [JsonPox] attribute:

// Depending on HTTP Content-Type header
// this returns JSON, XML or the default View

[JsonPox]
public ActionResult Index()
{
        ArrayList stuff = new ArrayList();
        stuff.Add("Hello World");
        stuff.Add(999);
        stuff.Add(1.0001);
        ViewData.Model = stuff;
        return View();
}

Sample Output

If Content-Type: text/xml HTTP header is present the output is:

<ArrayOfAnyType xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <anyType xsi:type="xsd:string">Hello World</anyType>
  <anyType xsi:type="xsd:int">999</anyType>
  <anyType xsi:type="xsd:double">1.0001</anyType>
</ArrayOfAnyType>

For the HTTP header Content-Type: application/json the output is:

["Hello World",999,1.0001]

And if neither of those headers are present, the default View is returned.

Once again, if you intend to use it, get the latest bits for JsonPoxFilter.cs here instead of copying the above code.