XML

XML
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
Agenda
 Overview
 Syntax and Structure
 The XML Alphabet Soup
 XML in .NET
 Relational Data and XML
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
Overview
What is XML?
 XML is a “use everywhere” data specification
XML XML
Application X
XML XML Configuration

Documents
Repository Database
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
Overview
XML and Structured Data
 Pre-XML representation of data:

“PO-1234”,”CUST001”,”X9876”,”5”,”14.98”
 XML representation of the same data:

<PURCHASE_ORDER>
<PO_NUM> PO-1234 </PO_NUM>
<CUST_ID> CUST001 </CUST_ID>
<ITEM_NUM> X9876 </ITEM_NUM>
<QUANTITY> 5 </QUANTITY>
<PRICE> 14.98 </PRICE>
</PURCHASE_ORDER>
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
Overview
Who Uses XML?
 Submissions by
 Microsoft
 IBM
 Hewlett-Packard
 Fujitsu Laboratories
 Sun Microsystems
 Netscape (AOL), and others…
 Technologies using XML
 SOAP, ebXML, BizTalk, WebSphere, many others…
Agenda
 Overview
 XML in .NET
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
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)
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
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>
Well-Formed XML?
 No, there are two root elements

<PARENT>
</PARENT>
<PARENT>
<CHILD1>This is another element 1</CHILD1>
</PARENT>
Well-Formed XML?
 Yes

<PARENT>
<CHILD2/>
<CHILD3></CHILD3>
</PARENT>
An XML Document
<?xml version='1.0'?>
<bookstore>
<book genre=‘autobiography’ publicationdate=‘1981’
ISBN=‘1-861003-11-0’>
<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=‘0-201-63361-2’>
<title>The Confidence Man</title>
<author>
<first-name>Herman</first-name>
<last-name>Melville</last-name>
</author>
<price>11.99</price>
</book>
</bookstore>
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
Namespaces: Declaration
Namespace declaration examples:

xmlns: bk = “http://www.example.com/bookinfo/”
xmlns: bk = “urn:mybookstuff.org:bookinfo”
xmlns: bk = “http://www.example.com/bookinfo/”
Namespace declaration Prefix URI (URL)

Namespaces: Examples
<BOOK xmlns:bk=“http://www.bookstuff.org/bookinfo”>
<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=“http://www.bookstuff.org/bookinfo”
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>
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=“http://www.bookstuff.org/bookinfo”>
<TITLE>All About XML</TITLE>
<AUTHOR>Joe Developer</AUTHOR>
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=“www.bookstuff.org/bookinfo”>
<PUBLISHER xmlns=“urn:publishers:publinfo”>
<NAME>Microsoft Press</NAME>
</PUBLISHER>
</BOOK>
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
Entities
 Entities provide a mechanism for textual substitution,
e.g.
Entity Substitution
< <
& &
 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.
Agenda
 Overview
 XML in .NET
The XML ‘Alphabet Soup’
 XML itself is fairly simple
 Most of the learning curve is knowing about
all of the related technologies
XML Extensible Markup Defines XML documents
Language
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 for expressing stylesheets;
Language 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
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 Flexible mechanism for querying XML
(draft) 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
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
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
Schemas: DTD Example
 XML document:
<BOOK>
</BOOK>
 DTD schema:
<!DOCTYPE BOOK [
<!ELEMENT BOOK (TITLE+, AUTHOR) >
<!ELEMENT TITLE (#PCDATA) >
<!ELEMENT AUTHOR (#PCDATA) >
]>
Schemas: XSD Example
 XML document:
<CATALOG>
<BOOK>
</BOOK>
…
</CATALOG>
Schemas: XSD Example
<xsd:schema id="NewDataSet“ targetNamespace="http://tempuri.org/schema1.xsd"
xmlns="http://tempuri.org/schema1.xsd"
xmlns:xsd="http://www.w3.org/1999/XMLSchema"
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:complexType>
</xsd:element>
</xsd:schema>
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
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)
Transformations: Overview
 XSLT – a language used to transform XML data

into a different form (commonly XML or HTML)
XML
XML,
HTML,
…
XSLT
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.
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" />
</region>
...
</data>
</sales>
<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 select="@number"/></th>
</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 test="number(@books_sold <= $low_sales)">
color:red;</xsl:when>
<xsl:otherwise>color:green;</xsl:otherwise></xsl:choose>
<xsl:value-of select="format-number(@books_sold,'###,###')"/></td>
...
<td><xsl:value-of
select="format-number(sum(quarter/@books_sold),'###,###')"/>
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.
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.)
XPath Operators
Operator 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
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)
/bookstore[@specialty = “textbooks”]
(find all bookstores where the specialty
attribute = “textbooks”)
/book[@style = /bookstore/@specialty]
(find all books where the style attribute = the
specialty attribute of the bookstore element
at the root)
XPointer
 Builds upon XPath to:

 Identify sub-node data
 Identify a range of data
 Identify data in local document or remote documents
 New standard
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.
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
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)
Data Islands
 XML embedded in an HTML document

 Manipulated via client side script or data binding
<XML id=“XMLID”>
<BOOK>
</BOOK>
</XML>
<XML id=“XMLID” src=“mydocument.xml”>

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”>
Data Islands
 Access the XML via the HTML DOM:

function returnXMLData() {
return document.all("XMLID").XMLDocument.nodeValue;
}
 Or access the XML directly via the ID:

function returnXMLData() {
return XMLID.documentElement.text;
}
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
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>
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
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
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))
Agenda
 Overview
 XML in .NET
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
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
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
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
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
XML in .NET
XmlDocument
 Declaration:
public class XmlDocument : XmlNode
 Constructor:
public XmlDocument();
 Code example:
XmlDocument myXmlDoc = new XmlDocument();
myXmlDoc.Load(“c:\Sample.xml”);
XML in .NET
XmlLinkedNode
 Retrieves the node immediately preceding or
following the current node
 An abstract class from which XmlElement is
derived
 Declaration:
public abstract class XmlLinkedNode : XmlNode
XML in .NET
XmlElement
 Represents an element in the DOM tree

 Properties and methods to view, modify, and
create element objects
 Declaration:
public class XmlElement : XmlLinkedNode
 Code example:
myXmlDoc.Load (“c:\Sample.xml”);
// DocumentElement retrieves the root element

XmlElement root = myXmlDoc.DocumentElement;
XML in .NET
XmlAttribute
 Represents an attribute of an XmlElement
 Valid and/or default values defined by schema
 Declaration:
public class XmlAttribute : XmlNode
XML in .NET
XmlAttribute
 Code example:
// 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);
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
XML in .NET
XPathNavigator
 Allows navigation over a XmlDocument
 XmlDocument is derived from XmlNode, which
implements IXPathNavigable
public class XmlDocument : XMLNode
{
XMLNode IXPathNavigable.CreateNavigator() { }
}
 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
XML in .NET
XPathNavigator
 Declaration:
public class XPathNavigator : IXPathNavigable
 Constructor:
public XPathNavigator (XmlDocument document);
 Code example:
XmlDocument myXmlDoc;
XPathNavigator nav = myXmlDoc.CreateNavigator();
nav.MoveToRoot(); // move to root element

nav.MoveToNext(); // move to next element
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)"));
}
XML in .NET
Demo XPathNavigator
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
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
XML in .NET
XmlTextReader
 Declaration:
public class XmlTextReader : XmlReader
 Constructor (overloaded):
public XmlTextReader(TextReader textreader);
public XmlTextReader(string url);
public XmlTextReader(Stream stream);
 Code example:
XmlTextReader reader = new XmlTextReader(“c:\Sample.xml”);
While (reader.Read()) {
...
}
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
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
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
XML in .NET
XmlTextWriter
 Declaration:
public class XmlTextWriter : XmlWriter
 Constructor (overloaded):
public XmlTextWriter(TextWriter textwriter);
public XmlTextReader(string file, Encoding encoding);
public XmlTextWriter(Stream stream, Encoding encoding);
 Code example:
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
XML in .NET
Demo XmlTextReader & XmlTextWriter
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
Agenda
 Overview
 XML in .NET
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
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
XmlDataDocument
Controls,
XSL/T, X-Path, Designers,
Validation, etc. Code-gen, etc.
XmlData- DataSet
Document Sync
XmlReader DataAdapter DataReader
XmlText- XmlNode- SqlData- OleDbData- SqlData- OleDbData-

Reader Reader Adapter Adapter Reader Reader
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) { }
}
}
DataDocumentNavigator
 Implements XmlNavigator over an

XmlDataDocument
 Contains the features of DocumentNavigator
 Cursor model access
 XPath support, etc.
 Includes support for relational data
(XmlDataDocument)
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");
 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};
 Add the tables to the DataSet:

dataset.Tables.Add (authors);
dataset.Tables.Add (books);
 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();
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
Conclusion
 Overview
 XML in .NET
Resources
 http://msdn.microsoft.com/xml/
 http://www.xml.com/
 http://www.w3.org/xml/
 Microsoft Press Books
(http://mspress.microsoft.com/)
 XML Step By Step
 XML In Action
 Developing XML Solutions
 O’Reilly Press
 XML In A Nutshell
Resources
 XML in .NET
http://msdn.microsoft.com/msdnmag/issues/
01/01/xml/xml.asp
 Working with XML in the .NET Platform
http://www.xmlmag.com/upload/free/feature
s/xml/2001/05may01/dw0102/dw0102.asp

XML

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

XML

Cargado por

Copyright:

Formatos disponibles

XML

 A tag-based meta language

 XML is a “use everywhere” data specification

XML XML Configuration

 XML is used to represent two main types of

 Pre-XML representation of data:

 XML representation of the same data:

 Open W3C standard

Elements with Attributes

 There must be one, and only one, root element

 No, CHILD2 and CHILD3 do not nest propertly

<xml? Version=“1.0” ?>

 No, there are two root elements

<xml? Version=“1.0” ?>

<xml? Version=“1.0” ?>

 Part of XML’s extensibility

Namespace declaration examples:

Namespace declaration Prefix URI (URL)

 An XML namespace declared without a prefix

 Unqualified elements belong to the inner-most

 Unqualified attributes do NOT belong to any

 You can define your own entities

XPath XML Path Language A language for addressing parts of an

 Define the “rules” (grammar) of the document

 Language for expressing document styles

 XSLT – a language used to transform XML data

 The language used for converting XML

 A set of formatting semantics

 General purpose query language for identifying

Operator Usage Description

./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)

 Builds upon XPath to:

 XML Linking Language

 XML embedded in an HTML document

<XML id=“XMLID” src=“mydocument.xml”>

 Can be embedded in an HTML SCRIPT element

 Access the XML via the HTML DOM:

 Or access the XML directly via the ID:

 An XML language for defining processes

 Microsoft BizTalk Server

 Microsoft SQL Server

 XML use is ubiquitous throughout .NET

 XML classes built on industry standards

Abstract (Base) Class Concrete (Derived) Class

 Represents a single node in a XML document

 Implements W3C XML Document Object Model

 Represents an element in the DOM tree

// DocumentElement retrieves the root element

// Get the attribute collection of the root element

// Create a new attribute and set it’s value

// Append the new attribute to the collection

XPathNavigator nav = myXmlDoc.CreateNavigator();

nav.MoveToRoot(); // move to root element

 Example: iterate over a subset of nodes

 Example: sum all Prices in a document

 Forward-only, non-cached access to XML data

 Abstract class providing fast, non-cached,

 Forward-only, non-cached method of writing

 Extends XmlDocument to include support for

XmlReader DataAdapter DataReader

XmlText- XmlNode- SqlData- OleDbData- SqlData- OleDbData-