GetType and typeof – how to get rid of overloads

The other day I needed a method for a piece of framework code handling different kinds of incoming parameters.

Since I don’t know what types the incomming parameters have I had to use some reflection and the operator typeof() and the GetType() method. If you haven’t used those methods before, here’s a small how to guide.

Using typeof()

The typeof() operator returns a System.Type and for example to get the value of a string the statement looks like this:

System.Type type = typeof(string);

The typeof operator is to be used for type checks at compile time, try and use it on anythign other than a namespace or a type and you will get a compilation error. Even though this is an operator it is not possible to overload it.

Using GetType()

The GetType() method is what you want to use for checking types during runtime. This method will also return a System.Type, and it’s used like this:

System.Type type = myObject.GetType();

A small example

My example code creates a container class that has a Dictionary with string keys and string values. The data coming in can be of the types string, double, int, decimal and bool.

Before adding the data to the Dictionary, a conversion is made, using culture info to change the formatting of the result string.

The Container class

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication
{
   internal class Container
   {
      Dictionary<string, string> collection = new Dictionary<string,string>();

      // Adds a parameter pair to the Dictionary.
      // If the parameter key already exists, it will remove the existing one and replace it.
      public void AddParameter(string keyName, object keyValue)
      {
         if (this.collection.ContainsKey(keyName))
         {
            this.collection.Remove(keyName);
         }

         Type type = keyValue.GetType();
         if (type.Equals(typeof(string)))
         {
            this.collection.Add(keyName, (string)keyValue);
         }
         else if (type.Equals(typeof(double)))
         {
            this.collection.Add(keyName, TypeConverter.DoubleToString((double)keyValue));
         }
         else if (type.Equals(typeof(int)))
         {
            this.collection.Add(keyName, TypeConverter.IntToString((int)keyValue));
         }
         else if (type.Equals(typeof(decimal)))
         {
            this.collection.Add(keyName, TypeConverter.DecimalToString((decimal)keyValue));
         }
         else if (type.Equals(typeof(bool)))
         {
            this.collection.Add(keyName, TypeConverter.BoolToString((bool)keyValue));
         }
      }

      public override string ToString()
      {
         StringBuilder result = new StringBuilder();
         foreach(var pair in collection)
         {
            result.Append("Key: " + pair.Key + "t" + " Value: " + pair.Value + "n");
         }
         return result.ToString();
      }
   }
}

The TypeConverter class

using System.Globalization;

namespace ConsoleApplication
{
   internal class TypeConverter
   {
      public static string DoubleToString(double value)
      {
         return value.ToString(CultureInfo.InvariantCulture);
      }

      public static string IntToString(int value)
      {
         return value.ToString(CultureInfo.InvariantCulture);
      }

      public static string DecimalToString(decimal value)
      {
         return value.ToString(CultureInfo.InvariantCulture);
      }

      public static string BoolToString(bool value)
      {
         return value.ToString();
      }
   }
}

The Program

using System;

namespace ConsoleApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Container container = new Container();

         container.AddParameter("int", (int)5);
         container.AddParameter("double",  (double) 55555555555.55555555555555555555555);
         container.AddParameter("decimal", (decimal)55555555555.55555555555555555555555m);
         container.AddParameter("bool", (bool)true);

         Console.WriteLine(container.ToString());
         Console.ReadKey();
      }
   }
}

Happy coding!