Books & Videos

C# 3.0 in a Nutshell, 3rd Edition

A Desktop Quick Reference

By Ben Albahari, Joseph Albahari

Publisher: O'Reilly Media

Release Date: February 2009

Pages: 864

Read on Safari with a 10-day trial

Start your free trial now Buy on Amazon

Where’s the cart? Now you can get everything on Safari. To purchase books, visit Amazon or your favorite retailer. Questions? See our FAQ or contact customer service:

1-800-889-8969 / 707-827-7019
support@oreilly.com

Download Example Code

View/Submit Errata

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 gets right to the point, covering the essentials of language syntax and usage as well as the parts of the .NET base class libraries you need to build working applications. But unlike earlier editions, this book is now organized entirely around concepts and use cases, providing greater depth and readability.

C# 3.0 introduces the most significant enhancements yet to the programming language, and C# 3.0 in a Nutshell delves deep into the subject while assuming minimal prior knowledge of C#-making it accessible to anyone with a reasonable background in programming. In addition to the language, the book covers the .NET CLR and the core Framework assemblies, along with the unified querying syntax called Language Integrated Query (LINQ), which bridges the traditional divide between programs and their data sources.

Free of clutter and long introductions, this book provides a map of C# 3.0 knowledge in a succinct and unified style:

Opening chapters concentrate purely on C#, starting with the basics of syntax, types and variables, and finishing with advanced topics such as unsafe code and preprocessor directives

Later chapters cover the core .NET 3.5 Framework, including such topics as LINQ, XML, collections, I/O and networking, memory management, reflection, attributes, security, threading, application domains and native interoperability

Designed as a handbook for daily use, C# 3.0 in a Nutshell 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, this one covers in detail.

Chapter 1 Introducing C# and the .NET Framework
1. Object Orientation
2. Type Safety
3. Memory Management
4. Platform Support
5. C#'s Relationship with the CLR
6. The CLR and .NET Framework
7. What's New in C# 3.0
Chapter 2 C# Language Basics
1. A First C# Program
2. Syntax
3. Type Basics
4. Numeric Types
5. Boolean Type and Operators
6. Strings and Characters
7. Arrays
8. Variables and Parameters
9. Expressions and Operators
10. Statements
11. Namespaces
Chapter 3 Creating Types in C#
1. Classes
2. Inheritance
3. The object Type
4. Structs
5. Access Modifiers
6. Interfaces
7. Enums
8. Nested Types
9. Generics
Chapter 4 Advanced C#
1. Delegates
2. Events
3. Lambda Expressions (C# 3.0)
4. Anonymous Methods
5. try Statements and Exceptions
6. Enumeration and Iterators
7. Nullable Types
8. Operator Overloading
9. Extension Methods (C# 3.0)
10. Anonymous Types (C# 3.0)
11. Attributes
12. Unsafe Code and Pointers
13. Preprocessor Directives
14. XML Documentation
Chapter 5 Framework Overview
1. The CLR and Core Framework
2. Applied Technologies
Chapter 6 Framework Fundamentals
1. String and Text Handling
2. Dates and Times
3. Dates and Time Zones
4. Formatting and Parsing
5. Standard Format Strings and Parsing Flags
6. Other Conversion Mechanisms
7. Working with Numbers
8. Enums
9. The Guid Struct
10. Equality Comparison
11. Order Comparison
12. Utility Classes
Chapter 7 Collections
1. Enumeration
2. The ICollection and IList Interfaces
3. The Array Class
4. Lists, Queues, Stacks, and Sets
5. Dictionaries
6. Customizable Collections and Proxies
7. Plugging in Equality and Order
Chapter 8 LINQ Queries
1. Getting Started
2. Lambda Queries
3. Comprehension Queries
4. Deferred Execution
5. Subqueries
6. Composition Strategies
7. Projection Strategies
8. Interpreted Queries
9. LINQ to SQL
10. Building Query Expressions
Chapter 9 LINQ Operators
1. Overview
2. Filtering
3. Projecting
4. Joining
5. Ordering
6. Grouping
7. Set Operators
8. Conversion Methods
9. Element Operators
10. Aggregation Methods
11. Quantifiers
12. Generation Methods
Chapter 10 LINQ to XML
1. Architectural Overview
2. X-DOM Overview
3. Instantiating an X-DOM
4. Navigating and Querying
5. Updating an X-DOM
6. Working with Values
7. Documents and Declarations
8. Names and Namespaces
9. Annotations
10. Projecting into an X-DOM
Chapter 11 Other XML Technologies
1. XmlReader
2. XmlWriter
3. Patterns for Using XmlReader/XmlWriter
4. XmlDocument
5. XPath
6. XSD and Schema Validation
7. XSLT
Chapter 12 Disposal and Garbage Collection
1. IDisposable, Dispose, and Close
2. Garbage Collection and Finalizers
3. Calling Dispose from a Finalizer
4. How the Garbage Collector Works
5. Alternatives to Garbage Collection
Chapter 13 Streams and I/O
1. Stream Architecture
2. Using Streams
3. Stream Adapters
4. File and Directory Operations
5. Compression
6. Isolated Storage
Chapter 14 Networking
1. Network Architecture
2. Addresses and Ports
3. URIs
4. Request/Response Architecture
5. HTTP-Specific Support
6. Writing an HTTP Server
7. Using FTP
8. Using DNS
9. Sending Mail with SmtpClient
10. Using TCP
11. Receiving POP3 Mail with TCP
Chapter 15 Serialization
1. Serialization Concepts
2. The Data Contract Serializer
3. Data Contracts and Collections
4. Extending Data Contracts
5. The Binary Serializer
6. Binary Serialization Attributes
7. Binary Serialization with ISerializable
8. XML Serialization
Chapter 16 Assemblies
1. What's in an Assembly
2. Signing an Assembly
3. Assembly Names
4. The Global Assembly Cache
5. Resources and Satellite Assemblies
6. Resolving and Loading Assemblies
7. Deploying Assemblies Outside the Base Folder
8. Packing a Single-File Executable
9. Working with Unreferenced Assemblies
Chapter 17 Reflection and Metadata
1. Reflecting and Activating Types
2. Reflecting and Invoking Members
3. Reflecting Assemblies
4. Working with Attributes
5. Dynamic Code Generation
6. Emitting Assemblies and Types
7. Emitting Type Members
8. Emitting Generic Methods and Types
9. Awkward Emission Targets
10. Parsing IL
Chapter 18 Security
1. Permissions
2. Code Access Security
3. Running in a Sandbox
4. Sandboxing Another Assembly
5. Operating System Security
6. Identity and Role Security
7. Cryptography Overview
8. Windows Data Protection
9. Hashing
10. Symmetric Encryption
11. Public Key Encryption and Signing
Chapter 19 Threading
1. Threading's Uses and Misuses
2. Getting Started
3. Asynchronous Delegates
4. Synchronization
5. Locking
6. Thread Safety
7. Nonblocking Synchronization
8. Signaling with Event Wait Handles
9. Signaling with Wait and Pulse
10. Interrupt and Abort
11. Local Storage
12. BackgroundWorker
13. ReaderWriterLockSlim
14. Timers
Chapter 20 Asynchronous Methods
1. Why Asynchronous Methods Exist
2. Asynchronous Method Signatures
3. Asynchronous Methods Versus Asynchronous Delegates
4. Using Asynchronous Methods
5. Writing Asynchronous Methods
6. Fake Asynchronous Methods
7. Alternatives to Asynchronous Methods
8. Asynchronous Events
Chapter 21 Application Domains
1. Application Domain Architecture
2. Creating and Destroying Application Domains
3. Using Multiple Application Domains
4. Using DoCallBack
5. Domains and Threads
6. Sharing Data Between Domains
Chapter 22 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. Shared Memory
8. Mapping a Struct to Unmanaged Memory
9. Interop Attribute Reference
Chapter 23 Diagnostics
1. Conditional Compilation
2. Debug and Trace Classes
3. Debugger Integration
4. Processes and Process Threads
5. StackTrace and StackFrame
6. Windows Event Logs
7. Performance Counters
8. The Stopwatch Class
Chapter 24 Regular Expressions
1. Regular Expression Basics
2. Quantifiers
3. Zero-Width Assertions
4. Groups
5. Replacing and Splitting Text
6. Cookbook Regular Expressions
7. Regular Expressions Language Reference

Appendix A C# Keywords
Appendix B Namespace-to-Assembly Reference
Colophon

Books & Videos

C# 3.0 in a Nutshell, 3rd Edition

A Desktop Quick Reference

Read on Safari with a 10-day trial

Table of Contents

Chapter 1 Introducing C# and the .NET Framework

Object Orientation

Type Safety

Memory Management

Platform Support

C#'s Relationship with the CLR

The CLR and .NET Framework

What's New in C# 3.0

Chapter 2 C# Language Basics

A First C# Program

Syntax

Type Basics

Numeric Types

Boolean Type and Operators

Strings and Characters

Arrays

Variables and Parameters

Expressions and Operators

Statements

Namespaces

Chapter 3 Creating Types in C#

Classes

Inheritance

The object Type

Structs

Access Modifiers

Interfaces

Enums

Nested Types

Generics

Chapter 4 Advanced C#

Delegates

Events

Lambda Expressions (C# 3.0)

Anonymous Methods

try Statements and Exceptions

Enumeration and Iterators

Nullable Types

Operator Overloading

Extension Methods (C# 3.0)

Anonymous Types (C# 3.0)

Attributes

Unsafe Code and Pointers

Preprocessor Directives

XML Documentation

Chapter 5 Framework Overview

The CLR and Core Framework

Applied Technologies

Chapter 6 Framework Fundamentals

String and Text Handling

Dates and Times

Dates and Time Zones

Formatting and Parsing

Standard Format Strings and Parsing Flags

Other Conversion Mechanisms

Working with Numbers

Enums

The Guid Struct

Equality Comparison

Order Comparison

Utility Classes

Chapter 7 Collections

Enumeration

The ICollection and IList Interfaces

The Array Class

Lists, Queues, Stacks, and Sets

Dictionaries

Customizable Collections and Proxies

Plugging in Equality and Order

Chapter 8 LINQ Queries

Getting Started

Lambda Queries

Comprehension Queries

Deferred Execution

Subqueries