1. Processing XML with .NET

   1. Chapter 1 Introduction to .NET and XML

      1. The .NET Framework
      2. The XML Family of Standards
      3. Introduction to XML in .NET
      4. Key Concepts
      5. Moving On

   2. Chapter 2 Reading XML

      1. Reading Data
      2. XmlReader
      3. Moving On

   3. Chapter 3 Writing XML

      1. Writing Data
      2. XmlWriter and Its Subclasses
      3. Moving On

   4. Chapter 4 Reading and Writing Non-XML Formats

      1. Reading Non-XML Documents with XmlReader
      2. Writing an XmlPyxWriter
      3. Moving On

   5. Chapter 5 Manipulating XML with DOM

      1. What Is the DOM?
      2. The .NET DOM Implementation
      3. Moving On

   6. Chapter 6 Navigating XML with XPath

      1. What Is XPath?
      2. Using XPath
      3. Moving On

   7. Chapter 7 Transforming XML with XSLT

      1. The Standards
      2. Introducing XSLT
      3. Using XSLT
      4. Moving On

   8. Chapter 8 Constraining XML with Schemas

      1. Introducing W3C XML Schema
      2. Using the XSD Tool
      3. Working with Schemas
      4. Moving On

   9. Chapter 9 SOAP and XML Serialization

      1. Defining Serialization
      2. Runtime Serialization
      3. XML Serialization
      4. SOAP Serialization
      5. Moving On

   10. Chapter 10 XML and Web Services

       1. Defining Web Services
       2. Using Web Services
       3. Moving On

   11. Chapter 11 XML and Databases

       1. Introduction to ADO.NET
       2. Manipulating Data Offline
       3. Reading XML from a Database
       4. Hierarchical XML

2. .NET XML Namespace Reference

   1. Chapter 12 How to Use These Quick Reference Chapters

      1. Finding a Quick-Reference Entry
      2. Reading a Quick-Reference Entry

   2. Chapter 13 The Microsoft.XmlDiffPatch Namespace

      1. Using the XmlDiffPatch Namespace
      2. Using the XmlDiff and XmlPatch Executables
      3. Microsoft.XmlDiffPatch Namespace Reference

   3. Chapter 14 The Microsoft.XsdInference Namespace

      1. Using the XsdInference Namespace
      2. Using the Infer Executable
      3. Microsoft.XsdInference Namespace Reference

   4. Chapter 15 The System.Configuration Namespace

      1. The Configuration Files
      2. Adding Your Own Configuration Settings
      3. System.Configuration Namespace Reference

   5. Chapter 16 The System.Xml Namespace

   6. Chapter 17 The System.Xml.Schema Namespace

   7. Chapter 18 The System.Xml.Serialization Namespace

   8. Chapter 19 The System.Xml.XPath Namespace

   9. Chapter 20 The System.Xml.Xsl Namespace

3. Chapter 21 Type, Method, Property, and Field Index

1. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of .NET and XML is a Canada goose (Branta canadensis). The Canada goose can be easily recognized by its black head, long neck, and whitish cheek patches. The underparts of the goose vary in color from light pearl gray, to chestnut, to blackish brown. There are at least 40, and possibly more, types of Canada geese. These groups also range in size. The largest Canada geese have a very deep honking voice, while the smallest have a high-pitched cackle. Males and females look similar, with the males being larger. The weights of the various types can range from 1.1 to 8 kilograms, and they can grow to a length of 43 inches, attaining a wingspan of 68 inches.

When geese migrate, they often fly at a considerable altitude. Long-distance flying by the flock is in a "V" formation. Flying just off the wing tips of the leader cuts turbulence, and creates a slipstream and a suction that lets the geese fly with less energy expended. The goose pilots take turns; one will drop back in the "V" to rest while another takes over.

Breeding season is from April to June. The pairs wait until the snow and ice melt before they begin nesting. Canada geese mate in their third year and pairs usually remain together as long as both birds are alive. There is a tendency for females to return to their own birth site to nest, and nesting areas are usually in marshes along sloughs or lakeshores. Both males and females collect debris for the nest. The female wiggles back and forth in the debris to shape the nest to her liking; she also plucks her down to line the nest. The female lays between 2 and 11 cream-colored eggs, and incubates them for 25 to 30 days while the male stands guard nearby. Both parents tend to the newborns, who are able to fly at about 8 weeks. The family bonds are strong, and the young remain with their parents on migration and throughout their first winter. Reg Aubry was the production editor and copyeditor, and Sarah Sherman was the proofreader for .NET and XML. Marlowe Shaeffer and Claire Cloutier provided quality control. Jamie Peppard provided production assistance. Lucie Haskins wrote the index.

Ellie Volckhausen designed the cover of this book, based on a series design by Edie Freedman. The cover image is an original illustration created by Susan Hart. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout. This book was converted by Julie Hawks to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read, using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Janet Santackas.