Errata

text refers to the "Test" class in the code on page 15.

second line of text in the paragraph: "the Test class could not access it."

in the code on page 15, there is no Test class - the class is called "Program"

Note from the Author or Editor:
In the code sample, change "class Program" to "class Test".

Instead of 'goto case-constant', it should be 'goto case case-constant', as correctly stated a few lines before.

Return type for get_CurrentPrice should be decimal, not int.

Note from the Author or Editor:
Change "int" to "decimal" in first line of first code listing on page 71

In the list of Object members, it should be:

protected virtual void Finalize();

instead of:

protected override void Finalize();

In the example code, "class GenericClass<T> where..." should read "class GenericClass<T,U> where..."

The event does not fit to the example.

False:
public event ProgressReporter Progress;

Right:
public event EventHandler PriceChanged;

Note from the Author or Editor:
In the code listing in the sidebar "How Do Events Work on the Inside?", the word "ProgressReporter" should be replaced with "EventHandler".

The set function in the Color property is technically correct, but I think it would not behave as expected. Instead of:

set { color = Color == parent.Color ? (Color)null : value; }

I think it should be:

set { color = value == parent.Color ? (Color)null : value; }

In the 'Null Coalescing operator' section, it is stated that the difference between using ?? and calling GetValueOrDefault with an explicit default value is that "the expression passed to GetValueOrDefault is never evaluated if the variable is not null".
This is the other way around: the expression to the right of the ?? operator is not evaluated if the left part is not null, but the expression passed to GetValueOrDefault is always evaluated.

--> should become 'the expression passed to the right of the ?? operator is never evaluated if the variable is not null'.

Note from the Author or Editor:
Change "expression passed to GetValueOrDefault" to "expression for the default value".

Console.WriteLine (s); // -1

should be:

Console.WriteLine (i); // -1

The conversion from dynamic 'expressions' to other types is no longer an assignment conversion but an implicit conversion. See Chris Burrows' blog post on 1 April 2010 (http://blogs.msdn.com/b/cburrows/) for details of the change.

Note from the Author or Editor:
Sure: remove the footnote from that page

In the code example:

int i = 1;
dynamic d = i;
int j = d;

According to the next paragraph that provides description of the example, declaration of "j" variable should be of "long" type.

Note from the Author or Editor:
Change "int j" to "long j".

The following example is used to illustrate the fact that casting a dynamic expression to a static type yield a static expression:

dynamic x = 2;
var y = (int)2;

However, '2' is not a dynamic expression, and the cast adds nothing. The second line of the example probably should have been:

var y = (int)x;

Note from the Author or Editor:
Agree.

The last line of code (declaring j) should have type long, otherwise the following comment "The preceding example worked because an int is implicitly convertible to a long." makes no sense.

Note from the Author or Editor:
Page 165, section "Dyanmic Conversions", first code listing.

In last line of code listing, int should be changed to long so that it reads:

long j = d;

"The compiler will not incorporate..." should be "The compiler will only incorporate...".

The ASCII set is the first 128 (0-127) characters of the Unicode set, not the first 127.

Note from the Author or Editor:
This is on page 203 in the printed edition.

In the IEnumerable<T> and IDisposable section on page 266, I think all instances of IEnumerable<T> are supposed to be replaced with IEnumerator<T>. At least, that's what makes the most sense in context of the previous section (IEnumerable<T> doesn't inherit IDisposable, IEnumerator<T> does).

Note from the Author or Editor:
Change "IEnumerable<T> implements IDisposable..." to "IEnumerator<T> implements IDisposable".

Default ValueType.GetHashCode() uses only the first field of the struct for the hash value. Demonstrated:

using System;

struct Test
{
public int Num;
public string Str;
}

static class Program
{
static void Main()
{
Test t = new Test { Num = 10, Str = "" };
Console.WriteLine( t.GetHashCode() );
t.Str = "Test";
Console.WriteLine( t.GetHashCode() );
}
}

Reverse order of the fields, and different hash values result.

Note from the Author or Editor:
Replace:

"The default for structs simply performs a bitwise exclusive OR on each of the fields, which typically generates more duplicate codes than if your wrote the algorithm yourself"

With:

"The default implementation for structs is at the discretion of the runtime and may be based on every field in the struct."

Tom, Dick and Harry are not variables (like names), but string literals. So they should be "Tom", "Dick" and "Harry".

I think Distinct actually has an overload that accepts an equality comparer that can be used instead of the default one.

Note from the Author or Editor:
Change 'Only the default equality comparer can be used for equality comparison' to 'You can optionally pass in a custom equality comparer.'

The explanation says that we want to filter out groups that have fewer than five files in them, so the filter should be:
where grouping.Count() >= 5
instead of:
where grouping.Count() < 5

original sentence:
XName also overloads the + operation, allowing you to combine a namespace and name without using braces:

shoule be:
XNamespace also overloads the + operation, allowing you to combine a namespace and name into XName without using braces:

reference:
Type: System.Xml.Linq.XNamespace
public static XName operator +(XNamespace ns, string localName)

Note from the Author or Editor:
Should be:

XNamespace also overloads the + operator, allowing you to combine a namespace and name into an XName without using braces:

"The default value for CloseInput and CloseOutput is true."

This should be...

"The default value for CloseInput and CloseOutput is false."

(last code segment at the bottom of 467, 4th ed):

XDocument doc = XDocument.Load( ...
Xelement e = e.XPathSelectElement( ...

Last code line should be
Xelement e = doc.XPathSelectElement( ...

Note from the Author or Editor:
Replace "XElement e = e" with "XElement e = doc".

The last sentence states :

"..., and see how Task.ContinueWithAny provides an alternative to WaitAny).

The Task class does not have a method named "ContinueWithAny". It does have various overloads of the method "ContinueWith", and has overloads of the methods "Wait", "WaitAll", and "WaitAny".

Note from the Author or Editor:
This should read: "..and see how TaskFactory?s ContinueWhenAny provides an alternative to WaitAny.)

Second code listing on page, 4th line: property accessor should needs type declaration. Instead of:

public Expensive

it should read:

public Expensive Expensive

(the word Expensive should be repeated). The same correction should be made to last code listing on page, 4th line in code listing.

Also, on page 861, the very first line on page (code listing) should end in:

... = new Expensive();

rather than:

... = new Foo();

The second and third sentences state :

"This means that the callback method or Tick event may fire on a different thread each time it is called. Furthermore, a Tick always fires (approximately) on time - regardless of whether the previous Tick has finished executing."

The class Timer in namespace System.Timers does not have an event named "Tick", but rather an event named "Elapsed".

The second and third sentences should therefore state :

"This means that the callback method or Elapsed event may fire on a different thread each time it is called. Furthermore, an Elapsed always fires (approximately) on time - regardless of whether the previous Elapsed has finished executing."