Errata

page 277
section name:
*Chapter 13 Quick Reference*
error:
> class Test : IDemo
> {
> public string IDemo.Name()
> {
> ...
> }
> public string IDemo.Description()
> {
> ...
> }
> }
compile time error: The modifier 'public' is not valid for this item

Note from the Author or Editor:
The reader is correct. You cannot use a modifier such as public or private when you implement an interface explicitly.

From Derrick Harrison, Calgary, Canada. [derrick.harrsison@shaw.ca]

Page 319
Obviously this page has generated some interest because when I first checked the errata there was a entry dated Jan 20, 2012 which was totally incorrect. I agree that the entry dated July 29 2011 is correct as far as the bits are concerned. However I do not think the statement ?the value of adapted is now 119? is correct. When I tested this code the value of adapted was unchanged at 126. I assume this is because adapted is passed as a reference to the structure and it is the private int bits field that is changed. When I added a method:
public int getBits()
{
return bits;
}
to the structure and then added
adapted = bits.getBits(};
after bits[3] = false;
then adapted was indeed changed to 119.

I have a few other comments which are minor in nature.
Page 185. In the Note ? line 6; Date is a struct and not a class.
Page 236. In the code Mammal1 MyMammal there should be a space between new and Mammal
Page 266.Step 3. I think I would have called it an Events tab rather than an Events button.
Page 546.Step 4. I don?t think the phrase ?The SQL SELCT statement appears? is true, at least not on C# 2010 express.

General comment. I went to my first computer lecture in England in 1959 and joined the computer industry in 1962. So I have seen a few changes in my time and programmed in almost all well know languages and some not so well known such as Mercury Autocoder.. Since retiring almost 20 years ago I have used Visual Basic almost exclusively but I thought I should get up to speed with C# because I think that is what I think I should be teaching the grandchildren. Also it is important to keep the brain alive as one ages. Of all the many computer books I have bought over the years I think this is definitely one of the best. I have actually only got up to Chapter 16 so far but I jumped ahead to Chapter25 because I thought I would try the SQL examples. In all previous books I was never able to get the examples to work exactly as the author had written. So I congratulate John Sharp for having done his homework.

I realize that the 2012 book is probably now in print but maybe the above comments still apply.

Note from the Author or Editor:
I believe that some of these issues have already been addressed in the reprint earlier this year, The comments about pages 236 and 546 are new and will be addressed:

On page 236, the code near the middle of the page should be:

Mammal myMammal = new Mammal("Mammalia");

On page 546, the sentence before the graphic should say:

The orders for the customer appear, as shown in the following image:

Minor mistake.

Current: "the compiler throws an IndexOutOfRangeException"
Correction: "the runtime throws an IndexOutOfRangeException"

The range of a dynamically-sized array is not known at compile time.

Note from the Author or Editor:
The reader is correct. The sentence immediately before the code near the bottom of the page should read:

If you specify an index that is less than 0 or greater than or equal to the length of the array, the runtime throws an IndexOutOfRangeException, as shown in this example:

In step 9, DateTime is a struct and not a class. The second sentence:

You can do this by setting the Text property of the control. You can obtain the current date from the static Today method of the DateTime class.

Should read:

You can do this by setting the Text property of the control. You can obtain the current date from the static Today method of the DateTime struct.

The final bullet and code example at the bottom of the page contradicts the previous bullets and is wrong. It should be removed. The text to be removed is:

The compiler detects and rejects any potentially ambiguous overloads. For example, the following two Min methods are ambiguous; it?s not clear which one should be called if you pass two int arguments:

// compile-time error
public static int Min(params int[] paramList)
...
public static int Min(int, params int[] paramList)
...

now that everyone has jumped on the complex number formula and coding errors, perhaps now the "Verify that the application displays the results shown" should be changed to show the results of a correct multiplication operation (I would suggest that the values should be (42 + 40i).

In addition, perhaps the sample code for Complex.cs should be changed from


return new Complex(lhs.Real * rhs.Real + lhs.Imaginary * rhs.Real,
lhs.Imaginary * rhs.Imaginary + lhs.Real * rhs.Imaginary);

to


return new Complex (lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginary,
lhs.Imaginary * rhs.Real + rhs.Real * lhs.Imaginary);

Note from the Author or Editor:
The image at the top of page 431 needs to be changed to show the correct results. The result of the multiply operation should be:

(42 + 40i)

Text states the following: "this is the leftmost button on the toolbar" when the referenced image clearly shows it is second from the left.

Note from the Author or Editor:
The reader is correct. The text in step 4 should state that this is the second leftmost button on the toolbar.

There are already two submitted confirmed errata for this calculation confirming that code in the book is wrong, the confirmed errata contradict each other. Additionally, assuming the calculation for imaginary number multiplication in the table on page 428 is correct, both of the confirmed errata are still wrong so far as I can see.

Here is the code from the book (B), the code as given by Steven Gregory's submission on 28-Dec-2010 (S) and the code as given by an anonymous submitter on 19-Apr-2011 (A). The following code snippets are best viewed in a monospaced editor in order to see the differences.

B: return new Complex(lhs.Real * rhs.Real + lhs.Imaginary * rhs.Real, lhs.Imaginary * rhs.Imaginary + lhs.Real * rhs.Imaginary);
S: return new Complex(lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginary, lhs.Imaginary * rhs.Real + rhs.Real * lhs.Imaginary);
A: return new Complex(lhs.Real * rhs.Real + lhs.Imaginary * rhs.Imaginery, lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary);

Returning to the table on page 428, the calculation for multiplication is given as "(( a * c - b * d) + (b * c + a * d)i)". If we simply substitute as follows...

a = lhs.Real
b = lhs.Imaginary
c = rhs.Real
d = rhs.Imaginary

...then that gives:
(( lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginary) + (lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary)i)

Or, in terms of the code itself:
return new Complex(lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginary, lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary)


Given that the book and at least one of the confirmed errata contain mistakes could someone please carefully check my logic and correct or remove any existing errata which are found to be incorrect, as at least one of them is regardless of whether I'm right or not.

Thanks.

Note from the Author or Editor:
OK. Here is the definitive answer. The code should be:

return new Complex(lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginary, lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary);

This will be updated in the next reprint.

Comment in code block is wrong about "the value of adapted is now ..." because the value of adapted is unchanged. Only the value of "bits" changed.

Note from the Author or Editor:
The values specified in the comment are also wrong!
The final comment in the block of code near the top of the page should be:

// the value in bits is now 110111, or 55 in decimal

The code in the Tip is incorrect. The Parallel.Invoke construct automatically starts a new task for each action, so there is no need to use the Task.Factory.StartNew method (indeed doing so is wrong as the Parallel.Invoke construct then just waits for the tasks to start.)

The code should be:

Parallel.Invoke(
() => generateGraphData(data, 0, pixelWidth / 8),
() => generateGraphData(data, pixelWidth / 8, pixelWidth / 4),
() => generateGraphData(data, pixelWidth / 4, pixelWidth * 3 / 8),
() => generateGraphData(data, pixelWidth * 3 / 8, pixelWidth / 2)
);

The final sentence states "The tree is passed back as the return value". This is not the case as the function's return type is void.

Note from the Author or Editor:
The final sentence in step 6 at the top of page 373 should be cut.

Line 3
error: TSource is the type of the collection...
correction: TSource is the type of the elements in the collection...

Line 11:
error: ... yields a collection of TResult...
correction: ... yields a TResult...

Regarding Line 11, the Select method yields a collection of TResults, but the selector parameter expects a method that takes a single TSource element and returns a single TResult element.

Note from the Author or Editor:
The point the reader raises about line 3 is, I feel, a matter of interpretation and how one reads the sentence; I am quite happy quite happy for line 3 to be left as-is.

Concerning line 11, the penultimate sentence in the paragraph at the bottom of page 399 should probably read:

The method referred to by the selector parameter takes a TSource (in this case customr) parameter, and yields a TResult (in this case string) object.

public static Complex operator *(Complex lhs, Complex rhs)
{
return new Complex(lhs.Real * rhs.Real + lhs.Imaginary * rhs.Real,
lhs.Imaginary * rhs.Imaginary + lhs.Real * rhs.Imaginary);
}

is not returning the desired output.

I think it should be:

return new Complex(lhs.Real * rhs.Real + lhs.Imaginary * rhs.Imaginary,
lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary);

Note from the Author or Editor:
The code for the operator* method in the first example at the top of page 430 should be:

public static Complex operator *(Complex lhs, Complex rhs)
{
return new Complex(lhs.Real * rhs.Real - lhs.Imaginary * rhs.Imaginery,
lhs.Imaginary * rhs.Real + lhs.Real * rhs.Imaginary);
}

Error:
"C# always rounds down in circumstances like this.";

Correction:
"C# always rounds towards zero in circumstances like this. Hence, 57 / 10 = 5, and -57 / 10 = -5.

Note from the Author or Editor:
The reader is correct.

In the penultimate paragraph on page 37, the sentence starting on the 6th line should read:

"C# always rounds towards zero in circumstances like this"

Paragraph reads "The third statement *assigns the Text property of the filename control to the Name property of the src variable*."
should this be:
"The third statement assigns the Name property of the src variable to the Text property of the filename control."?

Note from the Author or Editor:
The reader is correct. The first sentence in the final paragraph at the bottom of page 94 should read:

The third statement assigns the Name property of the src variable to the Text property of the filename control.

Misnamed variable name and typo in a string constant:
int numberOfCountries =
addresses.Select(addr => addr.Country).Distinct().Count();
Console.WriteLine("Number of companies: {0}", numberOfCompanies);
---
should be:
int numberOfCountries =
addresses.Select(addr => addr.Country).Distinct().Count();
Console.WriteLine("Number of countries: {0}", numberOfCountries);

Note from the Author or Editor:
The reader is correct. The following code statement near the bottom of page 403:

Console.WriteLine("Number of companies: {0}", numberOfCompanies);

Should be:

Console.WriteLine("Number of countries: {0}", numberOfCountries);

In item 7 at the top of page 81, in the first line of code, there is a mismatch with what's provided on the CD.
The book reads
private int compareClick(object sender, RoutedEventArgs e)
The CD reads
private void compareClick(object sender, RoutedEventArgs e)

Note from the Author or Editor:
The code on the CD is correct. The code in the book should be changed to read:

private void compareClick(object sender, RoutedEventArgs e)

2. Add the PrivilegeLevelConverter class shown next to the end of the file, after the
Customer class:

I think it should be TicketOrder class

Note from the Author or Editor:
In Step 2, change the instruction:

Add the PrivilegeLevelConverter class shown next to the end of the file, after the Customer class.

to:

Add the PrivilegeLevelConverter class shown next to the end of the file, after the TicketOrder class.

The example says (1 << 6) returns 00100000.
This is incorrect, the correct value is 01000000.

Note from the Author or Editor:
The reader is correct. In the examples at the bottom of page 316, every occurence of the following expression:

1 << 6

Should be replaced with:

1 << 5

This occurs 3 times

The first line of code reads "class Customer" where I think
"class TicketOrder" was intended, as it reads in the completed solution.

(More generally, I wonder if it is wise for the example to use similar names for different entities. The term "PrivilegeLevel" variously capitalized refers to an enumeration, a private variable, and a property; it works, but in a challenging chapter like #24 it seems to add an extra hurdle to comprehension; well to my comprehension anyway. I'm translating the solution to Visual Basic for my own benefit, so I used unique names which I found helped me figure out what was going on.)

Note from the Author or Editor:
The reader is correct. The instruction for Step 5 is correct, but the name of the class shown in the code fragment underneath is wrong. It should be TicketOrder and not Customer:

class TicketOrder
{
...
<REST OF CODE EXACTLY AS SHOWN IN STEP 5>
}

The example shown here causes the Products property of each Supplier entity to be populated as soon as the data for each Product entity is fetched...

Should read:

The example shown here causes the Products property of each Supplier entity to be populated as soon as the data for each Supplier entity is fetched...

Note from the Author or Editor:
The reader is correct. The offending sentence is in the middle of the final paragraph of page 558. It should read:

"The example shown here causes the Products property of each Supplier entity to be populated as soon as the data for each Supplier entity is fetched rather than being deferred."

I believe the code at the bottom of the page was intended to be:

object x = ...;
object y = ...;
ObjectComparer objectComparer = new ObjectComparer();
IComparer<object> objectComparator = objectComparer;
int result = objectComparator.Compare(x, y);

Note from the Author or Editor:
You are correct. The variable "comparer" declared on line 3 of the code should actually be named "objectComparer". The full code should be:

object x = ...;
object y = ...;
ObjectComparer objectComparer = new ObjectComparer();
IComparer<object> objectComparator = objectComparer;
int result = objectComparator.Compare(x, y);

the return statement in:

public static implicit operator int (Hour from)
{
return this.value;
}

should be:

return from.value;

'this'-keyword is not valid in a static method.

Note from the Author or Editor:
I concur. The complete code should be:

struct Hour
{
...
public static implicit operator int(Hour from)
{
return from.value;
}

private int value;
}

it should be 5 instead of 6 as shown below:
bool peek = bits[5]; //retrive bool at index 5; should be true (1)

Note from the Author or Editor:
Agreed. However, the remaining example code fragments on page 319 also refer to bits[6]. I suggest that we change the following line of code:

int adapted = 62; // 62 has the binary representation 111110

To:

int adapted = 126; // 126 has the binary representation 1111110


The final comment in the code block must also be changed to:

// the value in adapted is now 1110111, or 119 in decimal

---------

Additionally, on page 317, the first Note needs to change. The final phrase should be ", and the bit at position 6 is the bit seven places from the right."

The footnote reads:
A structure implicitly derives from System.Object, which contains methods that the structure can hide.

but the entry in the table indicates that the structure can *not* hide any methods.
The footnote should read:
'A structure implicitly derives from System.Object, which contains no methods that the structure can hide.'

Note from the Author or Editor:
Actually, the converse is true. The entries in the final column (Structure) for the rows labelled "new" and "override" are now out of date. They should both be "yes" rather than "no", and footnotes 2 and 3 should be deleted.

The two graphics on the page are reversed.

They do no match the text preceding each graphic.

Note from the Author or Editor:
The two images on page 183 should be swapped over