CLR via C#, Third Edition图书推荐及下载

我们先来看看这书的作者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