我们先来看看这书的作者Jeffrey Richter，Jeffrey Richter是一位在全球享有盛誉的技术作家，尤其在Windows/.NET领域有着杰出的贡献。他的第一本Windows著作Windows 3: A Developer's Guide大获好评，从而声名远扬。之后，他又推出了经典著作《Windows 高级编程指南》和《Windows核心编程》。如今这两本书早已成为Windows程序设计领域的颠峰之作，培育了几代软件开发设计人员。他的每一本新作问世，我们都有理由相信这是一本巨著，我们想要的一切尽在其中。Jeffery 是Wintellect公司的创始人之一，也是MSDN杂志.NET专栏的特邀编辑。现在他正领导开发该公司的.NET程序设计课程，向大众推广.NET技术。因为他自1999年开始就参与了微软.NET框架开发组的咨询工作，与这些一线人员一起经历了.NET的孕育与诞生，所以他对.NET思想的领悟、对.NET的细节熟稔，是其他任何作家难以企及的。他是.NET著作领域中当之无愧的一面旗帜。
2003年我买了这本书的第一版《Microsoft .NET框架程序设计（修订版）》，从那时我才真正深入了解.net，后来这本书被朋友借去没还，很让我咬牙切齿了一阵。
2006年我买了这本书的第二版《框架设计（第2版）：CLR Via C#》，没完全看完，翻译的虽然不如第一版，但还不算垃圾，英文不太好的可以买本看看，但如果英文过的去也比较有空的话可以看看原版，网上有电子版下载。
前天我在网上看到了这本书的最新版，下载，本来想看完再仔细写个读后感的，但鉴于全书896页，我觉得以我读英文的速度和我空余时间综合计算没3个月拿不下来，别耽误的别人，就先推荐一下吧。
作者：Jeffrey Richter
出版日期：February 2010
出版社：Microsoft Press
页数：896
ISBN：978-0-7356-4045-0
目录：
Part I CLR Basics
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 II Designing Types
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 Parameters . 219
Optional and Named Parameters . 219
Rules and Guidelines 220
The DefaultParameterValue and Optional Attributes 222
Implicitly Typed Local Variables 223
Passing Parameters by Reference to 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 III Essential Types
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 StringBuilder 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 IV Core Facilities
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 CriticalFinalizerObject 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
Generations . 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 of the 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 V Threading
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 Task to 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 ManualResetEventSlim and SemaphoreSlim Classes 830
The Monitor Class and Sync Blocks . 830
The ReaderWriterLockSlim Class . 836
The OneManyLock Class 838
The CountdownEvent 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