Question

How can I do this? Or will the serializer automatically go with recursion, and serialize all those child objects into XML?

Give me an example how would you serialize classes that contain other classes’ objects in themselves! That was the core of this question!

I’ve tried this, and it didn’t output anything (except the XML header) to the targeted XML file.

My problem is that I need to serialize a simple class, that just holds a List object. But, those Entities also hod List objects. (Another plus would be if I could avoid the serialization of some components, because some are derived and have dictionaries in them).

public void SaveCurrent(string MapFileName)
{
    string MapPath = world_.game_.Content.RootDirectory + "/Maps/" + MapFileName + ".xml";
    StreamWriter MapWriter = new StreamWriter(MapPath);

    Map SavedMap = new Map();
    SavedMap.Entities = world_.Entities;
    XmlSerializer xSerializer = new XmlSerializer(SavedMap.GetType());

    xSerializer.Serialize(MapWriter, SavedMap);
    MapWriter.Close();
}

That’s the piece of code that does the serialization.

public class Map
{
    internal string MapName;
    internal string MapDescription;
    internal string MapAuthor;
    public List<Entity> Entities = new List<Entity>();
}

And this is the class that’s serialized. Could internals be counted as publics, if the serialization is called from the same assembly? The code throws exception at the SavedMap.GetType() function, and I’ve tried typeof(Map) too, but without success. I guess it’s because I need some other way to handle each new class (deep serialization) how do I do that?

Also, I’ve found on some examples, that there are no interface inheritance or attributes, therefore I didn’t add those either, but I’m planning to use IXmlSerializable, though I don’t know how to call another serialization inside WriteXML implementation.

Answer 1

About the type problem that Josh Einstein mentionned, you do not have to work with the XmlInclude attribute : you can also pass the list of types to the serializer (signature being XmlSerializer(Type baseType, Type[] extraTypes)). This should be done especially if there’s a chance that the extra types list grow over time.

Finding the extra-types can be either done through reflection over the object to be serialized or reflection at startup on the loaded assemblies to fetch any needed types.

EDIT : raw example :

public abstract class Animal
{
}

public class Dog : Animal
{
}

public class Cat : Animal
{
}

public static class AnimalSerializer
{
    public static void Serialize(List<Animal> animals, Stream stream)
    {
        List<Type> animalTypes = new List<Type>();
        foreach (Animal animal in animals)
        {
            Type type = animal.GetType();
            if (!animalTypes.Contains(type))
            {
                animalTypes.Add(type);
            }
        }
        XmlSerializer serializer = new XmlSerializer(typeof(List<Animal>), animalTypes.ToArray());
        serializer.Serialize(stream, animals);
    }
}