You are previewing Professional XML.
O'Reilly logo
Professional XML

Book Description

  • As XML gains popularity, developers are looking to implement XML technologies in their line-of-business applications

  • This book offers readers real-world insight into XML so that they can build the best possible applications

  • Offers an in-depth look at XML and discusses XML tools, services (RSS, SOAP, REST, WSDL), programming (DOM, SAX, Ajax), and languages (.NET, Java, PHP)

Table of Contents

  1. Copyright
  2. Credits
  3. About the Authors
  4. Acknowledgments
  5. Introduction
    1. What You Need for This Book
    2. Who Should Read This Book?
    3. What This Book Covers
    4. Conventions
    5. Source Code
    6. Errata
    7. p2p.wrox.com
  6. I. XML Basics
    1. 1. XML Syntax
      1. 1.1. The Purpose of XML
      2. 1.2. XML Syntax and Rules
        1. 1.2.1. XML Parsers
        2. 1.2.2. XML Elements and Tags
          1. 1.2.2.1. Element Syntax
          2. 1.2.2.2. XML Elements Must Have a Start and End Tag
          3. 1.2.2.3. Naming Conventions for Elements
          4. 1.2.2.4. XML Elements Must Be Properly Nested
          5. 1.2.2.5. Empty Elements
          6. 1.2.2.6. Tag Syntax
        3. 1.2.3. XML Text
          1. 1.2.3.1. Text Length
          2. 1.2.3.2. Content
          3. 1.2.3.3. Spoken Languages
          4. 1.2.3.4. Whitespace
          5. 1.2.3.5. Entity References
          6. 1.2.3.6. CDATA Sections
        4. 1.2.4. The XML Document
          1. 1.2.4.1. Creating an .xml File
          2. 1.2.4.2. The XML Declaration
          3. 1.2.4.3. The version Attribute
          4. 1.2.4.4. The encoding Attribute
          5. 1.2.4.5. The standalone Attribute
          6. 1.2.4.6. XML Comments
          7. 1.2.4.7. XML Processing Instructions
        5. 1.2.5. Attributes
          1. 1.2.5.1. Naming Attributes
          2. 1.2.5.2. Empty Attributes
          3. 1.2.5.3. Attribute Names Must Be Unique
          4. 1.2.5.4. The xml:lang Attribute
          5. 1.2.5.5. The xml:space Attribute
      3. 1.3. XML Namespaces
      4. 1.4. Summary
    2. 2. XML Editors
      1. 2.1. Visual Studio .NET 2003
        1. 2.1.1. Basic Editing in Visual Studio .NET 2003
        2. 2.1.2. Schema Development in Visual Studio .NET 2003
        3. 2.1.3. Other Features
      2. 2.2. Visual Studio 2005
        1. 2.2.1. Basic Editing in Visual Studio 2005
        2. 2.2.2. Schema Development in Visual Studio 2005
        3. 2.2.3. XSLT Development in Visual Studio 2005
      3. 2.3. Altova XMLSpy 2006
        1. 2.3.1. Basic Editing in Altova XMLSpy 2006
        2. 2.3.2. Schema Development in XMLSpy
        3. 2.3.3. XSLT Development in XMLSpy
        4. 2.3.4. Other Features in XMLSpy
      4. 2.4. Stylus Studio 2006
        1. 2.4.1. Basic Editing in Stylus Studio 2006
        2. 2.4.2. Schema Development in Stylus Studio 2006
        3. 2.4.3. XSLT Development in Stylus Studio
        4. 2.4.4. Other Features in Stylus Studio
      5. 2.5. Oxygen XML Editor 6.2
        1. 2.5.1. Basic Editing in Oxygen XML Editor 6.2
        2. 2.5.2. Schema Development in Oxygen XML Editor 6.2
        3. 2.5.3. Converting between Schema Types in Oxygen XML Editor 6.2
        4. 2.5.4. XSLT Development in Oxygen XML Editor 6.2
        5. 2.5.5. Other Features in Oxygen XML Editor 6.2
      6. 2.6. Other XML Tools
      7. 2.7. Summary
  7. II. Presentation
    1. 3. XHTML and CSS
      1. 3.1. Understanding XHTML
        1. 3.1.1. The Evolution of Markup
        2. 3.1.2. The Basics of XHTML
        3. 3.1.3. Validating XHTML
          1. 3.1.3.1. W3C Validation Service
          2. 3.1.3.2. Tidy
          3. 3.1.3.3. Tidy UI
      2. 3.2. Understanding CSS
        1. 3.2.1. Basics of CSS
        2. 3.2.2. CSS Examples
          1. 3.2.2.1. Box Layout and Cross-Browser Compatibility
          2. 3.2.2.2. Multicolumn Layout with CSS
        3. 3.2.3. Validating CSS
      3. 3.3. Using Microformats
        1. 3.3.1. Elemental Microformats
          1. 3.3.1.1. RelNoFollow
          2. 3.3.1.2. Rel-Tag
        2. 3.3.2. Compound Microformats
          1. 3.3.2.1. hCard
          2. 3.3.2.2. hCalendar
          3. 3.3.2.3. hReview
      4. 3.4. Summary
      5. 3.5. Resources
    2. 4. XSL-FO
      1. 4.1. The Composition of XSL
      2. 4.2. XSL-FO Overview
        1. 4.2.1. Page Templates
        2. 4.2.2. fo:simple-page-master
      3. 4.3. XSL-FO Basics
        1. 4.3.1. Hello World for XSL-FO
        2. 4.3.2. Basic Formatting
          1. 4.3.2.1. Lists
          2. 4.3.2.2. Tables
        3. 4.3.3. A Working Example
      4. 4.4. Summary
  8. III. Defining Structure
    1. 5. Document Type Definitions (DTDs)
      1. 5.1. Why Document Type Definitions?
      2. 5.2. Internal DTDs
      3. 5.3. External DTDs
      4. 5.4. Building Your Own DTD
        1. 5.4.1. Document Type Declaration
          1. 5.4.1.1. The SYSTEM and PUBLIC Keywords
          2. 5.4.1.2. Using the URI and Inline DTD Together
        2. 5.4.2. Element Declarations
          1. 5.4.2.1. Content Specification with ANY
          2. 5.4.2.2. Placing Limits on Elements with #PCDATA
          3. 5.4.2.3. Empty Values
          4. 5.4.2.4. Child Elements
            1. 5.4.2.4.1. Specifying a Number of Instances Required
            2. 5.4.2.4.2. Reusing XML Elements
            3. 5.4.2.4.3. The + Quantifier
            4. 5.4.2.4.4. The ? Quantifier
            5. 5.4.2.4.5. The * Quantifier
            6. 5.4.2.4.6. Allowing a Choice
        3. 5.4.3. Attribute Declarations
          1. 5.4.3.1. Attribute Data Types
          2. 5.4.3.2. The #REQUIRED Keyword
          3. 5.4.3.3. The #IMPLIED Keyword
          4. 5.4.3.4. The #FIXED Keyword
          5. 5.4.3.5. Using Enumerations as Values
        4. 5.4.4. Entity Declarations
          1. 5.4.4.1. Internal Entities
          2. 5.4.4.2. External Entities
        5. 5.4.5. Notation Declarations
      5. 5.5. Using XML Tools to Create the DTD
      6. 5.6. DTD Validation
      7. 5.7. Summary
    2. 6. XML Schemas
      1. 6.1. The Issues with DTDs
      2. 6.2. Building the Root XML Schema Document
        1. 6.2.1. The XML Declaration
        2. 6.2.2. The Root Element
          1. 6.2.2.1. attributeFormDefault Attribute
          2. 6.2.2.2. elementFormDefault Attribute
          3. 6.2.2.3. targetNamespace Attribute
          4. 6.2.2.4. The version Attribute
          5. 6.2.2.5. xml:lang Attribute
      3. 6.3. Declaring Elements
        1. 6.3.1. Simple Types
          1. 6.3.1.1. Atomic Types
          2. 6.3.1.2. List Types
          3. 6.3.1.3. Union types
        2. 6.3.2. Complex Types
          1. 6.3.2.1. Looking at Reusability
            1. 6.3.2.1.1. sequence and all
        3. 6.3.3. Element Types
        4. 6.3.4. Groups and Choices
        5. 6.3.5. Element Restrictions
          1. 6.3.5.1. Cardinality in XML Schemas
          2. 6.3.5.2. minOccurs
          3. 6.3.5.3. maxOccurs
          4. 6.3.5.4. Default values
          5. 6.3.5.5. Fixed Values
          6. 6.3.5.6. Null Values
        6. 6.3.6. Defining Attributes
          1. 6.3.6.1. Default Values
          2. 6.3.6.2. use Attribute
          3. 6.3.6.3. Putting Restrictions on Attribute Values
          4. 6.3.6.4. Attribute Groups
      4. 6.4. Putting XML Schema Document Together
        1. 6.4.1. <import>
        2. 6.4.2. <include>
      5. 6.5. Commenting XML Schemas
        1. 6.5.1. Standard XML Comments
        2. 6.5.2. <annotation>
          1. 6.5.2.1. <documentation>
          2. 6.5.2.2. <appInfo>
      6. 6.6. XML Schema Tools
        1. 6.6.1. Microsoft's Visual Studio 2005
        2. 6.6.2. Altova's XMLSpy
      7. 6.7. Summary
    3. 7. RELAX NG
      1. 7.1. Why Another Schema Language?
      2. 7.2. Defining a RELAX NG Schema
      3. 7.3. Declaring Elements
        1. 7.3.1. Simple Elements
          1. 7.3.1.1. List Types
          2. 7.3.1.2. Union Types
        2. 7.3.2. Attributes
        3. 7.3.3. Order of Elements
        4. 7.3.4. Defining Grammar
        5. 7.3.5. Reusing Types
        6. 7.3.6. Merging Schemas
        7. 7.3.7. Namespaces and Name Classes
        8. 7.3.8. Annotating Schemas
      4. 7.4. RELAX NG Tools
        1. 7.4.1. Oxygen
        2. 7.4.2. Trang
      5. 7.5. RELAX NG Compact
      6. 7.6. Summary
      7. 7.7. Resources
  9. IV. XML as Data
    1. 8. XSLT
      1. 8.1. What Is XSLT?
      2. 8.2. XSLT Syntax
        1. 8.2.1. Required Items
          1. 8.2.1.1. Top-level Elements
          2. 8.2.1.2. Including Additional Stylesheets with include and import
          3. 8.2.1.3. Controlling Whitespace and Formatting with strip-space, preserve-space, and decimal-format
          4. 8.2.1.4. Controlling Output with output and key
        2. 8.2.2. Templates
        3. 8.2.3. Retrieving Values
          1. 8.2.3.1. Calling templates
          2. 8.2.3.2. Multiple Templates for a Single Element
        4. 8.2.4. Conditional Processing
        5. 8.2.5. Looping
        6. 8.2.6. Variables and Parameters
        7. 8.2.7. Other Functions and Expressions
        8. 8.2.8. Extending XSLT
      3. 8.3. Executing XSLT
        1. 8.3.1. Executing XSLT at the Command-line
        2. 8.3.2. Executing XSLT via Code
        3. 8.3.3. Executing XSLT in a Browser
      4. 8.4. Changes with XSLT 2.0
      5. 8.5. Generating Output with XSLT
        1. 8.5.1. Generating HTML with XSLT
        2. 8.5.2. Converting between XML Syntaxes with XSLT
      6. 8.6. Debugging XSLT
      7. 8.7. Summary
      8. 8.8. Resources
    2. 9. X Path
      1. 9.1. Major Features of XPath
        1. 9.1.1. Nodes
        2. 9.1.2. Tree Structure
        3. 9.1.3. Path Expressions
        4. 9.1.4. Predicates
        5. 9.1.5. Axes
        6. 9.1.6. Sequences
      2. 9.2. Lessons from the Trenches
        1. 9.2.1. When A ! = B Is Different from not(A = B)
        2. 9.2.2. The Many Faces of a Document
        3. 9.2.3. Tuning Your XPath Expressions
        4. 9.2.4. Function Calls in Path Expressions
        5. 9.2.5. Using Comments and Nested Comments
        6. 9.2.6. Using Regular Expressions
        7. 9.2.7. The unordered() Function: Quite an Oddity
        8. 9.2.8. Union and Sequence Operators
        9. 9.2.9. //h1[1] Different Than (//h1)[1]
        10. 9.2.10. Reverse Axis—Evil at Times
        11. 9.2.11. Debugging with trace()
      3. 9.3. XPath in Java, .NET, and PHP
        1. 9.3.1. XPath in Java
        2. 9.3.2. XPath on .NET
        3. 9.3.3. XPath in PHP
      4. 9.4. Tools for XPath
        1. 9.4.1. Online XPath Sandbox
        2. 9.4.2. XPath in Your Browser
        3. 9.4.3. XML Editors
        4. 9.4.4. Eclipse and IntelliJ
      5. 9.5. Summary
      6. 9.6. References
    3. 10. XQuery
      1. 10.1. What Is XQuery?
        1. 10.1.1. XQuery Use Cases
        2. 10.1.2. Advantages of XQuery
        3. 10.1.3. Structure of an XQuery Expression
      2. 10.2. A Simple XQuery Example
      3. 10.3. Enclosed Expressions
      4. 10.4. FLWOR Expressions
        1. 10.4.1. A Simple FLWOR Expression
        2. 10.4.2. An In-Depth Look at FLWOR Expressions
          1. 10.4.2.1. for Clause
          2. 10.4.2.2. let Clause
          3. 10.4.2.3. where Clause
          4. 10.4.2.4. order by Clause
          5. 10.4.2.5. return Clause
        3. 10.4.3. FLWOR Expressions Versus XPath Expressions
      5. 10.5. XQuery Functions
        1. 10.5.1. XQuery Built-In Functions
          1. 10.5.1.1. doc() Function
          2. 10.5.1.2. Aggregate Functions
          3. 10.5.1.3. String Functions
        2. 10.5.2. XQuery User-Defined Functions
      6. 10.6. XQuery in Java
        1. 10.6.1. Pre-requisites
        2. 10.6.2. Selecting XML with XQuery
          1. 10.6.2.1. Invoking execQuery() from an XmlObject
          2. 10.6.2.2. Invoking execQuery() from an XmlCursor
      7. 10.7. XQuery in Relational Databases
        1. 10.7.1. XQuery in SQL Server 2005
        2. 10.7.2. XML Data Type Query and Data Modification
          1. 10.7.2.1. Working with the query Method
          2. 10.7.2.2. Working with the value Method
          3. 10.7.2.3. Working with the exist Method
          4. 10.7.2.4. Working with the nodes Method
          5. 10.7.2.5. Working with the modify Method
      8. 10.8. Summary
    4. 11. XML in the Data Tier
      1. 11.1. XML and Databases
        1. 11.1.1. Retrieving Data as XML
        2. 11.1.2. Storing XML
      2. 11.2. Relational Databases
        1. 11.2.1. Microsoft SQL Server 2005
          1. 11.2.1.1. Retrieving XML
          2. 11.2.1.2. Storing XML
          3. 11.2.1.3. Additional XML-related features
        2. 11.2.2. Oracle 10g
          1. 11.2.2.1. Retrieving XML
          2. 11.2.2.2. Storing XML
      3. 11.3. XML Databases
        1. 11.3.1. Xindice
          1. 11.3.1.1. Retrieving XML
          2. 11.3.1.2. Storing XML
      4. 11.4. Other Databases
      5. 11.5. Summary
      6. 11.6. Resources
  10. V. Programming XML
    1. 12. XML Document Object Model (DOM)
      1. 12.1. What Is DOM?
        1. 12.1.1. Why Client-Side XML Processing?
        2. 12.1.2. XML DOM Object Model
        3. 12.1.3. Using the Document Interface
        4. 12.1.4. Loading an XML Document
          1. 12.1.4.1.
            1. 12.1.4.1.1. Using the readyState Property
        5. 12.1.5. Using the Element Interface
        6. 12.1.6. Creating a New Element
        7. 12.1.7. Using the Node Interface
          1. 12.1.7.1. Creating a New Node
          2. 12.1.7.2. Appending a New Child Node
          3. 12.1.7.3. Inserting a Node Before an Existing Node
          4. 12.1.7.4. Removing a Child Node
          5. 12.1.7.5. Replacing a Node
          6. 12.1.7.6. Accessing Text Values of Elements
        8. 12.1.8. Using the NodeList Interface
        9. 12.1.9. Using the NamedNodeMap Interface
        10. 12.1.10. Using the Attr Interface
        11. 12.1.11. Creating Attributes
        12. 12.1.12. Using the CharacterData Interface
        13. 12.1.13. Using the Comment Interface
        14. 12.1.14. Using the Text Interface
        15. 12.1.15. Using the CDATASection Interface
        16. 12.1.16. Handling Errors in XML DOM
        17. 12.1.17. XML Transformation Using XSL
      2. 12.2. XML Validation Using XML DOM
      3. 12.3. Summary
    2. 13. Simple API for XML (SAX)
      1. 13.1. Introducing XML Parsing
        1. 13.1.1. Tree-Based APIs
        2. 13.1.2. A Simple API for XML (SAX)
        3. 13.1.3. Installing SAX
      2. 13.2. SAX Architecture
        1. 13.2.1. Basic SAX Application Flow
      3. 13.3. SAX Packages and Classes
        1. 13.3.1. The SAXParser Class
        2. 13.3.2. The XMLReader Interface
        3. 13.3.3. Receiving SAX Events
          1. 13.3.3.1. The DefaultHandler Class
        4. 13.3.4. Using the XMLReader Interface
        5. 13.3.5. DefaultHandler Class
          1. 13.3.5.1. The startDocument() and endDocument() Methods
          2. 13.3.5.2. The processingInstruction() Method
          3. 13.3.5.3. Namespace Callbacks
          4. 13.3.5.4. The startElement() and endElement() Methods
          5. 13.3.5.5. Element Data Callback
          6. 13.3.5.6. The ignorableWhitespace() Method
          7. 13.3.5.7. The skippedEntity() Method
          8. 13.3.5.8. The setDocumentLocator() Method
        6. 13.3.6. Handling Errors and Warnings
      4. 13.4. Searching in an XML File
      5. 13.5. Writing XML Contents Using SAX
      6. 13.6. XML Validation Using SAX
      7. 13.7. Advantages and Disadvantages of SAX
      8. 13.8. Summary
    3. 14. Ajax
      1. 14.1. Adding JavaScript to a Web Page
        1. 14.1.1. Adding JavaScript to a Web Page
        2. 14.1.2. Functions in JavaScript
        3. 14.1.3. Data Types in JavaScript
          1. 14.1.3.1. Language Features of JavaScript
      2. 14.2. XMLHttpRequest
      3. 14.3. The DOM
        1. 14.3.1. Objects in the DOM
        2. 14.3.2. Events in the DOM
      4. 14.4. Putting It All Together
      5. 14.5. Ajax Libraries
        1. 14.5.1. Using the Microsoft AJAX Library to Add Ajax Functionality
        2. 14.5.2. Using Prototype to Add Ajax Functionality
      6. 14.6. Ajax Resources
      7. 14.7. Summary
    4. 15. XML and .NET
      1. 15.1. The Serialization of XML
        1. 15.1.1. Serializing Using the XmlSerializer Class
        2. 15.1.2. Changing the Output of the Serialized Object
      2. 15.2. Deserializing XML
      3. 15.3. XmlWriter
        1. 15.3.1. Writing XML Using XmlTextWriter
        2. 15.3.2. Writing XML Using XmlWriter
        3. 15.3.3. Writing XML Programmatically Using XmlWriter
      4. 15.4. XmlReader
        1. 15.4.1. Reading XML with a Schema Validation
        2. 15.4.2. Casting XML Types to .NET-Compliant Types
      5. 15.5. Reading XML Using XPathDocument
      6. 15.6. XML in ASP.NET 2.0
        1. 15.6.1. The XmlDataSource Server Control
        2. 15.6.2. The XmlDataSource Control's Namespace Problem
        3. 15.6.3. The Xml Server Control
      7. 15.7. Summary
    5. 16. XML and Java
      1. 16.1. Reading and Writing XML
        1. 16.1.1. Parsing from Java
          1. 16.1.1.1. SAX: Push Parsing
          2. 16.1.1.2. StAX: Pull Parsing
        2. 16.1.2. Writing XML (Serialization)
          1. 16.1.2.1. Using a JAXP Serializer
          2. 16.1.2.2. Serializing Using StAX
      2. 16.2. XML Tree Models
        1. 16.2.1. Alternatives to DOM
        2. 16.2.2. JDOM
        3. 16.2.3. DOM4J
        4. 16.2.4. XOM
        5. 16.2.5. Java/XML Data Binding
        6. 16.2.6. Controlling XSLT, XQuery, and XPath Processing from Java
          1. 16.2.6.1. JAXP: The Java API for XML Processing
            1. 16.2.6.1.1. The JAXP Factory Mechanism
            2. 16.2.6.1.2. The JAXP Parser API
            3. 16.2.6.1.3. The JAXP Transformation API
            4. 16.2.6.1.4. The JAXP Validation API
          2. 16.2.6.2. XQJ: The XQuery API for Java
      3. 16.3. Summary
    6. 17. Dynamic Languages and XML
      1. 17.1. Perl
        1. 17.1.1. Reading and Writing XML
          1. 17.1.1.1. Reading XML
          2. 17.1.1.2. Writing XML
        2. 17.1.2. Support for Other XML Formats
      2. 17.2. Python
        1. 17.2.1. Reading and Writing XML
          1. 17.2.1.1. Reading XML
          2. 17.2.1.2. Writing XML
        2. 17.2.2. Support for Other XML Formats
      3. 17.3. Ruby
        1. 17.3.1. Reading and Writing XML
          1. 17.3.1.1. Reading XML
          2. 17.3.1.2. Writing XML
        2. 17.3.2. Support for Other XML Formats
      4. 17.4. Summary
      5. 17.5. Resources
        1. 17.5.1. Perl Resources
        2. 17.5.2. Python Resources
        3. 17.5.3. Ruby Resources
  11. VI. XML Services
    1. 18. RSS and Atom
      1. 18.1. What Is RSS?
      2. 18.2. Specifications
        1. 18.2.1. RSS 2.0
        2. 18.2.2. RSS 1.0
      3. 18.3. What Is Atom?
      4. 18.4. Reading RSS and Atom
        1. 18.4.1. Reading with .NET
          1. 18.4.1.1. XmlDocument
          2. 18.4.1.2. XmlReader
        2. 18.4.2. Reading RSS with Java
      5. 18.5. Writing RSS and Atom
        1. 18.5.1. Writing with .NET
        2. 18.5.2. Writing with Java
        3. 18.5.3. Class Libraries Available for Processing RSS and Atom
      6. 18.6. Summary
      7. 18.7. Resources
    2. 19. Web Services
      1. 19.1. Why Web Services?
      2. 19.2. The Composition of Web Services
        1. 19.2.1. Representing and Communicating Data in Web Services
        2. 19.2.2. Describing Web Services
        3. 19.2.3. Discovering Web Services
      3. 19.3. Building Web Services with C#
        1. 19.3.1. Using the Microsoft Web Services Test Page
        2. 19.3.2. Testing the WebMethod
        3. 19.3.3. Altering the Protocols Used by the Web Service
      4. 19.4. Building Web Services with Java
        1. 19.4.1. Introduction to Axis and Tomcat
        2. 19.4.2. Setting Up Axis and Tomcat
        3. 19.4.3. Publishing Web Services Using Axis
          1. 19.4.3.1. Instant Deployment Through Renaming .java to .jws
          2. 19.4.3.2. Advanced Deployment
            1. 19.4.3.2.1. Creating the Service Implementation
            2. 19.4.3.2.2. Creating a Web Service Deployment Descriptor (WSDD) File
      5. 19.5. Consuming Web Services with C#
        1. 19.5.1. Consuming Web Services Using ASP.NET
          1. 19.5.1.1. Adding a Web Reference to Your ASP.NET Project
          2. 19.5.1.2. Building the Consuming Web Page
        2. 19.5.2. Consuming Web Services Using Windows Forms
      6. 19.6. Consuming Web Services with Java
        1. 19.6.1. Consuming the HelloWorld Service
        2. 19.6.2. Running the Client Application
        3. 19.6.3. Consuming the ProductService
        4. 19.6.4. Running the Client Application
      7. 19.7. Caching Web Services
      8. 19.8. Asynchronous Consumption of Web Services
        1. 19.8.1. Building a Slow Web Service
        2. 19.8.2. Consuming the TakeLongTime() WebMethod Asynchronously
      9. 19.9. Summary
    3. 20. SOAP and WSDL
      1. 20.1. SOAP Speak
      2. 20.2. The Basics of SOAP
        1. 20.2.1. Remember: SOAP Is XML!
        2. 20.2.2. Transport Protocols for SOAP
      3. 20.3. Looking Closely at the SOAP Specification
        1. 20.3.1. The SOAP Message
        2. 20.3.2. The SOAP Envelope
        3. 20.3.3. The SOAP Body
          1. 20.3.3.1. Looking at the SOAP Body of the Request
          2. 20.3.3.2. Looking at the SOAP Body of the Response
        4. 20.3.4. The SOAP Header
          1. 20.3.4.1. The actor Attribute
          2. 20.3.4.2. The role Attribute
          3. 20.3.4.3. The mustUnderstand Attribute
        5. 20.3.5. SOAP 1.1 Faults
          1. 20.3.5.1. <faultcode>
          2. 20.3.5.2. <faultstring>
          3. 20.3.5.3. <faultactor>
          4. 20.3.5.4. <detail>
        6. 20.3.6. SOAP 1.2 Faults
          1. 20.3.6.1. <Code>
            1. 20.3.6.1.1. <Value>
            2. 20.3.6.1.2. <Subcode>
            3. 20.3.6.1.3. <Reason>
            4. 20.3.6.1.4. <Text>
            5. 20.3.6.1.5. <Node>
            6. 20.3.6.1.6. <Role>
            7. 20.3.6.1.7. <Detail>
        7. 20.3.7. SOAP Encoding of Data Types
      4. 20.4. Tracing SOAP Messages
        1. 20.4.1. The Microsoft Trace Utility
          1. 20.4.1.1. Using the Trace Utility
        2. 20.4.2. Modifying the Consuming Application
        3. 20.4.3. Viewing the SOAP Messages
        4. 20.4.4. XMLSpy's SOAP Debugging
          1. 20.4.4.1. Using the SOAP Debugging Capabilities
        5. 20.4.5. Using XMLSpy to Issue SOAP Requests
      5. 20.5. Working with SOAP Headers
        1. 20.5.1. Creating SOAP Messages Using SOAP Headers
        2. 20.5.2. Consuming SOAP Messages Using SOAP Headers
      6. 20.6. Defining Web Services Using WSDL
        1. 20.6.1. The Structure of WSDL Documents
        2. 20.6.2. <definitions>
        3. 20.6.3. <types>
        4. 20.6.4. <message>
        5. 20.6.5. <portType>
        6. 20.6.6. <binding>
        7. 20.6.7. <soap:binding>
        8. 20.6.8. <soap:operation>
        9. 20.6.9. <soap:body>
        10. 20.6.10. <service>
        11. 20.6.11. <import>
        12. 20.6.12. <documentation>
      7. 20.7. Summary
    4. 21. Advanced Web Services
      1. 21.1. Expanding on a Foundation
      2. 21.2. Web Services Framework — The Paper
        1. 21.2.1. Message Envelope and Controlled Extensibility
        2. 21.2.2. Binary Attachments
        3. 21.2.3. Message Exchange aka Routing
        4. 21.2.4. Message Correlation
        5. 21.2.5. Guaranteed Message Exchange
        6. 21.2.6. Digital Signature
        7. 21.2.7. Encryption
        8. 21.2.8. Transactions and Activities
        9. 21.2.9. Service Description
        10. 21.2.10. Process Flow Contract Description
        11. 21.2.11. Inspection
        12. 21.2.12. Discovery
      3. 21.3. WS-I.org
      4. 21.4. Extending XML Web Services
        1. 21.4.1. SOAP Basics
        2. 21.4.2. SOAP Headers
        3. 21.4.3. SOAP Extensions
      5. 21.5. WS-* Specifications
        1. 21.5.1. WS-Security
          1. 21.5.1.1. Credential Exchange
          2. 21.5.1.2. Message Integrity
          3. 21.5.1.3. Message Confidentiality
        2. 21.5.2. WS-Addressing
        3. 21.5.3. WS-Attachments
        4. 21.5.4. WS-Coordination
        5. 21.5.5. WS-MetadataExchange
        6. 21.5.6. Core Specifications
      6. 21.6. Looking at Microsoft's Web Services Enhancements 3.0
        1. 21.6.1. The WSE 1.0 Contents
        2. 21.6.2. The WSE 2.0 Contents
        3. 21.6.3. The WSE 3.0 Contents
        4. 21.6.4. Functionality Provided by the WSE
        5. 21.6.5. How the WSE Works
        6. 21.6.6. Building a WSE 3.0 Example — The Server
          1. 21.6.6.1. Creating a Class That Verifies Credentials
          2. 21.6.6.2. Configuring the Application To Use the WSE 3.0
          3. 21.6.6.3. Configuring Diagnostics
          4. 21.6.6.4. The Result of the WSE Settings 3.0 Tool Configuration
          5. 21.6.6.5. Building the Web Service
        7. 21.6.7. Building a WSE 3.0 Example — The Client Application
        8. 21.6.8. The Result of the Exchange
      7. 21.7. Summary
    5. 22. REST
      1. 22.1. Introducing the Basics of REST
        1. 22.1.1. Pure REST
        2. 22.1.2. Just-enough REST
      2. 22.2. Accessing REST Services
        1. 22.2.1. Accessing REST Service Examples
      3. 22.3. Creating REST Services
        1. 22.3.1. Just-enough REST Service Example
        2. 22.3.2. A Pure REST Service Example
      4. 22.4. Summary
      5. 22.5. Resources
  12. VII. Applying XML
    1. 23. XML Form Development
      1. 23.1. Creating Forms
        1. 23.1.1. Creating Forms
        2. 23.1.2. XForms Model
        3. 23.1.3. XForms Controls
          1. 23.1.3.1. Common Control Children
          2. 23.1.3.2. Changing Control Appearance
          3. 23.1.3.3. Grouping Controls
        4. 23.1.4. Binding Instance Data
        5. 23.1.5. XForms Submit Protocol
      2. 23.2. XForms Logic
        1. 23.2.1. Events
        2. 23.2.2. Actions
      3. 23.3. XForms Sample
      4. 23.4. Alternatives to XForms
        1. 23.4.1. Microsoft InfoPath
        2. 23.4.2. Comparing XForms and InfoPath
      5. 23.5. Summary
      6. 23.6. Resources
    2. 24. The Resource Description Framework (RDF)
      1. 24.1. The Core Structure of RDF
      2. 24.2. The RDF Graph Model
      3. 24.3. Using Altova's SemanticWorks
      4. 24.4. The RDF XML Schema
      5. 24.5. Summary
    3. 25. XML in Office Development
      1. 25.1. Using XML with Microsoft Excel
        1. 25.1.1.
          1. 25.1.1.1. Saving Excel workbooks as XML
          2. 25.1.1.2. Editing XML documents
      2. 25.2. Using XML with Microsoft Word
        1. 25.2.1.
          1. 25.2.1.1. Saving Word documents as XML
          2. 25.2.1.2. Editing XML documents
      3. 25.3. Using XML in Other Office Applications
        1. 25.3.1. Microsoft Access
          1. 25.3.1.1. Importing XML
          2. 25.3.1.2. Saving as XML
        2. 25.3.2. Microsoft InfoPath
      4. 25.4. Office 2007 — Open XML Format
      5. 25.5. OpenOffice — The Open Document Format
      6. 25.6. Summary
      7. 25.7. Resources
    4. 26. XAML
      1. 26.1. Thin or Thick?
      2. 26.2. One More Application Style — Windows Presentation Foundation
        1. 26.2.1. WPF Within Visual Studio 2005
        2. 26.2.2. Nesting Controls
        3. 26.2.3. Case Study: Building a Document Viewer Using XAML
          1. 26.2.3.1. Create the WPF Application
          2. 26.2.3.2. Building the Document
          3. 26.2.3.3. Viewing the Document
          4. 26.2.3.4. Adding an Image to the Document
          5. 26.2.3.5. Final Step: Saving the Document as an XPS File
      3. 26.3. Summary