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 …
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.
Inside:
PART 1 PREPARING FOR THE JOURNEY
Chapter 1. The changing face of C# development
Chapter 1. Sorting and filtering
Chapter 1. Handling an absence of data
Chapter 1. COM and dynamic typing
Chapter 1. Dissecting the .NET platform
Chapter 1. Didactic code isn’t production code
Chapter 2. Core foundations: building on C# 1
Chapter 2. A recipe for simple delegates
Chapter 2. Combining and removing delegates
Chapter 2. Type system characteristics
Chapter 2. When is C# 1’s type system not rich enough?
Chapter 2. Value types and reference types
Chapter 2. Dispelling myths
Chapter 2. Boxing and unboxing
Chapter 2. Beyond C# 1: new features on a solid base
Chapter 2. Features related to the type system
Chapter 2. Features related to value types
PART 2 C# 2: SOLVING THE ISSUES OF C# 1
Chapter 3. Parameterized typing with generics
Chapter 3. Simple generics for everyday use
Chapter 3. Generic types and type parameters
Chapter 3. Generic methods and reading generic declarations
Chapter 3. Beyond the basics
Chapter 3. Type constraints
Chapter 3. Type inference for type arguments of generic methods
Chapter 3. Implementing generics
Chapter 3. The generic comparison interfaces
Chapter 3. Advanced generics
Chapter 3. How the JIT compiler handles generics
Chapter 3. Generic iteration
Chapter 3. Reflection and generics
Chapter 3. Limitations of generics in C# and other languages
Chapter 3. Lack of generic variance
Chapter 3. Lack of operator constraints or a “numeric” constraint
Chapter 3. Comparison with C++ templates
Chapter 3. Comparison with Java generics
Chapter 4. Saying nothing with nullable types
Chapter 4. Patterns for representing null values in C# 1
Chapter 4. System.Nullable and System.Nullable
Chapter 4. Boxing Nullable and unboxing
Chapter 4. C# 2’s syntactic sugar for nullable types
Chapter 4. Nullable conversions and operators
Chapter 4. Nullable logic
Chapter 4. The null coalescing operator
Chapter 4. Novel uses of nullable types
Chapter 4. Painless comparisons with the null coalescing operator
Chapter 5. Fast-tracked delegates
Chapter 5. Method group conversions
Chapter 5. Covariance of delegate return types
Chapter 5. Inline delegate actions with anonymous methods
Chapter 5. Returning values from anonymous methods
Chapter 5. Capturing variables in anonymous methods
Chapter 5. What’s the point of captured variables?
Chapter 5. Local variable instantiations
Chapter 5. Captured variable guidelines and summary
Chapter 6. Implementing iterators the easy way
Chapter 6. C# 2: Simple iterators with yield statements
Chapter 6. Advanced iterator execution flow
Chapter 6. Real-life iterator examples
Chapter 6. Iterating over lines in a file
Chapter 6. Filtering items lazily using an iterator block and a predicate
Chapter 6. Pseudo-synchronous code with the Concurrency and Coordination Runtime
Chapter 7. Concluding C# 2: the final features
Chapter 7. Creating a type with multiple files
Chapter 7. Partial methods—C# 3 only!
Chapter 7. Static classes
Chapter 7. Namespace aliases
Chapter 7. Pragma directives
Chapter 7. Exposing internal members to selected assemblies
PART 3 C# 3: REVOLUTIONIZING DATA ACCESS
Chapter 8. Cutting fluff with a smart compiler
Chapter 8. Implicit typing of local variables
Chapter 8. Pros and cons of implicit typing
Chapter 8. Simplified initialization
Chapter 8. Setting properties on embedded objects
Chapter 8. Uses of initialization features
Chapter 8. Anonymous types
Chapter 8. Projection initializers
Chapter 9. Lambda expressions and expression trees
Chapter 9. Preliminaries: Introducing the Func…> delegate types
Chapter 9. Simple examples using List and events
Chapter 9. Expression trees
Chapter 9. Converting C# lambda expressions to expression trees
Chapter 9. Expression trees at the heart of LINQ
Chapter 9. Changes to type inference and overload resolution
Chapter 9. Two-phase type inference
Chapter 9. Picking the right overloaded method
Chapter 10. Extension methods
Chapter 10. Extension method syntax
Chapter 10. Extension method discovery
Chapter 10. Extension methods in .NET 3.5
Chapter 10. Interlude: haven’t we seen the Where method before?
Chapter 10. Business examples involving chaining
Chapter 10. Usage ideas and guidelines
Chapter 11. Query expressions and LINQ to Objects
Chapter 11. Fundamental concepts in LINQ
Chapter 11. Simple beginnings: selecting elements
Chapter 11. Range variables and nontrivial projections
Chapter 11. Filtering and ordering a sequence
Chapter 11. Let clauses and transparent identifiers
Chapter 11. Joins
Chapter 11. Group joins with join…into clauses
Chapter 11. Groupings and continuations
Chapter 11. Choosing between query expressions and dot notation
Chapter 12. LINQ beyond collections
Chapter 12. Initial queries
Chapter 12. Translations using IQueryable and IQueryProvider
Chapter 12. Gluing expressions together: the Queryable extension methods
Chapter 12. LINQ-friendly APIs and LINQ to XML
Chapter 12. Declarative construction
Chapter 12. Flattened query operators
Chapter 12. Replacing LINQ to Objects with Parallel LINQ
Chapter 12. Introducing ParallelEnumerable, ParallelQuery, and AsParallel
Chapter 12. Inverting the query model with LINQ to Rx
Chapter 12. Querying observables
Chapter 12. Extending LINQ to Objects
Chapter 12. Sample extension: selecting a random element
PART 4 C# 4: PLAYING NICELY WITH OTHERS
Chapter 13. Minor changes to simplify code
Chapter 13. Optional parameters
Chapter 13. Named arguments
Chapter 13. Putting the two together
Chapter 13. Improvements for COM interoperability
Chapter 13. Calling named indexers
Chapter 13. Generic variance for interfaces and delegates
Chapter 13. Using variance in interfaces
Chapter 13. Complex situations
Chapter 13. Restrictions and notes
Chapter 13. Teeny tiny changes to locking and field-like events
Chapter 14. Dynamic binding in a static language
Chapter 14. When is dynamic typing useful, and why?
Chapter 14. The five-minute guide to dynamic
Chapter 14. Examples of dynamic typing
Chapter 14. Dynamic languages such as IronPython
Chapter 14. Dynamic typing in purely managed code
Chapter 14. Duck typing
Chapter 14. Looking behind the scenes
Chapter 14. DLR core concepts
Chapter 14. How the C# compiler handles dynamic
Chapter 14. The C# compiler gets even smarter
Chapter 14. Restrictions on dynamic code
Chapter 14. Implementing dynamic behavior
Chapter 14. Using DynamicObject
Chapter 14. Overriding TryXXX methods
Chapter 14. Implementing IDynamicMetaObjectProvider
PART 5 C# 5: ASYNCHRONY MADE SIMPLE
Chapter 15. Asynchrony with async/await
Chapter 15. First encounters of the asynchronous kind
Chapter 15. Thinking about asynchrony
Chapter 15. Syntax and semantics
Chapter 15. The awaitable pattern
Chapter 15. The flow of await expressions
Chapter 15. Returning from an async method
Chapter 15. Exceptions
Chapter 15. Asynchronous anonymous functions
Chapter 15. Implementation details: compiler transformation
Chapter 15. Structure of the skeleton method
Chapter 15. One entry point to rule them all
Chapter 15. Keeping track of a stack
Chapter 15. Using async/await effectively
Chapter 15. Composing async operations
Chapter 15. Unit testing asynchronous code
Chapter 15. The awaitable pattern redux
Chapter 16. C# 5 bonus features and closing thoughts
Chapter 16. Logging