Develop Reference

C# XmlSerializer conditionally serialialize List<T> items

i need to serialize and deserialize XML with C# XmlSerializer (or is there something better?).
[XmlElement]
public virtual List<Map> Maps { get; set; }
public class Map
{
[XmlAttribute("item")]
public string Item { get; set; }
[XmlAttribute("uri")]
public string Uri { get; set; }
}
Maps = new List<Map>{
new Map { Item="", Uri="" },
new Map { Item="something", Uri="foo" },
new Map { Item="", Uri="foo" },
}
The serializer should throw out every item with string.IsNullOrEmpty(map.Item) so that the resulting Xml only holds the map with "something".
How can I achieve this without a big hassle?:
<Maps>
<Map item="something" uri="foo" />
</Maps>

As far as I've understood, you want to filter your XML before you serialize it.
I suggest you use LINQ for this:
var filteredMaps = Maps.Where(map => !string.IsNullOrWhiteSpace(map.Item)).ToList();
Notice the .ToList() call at the end of the line. This is important, as your XmlSerializer is of type List<Map> I suppose. Put this line before you serialize your object and the result should look like this:
<?xml version="1.0" encoding="utf-8"?>
<ArrayOfMap xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Map item="something" uri="foo" />
</ArrayOfMap>
Don't forget the using System.Linq;

Well you can try creating an XmlWriter that filters out all elements with an xsi:nil attribute or containing an empty string, and passes all other calls to the underlying standard XmlWriter to "clean up" serialized XML.

How to deserialize XML file with nested elements of same name, with one of elements are root?

I am trying to use the XmlSerializer class in C# to deserialize some XML that I am pulling from someone. Unfortunately, they have their root element named "Employee", and then the inner elements inside that root element are also named "Employee":
<Employee xmlns="http://www.testxmlns.com/employee">
<Employee>
<OtherElement>OE</OtherElement>
...
</Employee>
<Employee>
<OtherElement>OE</OtherElement>
...
</Employee>
</Employee>
I was able to find another question that is very similar, but not exactly. Here is what my current object looks like:
[XmlType("Employee")]
[XmlRootAttribute(Namespace = "http://www.testxmlns.com/employee", IsNullable = true)]
public class Employee
{
[XmlElement("Employee")]
public Employee[] InnerEmployee;
[XmlElement("OtherElement")]
public String OtherElement;
...
}
When I run the following, everything seems to work (no exceptions thrown), but everything in the returned object is null, including the inner list of Employee objects, which should not be null based on the XML I am inputting:
Employee retObj;
XmlSerializer serializer = new XmlSerializer(typeof(Employee));
using (TextReader sr = new StringReader(xmlString))
{
retObj = (Employee)serializer.Deserialize(sr);
}
return retObj;
Any help would be appreciated!

You can see in this fiddle that if I take your code and run it... it works!
What I would suggest, however, is to have two classes: one for the 'root' and one for each child element. This would make it less confusing to work with:
[XmlRoot("Employee", Namespace = "http://www.testxmlns.com/employee")]
public class EmployeeRoot
{
[XmlElement("Employee")]
public Employee[] Employees { get; set; }
}
public class Employee
{
public string OtherElement { get; set; }
}
You can see in this fiddle that this also works.

how should I prevent the XML-serialized model from automatically generating tags? [duplicate]

Can I somehow disable rendering of root element of collection?
This class with serialization attributes:
[XmlRoot(ElementName="SHOPITEM", Namespace="")]
public class ShopItem
{
[XmlElement("PRODUCTNAME")]
public string ProductName { get; set; }
[XmlArrayItem("VARIANT")]
public List<ShopItem> Variants { get; set; }
}
generates this XML:
<SHOPITEM xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<PRODUCTNAME>test</PRODUCTNAME>
<Variants>
<VARIANT>
<PRODUCTNAME>hi 1</PRODUCTNAME>
</VARIANT>
<VARIANT>
<PRODUCTNAME>hi 2</PRODUCTNAME>
</VARIANT>
</Variants>
</SHOPITEM>
I don't want <Variants> element here. What must I do?
Also I don't need xsi and xsd namespaces in root element...

To disable rendering of root element of collection, you must replace the attribute [XmlArrayItem] with [XmlElement] in your code.
For removing the xsi and xsd namespaces, create an XmlSerializerNamespaces instance with an empty namespace and pass it when you need to serialize your object.
Take a look on this example:
[XmlRoot("SHOPITEM")]
public class ShopItem
{
[XmlElement("PRODUCTNAME")]
public string ProductName { get; set; }
[XmlElement("VARIANT")] // was [XmlArrayItem]
public List<ShopItem> Variants { get; set; }
}
// ...
ShopItem item = new ShopItem()
{
ProductName = "test",
Variants = new List<ShopItem>()
{
new ShopItem{ ProductName = "hi 1" },
new ShopItem{ ProductName = "hi 2" }
}
};
// This will remove the xsi/xsd namespaces from serialization
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", "");
XmlSerializer ser = new XmlSerializer(typeof(ShopItem));
ser.Serialize(Console.Out, item, ns); // Inform the XmlSerializerNamespaces here
I got this output:
<?xml version="1.0" encoding="ibm850"?>
<SHOPITEM>
<PRODUCTNAME>test</PRODUCTNAME>
<VARIANT>
<PRODUCTNAME>hi 1</PRODUCTNAME>
</VARIANT>
<VARIANT>
<PRODUCTNAME>hi 2</PRODUCTNAME>
</VARIANT>
</SHOPITEM>

Replace [XmlArrayItem("VARIANT")] with [XmlElement("VARIANT")].

I don't believe it is possible to remove this element using the default xml serialization (with attributes). If you could do this, then serializing your ShopItem class would result in badly formed xml (no root element) for the object, which is not allowed.
What you can do however, is manually implement IXmlSerializable. This will give you the sort of fine-grained control you a re after.
[Edit] - sorry - misread that you were trying to remove Variants, not SHOPITEM. To remove the List "outer" element, just mark it up with an [XmlElement] attribute rather than an [XmlArrayItem] attribute. This will cause the list entries to just use the specified element name, without wrapping the list in an outer element.
For removing the namespaces, this is controlled by the seriliazer itself, not the markup on the class.
I've just noticed that while I've updated this answer, Rubens Farias has provided an reply that shows you how to eliminate the namespace.

C# XML Object Serialization: setting xmlns root attribute

I am serializing an object to xml and would like to set an xmlns attribute to the root node.
eg:
...
<root xmlns="[specified url]">
...
</root>
I cant seem to have an xmlns property/attribute on the member or seem to add the namespace when serializing without a prefix?
Any ideas?

This can do it as following. For top level use XmlRoot and for Properties use XmlElement
[System.Xml.Serialization.XmlRoot(Namespace="http://topLevelNS")]
class MyClass
{
[System.Xml.Serialization.XmlElement(Namespace = "http://SomeOtherNS")]
public int MyVar { get; set; }
}

How can I Serialize Properly

If I have a class MovieClass as
[XmlRoot("MovieClass")]
public class Movie
{
[XmlElement("Novie")]
public string Title;
[XmlElement("Rating")]
public int rating;
}
How can I've an attribute "x:uid" in my "Movie" element, so that the output when XmlSerializer XmlSerializer s = new XmlSerializer(typeof(MovieClass)) was used
is like this:
<?xml version="1.0" encoding="utf-16"?>
<MovieClass>
<Movie x:uid="123">Armagedon</Movie>
</MovieClass>
and not like this
<?xml version="1.0" encoding="utf-16"?>
<MovieClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Movie x:uid="123" Title="Armagedon"/>
</MovieClass>
Note: I want the xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" removed, if possible.

I answered this in your original post, but I think this one is worded better so I will post it here as well, if it gets closed as duplicate you can modify your original post to mirror this question.
I don't think this is possible without having Title be a custom type or explicitly implementing serialization methods.
You could do a custom class like so..
class MovieTitle
{
[XmlText]
public string Title { get; set; }
[XmlAttribute(Namespace="http://www.myxmlnamespace.com")]
public string uid { get; set; }
public override ToString() { return Title; }
}
[XmlRoot("MovieClass")]
public class Movie
{
[XmlElement("Movie")]
public MovieTitle Title;
}
which will produce:
<MovieClass xmlns:x="http://www.myxmlnamespace.com">
<Movie x:uid="movie_001">Armagedon</Movie>
</MovieClass>
Although the serializer will compensate for unknown namespaces with a result you probably won't expect.
You can avoid the wierd behavior by declaring your namespaces and providing the object to the serializer..
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("x", "http://www.myxmlnamespace.com");

It's not valid XML if you don't have x declared as a namespace prefix. Quintin's response tells you how to get valid XML.