title: Reflection is too slow while deserialising JSON strings into .NET objects
body: <p>I'm having some issues with System.Reflection in C#. I'm pulling data from a database and retrieving that data in a JSON string. I've made my own implementation of handling the data from JSON into my self declared objects using Reflection. However, since I ussually get a JSON string with an array of like 50 - 100 objects my program runs really slow because of the loops I'm using with reflection.</p>
  
  <p>I've heard that reflection is slow but it shouldn't be this slow. I feel something is not right in my implementation since I have a different project where I use JSON.NET serializer and instantiate my objects a bit differently with reflection that runs just fine on the same output (less than a second) while my slow program takes about 10 seconds for 50 objects.</p>
  
  <p>Below are my classses that I'm using to store data</p>
  
  <pre><code>class DC_Host
  {
      public string name;
  
      public void printProperties()
      {
          //Prints all properties of a class usign reflection
          //Doesn't really matter, since I'm not usign this for processing
      }
  }
  
  class Host : DC_Host
  {
      public string asset_tag;
      public string assigned;
      public string assigned_to;
      public string attributes;
      public bool? can_print;
      public string category;
      public bool? cd_rom;
      public int? cd_speed;
      public string change_control;
      public string chassis_type;
      //And some more properties (around 70 - 80 fields in total)
  </code></pre>
  
  <p>Below you'll find my methods for processing the information into the objects that are stored inside a List. The JSON data is stored inside a dictionairy that contains a another dictionairy for every array object defined in the JSON input. Deserialising the JSON happens in a matter of miliseconds so there shouldn't be a problem in there.</p>
  
  <pre><code>public List&lt;DC_Host&gt; readJSONTtoHost(ref Dictionary&lt;string, dynamic&gt; json)
  {
      bool array = isContainer();
  
      List&lt;DC_Host&gt; hosts = new List&lt;DC_Host&gt;();
  
      //Do different processing on objects depending on table type (array/single)
      if (array)
      {
          foreach (Dictionary&lt;string, dynamic&gt; obj in json[json.First().Key])
          {
              hosts.Add(reflectToObject(obj));
          }
      }
      else
      {
          hosts.Add(reflectToObject(json[json.First().Key]));
      }
  
      return hosts;
  }
  
  private DC_Host reflectToObject(Dictionary&lt;string,dynamic&gt; obj)
  {
      Host h = new Host();
  
      FieldInfo[] fields = h.GetType().GetFields();
  
      foreach (FieldInfo f in fields)
      {
          Object value = null;
  
          /* IF there are values that are not in the dictionairy or where wrong conversion is
           * utilised the values will not be processed and therefore not inserted into the 
           * host object or just ignored. On a later stage I might post specific error messages
           * in the Catch module. */
  
          /* TODO : Optimize and find out why this is soo slow */
          try
          {
              value = obj[convTable[f.Name]];
          }
          catch { }
  
          if (value == null)
          {
              f.SetValue(h, null);
              continue;
          }
          // Het systeem werkt met list containers, MAAAR dan mogen er geen losse values zijn dus dit hangt
          // zeer sterk af van de implementatie van Service Now.
          if (f.FieldType == typeof(List&lt;int?&gt;)) //Arrays voor strings,ints en bools dus nog definieren 
          {
              int count = obj[convTable[f.Name]].Count;
              List&lt;int?&gt; temp = new List&lt;int?&gt;();
              for (int i = 0; i &lt; count; i++)
              {
                  temp.Add(obj[convTable[f.Name]][i]);
                  f.SetValue(h, temp);
              }
          }
          else if (f.FieldType == typeof(int?))
              f.SetValue(h, int.Parse((string)value));
          else if (f.FieldType == typeof(bool?))
              f.SetValue(h, bool.Parse((string)value));
          else
              f.SetValue(h, (string)value);
      }
  
      Console.WriteLine("Processed " + h.name);
  
      return h;
  }
  </code></pre>
  
  <p>I'm not sure what JSON.NET's implementation is in the background for using reflection but I'm assumign they use something I'm missing for optimising their reflection. </p>