Generic C# JSON Generator to Send Any Data to JavaScript

• Download source - 66.22 KB

Introduction

How would you like to have any data in C# (like this 3.5 sample)...

... and access it from JavaScript, using the same syntax as in C#:

"How Do They Do It?"

So there I was building a simple Ajax application using ASP.NET and it was very hard to send data from the code-behind in ASP.NET to the JavaScript code. Then I found out about JSON, which solved all the problems. The nice thing about JSON is that it is a format that browsers understand and can use to create rather complex data inside their JavaScript engines. So I wrote a recursive reflection based JSON generator that takes any managed class or struct and generates the JSON string that the browser understands.

Because this engine searches for fields in the class, there's no need to write such properties:

public int Id
{
    get { return this._id; }
    set { this._id = value; }
}

You can either select all fields or mark specific fields with an attribute and only send them to the JavaScript code.

More than that, the engine can handle even the anonymous types specific to .NET 3.5 (as seen in the picture above). It seems that the anonymous types are not stored identically to the proper types in the assembly's DLL.

Using the Code

Using the code is as simple as it gets: with one line of C# code you "convert" the object to the JSON string that is sent to the client code. No need for helper classes (like type serializers).

The client code uses one eval line of code to create the DOM object.

And that's it. In .NET 3.5, you don't even have to write the class with the complex constructor to receive all the data as parameters (as it was the case in .NET 2.0).

The engine can handle primitive data types (numeric types, strings and dates), classes, structs, arrays and null fields. If you have some data in a custom collection (like generic Lists), you can use the ToArray() method to get in a form the engine understands. I've chosen to use array(s) instead of IEnumerable(s) because you might have a class that implements IEnumerable but you might not want to treat it as a collection (string is such a class).

I know the whole point of this engine is to hide the representation of the object, but here's an example of how it looks (just to have an idea).

{
    'date' : new Date( 2008, 1, 23, 8, 5, 52 ) ,
    'Name' : 'some string' ,
    'StringSpecial' : '\\some \' \" string' ,
    'NullString' : null ,
    'Private' : null ,
    'i' : -1 ,
    'f' : 2.3 ,
    't2' :
    {
        'd' : 3.14 ,
        'D' : 3.15 ,
        'ThisIsAStruct' :
        {
            'str' : 'string in a struct'
        }
    }
}

Now that you've been briefed, go and download the archive and try it out.

There's a Visual Studio 2005 and a Visual Studio 2008 solution. The last one includes a .NET 3.5 ASP sample to test the anonymous types I was bragging about.

If you take a look at the generator's code, you'll notice it is not even 200 lines of code long.

PS: Don't forget to set the Web project as the "start up project" inside Visual Studio.

History

• Feb 23^rd, 2008 - Initial version
• Feb 16^th, 2009 - New code version