CODEWITHSUNDEEP
c#.netxml-serialization
Scott McKay
Scott McKay

Reputation: 353

Deserializing individual objects

Is there a way in .Net 4 to easily deserialize a stream of mixed objects one by one? I can read to the start of the element for an object I want to deserialize using XmlTextReader.Read(), but have tried many ways to deserialize that specific object unsuccessfully.

The types I want to deserialize can be read as a list of those types without a problem using XmlSerializer, however I want to be able to mix them rather than having input files containing just lists of one object type.

e.g. 

<Objects>
  <TypeA>...</TypeA>
  <TypeB>...</TypeB>
  <TypeA>...</TypeA>
  <TypeC>...</TypeC>
  ...
</Objects>

The ordering of the objects in would be random.

Many thanks for any pointers.

I've looked at XmlSerializer, DataContractSerializer and XElement, but could not get them to work for this (although I possibly didn't set those up correctly as I'm not very familiar with them).

Upvotes: 3

Views: 761

Answers (3)

Stephen Chung
Stephen Chung

Reputation: 14605

You can do that with the XmlSerializer.

However, be careful with the following:

  1. The array you are serializing/deserializing must be declared as an array of "object" (or the base object if all other types inherit from it)
  2. Each type will have "xsi:type" attached to it
  3. You must use [XmlInclude] to include all the type(s) you are ever going to need with the "root" object.

The need to [XmlInclude] all the object types mean that you're not going to be able to dynamically add types to the serialization. You'll need to add [XmlInclude]'s and recompile to include the new type(s).

Your XML, however, will become:

<Objects>
  <TypeObj xsi:type="TypeA">...</TypeObj>
  <TypeObj xsi:type="TypeB">...</TypeObj>
  <TypeObj xsi:type="TypeA">...</TypeObj>
  <TypeObj xsi:type="TypeC">...</TypeObj>
      :
</Objects>

This is the most flexible and "normal" way of approach XML serialization of multiple types. However, if you need to keep your exact format, you can declare your class this way:

[XmlRoot("Objects")]
public class Objects
{
    [XmlElement("TypeA")] public TypeA[] TypeAObjects;
    [XmlElement("TypeB")] public TypeB[] TypeBObjects;
    [XmlElement("TypeC")] public TypeC[] TypeCObjects;
         :
}

[XmlElement] means that all the objects are jumbled up on the same level (different from XmlArray). They do not even have to be in order.

The pitfalls of doing this, however, is that if you want to add a new type, you'll have to modify the "Objects" class.

Upvotes: 2

Joel C
Joel C

Reputation: 5567

You would need to create an XmlSerializer for each type. How many types you have and how many times each would get used would determine if it's better to create a new XmlSerializer for each object as you process it, or store them in a Dictionary<string, XmlSerializer> to be reused. The XmlSerializer takes the type in its constructor, and then you can call the Deserialize method, passing it a StringReader that contains the XML string you read from your file. Hopefully that's enough to get you started, but if you need more help I can throw together some sample code ;)

Upvotes: 0

Ben Cull
Ben Cull

Reputation: 9504

Not sure if this is helpful, but it might be an idea to take a look at how RestSharp does their deserialization. https://github.com/johnsheehan/RestSharp

Specifilcally Take a look at RestSharp/Deserializers/XmlDeserializer.cs

Upvotes: 0

Related Questions