How to dynamically provide T .. class ObjectXMLSerializer<T> where T : class

Question

Ok so the class I want to use is declared with:

public static class ObjectXMLSerializer<T> where T : class

I have many objects that I want to serialize, but I do not know their "class"

object myclass = new MyNamespace.MyClass() as object;

How do I do the following... ?

ObjectXMLSerializer< ? >.Save(myclass,"output.xml");

I can't do this because the type that is expected, is "class"

ObjectXMLSerializer< myclass.GetType() >.Save(myclass,"output.xml");

And this just wouldnt work ...

ObjectXMLSerializer< object >.Save(myclass,"output.xml");

Any thoughts would be appreciated!

Answer 1

You're trying to use generics for something it isn't designed for.

Generics are meant to give compile-time safety (and express information about the API at compile-time). You don't know the types involved at compile-time, so you've got a problem.

Options:

• Use a non-generic API
• Call the generic API via reflection
• Redesign your code so that the relevant method does know the type at compile-time (e.g. make the method that calls Save generic too)

Answer 2

You could try this without generics:

public static class ObjectXMLSerializer
{
    public static void Save(IXmlSerializable myObject, string fileName) 
    {
        // whatever
    }
}

Although, depending on what you're trying to do, you might be better off just using the framework's XmlSerializer instead of writing your own.

Answer 3

I'm recommending an interface IXmlSerializable with the method Serialize() exposed. If you need to refer to them generically (without knowing it's ClassA or ClassB , you can cast or box them to the interface and call the method.

Usually, I just attribute my objects with Serializable and make sure all the properties are serializable or attribute the property with XmlIgnore / Nonserialized

[Serializable]
public class MyClass
{
     [Nonserialized]
     private DataTable _myProperty;
     [XmlIgnore]
     public DataTable MyProperty { get; set; }
}

Answer 4

Don't use generics if XML serialization is all that you care about:

public static class ObjectXMLSerializer { 
  public static void Save(object objectToSerialize, string fileName) { 
    // ...
  } 
} 

Alternatively, look at the XmlSerializer class, it might already cover your requirements:

public static class ObjectXMLSerializer {
  public static void Save(object objectToSerialize, string fileName) {
    var serializer = new XmlSerializer(objectToSerialize.GetType());
    using (var stream = File.OpenWrite(fileName)) {
      serializer.Serialize(stream, objectToSerialize);
    }
  }
}

To deserialize, though, since you must know the compile-time type of the object that you want, you could use generics on the deserialization method:

public static class ObjectXMLDeserializer {
  public static T Load<T>(string fileName) { 
    var serializer = new XmlSerializer(typeof(T));
    using (var stream = File.OpenRead(fileName)) {
      return (T)serializer.Deserialize(stream);
    }
  } 
}

Answer 5

Despite the fact that you might be doing it wrong, you can construct a generic type and an instance of generic type using reflection. For example, if I would like to create a List<int> I can write

Type t = typeof(List<>).MakeGenericType(typeof(int));
object list = Activator.CreateInstance(t);
// add an integer to list and get Count property        
t.GetMethod("Add").Invoke(list, new object[] {3});
int count = (int) t.GetProperty("Count").GetValue(list, null);

... and that is why everybody would suggest redesigning your class.