C# has changed significantly since it was first introduced. With the many upgraded features, C# is more expressive than ever. However, an in depth understanding is required to get the most out of the language.
If you're a .NET developer, you'll use C# whether you're building an advanced enterprise application or just slamming out a quick app. In C# 5 you can do amazing things with generics, lambda expressions, dynamic typing, LINQ, iterator blocks, and other features.
But first you have to learn it in depth. C# in Depth, Third Edition has been thoroughly revised to cover the features of C# 5, including the subtleties of writing maintainable asynchronous code. You'll see the power of C# in action, learning how to work with high-value features that you'll be glad to have in your toolkit. And you'll learn to avoid hidden pitfalls of C# programming with the help of crystal clear explanations of "behind the scenes" issues.

1 The changing face of C# development
2 Sorting and filtering
3 Handling an absence of data
4 COM and dynamic typing
5 Dissecting the .NET platform
6 Didactic code isn't production code
7 Core foundations - building on C# 1
8 A recipe for simple delegates
9 Combining and removing delegates
10 Type system characteristics
11 When is C# 1's type system not rich enough
12 Value types and reference types
13 Dispelling myths
14 Boxing and unboxing
15 Beyond C# 1 - new features on a solid base
16 Features related to the type system
17 Features related to value types
18 Parameterized typing with generics
19 Simple generics for everyday use
20 Generic types and type parameters
21 Generic methods and reading generic declarations
22 Beyond the basics
23 Type constraints
24 Type inference for type arguments of generic methods
25 Implementing generics
26 The generic comparison interfaces
27 Advanced generics
28 How the JIT compiler handles generics
29 Generic iteration
30 Reflection and generics
31 Limitations of generics in C# and other languages
32 Lack of generic variance
33 Lack of operator constraints or a "numeric" constraint
34 Comparison with C++ templates
35 Comparison with Java generics
36 Saying nothing with nullable types
37 Patterns for representing null values in C# 1
38 System.Nullable_T_ and System.Nullable
39 Boxing Nullable_T_ and unboxing
40 C# 2's syntactic sugar for nullable types
41 Nullable conversions and operators
42 Nullable logic
43 The null coalescing operator
44 Novel uses of nullable types
45 Painless comparisons with the null coalescing operator
46 Fast-tracked delegates
47 Method group conversions
48 Covariance of delegate return types
49 Inline delegate actions with anonymous methods
50 Returning values from anonymous methods
51 Capturing variables in anonymous methods
52 What's the point of captured variables
53 Local variable instantiations
54 Captured variable guidelines and summary
55 Implementing iterators the easy way
56 C# 2 - Simple iterators with yield statements
57 Advanced iterator execution flow
58 Real-life iterator examples
59 Iterating over lines in a file
60 Filtering items lazily using an iterator block and a predicate
61 Pseudo-synchronous code with the Concurrency and Coordination Runtime
62 Concluding C# 2 - the final features
63 Creating a type with multiple files
64 Partial methods-C# 3 only!
65 Static classes
66 Namespace aliases
67 Pragma directives
68 Exposing internal members to selected assemblies
69 Cutting fluff with a smart compiler
70 Implicit typing of local variables
71 Pros and cons of implicit typing
72 Simplified initialization
73 Setting properties on embedded objects
74 Uses of initialization features
75 Anonymous types
76 Projection initializers
77 Lambda expressions and expression trees
78 Preliminaries - Introducing the Func_..._ delegate types
79 Simple examples using List_T_ and events
80 Expression trees
81 Converting C# lambda expressions to expression trees
82 Expression trees at the heart of LINQ
83 Changes to type inference and overload resolution
84 Two-phase type inference
85 Picking the right overloaded method
86 Extension methods
87 Extension method syntax
88 Extension method discovery
89 Extension methods in .NET 3.5
90 Interlude - haven't we seen the Where method before
91 Business examples involving chaining
92 Usage ideas and guidelines
93 Query expressions and LINQ to Objects
94 Fundamental concepts in LINQ
95 Simple beginnings - selecting elements
96 Range variables and nontrivial projections
97 Filtering and ordering a sequence
98 Let clauses and transparent identifiers
99 Joins
100 Group joins with join...into clauses
101 Groupings and continuations
102 Choosing between query expressions and dot notation
103 LINQ beyond collections
104 Initial queries
105 Translations using IQueryable and IQueryProvider
106 Gluing expressions together - the Queryable extension methods
107 LINQ-friendly APIs and LINQ to XML
108 Declarative construction
109 Flattened query operators
110 Replacing LINQ to Objects with Parallel LINQ
111 Introducing ParallelEnumerable, ParallelQuery, and AsParallel
112 Inverting the query model with LINQ to Rx
113 Querying observables
114 Extending LINQ to Objects
115 Sample extension - selecting a random element
116 Minor changes to simplify code
117 Optional parameters
118 Named arguments
119 Putting the two together
120 Improvements for COM interoperability
121 Calling named indexers
122 Generic variance for interfaces and delegates
123 Using variance in interfaces
124 Complex situations
125 Restrictions and notes
126 Teeny tiny changes to locking and field-like events
127 Dynamic binding in a static language
128 When is dynamic typing useful, and why
129 The five-minute guide to dynamic
130 Examples of dynamic typing
131 Dynamic languages such as IronPython
132 Dynamic typing in purely managed code
133 Duck typing
134 Looking behind the scenes
135 DLR core concepts
136 How the C# compiler handles dynamic
137 The C# compiler gets even smarter
138 Restrictions on dynamic code
139 Implementing dynamic behavior
140 Using DynamicObject
141 Overriding TryXXX methods
142 Implementing IDynamicMetaObjectProvider
143 Asynchrony with async_await
144 First encounters of the asynchronous kind
145 Thinking about asynchrony
146 Syntax and semantics
147 The awaitable pattern
148 The flow of await expressions
149 Returning from an async method
150 Exceptions
151 Asynchronous anonymous functions
152 Implementation details - compiler transformation
153 Structure of the skeleton method
154 One entry point to rule them all
155 Keeping track of a stack
156 Using async_await effectively
157 Composing async operations
158 Unit testing asynchronous code
159 The awaitable pattern redux
160 C# 5 bonus features and closing thoughts
161 Logging