How to serialize a class that contains objects of other classes (recursive serializing?)

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

Give m开发者_StackOverflow中文版e 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.

Add Serializable and XmlInclude your class:

[System.Serializable]
[System.Xml.Serialization.XmlInclude(typeof(Entity))]
public class Map
{
    internal string MapName;
    internal string MapDescription;
    internal string MapAuthor;
    public List<Entity> Entities = new List<Entity>();
}

Usage:

System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(Map));
serializer.Serialize(mapWriter, savedMap);

It will serialize the entire object graph (the object and any objects it exposes through public members, recursively) as long as all objects in the graph are serializable. Different serializers have different rules for what is serializable. For example the XmlSerializer needs a default public constructor.

Also, the XML serializer needs to be able to tell what kind of types it will serialize based only on the type info and attributes on those types. So say for example you have a class that has a property of type Animal, yet at runtime XmlSerializer finds an object of type Dog in there. To support this you will need to use the XmlInclude attribute to let it know ahead of time that it needs to support Dog.

In order to keep parts of the object graph out of the serialized output, you would use the XmlIgnore attribute. Different serializers also have different attributes for including/ignoring, etc.

Hope this helps clarify a little bit. You may also want to read up on this topic in MSDN.

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);
    }
}

How much control do you need? You can always implement IXmlSerializable -

http://msdn.microsoft.com/en-us/library/system.xml.serialization.ixmlserializable.aspx