1. Chapter 1 C# and .NET Programming

   1. C# and .NET

   2. The .NET Platform

   3. The .NET Framework

   4. The C# Language

   5. The Structure of C# Applications

   6. The Development Environment

2. Chapter 2 Getting Started with C#

   1. What's in a Program?

   2. Your First Program: Hello World

   3. Examining Your First Program

3. Chapter 3 Object-Oriented Programming

   1. Creating Models

   2. Classes and Objects

   3. Defining a Class

   4. Class Relationships

   5. The Three Pillars of Object-Oriented Programming

   6. Encapsulation

   7. Specialization

   8. Polymorphism

   9. Object-Oriented Analysis and Design

4. Chapter 4 Visual Studio .NET

   1. Start Page

   2. Inside the Integrated Development Environment (IDE)

   3. IntelliSense

   4. Building and Running

   5. For More Information

5. Chapter 5 C# Language Fundamentals

   1. Types

   2. Variables

   3. Definite Assignment

   4. Constants

   5. Strings

   6. Statements

   7. Expressions

   8. Whitespace

6. Chapter 6 Branching

   1. Unconditional Branching Statements

   2. Conditional Branching Statements

   3. Iteration (Looping) Statements

7. Chapter 7 Operators

   1. The Assignment Operator (=)

   2. Mathematical Operators

   3. Increment and Decrement Operators

   4. Relational Operators

8. Chapter 8 Classes and Objects

   1. Defining Classes

   2. Method Arguments

   3. Constructors

   4. Initializers

   5. Copy Constructors

   6. The this Keyword

   7. Static and Instance Members

   8. Destroying Objects

9. Chapter 9 Inside Methods

   1. Overloading Methods

   2. Encapsulating Data with Properties

   3. Returning Multiple Values

10. Chapter 10 Basic Debugging

    1. Setting a Breakpoint

    2. The Call Stack

11. Chapter 11 Inheritance and Polymorphism

    1. Specialization and Generalization

    2. Inheritance

    3. Polymorphism

    4. Abstract Classes

    5. Sealed Classes

    6. The Root of All Classes: Object

    7. Boxing and Unboxing Types

12. Chapter 12 Operator Overloading

    1. Using the operator Keyword

    2. Creating Useful Operators

    3. Logical Pairs

    4. Conversion Operators

13. Chapter 13 Structs

    1. Defining a Struct

14. Chapter 14 Interfaces

    1. Implementing an Interface

    2. Implementing More Than One Interface

    3. Casting to an Interface

    4. Extending Interfaces

    5. Combining Interfaces

    6. Overriding Interface Implementations

    7. Explicit Interface Implementation

15. Chapter 15 Arrays

    1. Arrays

    2. Multidimensional Arrays

    3. System.Array

    4. Indexers

16. Chapter 16 Collection Interfaces and Types

    1. The Collection Interfaces

    2. Array Lists

    3. Queues

    4. Stacks

    5. Copying from a Collection Type to an Array

17. Chapter 17 Strings

    1. Creating Strings

    2. Manipulating Strings

    3. Regular Expressions

    4. The Regex Class

18. Chapter 18 Throwing and Catching Exceptions

    1. Throwing Exceptions

    2. Searching for an Exception Handler

    3. The throw Statement

    4. The try and catch Statements

    5. How the Call Stack Works

    6. Creating Dedicated catch Statements

    7. The finally Statement

    8. Exception Class Methods and Properties

    9. Custom Exceptions

19. Chapter 19 Delegates and Events

    1. Delegates

    2. Multicasting

    3. Events

20. Chapter Afterword

    1. Where to Go from Here

    2. Advanced Topics in C#

    3. Web (ASP.NET) Programming

    4. Windows Forms Programming

    5. Other Resources

1. C# Keywords

2. 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 Learning C# is a goldfish. Goldfish are freshwater fish popular in aquariums and ponds. Though they are native to China, goldfish are one of the most common household pets all over the world. They were first domesticated centuries ago when it was discovered that carp, which are usually olivecolored, can have color mutations causing some of their scales to be red or gold. These mutated fish were bred to create many different varieties of goldfish, including the oranda, ryukin, lionhead, pearlscale, telescoped eye, and bubble eye types.

Most commercial goldfish are scaled and have metallic red, gold, white, silver, or black sheens. But the more rare "scaleless" fish have transparent scales, making them appear bright red, blue, purple, or calico-patterned. Though the wild carp from which goldfish are bred can measure up to 16 inches in length, most commercial goldfish are between 1 and 4 inches long. Darren Kelly was the production editor, Catherine Morris was the copyeditor, and Sheryl Avruch was the proofreader for Learning C#. Tatiana Apandi Diaz and Claire Cloutier provided quality control. Interior composition was done by Philip Dangler and Genevieve d'Entremont. Angela Howard wrote the index.

Hanna Dyer designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. 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 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 Lucas-Font'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 Linley Dolby.