Part Ⅰ CLR Basics 1
1 The CLR's Execution Model 1
Compiling Source Code into Managed Modules 1
Combining Managed Modules into Assemblies 5
Loading the Common Language Runtime 6
Executing your Assembly's Code 9
IL and Verification 15
Unsafe Code 16
The Native Code Generator Tool:NGen.exe 18
The Framework Class Library 20
The Common Type System 22
The Common Language Specification 25
Interoperability with Unmanaged Code 29
2 Building,Packaging,Deploying,and Administering Applications and Types 31
.NET Framework Deployment Goals 32
Building Types into a Module 33
Response Files 34
A Brief Look at Metadata 36
Combining Modules to Form an Assembly 43
Adding Assemblies to a Project by Using the Visual Studio IDE 49
Using the Assembly Linker 50
Adding Resource Files to an Assembly 52
Assembly Version Resource Information 53
Version Numbers 57
Culture 58
Simple Application Deployment(Privately Deployed Assemblies) 59
Simple Administrative Control(Configuration) 61
3 Shared Assemblies and Strongly Named Assemblies 65
Two Kinds of Assemblies,Two Kinds of Deployment 66
Giving an Assembly a Strong Name 67
The Global Assembly Cache 73
Building an Assembly That References a Strongly Named Assembly 75
Strongly Named Assemblies Are Tamper-Resistant 76
Delayed Signing 77
Privately Deploying Strongly Named Assemblies 80
How the Runtime Resolves Type References 81
Advanced Administrative Control(Configuration) 84
Publisher Policy Control 87
Part Ⅱ Designing Types 91
4 Type Fundamentals 91
All Types Are Derived from System.Object 91
Casting Between Types 93
Casting with the C# is and as Operators 95
Namespaces and Assemblies 97
How Things Relate at Runtime 102
5 Primitive,Reference,and Value Types 113
Programming Language Primitive Types 113
Checked and Unchecked Primitive Type Operations 117
Reference Types and Value Types 121
Boxing and Unboxing Value Types 127
Changing Fields in a Boxed Value Type by Using Interfaces(and Why You Shouldn't Do This) 140
Object Equality and Identity 143
Object Hash Codes 146
The dynamiC Primitive Type 148
6 Type and Member Basics 155
The Different Kinds of Type Members 155
Type Visibility 158
Friend Assemblies 159
Member Accessibility 160
Static Classes 162
Partial Classes,Structures,and Interfaces 164
Components,Polymorphism,and Versioning 165
How the CLR Calls Virtual Methods,Properties,and Events 167
Using Type Visibility and Member Accessibility Intelligently 172
Dealing with Virtual Methods When Versioning Types 175
7 Constants and Fields 181
Constants 181
Fields 183
8 Methods 187
Instance Constructors and Classes(Reference Types) 187
Instance Constructors and Structures(Value Types) 191
Type Constructors 194
Type Constructor Performance 198
Operator Overload Methods 200
Operators and Programming Language Interoperability 203
Conversion Operator Methods 204
Extension Methods 207
Rules and Guidelines 210
Extending Various Types with Extension Methods 211
The Extension Attribute 213
Partial Methods 213
Rules and Guidelines 216
9 Parametersv 219
Optional and Named Parameters 219
Rules and Guidelines 220
The Default Parameter Value and Optional Attributes 222
Implicitly Typed Local Variables 223
Passing Parameters by Referenceto a Method 225
Passing a Variable Number of Arguments to a Method 231
Parameter and Return Type Guidelines 233
Const-ness 235
10 Properties 237
Parameterless Properties 237
Automatically Implemented Properties 241
Defining Properties Intelligently 242
Object and Collection Initializers 245
Anonymous Types 247
The System.Tuple Type 250
Parameterful Properties 252
The Performance of Calling Property Accessor Methods 257
Property Accessor Accessibility 258
Generic Property Accessor Methods 258
11 Events 259
Designing a Type That Exposes an Event 260
Step #1：Define a type that will hold any additional information that should be sent to receivers of the event notification 261
Step #2：Define the event member 262
Step #3：Define a method responsible for raising the event to notify registered objects that the event has occurred 263
Step #4：Define a method that translates the input into the desired event 266
How the Compiler Implements an Event 266
Designing a Type That Listens for an Event 269
Explicitly Implementing an Event 271
12 Generics 275
Generics in the Framework Class Library 280
Wintellect's Power Collections Library 281
Generics Infrastructure 282
Open and Closed Types 283
Generic Types and Inheritance 285
Generic Type Identity 287
Code Explosion 288
Generic Interfaces 289
Generic Delegates 290
Delegate and Interface Contravariant and Covariant Generic Type Arguments 291
Generic Methods 293
Generic Methods and Type Inference 294
Generics and Other Members 296
Verifiability and Constraints 296
Primary Constraints 299
Secondary Constraints 300
Constructor Constraints 301
Other Verifiability Issues 302
13 Interfaces 307
Class and Interface Inheritance 308
Defining an Interface 308
Inheriting an Interface 310
More About Calling Interface Methods 312
Implicit and Explicit Interface Method Implementations(What's Happening Behind the Scenes) 314
Generic Interfaces 315
Generics and Interface Constraints 318
Implementing Multiple Interfaces That Have the Same Method Name and Signature 319
Improving Compile-Time Type Safety with Explicit Interface Method Implementations 320
Be Careful with Explicit Interface Method Implementations 322
Design:Base Class or Interface? 325
Part Ⅲ Essential Types 327
14 Chars,Strings,and Working with Text 327
Characters 327
The System.String Type 330
Constructing Strings 330
Strings Are Immutable 333
Comparing Strings 334
String Interning 340
String Pooling 343
Examining a String's Characters and Text Elements 343
Other String Operations 346
Constructing a String Efficiently 346
Constructing a String Builder Object 347
StringBuilder Members 348
Obtaining a String Representation of an Object:ToString 350
Specific Formats and Cultures 351
Formatting Multiple Objects into a Single String 355
Providing Your Own Custom Formatter 356
Parsing a String to Obtain an Object:Parse 359
Encodings:Converting Between Characters and Bytes 361
Encoding and Decoding Streams of Characters and Bytes 367
Base-64 String Encoding and Decoding 368
Secure Strings 369
15 Enumerated Types and Bit Flags 373
Enumerated Types 373
Bit Flags 379
Adding Methods to Enumerated Types 383
16 Arrays 385
Initializing Array Elements 388
Casting Arrays 390
All Arrays Are Implicitly Derived from System.Array 392
All Arrays Implicitly Implement IEnumerable,ICollection,and IList 393
Passing and Returning Arrays 394
Creating Non-Zero-Lower Bound Arrays 395
Array Access Performance 396
Unsafe Array Access and Fixed-Size Array 401
17 Delegates 405
A First Look at Delegates 405
Using Delegates to Call Back Static Methods 408
Using Delegates to Call Back Instance Methods 409
Demystifying Delegates 410
Using Delegates to Call Back Many Methods(Chaining) 415
C#'s Support for Delegate Chains 419
Having More Control over Delegate Chain Invocation 419
Enough with the Delegate Definitions Already(Generic Delegates) 422
C#'s Syntactical Sugar for Delegates 423
Syntactical Shortcut #1:No Need to Construct a Delegate Object 424
Syntactical Shortcut #2:No Need to Define a Callback Method 424
Syntactical Shortcut #3:No Need to Wrap Local Variables in a Class Manually to Pass Them to a Callback Method 428
Delegates and Reflection 431
18 Custom Attributes 435
Using Custom Attributes 435
Defining Your Own Attribute Class 439
Attribute Constructor and Field/Property Data Types 443
Detecting the Use of a Custom Attribute 444
Matching Two Attribute Instances Against Each Other 448
Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects 451
Conditional Attribute Classes 454
19 Nullable Value Types 457
C#'s Support for Nullable Value Types 459
C#'s Null-Coalescing Operator 462
The CLR Has Special Support for Nullable Value Types 463
Boxing Nullable Value Types 463
Unboxing Nullable Value Types 463
Calling GetType via a Nullable Value Type 464
Calling Interface Methods via a Nullable Value Type 464
Part Ⅳ Core Facilities 465
20 Exceptions and State Management 465
Defining"Exception" 466
Exception-Handling Mechanics 467
The try Block 468
The catch Block 469
The finally Block 470
The System.Exception Class 474
FCL-Defined Exception Classes 478
Throwing an Exception 480
Defining Your Own Exception Class 481
Trading Reliability for Productivity 484
Guidelines and Best Practices 492
Use finally Blocks Liberally 492
Don't Catch Everything 494
Recovering Gracefully from an Exception 495
Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State 496
Hiding an Implementation Detail to Maintain a"Contract" 497
Unhandled Exceptions 500
Debugging Exceptions 504
Exception-Handling Performance Considerations 506
Constrained Execution Regions(CERs) 509
Code Contracts 512
21 Automatic Memory Management(Garbage Collection) 519
Understanding the Basics of Working in a Garbage-Collected Platform 520
Allocating Resources from the Managed Heap 521
The Garbage Collection Algorithm 523
Garbage Collections and Debugging 527
Using Finalization to Release Native Resources 530
Guaranteed Finalization Using Critical Finalizer Object Types 532
Interoperating with Unmanaged Code by Using SafeHandle Types 535
Using Finalization with Managed Resources 537
What Causes Finalize Methods to Be Called? 540
Finalization Internals 541
The Dispose Pattern:Forcing an Object to Clean Up 544
Using a Type That Implements the Dispose Pattern 548
C#'s using Statement 551
An Interesting Dependency Issue 554
Monitoring and Controlling the Lifetime of Objects Manually 555
Resurrection 566
Generationsv 568
Other Garbage Collection Features for Use with Native Resources 574
Predicting the Success of an Operation that Requires a Lot of Memory 578
Programmatic Control ofthe Garbage Collector 580
Thread Hijacking 583
Garbage Collection Modes 585
Large Objects 588
Monitoring Garbage Collections 589
22 CLR Hosting and AppDomains 591
CLR Hosting 592
AppDomains 594
Accessing Objects Across AppDomain Boundaries 597
AppDomain Unloading 609
AppDomain Monitoring 610
AppDomain First-Chance Exception Notifications 612
How Hosts Use AppDomains 612
Executable Applications 612
Microsoft Silverlight Rich Internet Applications 613
Microsoft ASP.NET Web Forms and XML Web Services Applications 613
Microsoft SQL Server 614
Your Own Imagination 614
Advanced Host Control 615
Managing the CLR by Using Managed Code 615
Writing a Robust Host Application 616
How a Host Gets Its Thread Back 617
23 Assembly Loading and Reflection 621
Assembly Loading 621
Using Reflection to Build a Dynamically Extensible Application 626
Reflection Performance 627
Discovering Types Defined in an Assembly 628
What Exactly Is a Type Object? 628
Building a Hierarchy of Exception-Derived Types 631
Constructing an Instance of a Type 632
Designing an Application That Supports Add-Ins 634
Using Reflection to Discover a Type's Members 637
Discovering a Type's Members 638
BindingFlags:Filtering the Kinds of Members That Are Returned 643
Discovering a Type's Interfaces 644
Invoking a Type's Members 646
Bind Once,Invoke Multiple Times 650
Using Binding Handles to Reduce Your Process's Memory Consumption 658
24 Runtime Serialization 661
Serialization/Deserialization Quick Start 662
Making a Type Serializable 667
Controlling Serialization and Deserialization 668
How Formatters Serialize Type Instances 672
Controlling the Serialized/Deserialized Data 673
How to Define a Type That Implements ISerializable when the Base Type Doesn't Implement This Interface 678
Streaming Contexts 680
Serializing a Type as a Different Type and Deserializing an Object as a Different Object 682
Serialization Surrogates 684
Surrogate Selector Chains 688
Overriding the Assembly and/or Type When Deserializing an Object 689
Part Ⅴ Threading 691
25 Thread Basics 691
Why Does Windows Support Threads? 691
Thread Overhead 692
Stop the Madness 696
CPU Trends 699
NUMA Architecture Machines 700
CLR Threads and Windows Threads 703
Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation 704
Reasons to Use Threads 706
Thread Scheduling and Priorities 708
Foreground Threads versus Background Threads 713
What Now? 715
26 Compute-Bound Asynchronous Operations 717
Introducing the CLR's Thread Pool 718
Performing a Simple Compute-Bound Operation 719
Execution Contexts 721
Cooperative Cancellation 722
Tasks 726
Waiting for a Taskto Complete and Getting Its Result 727
Cancelling a Task 729
Starting a New Task Automatically When Another Task Completes 731
A Task May Start Child Tasks 733
Inside a Task 733
Task Factories 735
Task Schedulers 737
Parallel's Static For,ForEach,and Invoke Methods 739
Parallel Language Integrated Query 743
Performing a Periodic Compute-Bound Operation 747
So Many Timers,So Little Time 749
How the Thread Pool Manages Its Threads 750
Setting Thread Pool Limits 750
How Worker Threads Are Managed 751
Cache Lines and False Sharing 752
27 I/O-Bound Asynchronous Operations 755
How Windows Performs I/O Operations 755
The CLR's Asynchronous Programming Model(APM) 761
The AsyncEnumerator Class 765
The APM and Exceptions 769
Applications and Their Threading Models 770
Implementing a Server Asynchronously 773
The APM and Compute-Bound Operations 774
APM Considerations 776
Using the APM Without the Thread Pool 776
Always Call the EndXxx Method,and Call It Only Once 777
Always Use the Same Object When Calling the EndXxx Method 778
Using ref,out,and params Arguments with BeginXxx and EndXxx Methods 778
You Can't Cancel an Asynchronous I/O-Bound Operation 778
Memory Consumption 778
Some I/O Operations Must Be Done Synchronously 779
FileStream-Specific Issues 780
I/O Request Priorities 780
Converting the IAsyncResult APM to a Task 783
The Event-Based Asynchronous Pattern 784
Converting the EAP to a Task 786
Comparing the APM and the EAP 788
Programming Model Soup 788
28 Primitive Thread Synchronization Constructs 791
Class Libraries and Thread Safety 793
Primitive User-Mode and Kernel-Mode Constructs 794
User-Mode Constructs 796
Volatile Constructs 797
Interlocked Constructs 803
Implementing a Simple Spin Lock 807
The Interlocked Anything Pattern 811
Kernel-Mode Constructs 813
Event Constructs 817
Semaphore Constructs 819
Mutex Constructs 820
Calling a Method When a Single Kernel Construct Becomes Available 822
29 Hybrid Thread Synchronization Constructs 825
A Simple Hybrid Lock 826
Spinning,Thread Ownership,and Recursion 827
A Potpourri of Hybrid Constructs 829
The Manual Reset Event Slim and Semaphore Slim Classes 830
The Monitor Class and Sync Blocks 830
The Reader Writer Lock Slim Class 836
The One Many Lock Class 838
The Countdown Event Class 841
The Barrier Class 841
Thread Synchronization Construct Summary 842
The Famous Double-Check Locking Technique 844
The Condition Variable Pattern 848
Using Collections to Avoid Holding a Lock for a Long Time 851
The Concurrent Collection Classes 856
Index 861