C# 3.0 in a Nutshell, 3rd Edition
This is a concise yet thorough reference to C# 3.0 programming as implemented in Microsoft's Visual Studio 2008.
C# 3.0 in a Nutshell, 3rd Edition
Chapter 1. Introducing C# and the .NET Framework
Section 1.1. Object Orientation
Section 1.2. Type Safety
Section 1.3. Memory Management
Section 1.4. Platform Support
Section 1.5. C#'s Relationship with the CLR
Section 1.6. The CLR and .NET Framework
Section 1.7. What's New in C# 3.0
Chapter 2. C# Language Basics
Section 2.1. A First C# Program
Section 2.2. Syntax
Section 2.3. Type Basics
Section 2.4. Numeric Types
Section 2.5. Boolean Type and Operators
Section 2.6. Strings and Characters
Section 2.7. Arrays
Section 2.8. Variables and Parameters
Section 2.9. Expressions and Operators
Section 2.10. Statements
Section 2.11. Namespaces
Chapter 3. Creating Types in C#
Section 3.1. Classes
Section 3.2. Inheritance
Section 3.3. The object Type
Section 3.4. Structs
Section 3.5. Access Modifiers
Section 3.6. Interfaces
Section 3.7. Enums
Section 3.8. Nested Types
Section 3.9. Generics
Chapter 4. Advanced C#
Section 4.1. Delegates
Section 4.2. Events
Section 4.3. Lambda Expressions (C# 3.0)
Section 4.4. Anonymous Methods
Section 4.5. try Statements and Exceptions
Section 4.6. Enumeration and Iterators
Section 4.7. Nullable Types
Section 4.8. Operator Overloading
Section 4.9. Extension Methods (C# 3.0)
Section 4.10. Anonymous Types (C# 3.0)
Section 4.11. Attributes
Section 4.12. Unsafe Code and Pointers
Section 4.13. Preprocessor Directives
Section 4.14. XML Documentation
Chapter 5. Framework Overview
Section 5.1. The CLR and Core Framework
Section 5.2. Applied Technologies
Chapter 6. Framework Fundamentals
Section 6.1. String and Text Handling
Section 6.2. Dates and Times
Section 6.3. Dates and Time Zones
Section 6.4. Formatting and Parsing
Section 6.5. Standard Format Strings and Parsing Flags
Section 6.6. Other Conversion Mechanisms
Section 6.7. Working with Numbers
Section 6.8. Enums
Section 6.9. The Guid Struct
Section 6.10. Equality Comparison
Section 6.11. Order Comparison
Section 6.12. Utility Classes
Chapter 7. Collections
Section 7.1. Enumeration
Section 7.2. The ICollection and IList Interfaces
Section 7.3. The Array Class
Section 7.4. Lists, Queues, Stacks, and Sets
Section 7.5. Dictionaries
Section 7.6. Customizable Collections and Proxies
Section 7.7. Plugging in Equality and Order
Chapter 8. LINQ Queries
Section 8.1. Getting Started
Section 8.2. Lambda Queries
Section 8.3. Comprehension Queries
Section 8.4. Deferred Execution
Section 8.5. Subqueries
Section 8.6. Composition Strategies
Section 8.7. Projection Strategies
Section 8.8. Interpreted Queries
Section 8.9. LINQ to SQL
Section 8.10. Building Query Expressions
Chapter 9. LINQ Operators
Section 9.1. Overview
Section 9.2. Filtering
Section 9.3. Projecting
Section 9.4. Joining
Section 9.5. Ordering
Section 9.6. Grouping
Section 9.7. Set Operators
Section 9.8. Conversion Methods
Section 9.9. Element Operators
Section 9.10. Aggregation Methods
Section 9.11. Quantifiers
Section 9.12. Generation Methods
Chapter 10. LINQ to XML
Section 10.1. Architectural Overview
Section 10.2. X-DOM Overview
Section 10.3. Instantiating an X-DOM
Section 10.4. Navigating and Querying
Section 10.5. Updating an X-DOM
Section 10.6. Working with Values
Section 10.7. Documents and Declarations
Section 10.8. Names and Namespaces
Section 10.9. Annotations
Section 10.10. Projecting into an X-DOM
Chapter 11. Other XML Technologies
Section 11.1. XmlReader
Section 11.2. XmlWriter
Section 11.3. Patterns for Using XmlReader/XmlWriter
Section 11.4. XmlDocument
Section 11.5. XPath
Section 11.6. XSD and Schema Validation
Section 11.7. XSLT
Chapter 12. Disposal and Garbage Collection
Section 12.1. IDisposable, Dispose, and Close
Section 12.2. Garbage Collection and Finalizers
Section 12.3. Calling Dispose from a Finalizer
Section 12.4. How the Garbage Collector Works
Section 12.5. Alternatives to Garbage Collection
Chapter 13. Streams and I/O
Section 13.1. Stream Architecture
Section 13.2. Using Streams
Section 13.3. Stream Adapters
Section 13.4. File and Directory Operations
Section 13.5. Compression
Section 13.6. Isolated Storage
Chapter 14. Networking
Section 14.1. Network Architecture
Section 14.2. Addresses and Ports
Section 14.3. URIs
Section 14.4. Request/Response Architecture
Section 14.5. HTTP-Specific Support
Section 14.6. Writing an HTTP Server
Section 14.7. Using FTP
Section 14.8. Using DNS
Section 14.9. Sending Mail with SmtpClient
Section 14.10. Using TCP
Section 14.11. Receiving POP3 Mail with TCP
Chapter 15. Serialization
Section 15.1. Serialization Concepts
Section 15.2. The Data Contract Serializer
Section 15.3. Data Contracts and Collections
Section 15.4. Extending Data Contracts
Section 15.5. The Binary Serializer
Section 15.6. Binary Serialization Attributes
Section 15.7. Binary Serialization with ISerializable
Section 15.8. XML Serialization
Chapter 16. Assemblies
Section 16.1. What's in an Assembly
Section 16.2. Signing an Assembly
Section 16.3. Assembly Names
Section 16.4. The Global Assembly Cache
Section 16.5. Resources and Satellite Assemblies
Section 16.6. Resolving and Loading Assemblies
Section 16.7. Deploying Assemblies Outside the Base Folder
Section 16.8. Packing a Single-File Executable
Section 16.9. Working with Unreferenced Assemblies
Chapter 17. Reflection and Metadata
Section 17.1. Reflecting and Activating Types
Section 17.2. Reflecting and Invoking Members
Section 17.3. Reflecting Assemblies
Section 17.4. Working with Attributes
Section 17.5. Dynamic Code Generation
Section 17.6. Emitting Assemblies and Types
Section 17.7. Emitting Type Members
Section 17.8. Emitting Generic Methods and Types
Section 17.9. Awkward Emission Targets
Section 17.10. Parsing IL
Chapter 18. Security
Section 18.1. Permissions
Section 18.2. Code Access Security
Section 18.3. Running in a Sandbox
Section 18.4. Sandboxing Another Assembly
Section 18.5. Operating System Security
Section 18.6. Identity and Role Security
Section 18.7. Cryptography Overview
Section 18.8. Windows Data Protection
Section 18.9. Hashing
Section 18.10. Symmetric Encryption
Section 18.11. Public Key Encryption and Signing
Chapter 19. Threading
Section 19.1. Threading's Uses and Misuses
Section 19.2. Getting Started
Section 19.3. Asynchronous Delegates
Section 19.4. Synchronization
Section 19.5. Locking
Section 19.6. Thread Safety
Section 19.7. Nonblocking Synchronization
Section 19.8. Signaling with Event Wait Handles
Section 19.9. Signaling with Wait and Pulse
Section 19.10. Interrupt and Abort
Section 19.11. Local Storage
Section 19.12. BackgroundWorker
Section 19.13. ReaderWriterLockSlim
Section 19.14. Timers
Chapter 20. Asynchronous Methods
Section 20.1. Why Asynchronous Methods Exist
Section 20.2. Asynchronous Method Signatures
Section 20.3. Asynchronous Methods Versus Asynchronous Delegates
Section 20.4. Using Asynchronous Methods
Section 20.5. Writing Asynchronous Methods
Section 20.6. Fake Asynchronous Methods
Section 20.7. Alternatives to Asynchronous Methods
Section 20.8. Asynchronous Events
Chapter 21. Application Domains
Section 21.1. Application Domain Architecture
Section 21.2. Creating and Destroying Application Domains
Section 21.3. Using Multiple Application Domains
Section 21.4. Using DoCallBack
Section 21.5. Domains and Threads
Section 21.6. Sharing Data Between Domains
Chapter 22. Integrating with Native DLLs
Section 22.1. Calling into DLLs
Section 22.2. Marshaling Common Types
Section 22.3. Marshaling Classes and Structs
Section 22.4. In and Out Marshaling
Section 22.5. Callbacks from Unmanaged Code
Section 22.6. Simulating a C Union
Section 22.7. Shared Memory
Section 22.8. Mapping a Struct to Unmanaged Memory
Section 22.9. Interop Attribute Reference
Chapter 23. Diagnostics
Section 23.1. Conditional Compilation
Section 23.2. Debug and Trace Classes
Section 23.3. Debugger Integration
Section 23.4. Processes and Process Threads
Section 23.5. StackTrace and StackFrame
Section 23.6. Windows Event Logs
Section 23.7. Performance Counters
Section 23.8. The Stopwatch Class
Chapter 24. Regular Expressions
Section 24.1. Regular Expression Basics
Section 24.2. Quantifiers
Section 24.3. Zero-Width Assertions
Section 24.4. Groups
Section 24.5. Replacing and Splitting Text
Section 24.6. Cookbook Regular Expressions
Section 24.7. Regular Expressions Language Reference
Appendix A. C# Keywords
This book targets intermediate to advanced audiences. No prior knowledge of C# is required, but some general programming experience is necessary. For the beginner, this book complements, rather than replaces, a tutorial-style introduction to programming.
If you're already familiar with C# 2.0, you'll find more than a hundred pages dedicated to LINQ and other new C# 3.0 features. In addition, many other chapters are designed to lift your existing knowledge of C# and the core Framework.
This book is an ideal companion to any of the vast array of books that focus on an applied technology such as WPF, ASP.NET, or WCF. The areas of the language and .NET Framework that such books omit, C# 3.0 in a Nutshell covers in detail—and vice versa.
If you're looking for a book that skims every .NET Framework technology, this is not for you. This book is also unsuitable if you want a replacement for IntelliSense (i.e., the alphabetical listings of types and type members that appeared in previous editions).