Can I serialize a C# Type object?

Question

I'm trying to serialize a Type object in the following way:

Type myType = typeof (StringBuilder); var serializer = new XmlSerializer(typeof(Type)); TextWriter writer = new StringWriter(); serializer.Serialize(writer, myType); 

When I do this, the call to Serialize throws the following exception:

"The type System.Text.StringBuilder was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically."

Is there a way for me to serialize the Type object? Note that I am not trying to serialize the StringBuilder itself, but the Type object containing the metadata about the StringBuilder class.

Answer 1

I wasn't aware that a Type object could be created with only a string containing the fully-qualified name. To get the fully qualified name, you can use the following:

string typeName = typeof (StringBuilder).FullName; 

You can then persist this string however needed, then reconstruct the type like this:

Type t = Type.GetType(typeName); 

If you need to create an instance of the type, you can do this:

object o = Activator.CreateInstance(t); 

If you check the value of o.GetType(), it will be StringBuilder, just as you would expect.

Answer 2

I had the same problem, and my solution was to create a SerializableType class. It freely converts to and from System.Type, but it serializes as a string. All you have to do is declare the variable as a SerializableType, and from then on you can refer to it as System.Type.

Here is the class:

// a version of System.Type that can be serialized [DataContract] public class SerializableType {     public Type type;      // when serializing, store as a string     [DataMember]     string TypeString     {         get         {             if (type == null)                 return null;             return type.FullName;         }         set         {             if (value == null)                 type = null;             else             {                 type = Type.GetType(value);             }         }     }      // constructors     public SerializableType()     {         type = null;     }     public SerializableType(Type t)     {         type = t;     }      // allow SerializableType to implicitly be converted to and from System.Type     static public implicit operator Type(SerializableType stype)     {         return stype.type;     }     static public implicit operator SerializableType(Type t)     {         return new SerializableType(t);     }      // overload the == and != operators     public static bool operator ==(SerializableType a, SerializableType b)     {         // If both are null, or both are same instance, return true.         if (System.Object.ReferenceEquals(a, b))         {             return true;         }          // If one is null, but not both, return false.         if (((object)a == null) || ((object)b == null))         {             return false;         }          // Return true if the fields match:         return a.type == b.type;     }     public static bool operator !=(SerializableType a, SerializableType b)     {         return !(a == b);     }     // we don't need to overload operators between SerializableType and System.Type because we already enabled them to implicitly convert      public override int GetHashCode()     {         return type.GetHashCode();     }      // overload the .Equals method     public override bool Equals(System.Object obj)     {         // If parameter is null return false.         if (obj == null)         {             return false;         }          // If parameter cannot be cast to SerializableType return false.         SerializableType p = obj as SerializableType;         if ((System.Object)p == null)         {             return false;         }          // Return true if the fields match:         return (type == p.type);     }     public bool Equals(SerializableType p)     {         // If parameter is null return false:         if ((object)p == null)         {             return false;         }          // Return true if the fields match:         return (type == p.type);     } } 

and an example of usage:

[DataContract] public class A {      ...      [DataMember]     private Dictionary<SerializableType, B> _bees;      ...      public B GetB(Type type)     {         return _bees[type];     }      ...  } 

You might also consider using AssemblyQualifiedName instead of Type.FullName - see comment by @GreyCloud