Talking to myself…..in public

A lot of time I just want to quickly look at how an object graph will be serialized to XML. I end up writing quick and dirty code like below time after time since I cannot find the code snippet I had written a while back. I am documenting it here so I do not have to write it again when I need it next time.

 
public class SerUtils
{
  public static string SerializeToString<T>(T source)
  {
    if(null == source)
	    return string.Empty;
 
    XmlSerializer ser = new XmlSerializer(source.GetType());
    MemoryStream ms = new MemoryStream();
    ser.Serialize(ms, source);
    ms.Flush();
    ms.Position = 0;
    StreamReader sr = new StreamReader(ms);
    string s = sr.ReadToEnd();
    return s;
  }
 
  public static T DeserializeFromString<T>(string xml)
  {
    if(string.Empty == xml)
	    return default(T);
 
    XmlSerializer ser = new XmlSerializer(typeof(T));
    MemoryStream ms = new MemoryStream();
    StreamWriter sw = new StreamWriter(ms);
    sw.Write(xml);
    sw.Flush();
    ms.Position = 0;
    return (T) ser.Deserialize(ms);
  }
}
 

Don't use this in production!

If the GetType method is called on a variable of NullableType then you will get the underlying type instead of the NullableType. This is because of boxing that occurs when the type object is converted to Object as documented at MSDN. So how do you get the declared type if you have a variable of NullableType? Here is the code that will return the Type object of the declared type of the NullableType variable.

 
        private static Type GetUnderlyingType<T>(T t)
        {
            return typeof(T);
        }
 

The code above uses Generics and typeof operator to obtain the underlying NullableType. The trick here is to call typeof on the type itself and not the variable. This is not usually possible when you just have a variable but the power of Generics allows you to do so. So, say if you have declared a variable of NullableType int

int? i;

the code in GetUnderlyingType method above does the equivalent of

typeof(int?)

to return the underlying NullableType. To further understand the difference between calling GetType on a variable and using typeof operator on the Type itself, look at the following code.

 
	private static void PrintType<T>(T t)
        {
            Console.WriteLine("{0}, {1}", t.GetType().FullName, typeof(T).FullName);
        }
 

Calling GetType on variable t returns the underlying type where as using typeof operator on Generic type parameter T returns the declared type of variable t.
Given a variable we can further test if the variable holds a NullableType by using the following code.

 
        private static bool IsNullable<T>(T t)
        {
            Type tx = GetUnderlyingType(t);
            return tx.IsGenericType && tx.GetGenericTypeDefinition() == typeof(Nullable<>);
        }
 

The code above obtains the underlying type first and then tests if the type is Generic, and if it is Generic type then it tests for NullableType.