We Keep Coding

How to use array with XmlSerializer?

I'm making some test to use it.
I have the following xml:
<?xml version="1.0"?>
<test xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<ma>233</ma>
<ma>2333</ma>
</test>
I have this class to deserialize it:
[Serializable]
public class test
{
public string ma { get; set; }
}
It does contains the first element. Now I want both so I try setting an array
[Serializable]
public class test
{
public string[] ma { get; set; }
}
However setting an array I have now 0 result in ma variable, while I at least have the first one when it is not an array.
I found this answer Using XmlSerializer with an array in the root element, but he used another logic... I'd like to keep using [Serializable]

You have to indicate that the array doesn't have a separate xml element to wrap its items, but that the array items appear directly under the <test> element:
public class test
{
[XmlElement]
public string[] ma { get; set; }
}
PS. sometimes it's hard to get the mapping right - I usually fill in a class with test data and serilalize it, examining what XmlSerializer makes of that usually clears up what's going on.

The answer you found provides the information you need.
[Serializable] doesn't help you because it isn't used by XmlSerializer, see Why doesn't the XmlSerializer need the type to be marked [Serializable]?

Deserialize objects with RestSharp where the class is in a type attribute

I'm trying to consume data from a rest api.
I need to deserialize objects from a rest API using RestSharp.
The all objects in lists are an "object" element where the object's class is the value of a "type" attribute.
Here is an example of what I mean:
<list>
<object type="cat">
<id>107</id>
<name>Garry</name>
</object>
<object type="dog">
<id>83</id>
<name>Fluffy</name>
</object>
</list>
And partially implemented classes for the example:
public class Animal
{
public long Id { get; set; }
public string Name { get; set; }
}
[DeserializeAs(Name = "cat")]
public class Cat : Animal
{
}
[DeserializeAs(Name = "dog")]
public class Dog : Animal
{
}
It seems like the wrong way to go, but tried defining all of my classes using the attribute:
[DeserializeAs(Name = "object")]
This allows them to deserialize properly, as long as I know what type of object to expect in the list, and obviously the list only contains one type of object.
The problem comes in if I get a list containing different types of objects.
Is there a way to handle this well using the standard deserializer?
If not, I am open to ways to handle this effectively with a large number of different object types.

I looked at the standard deserializer. I am pretty sure it was not designed to handle this. I ended up making my own fork.
I added another attribute for describing the object in lists:
[DeserializeElementAs(Name = "", Attribute = "", Value = "")]
The attribute name might not be the best, but I was not sure what to call it.
So the classes for the xml from the question would be defined as:
public class Animal
{
public long Id { get; set; }
public string Name { get; set; }
}
[DeserializeElementAs(Name = "object", Attribute = "type", Value = "cat")]
[DeserializeAs(Name = "cat")]
public class Cat : Animal
{
}
[DeserializeElementAs(Name = "object", Attribute = "type", Value = "dog")]
[DeserializeAs(Name = "dog")]
public class Dog : Animal
{
}
I posted the code of fork to github if anyone else needs it.
https://github.com/comless/RestSharp/commit/1fea0fd97cadc7035dbea99c17b7423ca14b5267

How to Deserialize XML elements to generic list with unknown element names

I am retrieving and successfully deserializing an xml string from a database table column for the known element names (these do not change) but there are also some nested XML Elements called "Other Attributes" which are not always going to be known. I'm having some trouble deserialising these unknown element names to a generic list so I can display them in html once deserialised.
The XML is as follows:
<Detail>
<DetailAttributes>
<Name>Name_123</Name>
<Type>Type_123</Type>
</DetailAttributes>
<OtherAttributes>
<SummaryKey AttributeName="SummaryKey">SummaryKey_123</SummaryKey>
<Account AttributeName="Account">Account_123</Account>
</OtherAttributes>
</Detail>
I have no problem deserialising the 'Name' and 'Type' elements and I can deserialise the 'SummaryKey' and 'Account' elements but only if I explicitly specify their element names - which is not the desired approach because the 'OtherAttributes' are subject to change.
My classes are as follows:
[XmlRoot("Detail")]
public class objectDetailsList
{
[XmlElement("DetailAttributes"), Type = typeof(DetailAttribute))]
public DetailAttribute[] detailAttributes { get; set; }
[XmlElement("OtherAttributes")]
public List<OtherAttribute> otherAttributes { get; set; }
public objectDetailsList()
{
}
}
[Serializable]
public class Detail Attribute
{
[XmlElement("Type")]
public string Type { get;set; }
[XmlElement("Name")]
public string Name { get;set; }
public DetailAttribute()
{
}
}
[Serializable]
public class OtherAttribute
{
//The following will deserialise ok
//[XmlElement("SummaryKey")]
//public string sumKey { get; set; }
//[XmlElement("Account")]
//public string acc { get; set; }
//What I want to do below is create a list of all 'other attributes' without known names
[XmlArray("OtherAttributes")]
public List<Element> element { get; set; }
}
[XmlRoot("OtherAttributes")]
public class Element
{
[XmlAttribute("AttributeName")]
public string aName { get; set; }
[XmlText]
public string aValue { get; set; }
}
When I try to retrieve the deserialised list of OtherAttribute elements the count is zero so it's not able to access the elements nested within "Other Attributes".
Can anybody help me with this please?

With concrete classes and dynamic data like this, you won't be able to lean on the standard XmlSerializer to serialize / deserialize for you - as it reflects on your classes, and the properties you want to populate simply don't exist. You could provide a class with all possible properties if your set of 'OtherAttributes' is known and finite, and not subject to future change, but that would give you an ugly bloated class (and I think you've already decided this is not the solution).
Practical options therefore:
Do it manually. Use the XmlDocument class, load your data with .Load(), and iterate the nodes using .SelectNodes() using an XPath query (something like "/Detail/OtherAttributes/*"). You will have to write the lot yourself, but this gives you complete control over the serialization / deserialization. You won't have to cover your code in (arguably superfluous!) attributes either.
Use Json.NET (http://james.newtonking.com/json), it allows for far greater control over serialization and deserialization. It's fast, has good docs and is overall pretty nifty really.

attribute not being serialized by XmlSerializer

I'd like to serialize a class to XML, assigning an XML attribute to it. Snippet:
[XmlType(TypeName = "classmy")]
public class MyClass2 : List<object>
{
[XmlAttribute(AttributeName = "myattr")]
public string Name { get; set; }
}
public class MyConst
{
public MyConst()
{
MyClass2 myClass2 = new MyClass2 { 10, "abc" };
myClass2.Name = "nomm";
XmlSerializer serializer = new XmlSerializer(typeof(MyClass2));
serializer.Serialize(Console.Out, myClass2);
}
}
But the resulting XML looks like this
<?xml version="1.0" encoding="IBM437"?>
<classmy xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<anyType xsi:type="xsd:int">10</anyType>
<anyType xsi:type="xsd:string">abc</anyType>
</classmy>
All well and good, with the only exception being that myClass2.Name is not serialized. I was expecting something in the line of
<classmy myattr="nomm" [...]>[...]</classmy>
... Why isn't that serialized, and how can it be?

dont derive List<T>, create class with member List
[XmlType(TypeName = "classmy")]
public class MyClass2
{
[XmlAttribute(AttributeName = "Items")]
List<object> Items { get; set; } //need to change type in `<>`
[XmlAttribute(AttributeName = "myattr")]
public string Name { get; set; }
}

Alternative solution: use an array instead of a list and XmlElement
[XmlType(TypeName = "classmy")]
public class MyClass2
{
[XmlElement(ElementName = "Items")]
public object[] Items { get; set; }
[XmlAttribute(AttributeName = "myattr")]
public string Name { get; set; }
}

XmlSerializer treats List<> in special way:
XmlSerializer can process classes that implement IEnumerable or ICollection differently if they meet certain requirements. A class that implements IEnumerable must implement a public Add method that takes a single parameter. The Add method's parameter must be consistent (polymorphic) with the type returned from the IEnumerator.Current property returned from the GetEnumerator method. A class that implements ICollection in addition to IEnumerable (such as CollectionBase) must have a public Item indexed property (an indexer in C#) that takes an integer, and it must have a public Count property of type integer. The parameter passed to the Add method must be the same type as that returned from the Item property, or one of that type's bases. For classes implementing ICollection, values to be serialized will be retrieved from the indexed Item property rather than by calling GetEnumerator. Also note that public fields and properties will not be serialized, with the exception of public fields that return another collection class (one that implements ICollection). MSDN - scroll to XML Serialization Considerations
That why it serialized Your class as a list of objects only, without Your property. The best solution is to include List as class public property and mark it as XmlElement.

Serializing class, "move" attribute to other element

I'm trying to constrol where a class property is rendered when the class is serialized: I need the property to appear as an attribute on a specific element:
namespace ConsoleApplication6
{
public class Program
{
static void Main(string[] args)
{
var myClass = new MyClass();
myClass.MyList.Add(new Item() { ID = 1 });
myClass.MyList.Add(new Item() { ID = 2 });
myClass.Xxx = "Hello World!";
var sx = new XmlSerializer(myClass.GetType());
sx.Serialize(Console.Out, myClass);
}
public class MyClass
{
public MyClass()
{
MyList = new List<Item>();
}
public List<Item> MyList { get; set; }
[XmlAttributeAttribute(AttributeName = "x")]
public string Xxx { get; set; }
}
public class Item
{
public int ID { get; set; }
}
}
}
This serializes quite nicely into this:
<?xml version="1.0" encoding="ibm850"?>
<MyClass xmlns:xsi=" ... " xmlns:xsd=" ... " x="Hello World!">
<MyList>
<Item>
<ID>1</ID>
</Item>
<Item>
<ID>2</ID>
</Item>
</MyList>
</MyClass>
BUT: My problem is, I need the property Xxx to be rendered as an attribute on the <MyList> element rather than the <MyClass> root element, like this:
...
<MyList x="Hello World!">
...
I'm GUESSING this should be possible using XmlSerialization attributes on the class/properties, but I can't figure it out. I even tried creating a subclass of List adding the property Xxx to that, but the .NET XML serialization ignores the extra properties, and the XML output is just like the List<..> is normally serialized.
Update: Here's the code where I try to create a "custom list", that inherits from List<Item> and adds an extra property:
public class Program
{
static void Main(string[] args)
{
var myClass = new MyClass();
myClass.MyList.Add(new Item() { ID = 1 });
myClass.MyList.Add(new Item() { ID = 2 });
myClass.MyList.Xxx = "Hello World!";
var sx = new XmlSerializer(myClass.GetType());
sx.Serialize(Console.Out, myClass);
}
public class MyClass
{
public MyClass()
{
MyList = new CustomList();
}
public CustomList MyList { get; set; }
}
public class Item
{
public int ID { get; set; }
}
public class CustomList : List<Item>
{
[XmlAttributeAttribute(AttributeName = "x")]
public string Xxx { get; set; }
}
}
The output xml looks like this:
<?xml version="1.0" encoding="ibm850"?>
<MyClass xmlns:xsi=" ... " xmlns:xsd=" ... ">
<MyList>
<Item>
<ID>1</ID>
</Item>
<Item>
<ID>2</ID>
</Item>
</MyList>
</MyClass>
Notice how the Xxx property is not represented in the xml...

I think for that level of control you will need to look at using the IXmlSerializable interface. I don't think using attributes will work here.

According to this MSDN discussion:
XmlSerializer does not serialize any members if a collection. Only
collection items get serialized. This is by design, basically a
decision was made to handle collections as arrays not as classes with
multiple properties, so collections should look like arrays on the
wire, therefore they do not have any members other then collection
items, and can be “flattened” by adding the [XmlElement] to the member
of the ICollection type.
So apparently the flaw you describe is by design. Unless you decide to run the resulting XML through some transforms, I'm not sure how you plan to get this to work using the XML serialization attributes.

This post provides some additional information, including a few options:
When a class is inherited from List<>, XmlSerializer doesn't serialize other attributes
Summary:
IXmlSerializable (as mentioned by Kai)
DataContractSerializer
Create a new class where X (your attribute) is a property and provide an additional property that is a list (so instead of subclassing list, just create a wrapper class). For example:
public class MyListWrapper<T>
{
public MyListWrapper()
{
Data = new List<T>();
}
[XmlAttribute(AttributeName="x")]
public string Xxx { get; set; }
[XmlElement]
public List<T> Data { get; set; }
}
Note that this will output Items as "Data" elements. If you're willing to drop the generic type parameter on Data and make it List(Item) then you can get items.
Hope that helps!