In my recent post entitled The
MSDN Camp vs. The Raymond Chen Camp I wrote
Our team [and myself directly] has gone through a process of rethinking a number of
decisions we made in this light. Up until very recently we were planning to ship the System.Xml.XPath.XPathDocument
class as a replacement for the System.Xml.XmlDocument
class
...
The problem was that the XPathDocument had a radically different programming model
than the XmlDocument meaning that anyone who`d written code using the XmlDocument
against our v1.0/v1.1 bits would have to radically rewrite their code to get performance
improvements and new features. Additionally any developers migrating to the .NET Framework
from native code (MSXML) or from the Java world would already be familiar with the
XML DOM API but not the cursor-based model used by the XPathDocument. This was really
an untenable situation. For this reason we`ve reverted the XPathDocument to what it
was in v1.1 while new functionality and perf improvements will be made to the
XmlDocument. Similarly we will keep the new and improved XPathEditableNavigator XPathNavigator
class which will be the API for programming against XML data sources
where one wants to abstract away what the underlying store actually is. We`ve
shown the power of this model with examples such as the ObjectXPathNavigator and
the DataSetNavigator.
I`ve seen some concerned statements about this posts from XML developers who use System.Xml
such as Oleg Tkachenko, Fumiaki
Yoshimatsu and Tomas
Restrepo so it seems I should clarify some of the decisions we made and why
we made them.
In version 1.0 of the .NET Framework we provided two primary classes for interacting
with XML; the XmlDocument and XmlReader.
The XmlReader provided an abstract interface for interacting with a stream of XML.
One can create an XmlReader over textual XML using the XmlTextReader or
over virtual XML data sources such as is done with the XmlCsvReader.
On the other hand with the XmlDocument we decided to eschew the
approach favored by the Java world which used interfaces. Instead we
created a single concrete implementation. This turned out to be a bad idea. It tied
the the interface for programming against XML in a random access manner with a concrete
implementation of an XML store. This made it difficult for developers who wanted to
expose their data sources as XML stores and led to inefficient solutions such as the XmlDataDocument.
To rectify this we needed to separate the programming model for accessing XML
data sources from our concrete implementation of the XmlDocument. We chose
to do this by extending the cursor based programming model we introduced in v1 with
the XPathNavigator instead
of moving to an interface based approach with XmlDocument. The reason for choosing
to go with a cursor based model over a tree based model is summed up in this quote
from my article Can One
Size Fit All
In A Survey of APIs and
Techniques for Processing XML, I pointed out that cursor-model APIs could be used
to traverse in-memory XML documents just as well as tree-model APIs. Cursor-model
APIs have an added advantage over tree-model APIs in that an XML cursor need not require
the heavyweight interface of a traditional tree-model API where every significant
token in the underlying XML must map to an object.
So in Whidbey, the XPathNavigator will be the programming model for working with XML
data sources when one wants to abstract away from the underlying source. The XPathNavigator
will be changed from the v1.0 model in the following ways (i) it will be editable
and (ii) it will expose the post schema validation infoset. I`ve already worked
with Krzysztof Cwalina on updating the Design
Guidelines for Exposing XML data in WinFX to account for this change in affairs.
As for the XPathDocument, it is what it always has been. A class optimized for
use in XPath and XSLT. If you need 10% - 25% better perf [depending on your
scenario] when running XPath over an XML document or running XSLT over in-memory XML
then this class should be preferred to the XmlDocument.