C# Essentials
by Ben Albahari, Peter Drayton & Brad Merrill


Following are the changes made in the 4/01 reprint.


Here's a key to the markup:

        [page-number]: serious technical mistake
        {page-number}: minor technical mistake
        <page-number>: important language/formatting problem
        (page-number): language change or minor formatting problem
        ?page-number?: reader question or request for clarification


<2>  Changed "Safe type system" to "Type safety and a unified type system" 
and changed "Automatic memory management" to "Automatic and manual memory 
management."


(3)  Line 2 of the 2nd paragraph did read:

	".NET compiles source code and produces..."

Now reads:

	".NET compiles source code into..."


<5>  Replaced the section "A Minimal C# Program" with the following text:

<heada>A First C# Program</heada>

Here is a simple C# program:

	namespace FirstProgram {
	  using System;
	  class Test {
	    static void Main () {
	      Console.WriteLine ("Welcome to C#!");
	    }
	  }
	}

A C# program is composed of types (typically classes) that we organize into 
namespaces. Each type contains function members (typically methods), as well 
as data members (typically fields). In our program, we define a class named 
<lit>Test</lit> that contains a method, named <lit>Main</lit>, that writes 
<lit>Welcome to C#!</lit> to the <lit>Console</lit> window. The 
<lit>Console</lit> class encapsulates standard input/output functionality, 
providing methods such as <lit>WriteLine</lit>. To use types from another 
namespace, we use the <lit>using</lit> directive. Since the <lit>Console</lit>
class resides in the <lit>System</lit> namespace, we go <lit>using 
System</lit>; similarly, types from other namespaces could use our 
<lit>Test</lit> class by going <lit>using FirstProgram</lit>.

In C#, there are no standalone functions; functions are always associated with 
a type, or as we will see, instances of that type.  Our program is simple, and 
makes use of only static members, which means the member is associated with 
its type, rather than instances of its type.  In addition, we make use of only 
void methods, which means these methods do not return a value.  Of final note 
is that C# recognizes a method named <lit>Main</lit> as the default entry 
point of execution.


(8)  The first sentence of the 2nd paragraph did read:

	"Implicit conversions are guaranteed to succeeed and not lose 
	information." 

Now reads:

	"The rationale behind implicit conversions is that they are guaranteed 
	to succeed and not lose information."


(11)  In the 3rd code line, changed "strenngtgth" to "strength".


{11}  In the table under "decimal type", changed the 12 in the righthand column
to a 16.


(14)  In the first line under "Memory for reference types," changed "The 
memory location of a..." to "The memory of a..."


{15}  The 5th line of code did read:

	// object's type  synchronization state

Now reads:

	// object's type & synchronization state


(21)  In the first line under "Statements," changed "Execution off" to 
"Execution of."


{22}  In the first and third lines of the first full code block, removed "int" 
at beginning of lines.  They now read:

	x = 5 + 6; // assign result
	...
	y = Math.min(x, 20); // side effect and assign result


(35)  In the second line under "Versioning Virtual Function Members," changed:

	"the virtual method of a class or interface."

to:

	"a virtual method."


(38)  The second sentence in the first bulleted item did read:

	"Consequently, structs typically simple types, whereas value-type 
	semantics are desirable..."

Now reads:

	"Consequently, structs typically represent simple types, whereby 
	value-type semantics are desirable..."	


(57)  The line under the "Arrays" heading did read:

        type [*]+ = new type [ dimension+ ][*]*;

Now reads:

        type [*]+ array-name = new type [ dimension+ ][*]*;


{58}  Deleted the 5th line in the first code block (same as line 4).


(61)  In the first paragraph under "Delegates," the following text has been 
changed to a footnote: 

	"The signature of a delegate method includes its return type and also 
	allows the use of a params modifier in its parameter list, expanding 
	the list of elements that characterize an ordinary method signature. 
	The actual name of the target method is irrelevant to the delegate."


(67)  Changed the heading "catch Statement" to "catch".


{82}  In the list under the Object class definition, changed "Object(object o)"
to "Object()", and "Equals()" to "Equals(object o)".


{160}  The definition of decimal did read:

	"A twelve-bit precise decimal datatype."

Now reads:

	"A sixteen-bit precise decimal datatype."


(colophon) The second paragraph in the colophon did read:

	"The animal on the cover of C# Essentials is a star-nosed mole
	(condylura cristata)..."

Now reads:

	"The animal on the cover of C# Essentials is a star-nosed mole
	(Condylura cristata)..."