1. Computer Science Department
XML
Mark Sapossnek CS 594
Computer Science Department
Metropolitan College
Boston University

2. Learning Objectives Learn what XML is
Learn the various ways in which XML is used
Learn the key companion technologies
Learn how to use the .NET framework to read, write, and navigate XML documents

3. Agenda Overview Syntax and Structure The XML Alphabet Soup XML in .NET
Relational Data and XML

4. Overview What is XML? A tag-based meta language
Designed for structured data representation
Represents data hierarchically (in a tree)
Provides context to data (makes it meaningful)
Self-describing data
Separates presentation (HTML) from data (XML)
An open W3C standard
A subset of SGML
vs. HTML, which is an implementation of SGML

5. Overview What is XML? XML is a “use everywhere” data specification
Application X
XML
Documents
Configuration
XML
XML
Repository
Database

6. Overview Documents vs. Data
XML is used to represent two main types of things:
Documents
Lots of text with tags to identify and annotate portions of the document
Data
Hierarchical data structures

7. Overview XML and Structured Data
Pre-XML representation of data:
XML representation of the same data:
“PO-1234”,”CUST001”,”X9876”,”5”,”14.98”
<PURCHASE_ORDER>
<PO_NUM> PO-1234 </PO_NUM>
<CUST_ID> CUST001 </CUST_ID>
<ITEM_NUM> X9876 </ITEM_NUM>
<QUANTITY> 5 </QUANTITY>
<PRICE> </PRICE>
</PURCHASE_ORDER>

8. Overview Benefits of XML
Open W3C standard
Representation of data across heterogeneous environments
Cross platform
Allows for high degree of interoperability
Strict rules
Syntax
Structure
Case sensitive

9. Overview Who Uses XML? Submissions by Technologies using XML Microsoft
IBM
Hewlett-Packard
Fujitsu Laboratories
Sun Microsystems
Netscape (AOL), and others…
Technologies using XML
SOAP, ebXML, BizTalk, WebSphere, many others…

10. Agenda Overview Syntax and Structure The XML Alphabet Soup XML in .NET
Relational Data and XML

11. Syntax and Structure Components of an XML Document
Elements
Each element has a beginning and ending tag
<TAG_NAME>...</TAG_NAME>
Elements can be empty (<TAG_NAME />)
Attributes
Describes an element; e.g. data type, data range, etc.
Can only appear on beginning tag
Processing instructions
Encoding specification (Unicode by default)
Namespace declaration
Schema declaration

12. Syntax and Structure Components of an XML Document
<?xml version=“1.0” ?>
<?xml-stylesheet type="text/xsl" href=“template.xsl"?>
<ROOT>
<ELEMENT1><SUBELEMENT1 /><SUBELEMENT2 /></ELEMENT1>
<ELEMENT2> </ELEMENT2>
<ELEMENT3 type=‘string’> </ELEMENT3>
<ELEMENT4 type=‘integer’ value=‘9.3’> </ELEMENT4>
</ROOT>
Elements with Attributes
Elements
Prologue (processing instructions)

13. Syntax and Structure Rules For Well-Formed XML
There must be one, and only one, root element
Sub-elements must be properly nested
A tag must end within the tag in which it was started
Attributes are optional
Defined by an optional schema
Attribute values must be enclosed in “” or ‘’
Processing instructions are optional
XML is case-sensitive
<tag> and <TAG> are not the same type of element

14. Syntax and Structure Well-Formed XML?
No, CHILD2 and CHILD3 do not nest propertly
<xml? Version=“1.0” ?>
<PARENT>
<CHILD1>This is element 1</CHILD1>
<CHILD2><CHILD3>Number 3</CHILD2></CHILD3>
</PARENT>

15. Syntax and Structure Well-Formed XML?
No, there are two root elements
<xml? Version=“1.0” ?>
<PARENT>
<CHILD1>This is element 1</CHILD1>
</PARENT>
<CHILD1>This is another element 1</CHILD1>

16. Syntax and Structure Well-Formed XML?
Yes
<xml? Version=“1.0” ?>
<PARENT>
<CHILD1>This is element 1</CHILD1>
<CHILD2/>
<CHILD3></CHILD3>
</PARENT>

17. Syntax and Structure An XML Document
<?xml version='1.0'?>
<bookstore>
<book genre=‘autobiography’ publicationdate=‘1981’
ISBN=‘ ’>
<title>The Autobiography of Benjamin Franklin</title>
<author>
<first-name>Benjamin</first-name>
<last-name>Franklin</last-name>
</author>
<price>8.99</price>
</book>
<book genre=‘novel’ publicationdate=‘1967’ ISBN=‘ ’>
<title>The Confidence Man</title>
<first-name>Herman</first-name>
<last-name>Melville</last-name>
<price>11.99</price>
</bookstore>

18. Syntax and Structure Namespaces: Overview
Part of XML’s extensibility
Allow authors to differentiate between tags of the same name (using a prefix)
Frees author to focus on the data and decide how to best describe it
Allows multiple XML documents from multiple authors to be merged
Identified by a URI (Uniform Resource Identifier)
When a URL is used, it does NOT have to represent a live server
URLs and URNs for namespaces do not have to be “live” – they only need to be unique strings.

19. Syntax and Structure Namespaces: Declaration
Namespace declaration examples:
xmlns: bk = “
xmlns: bk = “urn:mybookstuff.org:bookinfo”
xmlns: bk = “
Namespace declaration
Prefix
URI (URL)

20. Syntax and Structure Namespaces: Examples
<BOOK xmlns:bk=“
<bk:TITLE>All About XML</bk:TITLE>
<bk:AUTHOR>Joe Developer</bk:AUTHOR>
<bk:PRICE currency=‘US Dollar’>19.99</bk:PRICE>
<bk:BOOK xmlns:bk=“ xmlns:money=“urn:finance:money”>
<bk:TITLE>All About XML</bk:TITLE>
<bk:AUTHOR>Joe Developer</bk:AUTHOR>
<bk:PRICE money:currency=‘US Dollar’>
19.99</bk:PRICE>

21. Syntax and Structure Namespaces: Default Namespace
An XML namespace declared without a prefix becomes the default namespace for all sub-elements
All elements without a prefix will belong to the default namespace:
<BOOK xmlns=“
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>

22. Syntax and Structure Namespaces: Scope
Unqualified elements belong to the inner-most default namespace.
BOOK, TITLE, and AUTHOR belong to the default book namespace
PUBLISHER and NAME belong to the default publisher namespace
<BOOK xmlns=“
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>
<PUBLISHER xmlns=“urn:publishers:publinfo”>
<NAME>Microsoft Press</NAME>
</PUBLISHER>
</BOOK>

23. Syntax and Structure Namespaces: Attributes
Unqualified attributes do NOT belong to any namespace
Even if there is a default namespace
This differs from elements, which belong to the default namespace

24. Syntax and Structure Entities
Entities provide a mechanism for textual substitution, e.g.
You can define your own entities
Parsed entities can contain text and markup
Unparsed entities can contain any data
JPEG photos, GIF files, movies, etc.
Entity
Substitution
<
&
&

25. Agenda Overview Syntax and Structure The XML Alphabet Soup XML in .NET
Relational Data and XML

26. The XML ‘Alphabet Soup’
XML itself is fairly simple
Most of the learning curve is knowing about all of the related technologies

27. The XML ‘Alphabet Soup’
Extensible Markup Language
Defines XML documents
Infoset
Information Set
Abstract model of XML data; definition of terms
DTD
Document Type Definition
Non-XML schema
XSD
XML Schema
XML-based schema language
XDR
XML Data Reduced
An earlier XML schema
CSS
Cascading Style Sheets
Allows you to specify styles
XSL
Extensible Stylesheet Language
Language for expressing stylesheets; consists of XSLT and XSL-FO
XSLT
XSL Transformations
Language for transforming XML documents
XSL-FO
XSL Formatting Objects
Language to describe precise layout of text on a page

28. The XML ‘Alphabet Soup’
XPath
XML Path Language
A language for addressing parts of an XML document, designed to be used by both XSLT and XPointer
XPointer
XML Pointer Language
Supports addressing into the internal structures of XML documents
XLink
XML Linking Language
Describes links between XML documents
XQuery
XML Query Language (draft)
Flexible mechanism for querying XML data as if it were a database
DOM
Document Object Model
API to read, create and edit XML documents; creates in-memory object model
SAX
Simple API for XML
API to parse XML documents; event-driven
Data Island
XML data embedded in a HTML page
Data Binding
Automatic population of HTML elements from XML data

29. The XML ‘Alphabet Soup’ Schemas: Overview
DTD (Document Type Definitions)
Not written in XML
No support for data types or namespaces
XSD (XML Schema Definition)
Written in XML
Supports data types
Current standard recommended by W3C
XDR (XML Data Reduced schema)
Interim schema proposed by Microsoft
Obsoleted by XSD

30. The XML ‘Alphabet Soup’ Schemas: Purpose
Define the “rules” (grammar) of the document
Data types
Value bounds
A XML document that conforms to a schema is said to be valid
More restrictive than well-formed XML
Define which elements are present and in what order
Define the structural relationships of elements

31. The XML ‘Alphabet Soup’ Schemas: DTD Example
XML document:
DTD schema:
<BOOK>
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>
</BOOK>
<!DOCTYPE BOOK [
<!ELEMENT BOOK (TITLE+, AUTHOR) >
<!ELEMENT TITLE (#PCDATA) >
<!ELEMENT AUTHOR (#PCDATA) >
]>

32. The XML ‘Alphabet Soup’ Schemas: XSD Example
XML document:
<CATALOG>
<BOOK>
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>
</BOOK> …
</CATALOG>

33. The XML ‘Alphabet Soup’ Schemas: XSD Example
<xsd:schema id="NewDataSet“ targetNamespace="
xmlns="
xmlns:xsd="
xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:element name="book">
<xsd:complexType content="elementOnly">
<xsd:all>
<xsd:element name="title" minOccurs="0" type="xsd:string"/>
<xsd:element name="author" minOccurs="0" type="xsd:string"/>
</xsd:all>
</xsd:complexType>
</xsd:element>
<xsd:element name=“Catalog" msdata:IsDataSet="True">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element ref="book"/>
</xsd:choice>
</xsd:schema>

34. The XML ‘Alphabet Soup’ Schemas: Why You Should Use XSD
Newest W3C Standard
Broad support for data types
Reusable “components”
Simple data types
Complex data types
Extensible
Inheritance support
Namespace support
Ability to map to relational database tables
XSD support in Visual Studio.NET

35. The XML ‘Alphabet Soup’ Transformations: XSL
Language for expressing document styles
Specifies the presentation of XML
More powerful than CSS
Consists of:
XSLT
XPath
XSL Formatting Objects (XSL-FO)

36. The XML ‘Alphabet Soup’ Transformations: Overview
XSLT – a language used to transform XML data into a different form (commonly XML or HTML)
XML
XML, HTML, …
XSLT

37. The XML ‘Alphabet Soup’ Transformations: XSLT
The language used for converting XML documents into other forms
Describes how the document is transformed
Expressed as an XML document (.xsl)
Template rules
Patterns match nodes in source document
Templates instantiated to form part of result document
Uses XPath for querying, sorting, etc.

38. The XML ‘Alphabet Soup’ Transformations: Example
<sales>
<summary>
<heading>Scootney Publishing</heading>
<subhead>Regional Sales Report</subhead>
<description>Sales Report</description>
</summary>
<data>
<region>
<name>West Coast</name>
<quarter number="1" books_sold="24000" />
<quarter number="2" books_sold="38600" />
<quarter number="3" books_sold="44030" />
<quarter number="4" books_sold="21000" />
</region>
...
</data>
</sales>

39. The XML ‘Alphabet Soup’ Transformations: Example
<xsl:param name="low_sales" select="21000"/>
<BODY>
<h1><xsl:value-of select="//summary/heading"/></h1>
...
<table><tr><th>Region\Quarter</th>
<xsl:for-each select="//data/region[1]/quarter">
<th>Q<xsl:value-of
</xsl:for-each>
<xsl:for-each select="//data/region">
<tr><xsl:value-of select="name"/></th>
<xsl:for-each select="quarter">
<td><xsl:choose>
<xsl:when <= $low_sales)">
color:red;</xsl:when>
<xsl:otherwise>color:green;</xsl:otherwise></xsl:choose>
<xsl:value-of
<td><xsl:value-of

40. The XML ‘Alphabet Soup’ Transformations: Example

41. The XML ‘Alphabet Soup’ XSL Formatting Objects (XSL-FO)
A set of formatting semantics
Denotes typographic elements (for example: page, paragraph, rule, etc.)
Allows finer control obtained via formatting elements
Word, letter spacing
Indentation
Widow, orphan, hyphenation control
Font style, etc.

42. The XML ‘Alphabet Soup’ XPath (XML Path Language)
General purpose query language for identifying nodes in an XML document
Declarative (vs. procedural)
Contextual – the results depend on current node
Supports standard comparison, Boolean and mathematical operators (=, <, and, or, *, +, etc.)

43. The XML ‘Alphabet Soup’ XPath Operators
Usage Description /
Child operator – selects only immediate children (when at the beginning of the pattern, context is root) //
Recursive descent – selects elements at any depth (when at the beginning of the pattern, context is root) .
Indicates current context *
Wildcard @
Prefix to attribute name (when alone, it is an attribute wildcard)
[ ]
Applies filter pattern

44. The XML ‘Alphabet Soup’ XPath Query Examples
./author (finds all author elements within current context)
/bookstore (find the bookstore element at the root)
/* (find the root element)
//author (find all author elements anywhere in document)
= “textbooks”]
(find all bookstores where the specialty
attribute = “textbooks”) =
(find all books where the style attribute = the
specialty attribute of the bookstore element
at the root)

45. The XML ‘Alphabet Soup’ XPointer
Builds upon XPath to:
Identify sub-node data
Identify a range of data
Identify data in local document or remote documents
New standard

46. The XML ‘Alphabet Soup’ XLink
XML Linking Language
Elements of XML documents
Describes links between resources
Simple links (for example, HTML HREFs)
Extended links
Remote resources
Local resources
Rules for how a link is followed, etc.

47. The XML ‘Alphabet Soup’ The XML DOM
XML Document Object Model (DOM)
Provides a programming interface for manipulating XML documents in memory
Includes a set of objects and interfaces that represent the content and structure of an XML document
Enables a program to traverse an XML tree
Allows elements, attributes, etc., to be added/deleted in an XML tree
Allows new XML documents to be created programmatically

48. The XML ‘Alphabet Soup’ SAX (Simple API for XML)
API to allow developers to read/write XML data
Event based
Uses a “push” model
Sequential access only (data not cached)
Requires less memory to process XML data than the DOM
SAX has less overhead (uses small input, work and output buffers) than the DOM
DOM constructs the data structure in memory (work and output buffers = to size of data)

49. The XML ‘Alphabet Soup’ Data Islands
XML embedded in an HTML document
Manipulated via client side script or data binding
<XML id=“XMLID”>
<BOOK>
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>
</BOOK>
</XML>
<XML id=“XMLID” src=“mydocument.xml”>
Data islands and data binding is available only in Microsoft Internet Explorer version 5.0 and later.

50. The XML ‘Alphabet Soup’ Data Islands
Can be embedded in an HTML SCRIPT element
XML is accessible via the DOM:
<SCRIPT language=“xml” id=“XMLID”>
<SCRIPT type=“text/xml” id=“XMLID”>
<SCRIPT language=“xml” id=“XMLID” src=“mydocument.xml”>

51. The XML ‘Alphabet Soup’ Data Islands
Access the XML via the HTML DOM:
Or access the XML directly via the ID:
function returnXMLData() {
return document.all("XMLID").XMLDocument.nodeValue; }
function returnXMLData() {
return XMLID.documentElement.text; }

52. The XML ‘Alphabet Soup’ Data Binding
Client-side data binding (in the browser)
The XML Data Source Object (DSO) binds HTML elements to an XML data set (or data island)
When the XML data set changes, the bound elements are updated dynamically
DATASRC: the source of the data (e.g., the ID of the data island)
DATAFLD: the field (XML element) to display
Can offload XSLT processing to the client
IE only

53. The XML ‘Alphabet Soup’ Data Binding
<HTML><BODY>
<XML ID="xmlParts">
<?xml version="1.0" ?>
<parts>
<part>
<partnumber>A1000</partnumber>
<description>Flat washer</description>
<quantity>1000</quantity>
</part>
...
</XML>
<table datasrc=#xmlParts border=1><tr>
<td><div datafld="partnumber"></div></td>
<td><div datafld="quantity"></div></td>
</tr></table>
</BODY></HTML>

54. The XML ‘Alphabet Soup’ XLang (BizTalk)
An XML language for defining processes
Processes usually on multiple platforms
Support for:
Concurrency
Long-running transactions
Exposed messaging and orchestration APIs
Connect to COM components
Connect to MSMQ queues
Connect to SQL components

55. The XML ‘Alphabet Soup’ XML-Based Applications
Microsoft BizTalk Server
Enables uniform exchange of data among disparate systems (XLang)
Backend interchange with partners/customers
Microsoft Commerce Server
XML-based Product Catalog System
Integrated with BizTalk Server for backend communication

56. The XML ‘Alphabet Soup’ XML-Based Applications
Microsoft SQL Server
Retrieve relational data as XML
Query XML data
Join XML data with existing database tables
Update the database via XML Updategrams
Microsoft Exchange Server
XML is native representation of many types of data
Used to enhance performance of UI scenarios (for example, Outlook Web Access (OWA))

57. Agenda Overview Syntax and Structure The XML Alphabet Soup XML in .NET
Relational Data and XML

58. XML in .NET Overview XML use is ubiquitous throughout .NET
Web Services
Based on XML standards: SOAP, WSDL, UDDI, …
ASP.NET
Application information stored in XML-based configuration files
ADO.NET
Provides conversion between DataSets and XML
DataSets are serialized as XML

59. XML in .NET Overview XML classes built on industry standards
e.g., DOM Level 2 Core, XML Schemas, SOAP
Introduces a stream-based (“pull”) interface
vs. the traditional SAX “push” model
Natural evolution of MSXML 3.0 (4.0)
MSXML 3.0 still available in .NET via COM Interop
.NET XML classes are well-factored for functionality, performance and extensibility

60. XML in .NET Core Classes in System.XML
Abstract (Base) Class
Concrete (Derived) Class
XmlNode
XmlDocument
XmlLinkedNode
XmlElement
XmlAttribute
XmlDataDocument
XmlReader
XmlTextReader
XmlNodeReader
XmlWriter
XmlTextWriter

61. XML in .NET XmlNode
Represents a single node in a XML document hierarchy
An abstract class
Properties and methods to
traverse XML document hierarchy
query properties
modify nodes
delete notes

62. XML in .NET XmlDocument
Implements W3C XML Document Object Model (DOM) Level 1 and Level 2 specifications
Implements XmlNode
Represents an entire XML document
All nodes are available to view/manipulate
Cached in memory
XmlDocument is analogous to a DataSet
Events for changing, inserting and removing nodes

63. XML in .NET XmlDocument Declaration: Constructor: Code example:
public class XmlDocument : XmlNode
public XmlDocument();
XmlDocument myXmlDoc = new XmlDocument();
myXmlDoc.Load(“c:\Sample.xml”);

64. XML in .NET XmlLinkedNode
Implements XmlNode
Retrieves the node immediately preceding or following the current node
An abstract class from which XmlElement is derived
Declaration:
public abstract class XmlLinkedNode : XmlNode

65. XML in .NET XmlElement Represents an element in the DOM tree
Properties and methods to view, modify, and create element objects
Declaration:
Code example:
public class XmlElement : XmlLinkedNode
XmlDocument myXmlDoc = new XmlDocument();
myXmlDoc.Load (“c:\Sample.xml”);
// DocumentElement retrieves the root element
XmlElement root = myXmlDoc.DocumentElement;

66. XML in .NET XmlAttribute
Implements XmlNode
Represents an attribute of an XmlElement
Valid and/or default values defined by schema
Declaration:
public class XmlAttribute : XmlNode

67. XML in .NET XmlAttribute
Code example:
XmlDocument myXmlDoc = new XmlDocument();
myXmlDoc.Load (“c:\Sample.xml”);
// Get the attribute collection of the root element
XmlAttributeCollection attrColl = myXmlDoc.DocumentElement.Attributes;
// Create a new attribute and set it’s value
XmlAttribute newAttr = myXmlDoc.CreateAttribute(“value”);
newAttr.Value = “new value”;
// Append the new attribute to the collection
attrColl.Append(newAttr);

68. XML in .NET Demo XmlDocument

69. XML in .NET XmlNode:IXPathNavigable
XmlNode has simple methods for traversing a XML document hierarchy
XmlNode is an interface for accessing XML data using a cursor model
Provides a generic navigation mechanism
Support for XPath expressions through IXPathNavigable interface
Can select and navigate a subset of a document
Properties and methods to view, modify, copy, delete nodes

70. XML in .NET XPathNavigator
Allows navigation over a XmlDocument
XmlDocument is derived from XmlNode, which implements IXPathNavigable
Caveats
“Current” node remains current when moved
Can be in a null state when not pointing to a node
Does not “walk” off end of tree
Failed methods leave XPathNavigator where it was
public class XmlDocument : XMLNode {
XMLNode IXPathNavigable.CreateNavigator() { } }

71. XML in .NET XPathNavigator
Declaration:
Constructor:
Code example:
public class XPathNavigator : IXPathNavigable
public XPathNavigator (XmlDocument document);
XmlDocument myXmlDoc;
myXmlDoc.Load (“c:\Sample.xml”);
XPathNavigator nav = myXmlDoc.CreateNavigator();
nav.MoveToRoot(); // move to root element
nav.MoveToNext(); // move to next element

72. XML in .NET XPathNavigator
Example: iterate over a subset of nodes
XmlDocument doc = new XmlDocument();
doc.Load("person.xml");
XPathNavigator nav = doc.CreateNavigator();
XPathNodeIterator iter = nav.Select("/person/name");
while (iter.MoveToNext ()) {
// process selection here… with iter.Current.Value }
Example: sum all Prices in a document
public static void SumPriceNodes(XPathNavigator nav) {
// in this case, evaluate returns a number
Console.WriteLine("sum=" + nav.Evaluate("sum(//Price)")); }

73. XML in .NET Demo XPathNavigator

74. XML in .NET XmlReader
XmlReader is an abstract class that provides fast, non-cached, forward-only, read-only access to XML data
Uses a “pull” model
Simpler than the SAX “push” model
User can easily implement “push” model if desired
But the reverse is not true
Reads in depth-first order
Same order as textual XML data
Analogous to an ADO.NET DataReader

75. XML in .NET XmlTextReader
Forward-only, read-only, non-cached access to stream-based XML data
Implements XmlReader
Access to data by parsing text input from:
Streams
TextReader objects
Strings
Properties and methods to view elements and attributes
Event support for validation

76. XML in .NET XmlTextReader
Declaration:
Constructor (overloaded):
Code example:
public class XmlTextReader : XmlReader
public XmlTextReader(TextReader textreader);
public XmlTextReader(string url);
public XmlTextReader(Stream stream);
XmlTextReader reader = new XmlTextReader(“c:\Sample.xml”);
While (reader.Read()) {
... }

77. XML in .NET XmlNodeReader
Forward-only, non-cached access to XML data
Implements XmlReader
Access to data via XPathNavigator
Reads data from an entire XmlDocument or a specific XmlNode
Properties and methods to view elements and attributes

78. XML in .NET XmlWriter
Abstract class providing fast, non-cached, forward-only, write-only creation of XML data
Makes it easy to create well-formed XML data in a type-safe manner

79. XML in .NET XmlTextWriter
Forward-only, non-cached method of writing XML data to a stream
Implements XmlWriter
Can write to:
Streams
Files
TextWriter objects
Properties and methods to write syntactically valid XML

80. XML in .NET XmlTextWriter
Declaration:
Constructor (overloaded):
Code example:
public class XmlTextWriter : XmlWriter
public XmlTextWriter(TextWriter textwriter);
public XmlTextReader(string file, Encoding encoding);
public XmlTextWriter(Stream stream, Encoding encoding);
Encoding can be null – will default to UTF-8
XmlTextWriter writer = new XmlTextWriter (“c:\Sample.xml”, null);
writer.WriteStartDocument(); // Write the declaration
writer.WriteStartElement(“ROOT”); // Write the root element
writer.WriteEndElement(); // Write the close tag of root
writer.Flush(); // Writer XML to file
writer.Close(); // Close writer

81. XML in .NET Demo XmlTextReader & XmlTextWriter

82. XML in .NET Other XML Namespaces
System.Xml – Core XML namespace
System.Xml.XPath – contains the XPathNavigator, XPath parser and evaluation engine
System.Xml.Xsl – support XSLT transformations
System.Xml.Serialization – Classes to serialize objects into XML documents or streams
System.Xml.Schema – Supports XSD schemas

83. Agenda Overview Syntax and Structure The XML Alphabet Soup XML in .NET
Relational Data and XML

84. Relational Data and XML Relational Support in System.Xml
XmlDataDocument
XPathDocument
XPathNavigator
Build a relation on a DataSet
Built-in XML support in SQL Server 2000

85. Relational Data and XML XmlDataDocument
Extends XmlDocument to include support for relational data (files, RDBMS, etc.)
Provides a DataSet property, which is kept synchronized with the XML data
Schema support
Schema can be loaded/saved as XSD
Schema can be inferred from XML data
Loading the XmlDataDocument and the DataSet synchronize them together
The DataSet can be populated from either an XmlReader or a managed data provider
Adding a row to the XmlDataDocument updates the DataSet
Adding a row to the DataSet, however, will update the XmlDataDocument only if the node is mapped to a DataSet table
The XmlDataDocument is a view into relational data – allowing full support of the DOM for viewing/updating

86. Relational Data and XML XmlDataDocument
XSL/T, X-Path, Validation, etc.
Controls, Designers, Code-gen, etc.
XmlData- Document
DataSet
Sync
XmlReader
XmlText-
Reader
XmlNode-
DataAdapter
SqlData-
Adapter
OleDbData-
DataReader
SqlData-
Reader
OleDbData-

87. Relational Data and XML XmlDataDocument
XmlDataDocument dataDoc = new XmlDataDocument();
// Read the XML into a DataSet
dataDoc.DataSet.ReadXml(new StreamReader(“c:\example.xml”);
foreach(DataTable table in dataDoc.DataSet.Tables) {
foreach(DataColumn column in table.Columns) { }
foreach(DataRow row in table.Rows) {
foreach(Object value in row.ItemArray) { } }

88. Relational Data and XML DataDocumentNavigator
Implements XmlNavigator over an XmlDataDocument
Contains the features of DocumentNavigator
Cursor model access
XPath support, etc.
Includes support for relational data (XmlDataDocument)

89. Relational Data and XML Building a DataSet Relation
Create DataSet
Define tables:
DataSet dataset = new DataSet();
dataset.Name = "BookAuthors";
DataTable authors = new DataTable("Author");
DataTable books = new DataTable("Book");

90. Relational Data and XML Building a DataSet Relation
Define columns
Define keys:
DataColumn id = authors.Columns.Add("ID", typeof(Int32));
id.AutoIncrement = true;
authors.PrimaryKey = new DataColumn[] {id};
DataColumn name = new authors.Columns.Add("Name", typeof(String));
DataColumn isbn = books.Columns.Add("ISBN", typeof(String));
books.PrimaryKey = new DataColumn[] {isbn};
DataColumn title = books.Columns.Add("Title", typeof(String));
DataColumn authid = books.Columns.Add(“AuthID”, typeof(Int32));
DataColumn[] foreignkey = new DataColumn[] {authid};

91. Relational Data and XML Building a DataSet Relation
Add the tables to the DataSet:
dataset.Tables.Add (authors);
dataset.Tables.Add (books);

92. Relational Data and XML Building a DataSet Relation
Add data and save the DataSet:
DataRow shkspr = authors.NewRow();
shkspr["Name"] = "William Shakespeare";
authors.Rows.Add(shkspr);
DataRelation bookauth = new DataRelation("BookAuthors",
authors.PrimaryKey, foreignkey);
dataset.Relations.Add (bookauth);
DataRow row = books.NewRow();
row["AuthID"] = shkspr["ID"];
row["ISBN"] = "1000-XYZ";
row["Title"] = "MacBeth";
books.Rows.Add(row);
dataset.AcceptChanges();

93. Relational Data and XML XML Support in SQL Server 2000
Ability to query SQL Server over HTTP
Retrieve XML using SELECT … FOR XML
Retrieve XML using XPath queries
Write XML data using OPENXML rowset provider

94. Conclusion Overview Syntax and Structure The XML Alphabet Soup
XML in .NET
Relational Data and XML

95. Resources Microsoft Press Books (http://mspress.microsoft.com/)
Microsoft Press Books (
XML Step By Step
XML In Action
Developing XML Solutions
O’Reilly Press
XML In A Nutshell

96. Resources
XML in .NET
Working with XML in the .NET Platform