Errata

The keyword 'in' appears in both the reserved keyword list and the contextual keyword list.

Note from the Author or Editor:
The 'in' keyword should appear only in the list of reserved keywords. Remove the 'in' keyword from the list of contextual keywords.

Item "longnamespace" should be two different items "long" and "namespace".

The Paragraph: "No conversion can be made from the bool type to numeric types or vice versa."

I do not believe that this is the intent, I believe that the intent is "No casting conversion can be made from..."

Thank you for your attention.
--Avi

The code:
string a2 = @ "\\server\fileshare\helloworld.cs";

Should be:
string a2 = @"\\server\fileshare\helloworld.cs";

Note from the Author or Editor:
Remove the space between the @ sign and the " symbol.

string s = (sb == null ? "nothing" : sb.ToString()); // the original line
if (s == null) s = "nothing"; // this is missing
// the original line is not strictly equivalent to the code line 23 because
// when sb.ToString() returns null, s in line 23 is "nothing", in 25 is null

Note from the Author or Editor:
Delete the following text:

The last line is equivalent to:
string s = (sb == null ? "nothing" : sb.ToString());

The text:
A method’s signature comprises its name and parameter types

Should also include order of parameters.

Note from the Author or Editor:
Change " parameter types" to " parameter types in order"

In the example that shows the effective substitution for Stack<int> the line:

int[] data;

should read:

int[] data = new int[100] ;

Should the sixth word in "For every value type or pointer type V, there is a corresponding pointer type V*." be reference instead of pointer?

Note from the Author or Editor:
Correct. The sentence should read: "For every value type or reference type V...

void Z(char[ ] 1, float[,] p2) {...}

should be

void Z(char[ ] a1, float[,] p2) {...}

CompareTo instance method or
the static Compare and CompareOrdinal methods: these return a positive or negative
number—or zero—depending on whether the first value comes before, after, or
alongside the second.

This is wrong because following two pages later is right.

All of the order-comparison methods return a positive number, a negative number,
or zero, depending on whether the first value comes after, before, or alongside the
second value:

void DisplayPrimeCountsFrom (int i)
{
var awaiter = GetPrimesCountAsync (i*1000000 + 2, 1000000).GetAwaiter();
awaiter.OnCompleted (() =>
{
Console.WriteLine (awaiter.GetResult() + " primes between...");
if (i++ < 10) DisplayPrimeCountsFrom (i);
else Console.WriteLine ("Done");
});
}

Here within awaiter.OnCompleted(()=>...), if(i++ <10) ... should be if(++i <10) instead. I am sure the author knows the difference between pre-increment and post-increment and it does make a difference here if the intent is to loop 10 times not 11 times.

ScriptEngine does not have a GetVariable method. The GetVariable method is defined on ScriptScope, and requires a single string argument specifying the name of the variable you wish to retrieve.

Note from the Author or Editor:
Yes, this needs to be updated to work with the latest version of IronPython.

The last line of the first code listing on page 861 should read:

Console.WriteLine (scope.GetVariable ("result")); // 6

instead of

Console.WriteLine (engine.GetVariable (scope, "result")); // 6

The text indicates that a number is appended to the list every second, but the argument passed to Thread.Sleep is only 100 (milliseconds), which is one tenth of a second.

Note from the Author or Editor:
In 3rd paragraph on page 920, change "every second" to "every 100ms".

The output shown is inconsistent with the call to NormalizeWhitespace on unit, which would insert carriage returns in the following locations in the output: after the semicolon, after "Program" and after the opening curly brace.

Note from the Author or Editor:
The code listing should be formatted as follows:

var tree = CSharpSyntaxTree.Create (unit.NormalizeWhitespace());
Console.WriteLine (tree.ToString());

// Output:
using System.Text;

class Program
{
}

The expression location.MetadataModule == compilation.References.Single() evaluates to False, not True as indicated. This is consistent with the fact that the operands are of different types (IModuleSymbol and MetadataReference, respectively).

Note from the Author or Editor:
Thanks - will fix for next edition.

While it does not affect the example, in the Program class in which symbols are renamed, the Foo declaration and usages are not consistent. Either the Foo call in Main should be static since it is defined statically, or the signature of Foo should be changed so that it is in fact an instance method and the instance call in Main can remain. This latter option also requires a change to the static call to Foo in Bar.

Note from the Author or Editor:
Thanks, will fix for next edition.