框架设计 第3版 影印版 英文PDF|Epub|txt|kindle电子书版本下载

框架设计 第3版 影印版 英文PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

Part Ⅰ CLR Basics1

1 The CLR's Execution Model1

Compiling Source Code into Managed Modules1

Combining Managed Modules into Assemblies5

Loading the Common Language Runtime6

Executing your Assembly's Code9

IL and Verification15

Unsafe Code16

The Native Code Generator Tool:NGen.exe18

The Framework Class Library20

The Common Type System22

The Common Language Specification25

Interoperability with Unmanaged Code29

2 Building,Packaging,Deploying,and Administering Applications and Types31

.NET Framework Deployment Goals32

Building Types into a Module33

Response Files34

A Brief Look at Metadata36

Combining Modules to Form an Assembly43

Adding Assemblies to a Project by Using the Visual Studio IDE49

Using the Assembly Linker50

Adding Resource Files to an Assembly52

Assembly Version Resource Information53

Version Numbers57

Culture58

Simple Application Deployment(Privately Deployed Assemblies)59

Simple Administrative Control(Configuration)61

3 Shared Assemblies and Strongly Named Assemblies65

Two Kinds of Assemblies,Two Kinds of Deployment66

Giving an Assembly a Strong Name67

The Global Assembly Cache73

Building an Assembly That References a Strongly Named Assembly75

Strongly Named Assemblies Are Tamper-Resistant76

Delayed Signing77

Privately Deploying Strongly Named Assemblies80

How the Runtime Resolves Type References81

Advanced Administrative Control(Configuration)84

Publisher Policy Control87

Part Ⅱ Designing Types91

4 Type Fundamentals91

All Types Are Derived from System.Object91

Casting Between Types93

Casting with the C# is and as Operators95

Namespaces and Assemblies97

How Things Relate at Runtime102

5 Primitive,Reference,and Value Types113

Programming Language Primitive Types113

Checked and Unchecked Primitive Type Operations117

Reference Types and Value Types121

Boxing and Unboxing Value Types127

Changing Fields in a Boxed Value Type by Using Interfaces(and Why You Shouldn't Do This)140

Object Equality and Identity143

Object Hash Codes146

The dynamiC Primitive Type148

6 Type and Member Basics155

The Different Kinds of Type Members155

Type Visibility158

Friend Assemblies159

Member Accessibility160

Static Classes162

Partial Classes,Structures,and Interfaces164

Components,Polymorphism,and Versioning165

How the CLR Calls Virtual Methods,Properties,and Events167

Using Type Visibility and Member Accessibility Intelligently172

Dealing with Virtual Methods When Versioning Types175

7 Constants and Fields181

Constants181

Fields183

8 Methods187

Instance Constructors and Classes(Reference Types)187

Instance Constructors and Structures(Value Types)191

Type Constructors194

Type Constructor Performance198

Operator Overload Methods200

Operators and Programming Language Interoperability203

Conversion Operator Methods204

Extension Methods207

Rules and Guidelines210

Extending Various Types with Extension Methods211

The Extension Attribute213

Partial Methods213

Rules and Guidelines216

9 Parametersv219

Optional and Named Parameters219

Rules and Guidelines220

The Default Parameter Value and Optional Attributes222

Implicitly Typed Local Variables223

Passing Parameters by Referenceto a Method225

Passing a Variable Number of Arguments to a Method231

Parameter and Return Type Guidelines233

Const-ness235

10 Properties237

Parameterless Properties237

Automatically Implemented Properties241

Defining Properties Intelligently242

Object and Collection Initializers245

Anonymous Types247

The System.Tuple Type250

Parameterful Properties252

The Performance of Calling Property Accessor Methods257

Property Accessor Accessibility258

Generic Property Accessor Methods258

11 Events259

Designing a Type That Exposes an Event260

Step #1：Define a type that will hold any additional information that should be sent to receivers of the event notification261

Step #2：Define the event member262

Step #3：Define a method responsible for raising the event to notify registered objects that the event has occurred263

Step #4：Define a method that translates the input into the desired event266

How the Compiler Implements an Event266

Designing a Type That Listens for an Event269

Explicitly Implementing an Event271

12 Generics275

Generics in the Framework Class Library280

Wintellect's Power Collections Library281

Generics Infrastructure282

Open and Closed Types283

Generic Types and Inheritance285

Generic Type Identity287

Code Explosion288

Generic Interfaces289

Generic Delegates290

Delegate and Interface Contravariant and Covariant Generic Type Arguments291

Generic Methods293

Generic Methods and Type Inference294

Generics and Other Members296

Verifiability and Constraints296

Primary Constraints299

Secondary Constraints300

Constructor Constraints301

Other Verifiability Issues302

13 Interfaces307

Class and Interface Inheritance308

Defining an Interface308

Inheriting an Interface310

More About Calling Interface Methods312

Implicit and Explicit Interface Method Implementations(What's Happening Behind the Scenes)314

Generic Interfaces315

Generics and Interface Constraints318

Implementing Multiple Interfaces That Have the Same Method Name and Signature319

Improving Compile-Time Type Safety with Explicit Interface Method Implementations320

Be Careful with Explicit Interface Method Implementations322

Design:Base Class or Interface?325

Part Ⅲ Essential Types327

14 Chars,Strings,and Working with Text327

Characters327

The System.String Type330

Constructing Strings330

Strings Are Immutable333

Comparing Strings334

String Interning340

String Pooling343

Examining a String's Characters and Text Elements343

Other String Operations346

Constructing a String Efficiently346

Constructing a String Builder Object347

StringBuilder Members348

Obtaining a String Representation of an Object:ToString350

Specific Formats and Cultures351

Formatting Multiple Objects into a Single String355

Providing Your Own Custom Formatter356

Parsing a String to Obtain an Object:Parse359

Encodings:Converting Between Characters and Bytes361

Encoding and Decoding Streams of Characters and Bytes367

Base-64 String Encoding and Decoding368

Secure Strings369

15 Enumerated Types and Bit Flags373

Enumerated Types373

Bit Flags379

Adding Methods to Enumerated Types383

16 Arrays385

Initializing Array Elements388

Casting Arrays390

All Arrays Are Implicitly Derived from System.Array392

All Arrays Implicitly Implement IEnumerable,ICollection,and IList393

Passing and Returning Arrays394

Creating Non-Zero-Lower Bound Arrays395

Array Access Performance396

Unsafe Array Access and Fixed-Size Array401

17 Delegates405

A First Look at Delegates405

Using Delegates to Call Back Static Methods408

Using Delegates to Call Back Instance Methods409

Demystifying Delegates410

Using Delegates to Call Back Many Methods(Chaining)415

C#'s Support for Delegate Chains419

Having More Control over Delegate Chain Invocation419

Enough with the Delegate Definitions Already(Generic Delegates)422

C#'s Syntactical Sugar for Delegates423

Syntactical Shortcut #1:No Need to Construct a Delegate Object424

Syntactical Shortcut #2:No Need to Define a Callback Method424

Syntactical Shortcut #3:No Need to Wrap Local Variables in a Class Manually to Pass Them to a Callback Method428

Delegates and Reflection431

18 Custom Attributes435

Using Custom Attributes435

Defining Your Own Attribute Class439

Attribute Constructor and Field/Property Data Types443

Detecting the Use of a Custom Attribute444

Matching Two Attribute Instances Against Each Other448

Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects451

Conditional Attribute Classes454

19 Nullable Value Types457

C#'s Support for Nullable Value Types459

C#'s Null-Coalescing Operator462

The CLR Has Special Support for Nullable Value Types463

Boxing Nullable Value Types463

Unboxing Nullable Value Types463

Calling GetType via a Nullable Value Type464

Calling Interface Methods via a Nullable Value Type464

Part Ⅳ Core Facilities465

20 Exceptions and State Management465

Defining"Exception"466

Exception-Handling Mechanics467

The try Block468

The catch Block469

The finally Block470

The System.Exception Class474

FCL-Defined Exception Classes478

Throwing an Exception480

Defining Your Own Exception Class481

Trading Reliability for Productivity484

Guidelines and Best Practices492

Use finally Blocks Liberally492

Don't Catch Everything494

Recovering Gracefully from an Exception495

Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State496

Hiding an Implementation Detail to Maintain a"Contract"497

Unhandled Exceptions500

Debugging Exceptions504

Exception-Handling Performance Considerations506

Constrained Execution Regions(CERs)509

Code Contracts512

21 Automatic Memory Management(Garbage Collection)519

Understanding the Basics of Working in a Garbage-Collected Platform520

Allocating Resources from the Managed Heap521

The Garbage Collection Algorithm523

Garbage Collections and Debugging527

Using Finalization to Release Native Resources530

Guaranteed Finalization Using Critical Finalizer Object Types532

Interoperating with Unmanaged Code by Using SafeHandle Types535

Using Finalization with Managed Resources537

What Causes Finalize Methods to Be Called?540

Finalization Internals541

The Dispose Pattern:Forcing an Object to Clean Up544

Using a Type That Implements the Dispose Pattern548

C#'s using Statement551

An Interesting Dependency Issue554

Monitoring and Controlling the Lifetime of Objects Manually555

Resurrection566

Generationsv568

Other Garbage Collection Features for Use with Native Resources574

Predicting the Success of an Operation that Requires a Lot of Memory578

Programmatic Control ofthe Garbage Collector580

Thread Hijacking583

Garbage Collection Modes585

Large Objects588

Monitoring Garbage Collections589

22 CLR Hosting and AppDomains591

CLR Hosting592

AppDomains594

Accessing Objects Across AppDomain Boundaries597

AppDomain Unloading609

AppDomain Monitoring610

AppDomain First-Chance Exception Notifications612

How Hosts Use AppDomains612

Executable Applications612

Microsoft Silverlight Rich Internet Applications613

Microsoft ASP.NET Web Forms and XML Web Services Applications613

Microsoft SQL Server614

Your Own Imagination614

Advanced Host Control615

Managing the CLR by Using Managed Code615

Writing a Robust Host Application616

How a Host Gets Its Thread Back617

23 Assembly Loading and Reflection621

Assembly Loading621

Using Reflection to Build a Dynamically Extensible Application626

Reflection Performance627

Discovering Types Defined in an Assembly628

What Exactly Is a Type Object?628

Building a Hierarchy of Exception-Derived Types631

Constructing an Instance of a Type632

Designing an Application That Supports Add-Ins634

Using Reflection to Discover a Type's Members637

Discovering a Type's Members638

BindingFlags:Filtering the Kinds of Members That Are Returned643

Discovering a Type's Interfaces644

Invoking a Type's Members646

Bind Once,Invoke Multiple Times650

Using Binding Handles to Reduce Your Process's Memory Consumption658

24 Runtime Serialization661

Serialization/Deserialization Quick Start662

Making a Type Serializable667

Controlling Serialization and Deserialization668

How Formatters Serialize Type Instances672

Controlling the Serialized/Deserialized Data673

How to Define a Type That Implements ISerializable when the Base Type Doesn't Implement This Interface678

Streaming Contexts680

Serializing a Type as a Different Type and Deserializing an Object as a Different Object682

Serialization Surrogates684

Surrogate Selector Chains688

Overriding the Assembly and/or Type When Deserializing an Object689

Part Ⅴ Threading691

25 Thread Basics691

Why Does Windows Support Threads?691

Thread Overhead692

Stop the Madness696

CPU Trends699

NUMA Architecture Machines700

CLR Threads and Windows Threads703

Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation704

Reasons to Use Threads706

Thread Scheduling and Priorities708

Foreground Threads versus Background Threads713

What Now?715

26 Compute-Bound Asynchronous Operations717

Introducing the CLR's Thread Pool718

Performing a Simple Compute-Bound Operation719

Execution Contexts721

Cooperative Cancellation722

Tasks726

Waiting for a Taskto Complete and Getting Its Result727

Cancelling a Task729

Starting a New Task Automatically When Another Task Completes731

A Task May Start Child Tasks733

Inside a Task733

Task Factories735

Task Schedulers737

Parallel's Static For,ForEach,and Invoke Methods739

Parallel Language Integrated Query743

Performing a Periodic Compute-Bound Operation747

So Many Timers,So Little Time749

How the Thread Pool Manages Its Threads750

Setting Thread Pool Limits750

How Worker Threads Are Managed751

Cache Lines and False Sharing752

27 I/O-Bound Asynchronous Operations755

How Windows Performs I/O Operations755

The CLR's Asynchronous Programming Model(APM)761

The AsyncEnumerator Class765

The APM and Exceptions769

Applications and Their Threading Models770

Implementing a Server Asynchronously773

The APM and Compute-Bound Operations774

APM Considerations776

Using the APM Without the Thread Pool776

Always Call the EndXxx Method,and Call It Only Once777

Always Use the Same Object When Calling the EndXxx Method778

Using ref,out,and params Arguments with BeginXxx and EndXxx Methods778

You Can't Cancel an Asynchronous I/O-Bound Operation778

Memory Consumption778

Some I/O Operations Must Be Done Synchronously779

FileStream-Specific Issues780

I/O Request Priorities780

Converting the IAsyncResult APM to a Task783

The Event-Based Asynchronous Pattern784

Converting the EAP to a Task786

Comparing the APM and the EAP788

Programming Model Soup788

28 Primitive Thread Synchronization Constructs791

Class Libraries and Thread Safety793

Primitive User-Mode and Kernel-Mode Constructs794

User-Mode Constructs796

Volatile Constructs797

Interlocked Constructs803

Implementing a Simple Spin Lock807

The Interlocked Anything Pattern811

Kernel-Mode Constructs813

Event Constructs817

Semaphore Constructs819

Mutex Constructs820

Calling a Method When a Single Kernel Construct Becomes Available822

29 Hybrid Thread Synchronization Constructs825

A Simple Hybrid Lock826

Spinning,Thread Ownership,and Recursion827

A Potpourri of Hybrid Constructs829

The Manual Reset Event Slim and Semaphore Slim Classes830

The Monitor Class and Sync Blocks830

The Reader Writer Lock Slim Class836

The One Many Lock Class838

The Countdown Event Class841

The Barrier Class841

Thread Synchronization Construct Summary842

The Famous Double-Check Locking Technique844

The Condition Variable Pattern848

Using Collections to Avoid Holding a Lock for a Long Time851

The Concurrent Collection Classes856

Index861