Notes

There are places in the book where there is more to say on a particular topic, but doing so in the printed text would be inappropriate. Sometimes these notes have been based on comments from the technical reviewer (Eric Lippert) and sometimes they're just my own additional thoughts. This page lists all the notes - both errors and extra comments - grouped by chapter. I hope you'll find them interesting and useful. Clicking on a chapter name will show you all the notes for that chapter; clicking on an individual note will show you just that one. Alternatively, you can see all the notes on one page.

Chapter 1 (The changing face of C# development)

• 1.1.1: Productizing Product
• 1.1.2: Implicit casting in foreach loops over generic collections
• 1.1.2: Nullity checking in comparisons and defensive coding
• 1.1.2: Why return a List<T> from GetSampleProducts?
• 1.1.3: List.ForEach - friend or foe?
• 1.2.1: Why did Sun create Java?
• 1.2.3: Slow adoption rates: sad or not?
• 1.2.5: Is IronPython really a Trojan horse?
• 1.4.2: Are using directives really harmless?

Chapter 2 (Core foundations: building on C# 1)

• 2.2.1: Strong vs weak typing
• 2.2.1: Terminology for what is currently "static"
• 2.2.1: Static, dynamic and middle grounds
• 2.2.1: More benefits on static typing
• 2.3.3: When is it appropriate to write your own struct?
• 2.3.4: Boxing copies values
• 2.3.4: The small cost of boxing
• 2.4.2: How many anonymous types?

Chapter 3 (Parameterized typing with generics)

• 3.1: More persuasion on the benefits of generics
• 3.2.1: Modifying the results of an indexer
• 3.2.1: Regex vs String.Split
• 3.2.3: List.ConvertAll - badly named?
• 3.2.3: MakeList revisited
• 3.2.3: Consider ArrayList and Hashtable to be deprecated
• 3.3.1: Derivation type constraints and implicit reference conversions
• 3.3.1: Derivation type constraints: specification terminology
• 3.3.1: Naked constraints!
• 3.3.2: Simple spec != simple implementation
• 3.3.2: Activator.CreateInstance<T>()
• 3.3.3: default(...) is an operator
• 3.3.3: Pair - class or struct?
• 3.3.3: XOR for hashcodes
• 3.4.3: Terminology: one interface "extending" another
• 3.5.1: Not quite a Sieve of Eratosthanes
• 3.5.2: ICloneable
• 3.5.4: The naming of SortedList/SortedDictionary
• 3.6.1: Lions and tigers and bears, oh my!
• 3.6.2: Complex<Complex<double>>
• 3.6.2: A new solution to generic operators
• 3.6.2: A generic Complex type
• 3.6.5: Java's interesting approach to generics

Chapter 4 (Saying nothing with nullable types)

• 4.1.2: Magic value traps
• 4.2.1: Mutable value types in the framework
• 4.2.3: Equality of nulls
• 4.3.1: Non-nullable reference types
• 4.3.2: Happy birthday, Donald Knuth
• 4.3.3: Lifted or not?
• 4.3.3: Unexpected conversion

Chapter 5 (Fast-tracked delegates)

• 5.0 (Introduction): Foresight or luck?
• 5.4.2: Predicate<T> in LINQ? Not so much...
• 5.5.1: Was Scheme the first language to support closures?
• 5.5.4: Stacks, heaps, and caring too much
• 5.5.7: Accidental capture of expensive resources

Chapter 6 (Implementing iterators the easy way)

• 6.2.2: No code is executed until MoveNext is called
• 6.2.3: Finally blocks in iterators
• 6.2.3: Why would you use a finally block in an iterator?
• 6.2.4: Why the <> in the names?
• 6.3.2: Differences in design in MiscUtil
• 6.3.3: The bug (fixed before printing) in listing 6.7
• 6.4: Coroutines and continuation passing style
• n/a - never mentioned!: Easy-to-write-but-inefficient recursive iterators

Chapter 7 (Concluding C# 2: the final features)

• 7.1.3: Partial method corner cases
• 7.2: Things the compiler won't spot
• 7.2: Making a class static shows your intention
• 7.3: Choices of defaults
• 7.3: Private - explicit or implicit?
• 7.5.1: Octal literals, warning pragmas, and \x escapes

Chapter 8 (Cutting fluff with a smart compiler)

• 8.1: Automatic properties - easy to implement (which doesn't mean "cheap")
• 8.1: "Fat" properties?
• 8.1: Why exposing properties rather than fields is best practice
• 8.2.1: "var" isn't "variant" - "object" is!
• 8.2.2: Additional (and inconsequential) restriction on implicit typing
• 8.2.3: Eric on the pros and cons of implicit typing
• 8.3.1: Town or city?
• 8.3.4: Fear is not the enemy...
• 8.3.4: Ages vs dates of birth
• 8.5.1: Introducing LINQ
• 8.5.2: Anonymous types in VB, and immutability

Chapter 9 (Lambda expressions and expression trees)

• 9.1.5: Another potential shortcut - lambdas with no arguments
• 9.2.1: No need for a lambda!
• 9.2.2: Security in lambdas
• 9.3.1: Expression trees and parameters
• 9.3.3: Lambda to expression tree conversion restrictions
• 9.3.3: infoof and tricks with expression trees
• 9.4.3: Hindley-Milner type inference

Chapter 10 (Extension methods)

• 10.2: Extension delegates
• 10.2.4: Null references vs null values
• 10.3.1: Features of Enumerable.Range
• 10.3.1: Detecting performance problems
• 10.3.2: Efficiency of examples
• 10.4.1: Extending the world... carefully

Chapter 11 (Query expressions and LINQ to Objects)

• 11.1.1: What does LINQ mean?
• 11.1.2: Deferred execution and iterator blocks
• 11.1.2: Truly silly query expressions
• 11.1.3: Naming of imaginary companies and products
• 11.1.3: Defect severities
• 11.3.3: Explicitly specifying an ascending order
• 11.5.1: Equijoins
• 11.5.1: Scoping of key selectors in joins
• 11.6.1: Copy editors get notes too

Chapter 12 (LINQ beyond collections)

• 12.1.2: Disposing of DataContexts

Chapter 13 (Elegant code in the new era)

• 13.0 (Introduction): Cheap vs good
• 13.1.1: There's more to functional coding than functions as first class data
• 13.1.1: F#, IronRuby etc - first class citizens?
• 13.1.2: Feature in a dynamic language != dynamic language feature
• 13.2: Inheritance - a single-shot opportunity for specialization
• 13.4: Massively parallel - but at different powers?