David Kline : XML

Quick Tip: Using XPath to find nodes by attribute value

DavidKlineMS — Tue, 13 Mar 2007 21:11:00 GMT

There are some things that I can just remember: phone numbers, locker combinations, and the like. There are others that I have to lookup again and again and again. XPath query syntax is one of the latter items. Today, I'd like to talk a little about XPath queries.

The following XML contains a collection of "Friend" nodes. Each node has attributes for name and birth date. To keep this post to a reasonable length, I am going to limit the XML to 5 nodes.

<MyFriends> <Friend name="Sam" birthMonth="July" birthDay="16" birthYear="1974" /> <Friend name="Pam" birthMonth="April" birthDay="7" birthYear="1967" /> <Friend name="George" birthMonth="February" birthDay="2" birthYear="1981" /> <Friend name="John" birthMonth="April" birthDay="11" birthYear="1972" /> <Friend name="Martha" birthMonth="August" birthDay="3" birthYear="1974" /> </MyFriends>

After loading this XML into an XmlDocument, I can use XPath to query for the nodes of interest.

Since April is coming soon, I would like to get a list of my friends who has a birthday that month. To do so, I query for Friend nodes where the value of the birthMonth attribute is "April".

// load the xml file into an XmlDocument XmlDocument doc = new XmlDocument(); doc.Load("myfriends.xml"); XmlElement rootNode = doc.DocumentElement; // select the friends who have a birthday in April String query = "Friend[@birthMonth='April']"; XmlNodeList friends = rootNode.SelectNodes(query); foreach(XmlElement friend in friends) { // TODO: display a reminder to buy a birthday card }

When the above snippet is run, two friends are returned: Pam and John. The application can retrieve the desired information from the node and display an appropriate reminder.

Enjoy!
-- DK

Edit: Fix grammar

Disclaimer(s):
This posting is provided "AS IS" with no warranties, and confers no rights.

Quick Tip: Specifying a field's name when using the XmlSerializer

DavidKlineMS — Wed, 08 Nov 2006 23:33:00 GMT

Last month, I wrote about how to instruct the XmlSerializer to create an XML attribute for fields in an object. Today, I'd like to talk about how to specify the name used to represent a field in the resulting XML.

By default, when an object is serialized, fields are serialized into nodes with names that match the name of the field. When an instance of the example TestData object(below) is serialized

public class TestData
{
    public Int32 TestID;
    public String Description;
}

the TestID and Description fields become

<TestID>0</TestID>
<Description>Sample test description.</Description>

At times, it may be desirable to change the default naming behavior. To change the name, we decorate the TestID field with an XmlElement attribute.

[XmlElement(ElementName="ID")]
public Int32 TestID;

After serialization, the XML contains

<ID>0</ID>

This same technique also works with the XmlAttribute attribute.

[XmlAttribute(AttributeName="ID")]
public Int32 TestID;

Creates an attribute called ID (highlighted in purple) in the TestData node.

<TestData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ID="0">

Enjoy!,
-- DK

Disclaimers:
This posting is provided "AS IS" with no warranties, and confers no rights.

Quick Tip: Serializing an Object Field as an XML Attribute

DavidKlineMS — Tue, 03 Oct 2006 00:55:00 GMT

The addition of the XML Serializer is one of the reasons I really love version 2 of the .NET Compact Framework. I use the XML Serializer in very nearly every application I write; to save application state, data files, etc. By default, the XML Serializer will create a child node for every field in a type. For example, the following object

public class TestData
{
    public Int32 TestID;
    public String Description;
}

becomes

<TestData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Description>Sample test description.</Description>
  <TestID>0</TestID>
</TestData>

There are times that you may wish to serialize one or more fields as attributes on the object's node (ex: reduce the size of the XML). By decorating the TestID field with an XmlAttribute attribute, the TestID field

[XmlAttribute()]
public Int32 TestID;

now becomes an attribute (highlighted in purple) on the TestData node.

<TestData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" TestID="0">
  <Description>Sample test description.</Description>
</TestData>

Enjoy!
-- DK

Disclaimers:
This posting is provided "AS IS" with no warranties, and confers no rights.

Simple object remoting using the XmlSerializer

DavidKlineMS — Thu, 28 Oct 2004 04:02:00 GMT

Today, I'm going to talk about how you can use the XmlSerializer, TcpClient and TcpListener classes to create a simple remoting layer to send your custom objects from one device to another. This post requires the .NET Compact Framework version 2 (beta 1) or the .NET Framework for desktop PCs.

Since NetCF doesn't support the TCP Remoting classes, you will need to setup the network connection yourself. The serializer handles all of the data transfer. You can use this technique to send data between any combination of systems which support the XmlSerializer and network connectivity.

As you can see from the code below, there isn't too much to making a simple connection, though a real application will need to be more robust and will typically need to handle bi-directional data flow.

Let's take a look at simple client and server code that remotes a custom object between devices.

Object
The only requirements on the object is that it is serializable. This means that it contains a nullary constructor and all of the public fields are either read/write or are a collection (supporting the Add method). The example we will be using is a very simple object containing a name, a team name and a player's jersey number.
public class Player { public String Name; pulbic String Team; public Int32 Number; }

Client
The client application instantiates the Player object and populates it's data fields.
Player p = new Player(); p.Name = "David"; p.Team = "NetCF"; p.Number = 43;

Next, it creates an XmlSerializer object, informing the serializer of the type of data which will be sent.
XmlSerializer xs = new XmlSerializer(typeof(Player));

Once we have our serializer, we create a TcpClient object, get connected to the remote server and acquire the stream to be used to communicate with the server.
TcpClient client = new TcpClient(); client.Connect(serverAddress, serverPort); Stream stream = client.GetStream();
Now, we can serialize our Player object. Since the stream we provide the serializer is a network stream, the data is sent to the server when the serializer writes the XML.
xs.Serialize(stream, p);

The rest of our client is housekeeping. We need to be sure to close our stream and client objects.
stream.Close(); client.Close();

Server
Now let's take a look at the server code.
Player p;

As with the client, we need to create an XmlSerializer object, informing the serializer of the type of data which will be received.
XmlSerializer xs = new XmlSerializer(typeof(Player));

Next, a listener needs to be created and started.
TcpListener listener = new TcpListener(port); listener.Start();

The listener accepts the incoming connection.
TcpClient client = listener.AcceptTcpClient();

And we can get the data stream from the client which was created by the call to AcceptTcpClient.
Stream stream = client.GetStream();
Now we can deserialize the Player object sent by the remote client. Like the client, the stream used for deserialization is a network stream. This causes the data to be received when the serializer reads the XML.
p = (Player)xs.Deserialize(stream);

Again, we need to perform some housekeeping. We need to be sure to close our stream, client and listener objects.
stream.Close(); client.Close(); listener.Close();

And we can display the received object.
MessageBox.Show(String.Format("Name: {0}\r\nTeam: {1}\r\nNumber: {2}", p.Name, p.Team, p.Number));

As mentioned earlier, the above is a very simple example of how to remote a data object using the XmlSerializer. The networking code for real world applications will likely be significantly more involved and handle being sent and received by both devices.

Enjoy!
-- DK

[Edited to fix formatting]
[Edited to fix typo]

Disclaimers:
This posting is provided "AS IS" with no warranties, and confers no rights.
Some of the information contained within this post may be in relation to beta software. Any and all details are subject to change.