Code Reference A collection of code for my reference (and perhaps other people too)

Adding Multiple Namespaces to an XDocument/XElement

Lets say you want 3 namespaces added to your document.
You would define each one with the XNamespace property:

XNamespace defaultNS = "urn://xml.voodoo.net/vd/vd-1.0";
XNamespace a = "urn://xml.voodoo.net/vd/activity-1.0";
XNamespace f = "urn://xml.voodoo.net/vd/formating-1.0";

One of the namespaces will be your default.
When you create your rood element, you first add the default and then the other after.
The other 2 are added as you see below:

XElement rootElement = new XElement(defaultNS + "root",
   new XAttribute(XNamespace.Xmlns + "f", f.NamespaceName),
   new XAttribute(XNamespace.Xmlns + "a", a.NamespaceName));

To access the other namespaces, you

XElement somethingElement = new XElement(a + "something");
somethingElement.Value = "stuff and more stuff";
rootElement.Add(somethingElement);

The result will look like this:

<root xmlns:f="urn://xml.voodoo.net/vd/formating-1.0" xmlns:a="urn://xml.voodoo.net/vd/activity-1.0" xmlns="urn://xml.voodoo.net/vd/vd-1.0">
      <a:something>stuff and more stuff</a:something>
</root>

Add a namespace and attributes to an XElement

Adding a namespace to an XElement is very very simple. However, there is one thing that will throw you off.

The root element has the namespace in most cases.
Microsoft thinks that the first child element may want a different namespace.
When you add the namespace to the first element, the children receives an empty xmlns attribute. If you want to prevent this, you have to add the namespace to the children also. This will prevent the empty xmlns attribute from showing.

Why is the empty xmlns added? Ask MS.

// Create a namespace element
XNamespace xmlns = "urn://some.strange.place.net/something/good-1.0";

// Add the namespace element to the root element name.
// The namespace is sort of an attribute, but is not added like one.
XElement rootElement = new XElement(xmlns + "root");

// You must also add the namespace to the first child element.
// If you don't you will get an empty namespace attribute in the element.
// Adding the same namespace to the children prevents the empty namespace from showing.
XElement customersElement = new XElement(xmlns + "customers");
rootElement.Add(customersElement);

XElement customerElement = new XElement(xmlns + "customer");
customersElement.Add(customerElement);

// Attributes are added just like child nodes. Very simple.
XAttribute typeAttribute = new XAttribute("customerType", "Corporate");
customersElement.Add(typeAttribute);

XElement nameElement = new XElement("Name", "John Smith");
customerElement.Add(nameElement);

This will create an xml document that looks like this:

<root xmlns='urn://some.strange.place.net/something/good-1.0'>
     <customers>
          <customer customerType='Corporate'>
               <Name>John Smith</Name>
          </customer>
     </customers>
</root>

Traversing an XML document (with a namespace) (part 2)

This xml document contains a namespace. This complicates traversing the document a little bit, but not much if you know how.

First the xml document:

<?xml version="1.0" encoding="UTF-8" ?>
<bla xmlns='urn://xml.somexml.net/xrda/xrda-1.0'>
   <response>
      <session secconds='10000' user='user@hotmail.com' username='My Name'>
         <message>This is my message!</message>
      </session>
   </response>
</bla>

We must declare the namespace and then use it when specifying the elements.

private XPathNavigator xpn;
private XmlNamespaceManager ns;

private XElement AcceptMessage(XmlElement xml)
{
if (xml == null)
   return new XElement("response");

// Declair the namespace
xpn = xml.CreateNavigator();
ns = new XmlNamespaceManager(xpn.NameTable);
ns.AddNamespace("x", xpn.NamespaceURI); // the x is our nickname for the namespace

// First lets get the content of the message.
string message = GetElement("x:message"); // add the x: in front of the element name

// Now let's get the attributes of the session element
string username = GetAttributeValue("x:session", "username"); // add the x:
string user = GetAttributeValue("x:session", "user"); // add the x:
string secconds = GetAttributeValue("x:session", "secconds"); // add the x: 

}

public string GetElement(string element)
{
    // The XPath syntax must be correct - add to slashes in front of the text 'message'.
    // If the XPath syntax is not correct you may get an exception or null.
    try
    {
        // Add the namespace to the select
        XPathNavigator navResult = xpn.SelectSingleNode("//" + element, ns);

        if (navResult != null)
            return navResult.InnerXml;

        return string.Empty;
    }
    catch (Exception ex)
    {
        return string.Empty;
    }
}

public string GetAttributeValue(string element, string attributeName)
{
    try
    {
        // Add the namespace to the select
        XPathNavigator navResult = xpn.SelectSingleNode("//" + element, ns);
        if (navResult != null)
        {
            // Once you have the 'navResult' you no longer need to specify the namespace.
            // This is becuase the navResult contains no namespace information.
            // add and empty string for the namepace URI
            string value = navResult.GetAttribute(attributeName, string.Empty);
            return value;
        }
        else
            return string.Empty;
    }
    catch (Exception ex)
    {
        return string.Empty;
    }
}

Traversing an xml document (part 1)

This explains how to process a simple xml document.

First the xml document:

<?xml version="1.0" encoding="UTF-8" ?>
<bla>
   <response>
      <session secconds='10000' user='user@hotmail.com' username='My Name'>
         <message>This is my message!</message>
      </session>
   </response>
</bla>

We will start from an XmlDocument (or an XmlElement - about the same thing)

The object is to get the content of the message element and the attributes in the session element.

private XElement AcceptMessage(XmlElement xml)
{
if (xml == null)
   return new XElement("response");

// First lets get the content of the message.
string message = GetElement("message");

// Now let's get the attributes of the session element
string username = GetAttributeValue("session", "username");
string user = GetAttributeValue("session", "user");
string secconds = GetAttributeValue("session", "secconds");

}

SelectSingleNode selectes the first node of the element specified.
The result is most often an XPathNavigator. Each selection will return a part of the xml from the node/element you searched for.
Selecting the 'message' node will return only that node. If message had child nodes, they would also be returned.

public string GetElement(string element)
{
    // The XPath syntax must be correct - add to slashes in front of the text 'message'.
    // If the XPath syntax is not correct you may get an exception or null.
    try
    {
        XPathNavigator navResult = xpn.SelectSingleNode("//" + element);

        if (navResult != null)
            return navResult.InnerXml;

        return string.Empty;
    }
    catch (Exception ex)
    {
        return string.Empty;
    }
}

GetAttribute returns the value of the attribute you specify in the curren node/element.
In this case, we selected the 'session' element. The session element has one child (the message element). The navResult contains only the session element and its children.
GetAttribute returns the string value of our attribute.
There is no namespace uri to specify, so we leave it empty.

public string GetAttributeValue(string element, string attributeName)
{
    try
    {
        XPathNavigator navResult = xpn.SelectSingleNode("//" + element);
        if (navResult != null)
        {
            string value = navResult.GetAttribute(attributeName, string.Empty);
            return value;
        }
        else
            return string.Empty;
    }
    catch (Exception ex)
    {
        return string.Empty;
    }
}

NEXT: adding a namespace to the XML complicates it. See how!

Deserialize XML to an Object

One of the more useful tools to have in your toolbox is a method or class to convert an Object to XML and XML to an Object.

Converting XML to an object is very easy.

You need your destination object:

public class PersonObject
{
    public string lastName;
    public string firstName;
    public string gender;
    public string email;
    public int age;
    public int telephone;
    public string city;
    public string state;

    public PersonObject() {}
}

Most likely you will recieve your XML from a web service. Here is some simple code to call a webservice and get the XML response:

StringBuilder sb = new StringBuilder();
byte[] buf = new byte[8192];
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://www.someurl.com/getPerson?...");
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream resStream = response.GetResponseStream();

string tempString = null;
int count = 0;
do
{
    count = resStream.Read(buf, 0, buf.Length);
    if (count != 0)
    {
        tempString = Encoding.ASCII.GetString(buf, 0, count);
        sb.Append(tempString);
    }
}
while (count > 0); 

PersonObject person = (PersonObject)XmlToObject(sb.ToString(), typeof(PersonObject));

Here is the method to convert the XML to the PersonObject:

private object XmlToObject(string XmlToConvert, Type DestinationType)
{
    XmlSerializer serializer = new XmlSerializer(DestinationType);
    StringReader stringReader = new StringReader(XmlToConvert);
    XmlTextReader xmlReader = new XmlTextReader(stringReader);
    object returnObject = serializer.Deserialize(xmlReader);
    xmlReader.Close();
    stringReader.Close();
    return returnObject;
}

It is just a few lines of code. Very simple.
You will notice the PersonObject does not contain any XML attributes for basic use.