C#

Using C# 4.0 and dynamic to parse JSON

Shawn Weisfeld — Sun, 22 Aug 2010 13:03:32 GMT

I recently had to get a JSON feed from the web and traverse it. Like any good developer I started off with a Bing search and stumbled across a few posts.

The first by Nikhil Kothari looked interesting but his implementation did way too much, all I needed to do was read a JSON file, did I really need all that code.

http://www.nikhilk.net/CSharp-Dynamic-Programming-JSON.aspx

The second post I saw by Alex Ghiondea again looked interesting but relied on a library from codeplex (JSON.NET, http://json.codeplex.com/) and again I thought this was a bit overkill for my project.

http://blogs.msdn.com/b/alexghi/archive/2008/12/22/using-anonymous-types-to-deserialize-json-data.aspx

But Nikhil’s post did get me thinking that this might be a good place to use the new dynamic “type” in C# 4.0. With some further research I dug up that in .NET 3.5 we got a new class called the JavaScriptSerializer, MSDN describes it as:

The JavaScriptSerializer class is used internally by the asynchronous communication layer to serialize and deserialize the data that is passed between the browser and the Web server. You cannot access that instance of the serializer. However, this class exposes a public API. Therefore, you can use the class when you want to work with JavaScript Object Notation (JSON) in managed code.

http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer(v=VS.100).aspx

To use the JavaScriptSerializer (from the System.Web.Extensions dll) you have to implement a JavaScriptConverter. I can do that. :) After poking around a bit with the JavaScriptSerializer I realized that it gives you a few things. A value, an array list of values, a dictionary of key value pairs, or an ArrayList containing an array of dictionary of key value pairs. What I want to do is if I see a dictionary I want my user to be able to use the key as a property on my dynamic, if I see an ArrayList I want the user to be able to iterate over the collection and see its members, finally if I see a value I want to just return it.

Lets start with a simple JSON file, that I borrowed from json.org:

{
    "glossary": {
        "title": "example glossary",
        "GlossDiv": {
            "title": "S",
            "GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
                    "SortAs": "SGML",
                    "GlossTerm": "Standard Generalized Markup Language",
                    "Acronym": "SGML",
                    "Abbrev": "ISO 8879:1986",
                    "GlossDef": {
                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
                        "GlossSeeAlso": ["GML", "XML"]
                    },
                    "GlossSee": "markup"
                }
            }
        }
    }
}

http://www.json.org/example.html

So with this the above JSON I want to be able to write “glossaryEntry.glossary.title” or “glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID” and get back “example glossary” and “SGML” respectively. All without having to actually create a static “glossary” object.

So the first step is to create our DynamicObject. I called mine DynamicJsonObject and as you can see it inherits from the base DynamicObject class.

public class DynamicJsonObject : DynamicObject
{
    private IDictionary<string, object> Dictionary { get; set; }
 
    public DynamicJsonObject(IDictionary<string, object> dictionary)
    {
        this.Dictionary = dictionary;
    }
 
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        result = this.Dictionary[binder.Name];
 
        if (result is IDictionary<string, object>)
        {
            result = new DynamicJsonObject(result as IDictionary<string, object>);
        }
        else if (result is ArrayList && (result as ArrayList) is IDictionary<string, object>)
        {
            result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
        }
        else if (result is ArrayList)
        {
            result = new List<object>((result as ArrayList).ToArray());
        }
 
        return this.Dictionary.ContainsKey(binder.Name);
    }
}

The tricky bit is in the “TryGetMember” Method. The binder.Name is the property value you used in your code. As you can see I am looking that guy up in the current internal dictionary. I then test its type. If it is a dictionary, I wrap it in another DynamicJsonObject and give it back. If it is an ArrayList of Dictionaries then I wrap each item as an DynamicJsonObject and send back the List. If it is just an Array List I convert it to a List and send it back. Finally we have to tell .NET if we found it at all.

The only other thing we need is an implementation of the JavaScriptConverter.

    public class DynamicJsonConverter : JavaScriptConverter
    {
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");
 
            if (type == typeof(object))
            {
                return new DynamicJsonObject(dictionary);
            }
 
            return null;
        }
 
        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }
 
        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
        }
    }

As you can see by the above code we are only supporting the deserialize method, and the only thing we do is wrap the dictionary with our DynamicJsonObject. Finally since we are using dynamic we can support any object type with this converter.

Now for the fun bit, lets use it.

            JavaScriptSerializer jss = new JavaScriptSerializer();
            jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });
 
            dynamic glossaryEntry = jss.Deserialize(json, typeof(object)) as dynamic;
 
            Console.WriteLine("glossaryEntry.glossary.title: " + glossaryEntry.glossary.title);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.title: " + glossaryEntry.glossary.GlossDiv.title);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID: " + glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.para: " + glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.para);
            foreach (var also in glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso)
            {
                Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso: " + also);
            }

To use our converter we create a serializer, register our converter with it and then call the deserialize method. Now we can use our standard “dot” notation to traverse our JSON object without the need for external libraries and in under 100 lines of code. Now JSON in .NET feels a lot like JSON in JavaScript. . . When I heard that C# was getting this dynamic stuff I was unsure of its power and relevance, now I have “seen the light” and can really see where this was a great addition to the language.

Developer: Utilizing .NET Generics to write better code by Shawn Weisfeld @ UT Dallas .NET UG on 02/27/2010

Shawn Weisfeld — Thu, 25 Feb 2010 01:45:54 GMT

This Saturday (2/27) I will be giving my .NET Generics talk for the UT Dallas .NET UG in Richardson TX. If you are in the area please check it out (http://www.usergroupsupportservices.com/UGEventView.ugss?EventID=9160). If you cannot make it but are interested in seeing the talk, you can watch it online.

Abstract:
Generics let you tailor a method, class, structure, or interface to the precise data type it acts upon. In this session we will discuss what capabilities Generics provide to you the developer and how to use them in collections, and with delegates. We will also talk about creating your own generic classes and methods.

Download
PowerPoint & Demos

Bio:
Shawn Weisfeld (shawn@shawnweisfeld.com) is a Staff Developer at a fortune 100 company, currently located at Dallas TX facility. There he specializes in intranet & smart client development for internal line of business applications. Besides his day job Shawn also is an Adjunct Professor at The Florida Institute of Technology (http://www.fit.edu). He also does freelance software development work for local small businesses and training. In his free time he volunteers with INETA NorAm (http://www.ineta.org) and is a member of the Board of Directors and Mentor for North Texas. Shawn started his career at his family business in Port St. Lucie FL while working on his undergraduate degree in Business Administration at the University of Central Florida and after a year off Shawn moved back to Orlando to pursue a Masters degree in Management Information Systems at The University of Central Florida and has since earned a second Masters degree in Computer Information Systems from Florida Institute of Technology. Shawn was awarded the Microsoft C# Most Valuable Professional award for 2007 - 2010. Shawn is an avid technology presenter and since July of 2005 Shawn has presented at many user group events, and even got to speak at the launch of Visual Studio. Shawn has served as the President of the Orlando .NET UG (http://www.onetug.org) from 2006 – 2008, and started the Developer Round Table UG (http://www.developerroundtable.com) in 2009. Shawn regularly attends, and records for INETA LIVE (http://live.ineta.org), many of the local user groups in the D/FW metroplex, including; D/FW Connected Systems UG, Dallas .NET UG, Dallas ASP.NET UG, Dallas C# Programming Sig, Dallas VSTS UG, North Dallas .NET UG, North Texas PC UG, UT Dallas .NET UG. So be sure to say hello if you see him.

Shawn @ Dallas Dev Cares 2009/12/11

Shawn Weisfeld — Sat, 12 Dec 2009 16:10:00 GMT

Thanks to all that attended my 3 talks at the Dallas Dev Cares UG yesterday and thanks Ken Byrd from TekFocus for hosting the meeting. As promised here is the download of the PowerPoint and code bits. I also included links to recordings of 2 of the 3 talks.

Download Presentations Here

Recording of ASP.NET Dynamic Data:

Recording of Developer of <T> Generics talk:

Dallas DevCares – Dec 11 2009: C# Generics, ASP.NET Dynamic Data & VS.NET Tips and Tricks

Shawn Weisfeld — Tue, 10 Nov 2009 12:43:44 GMT

By popular request on Dec 11 I will be giving 2 of my most popular talks on C# Generics and ASP.NET Dynamic Data. Then as a bonus just for the DevCares Community I will put together some of my favorite VS.NET Tips and Tricks. You can attend online or in person. Get all the details on there website at http://www.dallasdevcares.com/

Tulsa Tech Fest 2009

Shawn Weisfeld — Fri, 06 Nov 2009 15:37:36 GMT

Thanks to everyone that attended my .NET Generics Talk at the Tulsa Tech Fest today. You can download the code and PowerPoint here, and the recording will be posted to this blog and INETA Live shortly.

Developer<T>: Utilizing .NET Generics to write better code

Shawn Weisfeld

Generics let you tailor a method, class, structure, or interface to the precise data type it acts upon. In this session we will discuss what capabilities Generics provide to you the developer and how to use them in collections, and with delegates. We will also talk about creating your own generic classes and methods.

I wanted to thanks Scott Dorman author of the yet to be released Sams Teach Yourself C# 2010 in 24 Hours, for his help during the creation of this presentation.

Call a Multiple-Rowset stored procedure with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 21:45:23 GMT

Multiple-Rowset allows you to return more than one select from your stored procedure. For example in the stored procedure below you can see we have 2 select statements.

As we learned in my last 2 posts it is possible to use LINQ to SQL without the designer.

A simple select with LINQ to SQL and without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/a-simple-select-with-linq-to-sql-and-without-the-designer.aspx)
Call a stored procedure with LINQ to SQL and without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/call-a-stored-procedure-with-linq-to-sql-and-without-the-designer.aspx)

To utilize Multiple-Rowset we just need to tweak our function in our data context a little.

Here you can see that we added 2 result type attributes. These map to our result sets. Since our stored procedure returns 2 result sets of customers we tell LINQ to SQL to mach each to the customer object. However if your stored procedure returns different types you can of course do that. We also changed our result type to that of IMultipleResults. This will allow us to pick off each of the result sets when we call our method.

Here is the call to the method. You can see when we call “GetResult” the first time we get our first result set. Then when we call it a second time we get the second result set.

That is it.

Call a stored procedure with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 03:15:00 GMT

In my last post I talked about how to do a simple select with LINQ to SQL without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/a-simple-select-with-linq-to-sql-and-without-the-designer.aspx). This is all well and good, but what if you need to use a stored procedure. Like this one. . . .

The first step is to add to our data context a method that maps to our stored procedure. You can see we start off with a Function attribute that tells LINQ to SQL what stored procedure to use. Additionally we decorate the parameters on our method with Parameter attributes that tell LINQ to SQL how to map the parameters. Then we just call our base classes ExecuteMethodCall passing along all the attributes (using the .NET reflection MethodInfo class), and our parameter.

Now we just need to use our new method.

Here we can see we get the same results as we did in my last post.

In my next post we will use Multiple-Rowset to return multiple result sets from my stored procedure.

A simple select with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 02:57:42 GMT

Many folks poo-poo LINQ to SQL because they don’t like designers. On the other hand some developers, myself included, like knowing how things work behind the scenes, for those edge case moments when the designer cannot do something. The most common business case for this is if you want to LINQ to SQL-afy an existing suite of objects. Well using the designers is NOT a requirement of LINQ to SQL.

Lets say for example you had an existing customer table and customer business object:

Lets see if we can get LINQ to SQL to populate a list of customers from the database.

Ok first we need to make sure we have a valid connection string.

The next step is to create our DataContext. If you have used LINQ to SQL you will know that this guy does all the heavy lifting when it comes to getting data from and pushing data to the database.

Creating the DataContext is simple. Just create a new class and set its parent class to DataContext. (You will probably need to add a reference to System.Data.Linq.) Once you have the class created create a private static member called for the mapping source, and a constructor. The mapping source tells LINQ if it should look for attributes on the object, or in an xml configuration file for instructions on how to map the object model to the db model. This constructor will be chained to our base class passing up the mapping source and the connection string.

Since we selected an Attribute Mapping Source, lets go and decorate our customer class. using the attributes in the System.Data.Linq.Mapping namespace I tell LINQ to SQL what db table our object maps to and what columns each of the properties map to.

The next step is to add a helper method to our Data Context exposing the data so we can easily query it.

Now we can just write our LINQ query, just like normal.

That is it a simple LINQ to SQL query without the designer. Here are the results of the above query.

In my next post I will kick this up a notch by using a stored procedure to get these same results.

Extension Method to Resize an Image

sweisfeld — Sun, 28 Jun 2009 23:52:00 GMT

I wrote this for an INETA project that I have been working on, but thought it would be great to share with everyone. We had a need to take an image and change its size. Below is an implementation of a Resize Extension Method on the .NET Image object.

I borrowed some ideas from this post by Mark McDonnell (http://weblogs.asp.net/markmcdonnell/archive/2008/03/09/resize-image-before-uploading-to-server.aspx)

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Drawing;

   6:  using System.Drawing.Drawing2D;

7:

   8:  namespace Demo

   9:  {

  10:      public enum ResizeMode

  11:      {

  12:          Width,

  13:          Height,

  14:          Bigger

  15:      }

16:

  17:      public static class ImageHelper

  18:      {

  19:          public static Image Resize(this Image source, int size, ResizeMode mode)

  20:          {

  21:              //Convert the source image into a bitmap so we can work with it

  22:              Bitmap originalBMP = new Bitmap(source);

  23:              Image result;

24:

  25:              // Calculate the new image dimensions

  26:              int origWidth = originalBMP.Width;

  27:              int origHeight = originalBMP.Height;

  28:              int newWidth = 0;

  29:              int newHeight = 0;

30:

  31:              //If the size mode is set to bigger then find the widest side

  32:              if (mode == ResizeMode.Bigger)

  33:              {

  34:                  if (origHeight > origWidth)

  35:                      mode = ResizeMode.Height;

  36:                  else

  37:                      mode = ResizeMode.Width;

  38:              }

39:

  40:              //keeping the aspect ratio constant, calculate the new size

  41:              if (mode == ResizeMode.Width)

  42:              {

  43:                  newWidth = size;

  44:                  newHeight = (int)(size / ((double)origWidth / (double)origHeight));

  45:              }

  46:              else

  47:              {

  48:                  newHeight = size;

  49:                  newWidth = (int)(size / ((double)origHeight / (double)origWidth));

  50:              }

51:

52:

  53:              // Create a new bitmap which will hold the previous resized bitmap

  54:              Bitmap newBMP = new Bitmap(originalBMP, newWidth, newHeight);

55:

  56:              // Create a graphic based on the new bitmap

  57:              using (Graphics oGraphics = Graphics.FromImage(newBMP))

  58:              {

  59:                  // Set the properties for the new graphic file

  60:                  oGraphics.SmoothingMode = SmoothingMode.AntiAlias;

  61:                  oGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

62:

  63:                  // Draw the new graphic based on the resized bitmap

  64:                  oGraphics.DrawImage(originalBMP, 0, 0, newWidth, newHeight);

65:

  66:                  // Save the new graphic file to the server

  67:                  result = newBMP.Clone() as Image;

68:

  69:                  // Once finished with the bitmap objects, we deallocate them.

  70:                  originalBMP.Dispose();

  71:                  newBMP.Dispose();

  72:                  oGraphics.Dispose();

  73:              }

74:

  75:              return result;

  76:          }

  77:      }

  78:  }

Using an extension method makes it really easy to use the new “resize” functionality:

   1:              Image img = Image.FromFile("img.jpg");

   2:              Image resized = img.Resize(100, ResizeMode.Bigger);

   3:              resized.Save("resized.jpg");

So we went from a source size of 2304x1728 and 782 KB

to 100x75 and 23.3 KB

Now you to can shrink the size of your memories. :)

Property Causing a Stack Dump

sweisfeld — Tue, 16 Jun 2009 05:26:50 GMT

Got a call today, someone was getting a stack dump every time they tried to assign a value to a property. Here is a screen print of the problem they were having. can you spot the problem?

If you said that the property is calling itself you get a gold star. What was happening is that every time we tried to set the Name property, it calls the Name property to set it, and that called the Name property, and that called the Name property, over and over again, till .NET stack dumped. We are missing a backing variable.

By backing the property with a private variable, it removes the infinite recursion. Since the variable itself is private nobody can see it, or can use it outside the class, they are forced to use the property, and all is right with the world again!