ESSENTIAL C# 2.0（英文版）

1　Introducing C#　1
　Hello, World　2
　　Compiling and Running the Application　3
　　Managed Execution and the Common Language Infrastructure　4
　C# Syntax Fundamentals　7
　　C# Keywords　7
　　Type Definition　9
　　Main　10
　　Statements and Statement Delimiters　12
　　Whitespace　13
　Working with Variables　14
　　Data Types　15
　　Declaring a Variable　16
　　Assigning a Variable　16
　　Using a Variable　18
　Console Input and Output　18
　　Getting Input from the Console　18
　　Writing Output to the Console　20
　Comments　22
　Common Intermediate Language and ILDASM　25
2　Data Types　29
　Fundamental Numeric Types　30
　　Integer Types　30
　　Floating-Point Types (float, double)　31
　　Decimal Type　32
　　Literal Values　33
　More Fundamental Types　38
　　Boolean Type (bool)　38
　　Character Type (char)　39
　　Strings　41
　null and void　49
　　null　49
　　The void Nontype　50
　Categories of Types　50
　　Value Types　50
　　Reference Types　51
　Nullable Modifier　53
　Conversions between Data Types　53
　　Explicit Cast　54
　　Implicit Cast　57
　　Type Conversion without Casting　58
　Arrays　60
　　Declaring an Array　60
　　Instantiating and Assigning Arrays　61
　　Using an Array　65
　　Strings as Arrays　71
　　Common Errors　73
3　Operators and Control Flow　77
　Operators　78
　　Plus and Minus Unary Operators (+, -)　78
　　Arithmetic Binary Operators (+, -, *, /, %)　79
　　Parenthesis Operator　86
　　Assignment Operators (+=, -=, *=, /=, %=)　87
　　Increment and Decrement Operators (++, --)　88
　　Constant Expressions (const)　92
　Introducing Flow Control　92
　　if　Statement　96
　　Nested if　 97
　Code Blocks ({})　99
　Scope　101
　Boolean Expressions　102
　　Relational and Equality Operators　103
　　Logical Boolean Operators　104
　　Logical Negation Operator (!)　106
　　Conditional Operator (?)　107
　Bitwise Operators (  ,   , |, &, ^, ~)　108
　　Shift Operators (  ,   ,   =,   =)　109
　　Bitwise Operators (&, |, ^)　110
　　Bitwise Assignment Operators (&=, |=, ^=)　112
　　Bitwise Complement Operator (~)　113
　Control Flow Statements, Continued　113
　　The while and do/while Loops　113
　　The for loop　116
　　The foreach Loop　119
　　The switch Statement　122
　Jump Statements　124
　　The break Statement　124
　　The continue Statement　127
　　The goto Statement　128
　C# Preprocessor Directives　130
　　Excluding and Including Code (#if, #elif, #else, #endif)　131
　　Defining Preprocessor Symbols (#define, #undef)　132
　　Emitting Errors and Warnings (#error, #warning)　133
　　Turning Off Warning Messages (#pragma)　134
　　nowarn: warn list  Option　134
　　Specifying Line Numbers (#line)　135
　　Hints for Visual Editors (#region, #endregion)　135
4　Methods and Parameters　139
　Calling a Method　140
　　Namespace　142
　　Type Name　144
　　Scope　144
　　Method Name　145
　　Parameters　145
　　Method Return　145
　　Statement versus Method Call　146
　Declaring a Method　146
　　Parameter Declaration　148
　　Method Return Declaration　149
　The using Directive　151
　　Aliasing　154
　Returns and Parameters on Main()　155
　Parameters　158
　　Value Parameters　158
　　Reference Parameters (ref)　160
　　Output Parameters (out)　161
　　Parameter Arrays (params)　163
　Recursion　166
　Method Overloading　169
　Basic Error Handling with Exceptions　171
　　Trapping Errors　173
　　Reporting Errors Using a throw Statement　181
5　Classes　185
　Defining and Instantiating a Class　189
　Instance Fields　193
　　Declaring an Instance Field　193
　　Accessing an Instance Field　194
　Instance Methods　195
　Using the this Keyword　196
　Access Modifiers　202
　Constructors　204
　　Declaring a Constructor　205
　　Default Constructors　206
　　Overloading Constructors　208
　　Calling Another Constructor Using this　209
　Static　211
　　Static Fields　212
　　Static Methods　215
　　Static Constructors　215
　　Static Classes　216
　const and readonly Modifiers　218
　　const　218
　　readonly　219
　Properties　220
　　Declaring a Property　221
　　Naming Conventions　224
　　Static Properties　225
　　Using Properties with Validation　225
　　Read-Only and Write-Only Properties　227
　　Access Modifiers on Getters and Setters　228
　　Properties as Virtual Fields　229
　　Properties and Method Calls Not Allowed as ref or out Parameter Values　232
　Nested Classes　232
　Partial Classes　234
6　Inheritance　237
　Derivation　238
　　Casting between Base and Derived Types　241
　　Support for Parameter Covariance and Contravariance　243
　　private Access Modifier　244
　　protected Access Modifier　245
　　Single Inheritance　246
　　Sealed Classes　250
　Overriding the Base Class　250
　　virtual Modifier　251
　　new Modifier　256
　　sealed Modifier　260
　　base Member　261
　　Constructors　262
　Abstract Classes　263
　Everything Ultimately Derives from System.Object　268
　Verifying the Underlying Type with the is Operator　270
　Conversion Using the as Operator　271
7　Interfaces　273
　Introducing Interfaces　274
　Polymorphism through Interfaces　275
　Interface Implementation　279
　　Explicit Member Implementation　281
　　Implicit Member Implementation　282
　　Explicit versus Implicit Interface Implementation　283
　Casting between the Implementing Class and Its Interfaces　284
　Interface Inheritance　285
　Multiple Interface Inheritance　287
　Implementing Multiple Inheritance via Interfaces　288
　Versioning　291
　Interfaces Compared with Classes　293
8　Value Types　297
　Structs　298
　　Initializing structs　302
　　Using the default Operator　304
　　Inheritance and Interfaces with Value Types　304
　Boxing　305
　Enums　311
　　Type Compatibility between Enums　315
　　Converting between Enums and Strings　315
　　Enums as Flags　316
9　Well-Formed Types　323
　Overriding object Members　323
　　Overriding ToString()　324
　　Overriding GetHashCode()　324
　　Overriding Equals()　326
　　Guidelines for Implementing Equality　333
　Operator Overloading　334
　　Comparison Operators (==, !=,  ,  ,  =,  =)　334
　　Binary Operators (+, -, *, /, %, &, |, ^,   ,   )　335
　　Combining Assignment with Binary Operators (+=, -=, *=, /=, %=, &=...)　337
　　Conditional Logical Operators (&&, ||)　337
　　Unary Operators (+, -, !, ~, ++, --, true, false)　338
　　Conversion Operators　339
　　Guidelines for Conversion Operators　340
　Referencing Other Assemblies　341
　　Changing the Assembly Target　342
　　Encapsulation of Types　343
　　Referencing an Assembly　345
　Defining Namespaces　346
　　Namespace Alias Qualifier　348
　XML Comments　349
　　Associating XML Comments with Programming Constructs　350
　　Generating an XML Documentation File　352
　Garbage Collection　353
　　Weak References　355
　Resource Cleanup　356
　　Finalizers　357
　　Deterministic Finalization with the using Statement　359
　　Garbage Collection and Finalization　362
　　Resource Utilization and Finalization Guidelines　363
10　Exception Handling　365
　Multiple Exception Types　365
　Catching Exceptions　367
　General Catch Block　368
　Guidelines for Exception Handling　371
　Defining Custom Exceptions　373
　　
11　Generics　379
　C# without Generics　380
　Introducing Generic Types　385
　　Using a Generic Class　385
　　Defining a Simple Generic Class　387
　　Benefits of Generics　388
　　Type Parameter Naming Guidelines　389
　　Generic Interfaces and Structs　389
　　Defining a Constructor and a Finalizer　392
　　Specifying a Default Value　393
　　Multiple Type Parameters　394
　　Nested Generic Types　395
　　Type Compatibility between Generic Classes with Type-Compatible Type Parameters　396
　Constraints　396
　　Interface Constraints　400
　　Base Class Constraints　401
　　struct/class Constraints　402
　　Multiple Constraints　403
　　Constructor Constraints　404
　　Constraint Inheritance　405
　Generic Methods　409
　　Type Inferencing　411
　　Specifying Constraints　412
　Generic Internals　413
　　Instantiating Generics Based on Value Types　415
　　Instantiating Generics Based on Reference Types　416
12　Collections　419
　Primary Collection Classes　420
　　List Collections: List T  and ArrayList　420
　　Dictionary Collections: Dictionary TKey, TValue  and Hashtable　425
　　Sorted Collections: SortedDictionary TKey, TValue  and SortedList T 　429
　　Stack Collections: Stack T  and Stack　431
　　Queue Collections: Queue T  and Queue　432
　　Linked Lists: LinkedList T 　433
　Introducing Collection Class Interfaces　433
　　IList T  versus IDictionary TKey, TValue 　434
　　IComparable T 　435
　　ICollection T 　438
　　Iterating Using a foreach Loop　438
　Providing an Index Operator　444
　Returning Null or an Empty Collection　448
　Iterators　448
　　Defining an Iterator　449
　　Iterator Syntax　450
　　Yielding Values from an Iterator　451
　　Iterators and State　453
　　More Iterator Examples　455
　　Placing a　yield return　within a Loop　456
　　Canceling Further Iteration: yield break　459
　　Creating Multiple Iterators in a Single Class　461
　　yield Statement Characteristics　462
13　Delegates and Events　465
　Method Pointers　466
　　Defining the Scenario　466
　　Delegate Data Types　468
　　Delegate Internals　469
　　Defining a Delegate Type　470
　　Instantiating a Delegate　471
　　Anonymous Methods　475
　　Outer Variables　479
　Multicast Delegates and the Observer Pattern　482
　　Coding the Observer Pattern with Delegates　482
　　Sequential Invocation　490
　Events　496
　　Why Events?　496
　　Declaring an Event　498
　　Coding Conventions　500
　　Generics and Delegates　501
　　Customizing the Event Implementation　505
14　Reflection and Attributes　509
　Refiection　510
　　Accessing Metadata Using System.Type　511
　　Member Invocation　513
　　Refiection on Generic Types　517
　Attributes　520
　　Custom Attributes　524
　　Looking for Attributes　525
　　Initializing an Attribute through a Constructor　526
　　System.AttributeUsageAttribute　531
　　Named Parameters　532
15　Multithreading　549
　Running and Controlling a Separate Thread　552
　　Starting a Thread　553
　　Thread Management　555
　Passing Parameters to Threads　557
　Thread Pooling　561
　Unhandled Exceptions　563
　Synchronization　565
　　Synchronization Using Monitor　568
　　Using the lock Keyword　570
　　Choosing a lock Object　571
　　Why to Avoid Locking on this and typeof(type)　572
　　Declaring Fields as volatile　573
　　Using the System.Threading.Interlocked Class　573
　　Event Notification with Multiple Threads　575
　　Synchronization Design Best Practices　576
　　More Synchronization Types　578
　Timers　584
16　Multithreading Patterns　591
Asynchronous Results Pattern　592
　　Introducing the Asynchronous Results Pattern　593
　　Passing Data to and from an Alternate Thread　595
　　Receiving Notification of Thread Completion　600
　　Passing Arbitrary State　603
　Asynchronous Results Conclusions　605
　　Background Worker Pattern　606
　　Establishing the Pattern　609
　　Exception Handling　610
Windows Forms　611
17　Platform Interoperability and Unsafe Code　615
　Platform Invoke　616
　　Declaring External Functions　617
　　Parameter Data Types　618
　　Using ref Rather Than Pointers　619
　　Using StructLayoutAttribute for Sequential Layout　620
　　Error Handling　621
　　Using SafeHandle　623
　　Calling External Functions　626
　　Simplifying API Calls with Wrappers　628
　　Function Pointers Map to Delegates　629
　　Guidelines　629
　Pointers and Addresses　630
　　Unsafe Code　630
　　Pointer Declaration　632
　　Assigning a Pointer　634
　　Dereferencing a Pointer　636
　　Accessing the Member of a Referent Type　638
18　The Common Language Infrastructure　641
　Defining the Common Language Infrastructure (CLI)　642
　CLI Implementations　643
　C# Compilation to Machine Code　644
　Runtime　647
　　Garbage Collection　647
　　Garbage Collection on .NET　648
　　Type Safety　649
　　Code Access Security　650
　　Platform Portability　650
　　Performance　651
　Application Domains　652
　Assemblies, Manifests, and Modules　653
　Common Intermediate Language (CIL)　656
　Common Type System (CTS)　656
　Common Language Specification (CLS)　657
　Base Class Library (BCL)　658
　Metadata　658
A　Downloading and Installing the C# Compiler and the CLI Platform　663
B　Complete Source Code Listings　667
C　C# 2.0 Topics　693
Index　697