We Keep Coding

How do you deserialize XML with incremented ID on the collection?

I have a set of large XML files with various sections in them.
As an example file I have mocked this up which serializes and deserializes just fine if I don't have the appended counter of 1, 2, 3... etc.
<?xml version="1.0" encoding="utf-16"?>
<employees xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<category name="TestCategory" baseicon="0" decalicon="0">
<EmployeeList1>
<name type="string">Peter Parker</name>
<age type="number">25</age>
</EmployeeList1>
<EmployeeList2>
<name type="string">J.J. Jameson</name>
<age type="number">57</age>
</EmployeeList2>
</category>
</employees>
However, when I have the incremented elements in the collection I get back no objects in the EmployeeList collection but will get back the overall Employees object.
So all the objects within the EmployeeList elements have the same structure overall although some will have optional fields like, let's say "homeowner".
[XmlRoot(ElementName = "category")]
public class Category
{
[XmlAttribute(AttributeName = "name")]
public string Name;
[XmlAttribute(AttributeName = "baseicon")]
public int Baseicon;
[XmlAttribute(AttributeName = "decalicon")]
public int Decalicon;
[XmlElement]
public List<Employee> EmployeeList { get; set; }
public Category()
{
}
}
And the Employee class looks like this:
[XmlRoot(ElementName = "employees")]
public class Employees
{
[XmlElement(ElementName = "category")]
public Category Category;
public Employees()
{
}
}
[XmlRoot(ElementName = "employee")]
public class Employee
{
[XmlElement(ElementName = "name")]
public Name Name { get; set; }
[XmlElement(ElementName = "age")]
public Age Age { get; set; }
}
Then, of course the follow up is how to serialize a collection of elements with an incremented ID?

I can offer a custom XmlReader that will replace the specified element names on the fly.
public class ReplacingXmlReader : XmlTextReader
{
private readonly string _nameToReplace;
public ReplacingXmlReader(string url, string nameToReplace)
: base(url)
{
_nameToReplace = nameToReplace;
}
// Define the remaining constructors here.
public override string LocalName
{
get
{
if (base.LocalName.StartsWith(_nameToReplace))
return _nameToReplace;
return base.LocalName;
}
}
}
Usage is easy:
var xs = new XmlSerializer(typeof(Employees));
using var reader = new ReplacingXmlReader("test.xml", "EmployeeList");
var employees = (Employees)xs.Deserialize(reader);
If necessary, you can make a list of element names to replace.

Using serial numbers as part of the element name is really bad XML design, and the best way of dealing with badly designed XML is often to put it through an XSLT transformation that turns it into something more manageable, before doing any further processing. In this case you might simply strip off the numeric suffixes, because they're completely redundant.
In XSLT 3.0 that would be:
<xsl:transform version="3.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:mode on-no-match="shallow-copy">
<xsl:template match="*[starts-with(local-name(), 'EmployeeList'>
<EmployeeList>
<xsl:apply-templates/>
</EmployeeList>
</xsl:template>
</xsl:transform>

XmlSerializer Deserializing List Without namespace

Trying to deserialize List.
Im getting the following error:
System.InvalidOperationException: There is an error in XML document
(1, 2). ---> System.InvalidOperationException: was not expected.
Saw other quesitons like : {"<user xmlns=''> was not expected.} Deserializing Twitter XML but this does not solve my problem either.
This is an Xml Sample
<authorizations>
<id>111</id>
<name>Name 1</name>
<Lists>
<List>
<id>1</id>
<id>2</id>
</List>
</Lists>
</authorizations>
<authorizations>
<id>222</id>
<name>Name 2</name>
<List />
</authorizations>
<authorizations>
<id>333</id>
<name>Name 3</name>
<List />
</authorizations>
The class are created as follow:
public class Authorization
{
[XmlElement("id")]
public string Id{ get; set; }
[XmlElement("name")]
public string Name{ get; set; }
[XmlArray("Lists")]
[XmlArrayItem("List")]
public List[] Items{ get; set; }
}
public class List
{
[XmlElement("id")]
public string Id{ get; set; }
}
public class AuthorizationList
{
[XmlArray("authorizations")]
public Authorization Authorizations{ get; set; }
}
Have tried changing the list to XmlArray, XmlArrayItem or Element. but still get the same error when I deserialize.
Deserializing Code Sample:
public static T FromXml<T>(string xmlString)
{
T obj = default(T);
if (!string.IsNullOrWhiteSpace(xmlString))
{
using (var stringReader = new StringReader(xmlString))
{
var xmlSerializer = new XmlSerializer(typeof(T));
obj = (T)xmlSerializer.Deserialize(stringReader);
}
}
return obj;
}

This is ALL premised on the assumption that you have minimal control over the xml and don't have the luxury of changing that too much. As others have noted, it is not well-formed. Here is one way to get serialization to work with minimal changes to your XML and types. First, get rid of your AuthorizationList type and assign an XmlType attribute to your Authorization type (this step serves to simply pluralize the name to match how your XML has it).
[XmlType("authorizations")]
public class Authorization { ... }
public class List { ... }
Wrap your XML in the following root element:
<ArrayOfAuthorizations>
...
</ArrayOfAuthorizations>
The XML now represents a list of "authorizations" so to deserialize is just this:
List<Authorization> l = FromXml<List<Authorization>>(xml);
Another Solution:
Change the Authorizations member to be of type Authorization[] (array type rather than singular) and to have an XmlElement attribute (not XmlArray). Apply the XmlType attribute to the Authorization (as with the above solution this is to match the xml since it has the pluralized name for each array element).
[XmlType("authorizations")]
public class Authorization
{
[XmlElement("id")]
public string Id { get; set; }
[XmlElement("name")]
public string Name { get; set; }
[XmlArray("Lists")]
[XmlArrayItem("List")]
public List[] Items { get; set; }
}
public class List
{
[XmlElement("id")]
public string Id { get; set; }
}
public class AuthorizationList
{
[XmlElement("authorizations")]
public Authorization[] Authorizations { get; set; }
}
Like before, you need to wrap your XML with the matching 'AuthorizationList' root element:
<AuthorizationList>
...
</AuthorizationList>
Then you deserialize instance of your AuthorizationList type rather that List<T> as with the previous solution.
AuthorizationList l = FromXml<AuthorizationList>(xml);
Note that the root XML element will also need to match that type name also.
<AuthorizationList>
<authorizations>
<id>111</id>
<name>Name 1</name>
<Lists>
<List>
<id>1</id>
<id>2</id>
</List>
</Lists>
</authorizations>
<authorizations>
<id>222</id>
<name>Name 2</name>
<List />
</authorizations>
<authorizations>
<id>333</id>
<name>Name 3</name>
<List />
</authorizations>
</AuthorizationList>

C# Deserialize XML to a list of ChildClasses

I have a XML from a 3rd party software that I have to deserialize, but I have the spec of the XML.
At a certain point I have a node that contains a bunch of different Nodes of different types. I have to deserialize this Node (Vehicles) as a list. Each of the child nodes is one subclass of the class Vehicle
public List<Vehicle> Vehicles = new List<Vehicles>();
the definition of the class is as following
public class Vehicle
{
public string Vehicletype { get; set; }
public virtual bool Drive() { return true; }
}
public class Car:Vehicle
{
public int NumberOfDoors { get; set; }
public override bool Drive() { return false; }
}
public class Boat:Vehicle
{
public int NumberOfSeats { get; set; }
}
The definition of the XML looks like this
<vehicles>
<car NumberOfDoors="4" />
<car NumberOfDoors="3" />
<boat NumberOfSeats="1024" />
<boat NumberOfSeats="20" />
<car NumberOfDoors="5" />
</vehicles>
At a certain point I have to loop through them and let them "Drive". I don't have the experience With XMLSchema definitions. Now I am using The vehicleType in a factory and some other things. It's basically becoming a mess.
I would need a suggestion how to let the Serializer do this instead of me. I doubt that I am the first one to have this issue.

Firstly, you have to mark NumberofSeats and NumberOfDoors with the XmlAttribute attribute to tell XmlSerializer that these properties should appear as XML attributes:
public class Car : Vehicle
{
[XmlAttribute]
public int NumberOfDoors { get; set; }
public override bool Drive() { return false; }
}
public class Boat : Vehicle
{
[XmlAttribute]
public int NumberOfSeats { get; set; }
}
Next, if <vehicles> appears as an XML Node inside some containing root element, you can make your public List<Vehicle> Vehicles appear as a member inside the corresponding container class, and apply an XmlArray attribute to it to indicate that the list should be serialized in two levels, and XmlArrayItem attributes to inform XmlSerializer of the possible of vehicles that might be encountered in the list along with the start tag to use for each:
public class VehiclesContainer // Your container class
{
[XmlArray("vehicles")]
[XmlArrayItem("vehicle", typeof(Vehicle))]
[XmlArrayItem("car", typeof(Car))]
[XmlArrayItem("boat", typeof(Boat))]
public List<Vehicle> Vehicles = new List<Vehicle>();
}
On the other hand, <vehicles> is the root node of the XML document and there is no containing node, you can introduce a root node class containing the list of vehicles, then apply multiple XmlElement attributes to indicate that the list should be serialized in one level rather than two along with the start tag to use for each possible vehicle type:
[XmlRoot("vehicles")]
public class VehicleList
{
[XmlElement("vehicle", typeof(Vehicle))]
[XmlElement("car", typeof(Car))]
[XmlElement("boat", typeof(Boat))]
public List<Vehicle> Vehicles = new List<Vehicle>();
}
Having done this, XmlSerializer will automatically deserialize your class hierarchy.
For more information, see here.

Class not serializing as expected

I've been struggling with this all day. I done a lot of research, but I just can't seem to put it all together.
I have a XML response from a server like so:
<?xml version="1.0" ?>
<inboxRecords>
<inboxRecord>
<field1 />
<field2 />
<field3 />
</inboxRecord>
<inboxRecord>
<field1 />
<field2 />
<field3 />
</inboxRecord>
</inboxRecords>
I created the following code to represent the response. The intention is that I will de-serialize the response using the following:
[XmlRoot("inboxRecords")]
public sealed class QueueQueryResult
{
public InboxRecord[] InboxRecords;
public QueueQueryResult()
{
InboxRecords = null;
}
public sealed class InboxRecord
{
public string field1 { get; set; }
public string field2 { get; set; }
public string field3 { get; set; }
}
}
The classes above are based on one of the numerous examples I found online. The problem is, when I serialize the class above (to confirm that it is correct), it comes out like this:
<?xml version="1.0" encoding="utf-16"?>
<inboxRecords>
<InboxRecords>
<InboxRecord>
<field1>some value</field1>
</InboxRecord>
<InboxRecord>
<field1>some value</field1>
</InboxRecord>
</InboxRecords>
</inboxRecords>
So, first problem, how do I get rid of the extra InboxRecords element? I only want the root to say that (with a small 'i'). Second, for quick testing, I only put a value in the first field. Why didn't the other fields come out as empty elements? Do I need another decorator for that?
Thanks!
Thanks!

Use the XmlElement attribute:
[XmlRoot("inboxRecords")]
public sealed class QueueQueryResult
{
[XmlElement("inboxRecord")]
public InboxRecord[] InboxRecords;
public QueueQueryResult()
{
InboxRecords = null;
}
public sealed class InboxRecord
{
public string field1 { get; set; }
public string field2 { get; set; }
public string field3 { get; set; }
}
}
This removes the Array wrapper element and allows you to control the name for each xml element so that you can use lower case names.

Untested, but I reckon you could probably do something like this:
[XmlRoot("inboxRecords")]
public sealed class QueueQueryResult : Collection<QueueQueryResult.InboxRecord>
{
public QueueQueryResult()
{
InboxRecords = null;
}
public sealed class InboxRecord
{
public string field1 { get; set; }
public string field2 { get; set; }
public string field3 { get; set; }
}
}
The problem with your code is that you've got a member InboxRecords within an object that is serialising to inboxRecords. By making the class inherit from Collection, you're providing it with the capability to handle a set of InboxRecords without the extra inner element.

After generating an XSD from your first sample XML (and then a .cs) using xsd.exe, I can create and serialize an instance from your second example:
<?xml version="1.0" encoding="utf-16"?>
<inboxRecords xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<inboxRecord>
<field1>some value</field1>
</inboxRecord>
<inboxRecord>
<field1>some value</field1>
</inboxRecord>
</inboxRecords>
With the exception of the encoding attribute and the schema namespace, this looks pretty darn similar to the first sample.

Deserialize XML to object (need to return a list of objects)

Started practicing with XML and C# and I have an error message of "There is an error in XML document (3,2)". After looking at the file, I can't see anything wrong with it (Mind you, I probably missed something since I'm a noob). I'm using a Console Application for C# right now. I'm trying to return a list of Adventurers and just a side note, the GEAR element is optional. Here is what I have so far:
XML File - Test1
<?xml version="1.0" encoding="utf-8"?>
<Catalog>
<Adventurer>
<ID>001</ID>
<Name>John Smith</Name>
<Address>123 Fake Street</Address>
<Phone>123-456-7890</Phone>
<Gear>
<Attack>
<Item>
<IName>Sword</IName>
<IPrice>15.00</IPrice>
</Item>
<Item>
<IName>Wand</IName>
<IPrice>20.00</IPrice>
</Item>
</Attack>
<Defense>
<Item>
<IName>Shield</IName>
<IPrice>5.00</IPrice>
</Item>
</Defense>
</Gear>
</Adventurer>
<Adventurer>
<ID>002</ID>
<Name>Guy noone likes</Name>
<Address>Some Big House</Address>
<Phone>666-666-6666</Phone>
<Gear></Gear>
</Adventurer>
</Catalog>
C# Classes
public class Catalog
{
List<Adventurer> Adventurers { get; set; }
}
public class Adventurer
{
public int ID { get; set; }
public string Name { get; set; }
public string Address { get; set; }
public string Phone { get; set; }
public Gear Gear { get; set; }
}
public class Gear
{
public List<Item> Attack { get; set; }
public List<Item> Defense { get; set; }
}
public class Item
{
public string IName { get; set; }
public decimal IPrice { get; set; }
}
Serialize Function - Where the Problem Occurs at Line 5
Catalog obj = null;
string path = #"C:\Users\Blah\Desktop\test1.xml";
XmlSerializer serializer = new XmlSerializer(typeof(Catalog));
StreamReader reader = new StreamReader(path);
obj = (Catalog)serializer.Deserialize(reader);
reader.Close();
Console.ReadLine();

The issue is the list of Adventurers in Catalog:
<?xml version="1.0" encoding="utf-8"?>
<Catalog>
<Adventurers> <!-- you're missing this -->
<Adventurer>
</Adventurer>
...
<Adventurer>
</Adventurer>
</Adventurers> <!-- and missing this -->
</Catalog>
You don't have the wrapping element for the Adventurers collection.
EDIT: By the way, I find the easiest way to build the XML structure and make sure it's compatible is to create the object(s) in C#, then run through the built-in XmlSerializer and use its XML output as a basis for any XML I create rather than forming it by hand.

First, "Adventurers" property is not public, it's inaccessible, I think that the best way to find the error is to serialize your object and then compare the result with your xml file.

Your XML doesn't quite line up with your objects... namely these two...
public string City { get; set; }
and
<Address>123 Fake Street</Address>
Change City to Address or vice versa and it should fix the problem.
Edit: Got this to work in a test project, combination of all our answers...
Add <Adventurers> tag after <Catalog> (and </Adventurers> before </Catalog>) and change
List<Adventurer> Adventurers { get; set; }
to
public List<Adventurer> Adventurers { get; set; }
and it works properly for me.

I was able to get your xml to deserialize with a couple minor changes (namely the public qualifier on Adventurer).
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml.Serialization;
namespace TempSandbox
{
[XmlRoot]
public class Catalog
{
[XmlElement("Adventurer")]
public List<Adventurer> Adventurers;
private readonly static Type[] myTypes = new Type[] { typeof(Adventurer), typeof(Gear), typeof(Item) };
private readonly static XmlSerializer mySerializer = new XmlSerializer(typeof(Catalog), myTypes);
public static Catalog Deserialize(string xml)
{
return (Catalog)Utils.Deserialize(mySerializer, xml, Encoding.UTF8);
}
}
[XmlRoot]
public class Adventurer
{
public int ID;
public string Name;
public string Address;
public string Phone;
[XmlElement(IsNullable = true)]
public Gear Gear;
}
[XmlRoot]
public class Gear
{
public List<Item> Attack;
public List<Item> Defense;
}
[XmlRoot]
public class Item
{
public string IName;
public decimal IPrice;
}
}
I'm using [XmlElement("Adventurer")] because the xml element names don't exactly match the class property names.
NOTE: I'm using a generic deserialization utility i already had on hand .