Answered: Help! Deserialising custom classes that contain lists of classes :!

Unity Engine
1

Hi all,

I’m currently creating a simple multiplayer game using an authorative server approach (more of a learning curve for me than anything). I’ve hit a snag when it comes to passing a complex game object structure from the client to the server.

I’m using XML Serialiser to send the xml structure over, and the structure is getting there in one piece and I can see from the debug log its held all its elements etc.
My problem comes when I try to deserialise this into its original class. example class structure:

[XmlRoot("Armies")]
[System.Serializable]
public class  Armies  {
    public Army army = new Army();
  
public string armyName;

    [System.Serializable]
    public class Army    {
[XmlArray("regiments")]
        [XmlArrayItem("Regiment")]
        public List<Regiment> regiments = new List<Regiment>();
[System.Serializable]
public class Regiment
{
public string regimentName;
}
}
}

It goes through and gets the right fields for the first part (i.e. army section) but once it comes to the list of regiments it leaves it blank (empty), and just returns a collection of regiments of 0.

From what I’ve read this is because it doesn’t understand the type as it is serialised/deserialised so doesn’t understand how to recreate the sub class??

Would be very appreciative of any advice/guidance on:
a) a better way to pass data structures for a multiplayer game, or
b) if there is something i’m fundamentally doing wrong that could fix this issue? I’ve tried researching this but haven’t been able to come to any solutions!

I’ve included my serialiser code for reference:

 public string SerializeXMLObject(Type myType, object pObject)
    {
        string XmlizedString = null;
        MemoryStream memoryStream = new MemoryStream();
        XmlSerializer xs = new XmlSerializer(myType);
        XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
        xs.Serialize(xmlTextWriter, pObject);
        memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
        XmlizedString = UTF8ByteArrayToString(memoryStream.ToArray());
        return XmlizedString;
       
    }

    // Here we deserialize it back into its original form
   public  object DeserializeObject(Type myType, string pXmlizedString)
    {
        XmlSerializer xs = new XmlSerializer(myType);
        MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(pXmlizedString));
               return xs.Deserialize(memoryStream);
    }
2

And you did put instances of Regiments in your list… right?

3

when dealing with plain text serialization under unity - i’d strongly suggest using a json.net implementation.

there’s a json.net imp on the app store that even works on ios.

4

Hi LightStriker - little bit unsure what you are referring to here? Do you mean adding blank regiment instances before you try to assign the data? If so yes I have tried that.

myArmy.army.regiments.Add(newReg);
myArmy = (Armies)xmlSerialise.xmlSerial.DeserializeObject(typeof(Armies), _armyData);

this still appears to come up blank with no data in the myArmy variable which is an instance of the class Armies

5

Annotate your Regiment class with [XmlType(“Regiment”)]

Also you don’t need the System.Serializable attribute unless you’re also letting Unity serialize it.

6

Hmm this still isn’t working. either I am doing something fundamentally wrong or I still haven’t got my head around this code. so to give a really basic example of the idea tell me if this should work, as I walk through an example with code from end to end:

Basic XML File

<armies>
        <army>
        <armyName>Army 1</armyName>
              <regiments>
                         <regiment>
                         <regimentName>Regiment 1</regimentName>
                         </regiment>
                         <regiment>
                         <regimentName>Regiment 2</regimentName>
                         </regiment>
              </regiments>
        </army>
</armies>

Then we have the basic class definition within unity:

[XmlRoot("armies")]
public class armies {
    public army myArmy = new army(); //declare instance of sub class army

    public class Army {
        public string armyName;
        [XmlArray("regiments")]
            [XmlArrayItem("regiment")]
            public List<regiment> regiments = new List<regiment>();

        [XmlType("regiment")]
            public class regiment { public string regimentName;}
    }
}

then using this load function to load into a string the xml file:

   public string LoadFile(string _FileLocation, string FileName)
    {
        string data;
        StreamReader r = File.OpenText(_FileLocation + FileName);
        string _info = r.ReadToEnd();
        r.Close();
        data = _info;
        Debug.Log("File Read");
        return data;
    }

you can then run this code to serialise that xml data string, into an object of type “armies”, populating all sub classes with the correct data

armies ourArmyObject = new ourArmyObject();
ourArmyObject = (armies)xmlSerialise.xmlSerial.DeserializeObject(typeof(armies), _armyData);

and this calls out to the aforementioned deserialiser class which is the following:

public  object DeserializeObject(Type myType, string pXmlizedString)
    {
        XmlSerializer xs = new XmlSerializer(myType);
   
        MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(pXmlizedString));
return xs.Deserialize(memoryStream);
    }

The final result should be a completely populated armies object with all of its subclasses data.

Please feel free to point out anything that doesn’t look right, or if it does maybe I’m just trying to do something that cant be done and will need to look into the JSON implementation as mentioned by Frozen.

7

Your element doesn’t map to anything. If you don’t provide an XmlElement annotation then I think it’ll default to the field name which would be

1 Like
8

WOOOO! I have finally got it working, a combination it would appear of me not quite understanding how to tag my class correctly and going back and working through a really basic example!

Key takeaway for anyone following along is for the list, make sure you tag the XML Array & array item correctly, for the above example of regiment, use the following:

    [XmlArray("regiments")]
        [XmlArrayItem("regiment")]
        public List<Regiment> regiments = new List<Regiment>();

Please note that the list regiments is NOT what the XmlArray tag is referring to - that is actually the XmlTag in your xml files name. The ArrayItem is also referring to the XmlTag within your Xml file which defines each instance of the element.
The next part which Kelso kindly pointed out is to make sure all your classes are Typed.

 [XmlType("Regiment")]
        public class Regiment

This time the XmlType IS referring to the name of the class within your code.

Hope that helps anyone else who runs across this issue and thanks heaps to everyone who responded in particular KelsoMRK!

9

Glad you got it working.

It’s worth noting that if regiments was a Regiment[ ] instead of a List then the XmlType annotation would not be necessary.