Errata

char is listed as taking up one byte. Char's in C# are, as listed, Unicode characters and thus must take up 2 bytes. Visual Studio.Net documentation confirms this.

The table says that char has a size of 1 byte. In fact the C# language specification
in section 4.1.4 says that it has a length of 16 bits (2 bytes).

"...while a ulong can hold values from 0 through 4,294,967,295." Maximum value should be 18,446,744,073,709,551,615?

The minimum value for an int is given as -2,147,483,647; it should be -2,147,483,648
(one less) as it is a 32-bit twos complement number. (Note that all signed types are
twos complement and so their lower bound is even).

The sentence: "Because any nonzero value evaluates to true in C and C#" should
read: "Because any nonzero value evaluates to true in C and C++".

Should read "#endregion", not "#end region"

Window. Within the Window class, two variables are defined called top and left. The
comment that appears above them reads;

// these members are private and thus invisible
// to derived class methods. We'll examine this
// later in the chapter.

Then the two variables are declared immediately after, thus;

protected int top;
protected int left;

The access modifier provided in the declaration is protected, not private so the two
variables are not invisible to derived class methods.

static and non-static switched

nested classes are roughly equivalent to inner classes (non-static);
there is no C# equivalent to Java's static nested classes.

also:
inner class is Java's term for non-static nested classes.
static nested classes are just called static nested classes.
static inner class is a contradiction.

"FractionArtist is public".
It appears to be defined in the example as "internal".
[Yes, it can be accessed from outside Fraction -- in that sense it is
"public" -- but it's not REALLY "public"

Also, that sentence seems to be worded badly: "it is scoped to within the Fraction class"?!?!

Last sentence of this paragraph states "Thus, for example, ArrayList expects you to implement Equals().", where the author must hav
e meant:

"Thus, for example, Fraction expects you to implement Equals().",

since the "ArrayList" word in the previous sentence is not consistent with the ongoing discussion prior to this topic, where the au
thor was using a "Fraction" class as an example.

empArray[i]=new Employee(i+10)

should read

empArray[i]=new Employee(i+5)

as in example 9-1 if the output is to agree,

I think the SetCheck() method has some minor problem. In your book, you write these
private void SetCheck(TreeNode node, bool check)
{
node.Checked = check;
foreach (TreeNode n in node.Nodes)
{
if (node.Nodes.Count == 0)
{
node.Checked = check;
}
else
{
SetCheck(n,check);
}
}
}

It can not run correctly. I have seen the last update source code for downloading in
your website. In the source code, the SetCheck has changed to
private void SetCheck(TreeNode node, bool check)
{
// find all the child nodes from this node
foreach (TreeNode n in node.Nodes)
{
n.Checked = check; // check the node

// if this is a node in the tree, recurse
if (n.Nodes.Count != 0)
{
SetCheck(n,check);
}
}
}

Though it can work correctly. But I think the if statement (judge if n.Nodes.Count!=0
and SetCheck) is unnecessary. Because when n.Checked=check is execute, it will
activate the AfterCheck event again, then we have already a recursive. Do not need a
if stament and SetCheck to form another recursive.
I have removed if(n.Nodes.Count !=0) statement, and the result is fairly well. Please
consider my opinion.

The book breaks the coding standards that are specified within the book (page 15) in
many places (mainly with regards to capitalization of variable names), but this
listing is particularly bad:
DataSet DataSet = new DataSet();
Here an object is given the same name as the class.
In the same code listing there is also:
SqlDataAdapter DataAdapter = ...

Web Application icon should have a name as "ASP.NET Web Application".

2nd line should be: Codebehind="HelloWeb.aspx.cs"

After the beginning <% %>, there should be a line start with <!DOCTYPE ...>

After the <meta name="CODE_LANGUAGE" Content="C#"> line, there should be 2 more line
with meta content.

Again the Codebehind="HelloWeb.cs" should be Codebehind="HelloWeb.aspx.cs"

- Pow(a, 0) should return 1, but it returns a!
This implementation says a^0 = a^1 which is not true for all the a's.

- The method doesn't handle exponents correct if they are not ints
8.666^4.74 should be treated as (8.666 ^(474/100)) not (8.666^4)

- Also negative exponents are not handled with this method. 8.666^(-4) is (1/(8^4))

Despite the fact that the pow method takes two double arguments, it will return an
incorrect result if the power is negative or non-integer. Maybe it would be better
for the method to use System.Math.Pow instead of attempting to calculate the result.

Furthermore the name of the function is in lowercase which is not consistent with the
other web methods in the example (Add, Sub etc), or the C# coding standards.

I haven't run this program yet, example 20-1, but it seems fairly clear that threads one and two will be started, then, while they are running, DoTest will return, and then Main will return, and the program will end because the main thread has ended. wjithout threads one and two being able to complete their work.

Also, I don't see any reason for these threads to be run outside of Main, and why there needs to be an instance created of the Tester class.

I suggest rewritting this section of code:
int bytesRead =
reader.Read(buffer,0,BufferSize);
if (bytesRead == 0) // none? quite
fQuit = true;
else // got some?
{
// display it as a string
string theString = new String(buffer);
Console.WriteLine(theString);
}

Like so:
int bytesRead =
reader.Read(buffer, 0, BufferSize);

if (bytesRead < BufferSize) // didn't fill buffer? quit
fQuit = true;

if (bytesRead > 0) // got some?
{
// display it as a string
string theString = new String(buffer);
Console.WriteLine(theString);
}

Two points:
- When I run it as is, the client never finishes, because I never get a zero length buffer.
I get one buffer of length 86. This may be because the file I used is smaller than one
buffer in size.

- In the comment "quite" should be "quit"