public static string GetContent(string id, string locale, string version)
{
    // If the data is in the cache, retrieve it from there.
    if (IsInCache(id)) return GetCacheFileName(id);

    // Otherwise, go to the Web service to get it. 
    getContentRequest request = new getContentRequest();
    request.contentIdentifier = id;
    request.locale = locale;
    request.version = version;

    // Make sure to request that the Web service send back the body of 
    // the Mtps.Xhtml primary document. Without this you just get 
    // summary information. 
    requestedDocument[] requestedDocuments = new requestedDocument[1];
    requestedDocuments[0] = new requestedDocument();
    requestedDocuments[0].type = documentTypes.primary;
    requestedDocuments[0].selector = "Mtps.Xhtml";

    request.requestedDocuments = requestedDocuments;
    ContentService proxy = new ContentService();
    getContentResponse response = null;
    try
    {
        response = proxy.GetContent(request);
    }
    catch (SoapException e)
    {
        // If the call contains any MTPS-specific error messages, format
        // them for display and rethrow a new exception. 
        throw MapSoapException(e);
    }

    // Look through the returned documents and pull out the body of the 
    // Mtps.Xhtml document. 
    XmlElement xhtml = GetXhtml(response);

    if (xhtml == null) throw new MtpsClientException(
        "No XHTML was returned from the web service.");

    // Cache the XHTML document.
    string cachefile = WriteXhtmlToCache(id, xhtml);
    return cachefile;
}

private static XmlElement GetXhtml(getContentResponse response)
{
    return GetPrimaryDocument(response, "Mtps.Xhtml");
}
private static XmlElement GetPrimaryDocument(
    getContentResponse response, string format)
{
    foreach (primary document in response.primaryDocuments)
    {
        if (string.Compare(document.primaryFormat, format, true) == 0)
        {
            return document.Any;
        }
    }
    return null;
}

<mtps:links xmlns:mtps="urn:msdn-com:public-content-syndication">
  <mtps:link>
    <mtps:assetId>assetid:t%3asystem.xml.xmlurlresolver</mtps:assetId>
    <k:contentId xmlns:k=
        "urn:mtpg-com:mtps/2004/1/key">008et5fc</k:contentId>
    <k:contentGuid xmlns:k="urn:mtpg-com:mtps/2004/1/key">
        725ceabb-b81d-4b7e-8e5c-4b3179bdae5d</k:contentGuid>
    <k:contentAlias xmlns:k=
        "urn:mtpg-com:mtps/2004/1/key">
            system.xml.xmlurlresolver</k:contentAlias>
  </mtps:link>
  <mtps:link>
    <mtps:assetId>
        assetid:e695047f-3c0f-4045-8708-5baea91cc380</mtps:assetId>
    <k:contentId xmlns:k=
        "urn:mtpg-com:mtps/2004/1/key">2bcctyt8</k:contentId>
    <k:contentGuid xmlns:k=
        "urn:mtpg-com:mtps/2004/1/key">
            e695047f-3c0f-4045-8708-5baea91cc380</k:contentGuid>
    <k:contentAlias xmlns:k="urn:mtpg-com:mtps/2004/1/key" />
  </mtps:link>
</mtps:links>

<toc:Node toc:Title="XmlReader Class" 
    toc:SubTree="AssetId:VS%7ccpref19%7c%24%5ccpref.hxt%400%2c0%2c47" 
    toc:SubTreeVersion="VS.80" toc:SubTreeLocale="en-US" 
    toc:Description="" toc:Target="AssetId:T%3aSystem.Xml.XmlReader" 
    toc:TargetLocale="en-US" toc:TargetVersion="VS.80" 
    toc:IsPhantom="false" xmlns:toc="urn:mtpg-com:mtps/2004/1/toc">  
    <toc:Node toc:Title="XmlReader Members" 
        toc:Target="AssetId:AllMembers.T%3aSystem.Xml.XmlReader" 
        toc:TargetLocale="en-US" toc:TargetVersion="VS.80" 
        toc:IsPhantom="false" />
    <toc:Node toc:Title="XmlReader Constructor"   
        toc:Target="AssetId:M%3aSystem.Xml.XmlReader.%23ctor" 
        toc:TargetLocale="en-US" toc:TargetVersion="VS.80" 
        toc:IsPhantom="false" />
    <toc:Node toc:Title="XmlReader Methods"  
        toc:SubTree="AssetId:VS%7ccpref19%7c%24%5ccpref.hxt
                     %400%2c0%2c47%2c2" 
        toc:SubTreeVersion="VS.80" toc:SubTreeLocale="en-US" 
        toc:Target="AssetId:Methods.T%3aSystem.Xml.XmlReader" 
        toc:TargetLocale="en-US" toc:TargetVersion="VS.80" 
        toc:IsPhantom="false" />
    <toc:Node toc:Title="XmlReader Properties" 
        toc:SubTree="AssetId:VS%7ccpref19%7c%24%5ccpref.hxt
                     %400%2c0%2c47%2c3" 
        toc:SubTreeVersion="VS.80" toc:SubTreeLocale="en-US" 
        toc:Target="AssetId:Properties.T%3aSystem.Xml.XmlReader" 
        toc:TargetLocale="en-US" toc:TargetVersion="VS.80" 
        toc:IsPhantom="false" />
</toc:Node>

private void PopulateNode(
    string id, string locale, string version, TreeNode parent)
{
    // Let the TreeView control know that I’m going to be making a bunch
    // of changes. Calling this now prevents flickering.
    parent.TreeView.BeginUpdate();
    try
    {
        // Clear out the children of this TreeNode and re-add them based
        // on the information in the Mtps.Toc document.
        parent.Nodes.Clear();

        // If there’s no ID (which there may not be in cases where we’re 
        // populating a leaf node) then we’ve done all we can. 
        if (string.IsNullOrEmpty(id)) return;

        // Retrieve the Mtps.Toc document from the Web service.
        XmlElement tocElement = ServiceHelper.GetToc(id, locale, version);

        // If no TOC element is returned, that means this node is a leaf 
        // node so there’s no more work to do.
        if (tocElement != null)
        {
            // Deserialize it into a Toc object.
            XmlSerializer ser = new XmlSerializer(typeof(Toc));
            XmlNodeReader reader = new XmlNodeReader(tocElement);
            Toc toc = (Toc) ser.Deserialize(reader);

            foreach (Toc child in toc.Children)
            {
                TreeNode treeNode = new TreeNode();
                treeNode.Text = child.Title ?? "[no title]";

                // I store the Toc object right in the TreeNode so I can 
                // later look up things like the content key for this 
                // node. 
                treeNode.Tag = child;

                // I can tell from looking at the Toc data whether a node 
                // has children or not—the SubTree property will be 
                // missing for nodes that don’t. So I can add a dummy 
                // node for any nodes that have children, which will cause 
                // the little plus sign to appear in the tree. 
                if (!string.IsNullOrEmpty(child.SubTree))
                {
                    TreeNode placeholder = new TreeNode("Loading...");
                    treeNode.Nodes.Add(placeholder);
                    treeNode.Collapse();
                }

                // Red nodes indicate data that’s in our local cache. 
                if (ServiceHelper.IsInCache(child.Target))
                {
                    treeNode.ForeColor = Color.Red;
                }

                parent.Nodes.Add(treeNode);
            }
        }
    }
    finally
    {
        // Let the TreeView know I’m done making updates, and that it 
        // can redraw itself now. 
        parent.TreeView.EndUpdate();
    }
}

private void SyncToc(string id, string locale, string version)
{
    // Retrieve the navigation path between the root of the TOC and the 
    // specified node.
    navigationPathNode[] path = ServiceHelper.GetNavigationPath(
        id, locale, version);

    // Now walk down the tree, matching each path node if possible. I 
    // match by title because the IDs in the TOC are asset IDs, but the 
    // IDs we get back from GetNavigationPaths are short IDs. 
    TreeNode currentNode = navigationTree.Nodes[0];
    for (int i = 1; i < path.Length; i++)
    {
        foreach (TreeNode node in currentNode.Nodes)
        {
            Toc nodeInfo = node.Tag as Toc;
            if (nodeInfo != null && nodeInfo.Title == path[i].title)
            {
                node.Expand();
                currentNode = node;
                break;
            }
        }
    }

    navigationTree.SelectedNode = currentNode;
}

public static navigationPathNode[] GetNavigationPath(
    string id, string locale, string version)
{
    // I start off with the root of the documentation tree, which has a 
    // well-known content key. 
    navigationKey root = new navigationKey();
    root.contentId = "ms310241";
    root.locale = "en-us";
    root.version = "msdn.10";

    // Since I don’t know whether the specified ID is an asset ID, a 
    // short ID, or so on, I have to resolve it to a short ID first—
    // GetNavigationPaths only accepts short IDs. Also, I may not know 
    // the version, so I grab that in the same round-trip. 
    navigationKey target = GetNavigationKeyFromId(id);
    if (!string.IsNullOrEmpty(version))
    {
        target.version = version;
    }

    getNavigationPathsRequest request = new getNavigationPathsRequest();
    request.root = root;
    request.target = target;

    ContentService proxy = new ContentService();

    getNavigationPathsResponse response = null;
    try
    {
        response = proxy.GetNavigationPaths(request);
    }
    catch (SoapException e)
    {
        // If the call contains any MTPS-specific error messages, format
        // them for display and rethrow a new exception. 
        throw MapSoapException(e);
    }

    if (response == null || response.navigationPaths.Length == 0)
    {
        throw new MtpsClientException("No navigation information " +
            "was returned from the web service.");
    }

    return response.navigationPaths[0].navigationPathNodes;
}

private static Exception MapSoapException(SoapException e)
{
    string eventId = null;
    string helpLink = null;
    string source = null;
    XmlNode detailNode = e.Detail;

    // If the detail node contains the mtpsFaultDetail element, then I 
    // try to extract the eventID, helpLink, and source elements from the 
    // fault message. 
    if (detailNode.NamespaceURI == 
            "urn:msdn-com:public-content-syndication" &&
        detailNode.LocalName == "mtpsFaultDetail")
    {
        XmlNamespaceManager nsMgr = 
            new XmlNamespaceManager(detailNode.OwnerDocument.NameTable);
        nsMgr.AddNamespace(
            "mtps", "urn:msdn-com:public-content-syndication");
        if (detailNode.LocalName == "mtpsFaultDetail")
        {
            XmlNode helpLinkNode = 
                detailNode.SelectSingleNode("mtps:helpLink");
            if (helpLinkNode != null)
            {
                helpLink = helpLinkNode.Value;
            }
            XmlNode eventIdNode = 
                detailNode.SelectSingleNode("mtps:eventId");
            if (eventIdNode != null)
            {
                eventId = eventIdNode.Value;
            }
            XmlNode sourceNode = 
                detailNode.SelectSingleNode("mtps:source");
            if (sourceNode != null)
            {
                source = sourceNode.Value;
            }
        }
    }

    string message = "ERROR: The MSDN web service reported the " +
        "following error: " + e.Message;

    // After extracting eventId, source, and helpLink information
    // from the fault, I append them to the message. 

    if (eventId != null && eventId.Length > 0)
    {
        message += "\nThe event ID was " + eventId;
    }
    else
    {
        message += "\nNo event ID was reported.";
    }

    if (source != null && source.Length > 0)
    {
        message += "\nThe source was " + source;
    }

    if (helpLink != null && helpLink.Length > 0)
    {
        message += "\nFor more infomation, see " + helpLink;
    }

    return new MtpsClientException(message, e);
}