CLR via C#, Third Edition

Table of Contents

Foreword; Introduction; Who This Book Is For; Dedication; Acknowledgments; Support for This Book; We Want to Hear from You; Part I: CLR Basics; Chapter 1: The CLR's Execution Model; 1.1 Compiling Source Code into Managed Modules; 1.2 Combining Managed Modules into Assemblies; 1.3 Loading the Common Language Runtime; 1.4 Executing your Assembly's Code; 1.5 The Native Code Generator Tool: NGen.exe; 1.6 The Framework Class Library; 1.7 The Common Type System; 1.8 The Common Language Specification; 1.9 Interoperability with Unmanaged Code; Chapter 2: Building, Packaging, Deploying, and Administering Applications and Types; 2.1 .NET Framework Deployment Goals; 2.2 Building Types into a Module; 2.3 A Brief Look at Metadata; 2.4 Combining Modules to Form an Assembly; 2.5 Assembly Version Resource Information; 2.6 Culture; 2.7 Simple Application Deployment (Privately Deployed Assemblies); 2.8 Simple Administrative Control (Configuration); Chapter 3: Shared Assemblies and Strongly Named Assemblies; 3.1 Two Kinds of Assemblies, Two Kinds of Deployment; 3.2 Giving an Assembly a Strong Name; 3.3 The Global Assembly Cache; 3.4 Building an Assembly That References a Strongly Named Assembly; 3.5 Strongly Named Assemblies Are Tamper-Resistant; 3.6 Delayed Signing; 3.7 Privately Deploying Strongly Named Assemblies; 3.8 How the Runtime Resolves Type References; 3.9 Advanced Administrative Control (Configuration); Part II: Designing Types; Chapter 4: Type Fundamentals; 4.1 All Types Are Derived from System.Object; 4.2 Casting Between Types; 4.3 Namespaces and Assemblies; 4.4 How Things Relate at Runtime; Chapter 5: Primitive, Reference, and Value Types; 5.1 Programming Language Primitive Types; 5.2 Reference Types and Value Types; 5.3 Boxing and Unboxing Value Types; 5.4 Object Hash Codes; 5.5 The dynamic Primitive Type; Chapter 6: Type and Member Basics; 6.1 The Different Kinds of Type Members; 6.2 Type Visibility; 6.3 Member Accessibility; 6.4 Static Classes; 6.5 Partial Classes, Structures, and Interfaces; 6.6 Components, Polymorphism, and Versioning; Chapter 7: Constants and Fields; 7.1 Constants; 7.2 Fields; Chapter 8: Methods; 8.1 Instance Constructors and Classes (Reference Types); 8.2 Instance Constructors and Structures (Value Types); 8.3 Type Constructors; 8.4 Operator Overload Methods; 8.5 Conversion Operator Methods; 8.6 Extension Methods; 8.7 Partial Methods; Chapter 9: Parameters; 9.1 Optional and Named Parameters; 9.2 Implicitly Typed Local Variables; 9.3 Passing Parameters by Reference to a Method; 9.4 Passing a Variable Number of Arguments to a Method; 9.5 Parameter and Return Type Guidelines; 9.6 Const-ness; Chapter 10: Properties; 10.1 Parameterless Properties; 10.2 Parameterful Properties; 10.3 The Performance of Calling Property Accessor Methods; 10.4 Property Accessor Accessibility; 10.5 Generic Property Accessor Methods; Chapter 11: Events; 11.1 Designing a Type That Exposes an Event; 11.2 How the Compiler Implements an Event; 11.3 Designing a Type That Listens for an Event; 11.4 Explicitly Implementing an Event; Chapter 12: Generics; 12.1 Generics in the Framework Class Library; 12.2 Wintellect's Power Collections Library; 12.3 Generics Infrastructure; 12.4 Generic Interfaces; 12.5 Generic Delegates; 12.6 Delegate and Interface Contravariant and Covariant Generic Type Arguments; 12.7 Generic Methods; 12.8 Generics and Other Members; 12.9 Verifiability and Constraints; Chapter 13: Interfaces; 13.1 Class and Interface Inheritance; 13.2 Defining an Interface; 13.3 Inheriting an Interface; 13.4 More About Calling Interface Methods; 13.5 Implicit and Explicit Interface Method Implementations (What's Happening Behind the Scenes); 13.6 Generic Interfaces; 13.7 Generics and Interface Constraints; 13.8 Implementing Multiple Interfaces That Have the Same Method Name and Signature; 13.9 Improving Compile-Time Type Safety with Explicit Interface Method Implementations; 13.10 Be Careful with Explicit Interface Method Implementations; 13.11 Design: Base Class or Interface?; Part III: Essential Types; Chapter 14: Chars, Strings, and Working with Text; 14.1 Characters; 14.2 The System.String Type; 14.3 Constructing a String Efficiently; 14.4 Obtaining a String Representation of an Object: ToString; 14.5 Parsing a String to Obtain an Object: Parse; 14.6 Encodings: Converting Between Characters and Bytes; 14.7 Secure Strings; Chapter 15: Enumerated Types and Bit Flags; 15.1 Enumerated Types; 15.2 Bit Flags; 15.3 Adding Methods to Enumerated Types; Chapter 16: Arrays; 16.1 Initializing Array Elements; 16.2 Casting Arrays; 16.3 All Arrays Are Implicitly Derived from System.Array; 16.4 All Arrays Implicitly Implement IEnumerable, ICollection, and IList; 16.5 Passing and Returning Arrays; 16.6 Creating Non-Zero–Lower Bound Arrays; 16.7 Array Access Performance; 16.8 Unsafe Array Access and Fixed-Size Array; Chapter 17: Delegates; 17.1 A First Look at Delegates; 17.2 Using Delegates to Call Back Static Methods; 17.3 Using Delegates to Call Back Instance Methods; 17.4 Demystifying Delegates; 17.5 Using Delegates to Call Back Many Methods (Chaining); 17.6 Enough with the Delegate Definitions Already (Generic Delegates); 17.7 C#'s Syntactical Sugar for Delegates; 17.8 Delegates and Reflection; Chapter 18: Custom Attributes; 18.1 Using Custom Attributes; 18.2 Defining Your Own Attribute Class; 18.3 Attribute Constructor and Field/Property Data Types; 18.4 Detecting the Use of a Custom Attribute; 18.5 Matching Two Attribute Instances Against Each Other; 18.6 Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects; 18.7 Conditional Attribute Classes; Chapter 19: Nullable Value Types; 19.1 C#'s Support for Nullable Value Types; 19.2 C#'s Null-Coalescing Operator; 19.3 The CLR Has Special Support for Nullable Value Types; Part IV: Core Facilities; Chapter 20: Exceptions and State Management; 20.1 Defining "Exception"; 20.2 Exception-Handling Mechanics; 20.3 The System.Exception Class; 20.4 FCL-Defined Exception Classes; 20.5 Throwing an Exception; 20.6 Defining Your Own Exception Class; 20.7 Trading Reliability for Productivity; 20.8 Guidelines and Best Practices; 20.9 Unhandled Exceptions; 20.10 Debugging Exceptions; 20.11 Exception-Handling Performance Considerations; 20.12 Constrained Execution Regions (CERs); 20.13 Code Contracts; Chapter 21: Automatic Memory Management (Garbage Collection); 21.1 Understanding the Basics of Working in a Garbage-Collected Platform; 21.2 The Garbage Collection Algorithm; 21.3 Garbage Collections and Debugging; 21.4 Using Finalization to Release Native Resources; 21.5 Using Finalization with Managed Resources; 21.6 What Causes Finalize Methods to Be Called?; 21.7 Finalization Internals; 21.8 The Dispose Pattern: Forcing an Object to Clean Up; 21.9 Using a Type That Implements the Dispose Pattern; 21.10 C#'s using Statement; 21.11 An Interesting Dependency Issue; 21.12 Monitoring and Controlling the Lifetime of Objects Manually; 21.13 Resurrection; 21.14 Generations; 21.15 Other Garbage Collection Features for Use with Native Resources; 21.16 Predicting the Success of an Operation that Requires a Lot of Memory; 21.17 Programmatic Control of the Garbage Collector; 21.18 Thread Hijacking; 21.19 Garbage Collection Modes; 21.20 Large Objects; 21.21 Monitoring Garbage Collections; Chapter 22: CLR Hosting and AppDomains; 22.1 CLR Hosting; 22.2 AppDomains; 22.3 AppDomain Unloading; 22.4 AppDomain Monitoring; 22.5 AppDomain First-Chance Exception Notifications; 22.6 How Hosts Use AppDomains; 22.7 Advanced Host Control; Chapter 23: Assembly Loading and Reflection; 23.1 Assembly Loading; 23.2 Using Reflection to Build a Dynamically Extensible Application; 23.3 Reflection Performance; 23.4 Designing an Application That Supports Add-Ins; 23.5 Using Reflection to Discover a Type's Members; Chapter 24: Runtime Serialization; 24.1 Serialization/Deserialization Quick Start; 24.2 Making a Type Serializable; 24.3 Controlling Serialization and Deserialization; 24.4 How Formatters Serialize Type Instances; 24.5 Controlling the Serialized/Deserialized Data; 24.6 Streaming Contexts; 24.7 Serializing a Type as a Different Type and Deserializing an Object as a Different Object; 24.8 Serialization Surrogates; 24.9 Overriding the Assembly and/or Type When Deserializing an Object; Part V: Threading; Chapter 25: Thread Basics; 25.1 Why Does Windows Support Threads?; 25.2 Thread Overhead; 25.3 Stop the Madness; 25.4 CPU Trends; 25.5 NUMA Architecture Machines; 25.6 CLR Threads and Windows Threads; 25.7 Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation; 25.8 Reasons to Use Threads; 25.9 Thread Scheduling and Priorities; 25.10 Foreground Threads versus Background Threads; 25.11 What Now?; Chapter 26: Compute-Bound Asynchronous Operations; 26.1 Introducing the CLR's Thread Pool; 26.2 Performing a Simple Compute-Bound Operation; 26.3 Execution Contexts; 26.4 Cooperative Cancellation; 26.5 Tasks; 26.6 Parallel's Static For, ForEach, and Invoke Methods; 26.7 Parallel Language Integrated Query; 26.8 Performing a Periodic Compute-Bound Operation; 26.9 How the Thread Pool Manages Its Threads; 26.10 Cache Lines and False Sharing; Chapter 27: I/O-Bound Asynchronous Operations; 27.1 How Windows Performs I/O Operations; 27.2 The CLR's Asynchronous Programming Model (APM); 27.3 The AsyncEnumerator Class; 27.4 The APM and Exceptions; 27.5 Applications and Their Threading Models; 27.6 Implementing a Server Asynchronously; 27.7 The APM and Compute-Bound Operations; 27.8 APM Considerations; 27.9 I/O Request Priorities; 27.10 Converting the IAsyncResult APM to a Task; 27.11 The Event-Based Asynchronous Pattern; 27.12 Programming Model Soup; Chapter 28: Primitive Thread Synchronization Constructs; 28.1 Class Libraries and Thread Safety; 28.2 Primitive User-Mode and Kernel-Mode Constructs; 28.3 User-Mode Constructs; 28.4 Kernel-Mode Constructs; Chapter 29: Hybrid Thread Synchronization Constructs; 29.1 A Simple Hybrid Lock; 29.2 Spinning, Thread Ownership, and Recursion; 29.3 A Potpourri of Hybrid Constructs; 29.4 The Famous Double-Check Locking Technique; 29.5 The Condition Variable Pattern; 29.6 Using Collections to Avoid Holding a Lock for a Long Time; 29.7 The Concurrent Collection Classes;

Jeffrey Richter is a cofounder of Wintellect (www.wintellect.com)-a training, debugging, and consulting firm dedicated to helping companies build better software faster. He is the author of the previous editions of this book, Windows via C/C++, and several other Windows-related programming books. Jeffrey has been consulting with the Microsoft .NET Framework team since October 1999.