Develop Reference

C# XML - Collapse XML properties into a list/array

I'm trying to serialize an XML file returned from a SOAP API service. The issue is that they have defined an array of objects as such:
<soap_xml>
...
<item __array="true">
<some_property>text here<some_property/>
</item>
<item>
<some_property>text here<some_property/>
</item>
...
</soap_xml>
Is there anyway to use the XmlSerializer to condense this down into an array when deserializing this XML file, or will I have to process the entire XML file manually. I'm not keen on having to process the XML manually, since it has over 100 different properties/fields, but if there is no other solution, then I'll have to use a XMLReader and write a custom serializer.
Also, asking the API provider to change the format of the returned XML is out of the question.

You'll need to define a class that follows the schema of the XML file - do you have a schema from the API provider? If so, you could use xsd.exe to generate a class file that can load it.
Alternatively, you'll need to annotate your own class with the appropriate XML attributes that follows the format.

Extract a list of certain elements from XML

I'm trying to create a C# application that extracts data from pages like this one. It's basically an XML file that stores information about a music album. Here's the relevant code:
<resp stat="ok" version="2.0">
<release id="368116" status="Accepted">
<title>The Bends</title>
<tracklist>
<track>
<position>1</position>
<title>Planet Telex</title>
<duration>4:18</duration>
</track>
</tracklist>
</release>
I'd like to extract all the track titles from the album (in the above code "Planet Telex") and output them in a list like this:
Planet Telex
The Bends
...
what would be the best/most elegant way to do this? From what I've read, the XmlTextReader is a good class to use. I've also seen many mentions of Linq to XML... Thanks in advance!
BTW, I've posted this question again (albeit formulated differently). I'm not sure why it was removed last time.

If you can, go with LINQ to XML:
XDocument doc = XDocument.Load(xml);
var titles = doc.Descendants("title").Select(x => x.Value);
A more sophisticated version that distinguishes between the album and the track title is the following:
var titles = doc.Descendants("release")
.Select(x => new
{
AlbumTitle = x.Element("title").Value,
Tracks = x.Element("tracklist")
.Descendants("title")
.Select(y => y.Value)
});
It returns a list of anonymous types, each with a property AlbumTitle of type string and an IEnumerable<string> representing the track titles.

Use xsd.exe to generate a class structure from your XML file, then deserialize your XML into that class structure. It should be pretty straightforward.

Check out this simpleXml library
https://bitbucket.org/kberridge/simplexml
It's on NuGet by the way!
Install-package simpleXml

Although LINQ is certainly a valid approach, I figured I would mention at least one quick alternative: XPath. Here is an example:
XPathDocument doc = new XPathDocument("http://api.discogs.com/release/368116?f=xml");
XPathNavigator nav = doc.CreateNavigator();
XPathNodeIterator iter = (XPathNodeIterator)nav.Evaluate("//tracklist/track/title");
while (iter.MoveNext())
{
Console.WriteLine(iter.Current.Value);
}
Output is as follows:
Planet Telex
The Bends
High And Dry
Fake Plastic Trees
Bones
(Nice Dream)
Just
My Iron Lung
Bullet Proof..I Wish I Was
Black Star
Sulk
Street Spirit (Fade Out)
Note that I added ?f=xml on your sample URL, since the default output from the API is JSON.

Parse XDocument without having to keep specifying the default namespace

I have some XML data (similar to the sample below) and I want to read the values in code.
Why am I forced to specify the default namespace to access each element? I would have expected the default namespace to be used for all elements.
Is there a more logical way to achieve my goal?
Sample XML:
<?xml version="1.0" encoding="UTF-8"?>
<ReceiptsBatch xmlns="http://www.secretsonline.gov.uk/secrets">
<MessageHeader>
<MessageID>00000173</MessageID>
<Timestamp>2009-10-28T16:50:01</Timestamp>
<MessageCheck>BX4f+RmNCVCsT5g</MessageCheck>
</MessageHeader>
<Receipts>
<Receipt>
<Status>OK</Status>
</Receipt>
</Receipts>
</ReceiptsBatch>
Code to read xml elements I'm after:
XDocument xDoc = XDocument.Load( FileInPath );
XNamespace ns = "http://www.secretsonline.gov.uk/secrets";
XElement MessageCheck = xDoc.Element(ns+ "MessageHeader").Element(ns+"MessageCheck");
XElement MessageBody = xDoc.Element("Receipts");

As suggested by this answer, you can do this by removing all namespaces from the in-memory copy of the document. I suppose this should only be done if you know you won't have name collisions in the resulting document.
/// <summary>
/// Makes parsing easier by removing the need to specify namespaces for every element.
/// </summary>
private static void RemoveNamespaces(XDocument document)
{
var elements = document.Descendants();
elements.Attributes().Where(a => a.IsNamespaceDeclaration).Remove();
foreach (var element in elements)
{
element.Name = element.Name.LocalName;
var strippedAttributes =
from originalAttribute in element.Attributes().ToArray()
select (object)new XAttribute(originalAttribute.Name.LocalName, originalAttribute.Value);
//Note that this also strips the attributes' line number information
element.ReplaceAttributes(strippedAttributes.ToArray());
}
}

You can use XmlTextReader.Namespaces property to disable namespaces while reading XML file.
string filePath;
XmlTextReader xReader = new XmlTextReader(filePath);
xReader.Namespaces = false;
XDocument xDoc = XDocument.Load(xReader);

This is how the Linq-To-Xml works. You can't find any element, if it is not in default namespace, and the same is true about its descendants. The fastest way to get rid from namespace is to remove link to the namespace from your initial XML.

The theory is that the meaning of the document is not affected by the user's choice of namespace prefixes. So long as the data is in the namespace http://www.secretsonline.gov.uk/secrets, it doesn't matter whether the author chooses to use the prefix "s", "secrets", "_x.cafe.babe", or the "null" prefix (that is, making it the default namespace). Your application shouldn't care: it's only the URI that matters. That's why your application has to specify the URI.

Note that the element Receipts is also in namespace http://www.secretsonline.gov.uk/secrets, so the XNamespace would also be required for the access to the element:
XElement MessageBody = xDoc.Element(ns + "Receipts");
As an alternative to using namespaces note that you can use "namespace agnostic" xpath using local-name() and namespace-uri(), e.g.
/*[local-name()='SomeElement' and namespace-uri()='somexmlns']
If you omit the namespace-uri predicate:
/*[local-name()='SomeElement']
Would match ns1:SomeElement and ns2:SomeElement etc. IMO I would always prefer XNamespace where possible, and the use-cases for namespace-agnostic xpath are quite limited, e.g. for parsing of specific elements in documents with unknown schemas (e.g. within a service bus), or best-effort parsing of documents where the namespace can change (e.g. future proofing, where the xmlns changes to match a new version of the document schema)

What is the best way to send xml data to a web service rather than using CDATA?

I have a web service that takes a single string parameter.
In my case I need to send a string which is an xml document where one of its elements contains an xml fragment (which I will use to create a file).
So for example I am sending:
<people>
<person>
<name>J Smith</name>
<value><![CDATA[<content>rest of xml document here</content>]]></value>
</person>
</people>
I used .. to create an xml file.
I was wondering if there is a better way to do this rather than using CDATA?. The CDATA files are very small (less than 20KB).
JD

There is no need to use CDATA. You can pass the xml fragment directly as is.
See, for example, http://msdn.microsoft.com/en-us/library/aa480498.aspx
UPDATE:
Steve pointed out that you have a string parameter not XmlElement parameter. I'm not sure if it would still work that way (though I feel like it could :).
Another option besides CDATA and Base64 would be Xml encoding, e.g.
var xml = new XmlDocument();
var node = xml.CreateElement("root");
node.InnerText = "<content>Anything</content>";
var xmlString = node.InnerXml; /// <content>Anything</content>

I'd suggest Base64-Encoding the XML fragment.

How about a standard HTTP POST using Mutipart/Form-Data ? Make the single parameter part of the url or querystring.
This is the more "RESTful" way of doing things.
It's just a standard file upload.

Converting string to xml nodes

i have the string, it contains xml nodes, returned from the PHP file.
It's like
<a>1</a><b>0</b><c>4</c>..............
Now i need to find out what value each node have i.e a, b, c......
while loading this string to xmlDocument i'm getting error like "There are multiple root elements".
any solution for this

One of the basic rules for well-formed XML that it has a single root node. With your example, you have multiple roots:
<a>1</a>
<b>0</b>
<c>4</c>
To make it well-formed you will have to make these elements a child of a single root:
<root>
<a>1</a>
<b>0</b>
<c>4</c>
</root>
An XML document that is not well-formed is not really an XML document at all and you will find that no XML parser will be able to read it!

Wrap it in a root element. E.g:
From <a>1</a><b>2</b>...
To <root><a>1</a><b>2</b>...</root>
Then compute as normal.

That is because each element is at the same level. There need to be a "root" that encloses all of them. Wrap them in a arbitrary node, say <root>...</root> then load the new string to the xmlDocument.

This seems like XML, but it's not valid XML. In XML, you have a root element that wraps all of the other elements.
So, if you have that string in str, do this:
str = String.Format("<root>{0}</root>", str);