1. Programming with C#

   1. Chapter 1 Introducing C# and the .NET Framework

      1. The C# Language
      2. The .NET Framework
      3. ECMA Standardization

   2. Chapter 2 C# Language Basics

      1. A First C# Program
      2. Identifiers and Keywords
      3. Type Basics
      4. Value Types and Reference Types
      5. Predefined Types
      6. Arrays
      7. Variables and Parameters
      8. Expressions and Operators
      9. Statements
      10. Namespaces

   3. Chapter 3 Creating Types in C#

      1. Classes
      2. Inheritance
      3. Access Modifiers
      4. Structs
      5. Interfaces
      6. Enums

   4. Chapter 4 Advanced C# Features

      1. Delegates
      2. Delegates Versus Function Pointers
      3. Delegates Versus Interfaces
      4. Events
      5. Operator Overloading
      6. Try Statements and Exceptions
      7. Attributes
      8. Unsafe Code and Pointers
      9. Preprocessor Directives
      10. XML Documentation

2. Programming with the .NET Framework

   1. Chapter 5 Framework Class Library Overview

      1. Core Types
      2. Text
      3. Collections
      4. Streams and I/O
      5. Networking
      6. Threading
      7. Security
      8. Reflection and Metadata
      9. Assemblies
      10. Serialization
      11. Remoting
      12. Web Services
      13. Data Access
      14. XML
      15. Graphics
      16. Rich Client Applications
      17. Web-Based Applications
      18. Globalization
      19. Configuration
      20. Advanced Component Services
      21. Diagnostics and Debugging
      22. Interoperating with Unmanaged Code
      23. Compiler and Tool Support
      24. Runtime Facilities
      25. Native OS Facilities
      26. Undocumented Types

   2. Chapter 6 String Handling

      1. String Class
      2. StringBuilder Class
      3. Regular Expression Support
      4. Regular Expression Basics
      5. Procedural- and Expression-Based Patterns
      6. Cookbook Regular Expressions

   3. Chapter 7 Collections

      1. Iterating Over Collections
      2. Standard Collection Interfaces
      3. Predefined Collection Classes
      4. Ordering Instances
      5. Generating Hash Code

   4. Chapter 8 XML I/O

      1. Accessing XML Documents
      2. Parsing an XML Stream
      3. Selecting Nodes Using XPath
      4. Transforming a Document Using XSLT

   5. Chapter 9 Networking

      1. Network Programming Models
      2. Generic Request/Response Architecture
      3. HTTP-Specific Support
      4. WebClient
      5. Adding New Protocol Handlers
      6. Using TCP, UDP, and Sockets
      7. Using DNS

   6. Chapter 10 Streams and I/O

      1. Streams and Backing Stores
      2. Encapsulating Raw Streams
      3. Directories and Files
      4. Isolated Storage

   7. Chapter 11 Serialization

      1. What Is Serialization?
      2. Serialization Support in the Framework
      3. Explicit Serialization
      4. Implicit Serialization
      5. [Serializable]
      6. [NonSerialized]
      7. IDeserializationCallback
      8. ISerializable
      9. [Serializable] and ISerializable

   8. Chapter 12 Assemblies

      1. Elements of an Assembly
      2. Assemblies and Modules
      3. Scoping Types and Type References
      4. Naming and Signing Assemblies
      5. Resolving and Loading Assemblies
      6. Deployment
      7. Security Permissions

   9. Chapter 13 Reflection

      1. Type Hierarchy
      2. Types, Members, and Nested Types
      3. Retrieving the Type for an Instance
      4. Retrieving a Type Directly
      5. Reflecting Over a Type Hierarchy
      6. Late Binding
      7. Advanced Uses of Reflection
      8. Creating New Types at Runtime

   10. Chapter 14 Custom Attributes

       1. Language Support
       2. Compiler Support
       3. Runtime Support
       4. Predefined Attributes
       5. Defining a New Custom Attribute
       6. Retrieving a Custom Attribute at Runtime

   11. Chapter 15 Memory Management

       1. The Garbage Collector
       2. Optimization Techniques
       3. Finalizers
       4. Dispose and Close Methods

   12. Chapter 16 Threading

       1. Thread Synchronization
       2. Common Thread Types
       3. Asynchronous Delegates

   13. Chapter 17 Integrating with Native DLLs

       1. Calling Into DLLs
       2. Marshaling Common Types
       3. Marshaling Classes and Structs
       4. In and Out Marshaling
       5. Callbacks from Unmanaged Code
       6. Simulating a C Union
       7. Mapping a Struct to a Binary Format
       8. Predefined Interop Support Attributes

   14. Chapter 18 Integrating with COM Components

       1. Binding COM and C# Objects
       2. Exposing COM Objects to C#
       3. Exposing C# Objects to COM
       4. COM Mapping in C#
       5. Common COM Interop Support Attributes
       6. COM+ Support

   15. Chapter 19 Diagnostics

       1. Logging and Assertion Facilities
       2. Conditional Compilation
       3. Debugger Integration
       4. Processes, Threads, and Stacks
       5. Event Logs
       6. Performance Counters

3. Language and Tools Reference

   1. Chapter 20 C# Language Reference

   2. Chapter 21 XML Documentation Tag Reference

   3. Chapter 22 C# Naming and Coding Conventions

      1. Case
      2. Mechanics
      3. Word Choice
      4. Namespaces

   4. Chapter 23 C# Development Tools

4. API Quick Reference

   1. Chapter 24 How to Use This Quick Reference

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

   2. Chapter 25 Microsoft.Win32

   3. Chapter 26 System

   4. Chapter 27 System.Collections

   5. Chapter 28 System.Collections.Specialized

   6. Chapter 29 System.Diagnostics

   7. Chapter 30 System.Globalization

   8. Chapter 31 System.IO

   9. Chapter 32 System.IO.IsolatedStorage

   10. Chapter 33 System.Net

   11. Chapter 34 System.Net.Sockets

   12. Chapter 35 System.Reflection

   13. Chapter 36 System.Reflection.Emit

   14. Chapter 37 System.Runtime.InteropServices

   15. Chapter 38 System.Runtime.Serialization

   16. Chapter 39 System.Runtime.Serialization.Formatters

   17. Chapter 40 System.Text

   18. Chapter 41 System.Text.RegularExpressions

   19. Chapter 42 System.Threading

   20. Chapter 43 System.Timers

   21. Chapter 44 System.Xml

   22. Chapter 45 System.Xml.XPath

   23. Chapter 46 System.Xml.Xsl

5. Appendixes

   1. Appendix A Regular Expressions

   2. Appendix B Format Specifiers

      1. Picture Format Specifiers
      2. DateTime Format Specifiers

   3. Appendix C Data Marshaling

   4. Appendix D C# Keywords

   5. Appendix E Namespaces and Assemblies

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 C# in a Nutshell is a numidian crane. The numidian crane (Antropoides virgo) is also called the demoiselle crane because of its grace and symmetry. This species of crane is native to Europe and Asia and migrates to India, Pakistan, and northeast Africa in the winter.

Though numidian cranes are the smallest cranes, they defend their territories as aggressively as other crane species, using their loud voices to warn others of trespassing. If necessary, they will fight. Numidian cranes nest in uplands rather than wetlands and will even live in the desert if there is water within 200 to 500 meters. They sometimes make nests out of pebbles in which to lay their eggs, though more often they will lay eggs directly on the ground, protected only by spotty vegetation.

Numidian cranes are considered a symbol of good luck in some countries and are sometimes even protected by law. Darren Kelly was the production editor, and Mary Brady was the copyeditor for C# in a Nutshell. Matt Hutchinson and Claire Cloutier provided quality control. Interior composition was done by Philip Dangler. Nancy Crumpton wrote the index. Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is an original engraving from the 19th century. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout based on a series design by Nancy Priest. The print version of this book was created by translating the DocBook XML markup of its source files into a set of gtroff macros using a filter developed at O'Reilly & Associates by Norman Walsh. Steve Talbott designed and wrote the underlying macro set on the basis of the GNU troff -gs macros; Lenny Muellner adapted them to XML and implemented the book design. Neil Walls converted some of the files from Microsoft Word to XML. The GNU groff text formatter version 1.11.1 was used to generate PostScript output. The text and heading fonts are ITC Garamond Light and Garamond Book. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. This colophon was written by Linley Dolby.