CLR Basics Chapter 1 The CLR's Execution Model Compiling Source Code into Managed Modules Combining Managed Modules into Assemblies Loading the Common Language Runtime Executing your Assembly's Code The Native Code Generator Tool: NGen.exe The Framework Class Library The Common Type System The Common Language Specification Interoperability with Unmanaged Code Chapter 2 Building, Packaging, Deploying, and Administering Applications and Types .NET Framework Deployment Goals Building Types into a Module A Brief Look at Metadata Combining Modules to Form an Assembly Assembly Version Resource Information Culture Simple Application Deployment (Privately Deployed Assemblies) Simple Administrative Control (Configuration) Chapter 3 Shared Assemblies and Strongly Named Assemblies Two Kinds of Assemblies, Two Kinds of Deployment Giving an Assembly a Strong Name The Global Assembly Cache Building an Assembly That References a Strongly Named Assembly Strongly Named Assemblies Are Tamper-Resistant Delayed Signing Privately Deploying Strongly Named Assemblies How the Runtime Resolves Type References Advanced Administrative Control (Configuration) Designing Types Chapter 4 Type Fundamentals All Types Are Derived from System.Object Casting Between Types Namespaces and Assemblies How Things Relate at Runtime Chapter 5 Primitive, Reference, and Value Types Programming Language Primitive Types Reference Types and Value Types Boxing and Unboxing Value Types Object Hash Codes The dynamic Primitive Type Chapter 6 Type and Member Basics The Different Kinds of Type Members Type Visibility Member Accessibility Static Classes Partial Classes, Structures, and Interfaces Components, Polymorphism, and Versioning Chapter 7 Constants and Fields Constants Fields Chapter 8 Methods Instance Constructors and Classes (Reference Types) Instance Constructors and Structures (Value Types) Type Constructors Operator Overload Methods Conversion Operator Methods Extension Methods Partial Methods Chapter 9 Parameters Optional and Named Parameters Implicitly Typed Local Variables Passing Parameters by Reference to a Method Passing a Variable Number of Arguments to a Method Parameter and Return Type Guidelines Const-ness Chapter 10 Properties Parameterless Properties Parameterful Properties The Performance of Calling Property Accessor Methods Property Accessor Accessibility Generic Property Accessor Methods Chapter 11 Events Designing a Type That Exposes an Event How the Compiler Implements an Event Designing a Type That Listens for an Event Explicitly Implementing an Event Chapter 12 Generics Generics in the Framework Class Library Wintellect's Power Collections Library Generics Infrastructure Generic Interfaces Generic Delegates Delegate and Interface Contravariant and Covariant Generic Type Arguments Generic Methods Generics and Other Members Verifiability and Constraints Chapter 13 Interfaces Class and Interface Inheritance Defining an Interface Inheriting an Interface More About Calling Interface Methods Implicit and Explicit Interface Method Implementations (What's Happening Behind the Scenes) Generic Interfaces Generics and Interface Constraints Implementing Multiple Interfaces That Have the Same Method Name and Signature Improving Compile-Time Type Safety with Explicit Interface Method Implementations Be Careful with Explicit Interface Method Implementations Design: Base Class or Interface? Essential Types Chapter 14 Chars, Strings, and Working with Text Characters The System.String Type Constructing a String Efficiently Obtaining a String Representation of an Object: ToString Parsing a String to Obtain an Object: Parse Encodings: Converting Between Characters and Bytes Secure Strings Chapter 15 Enumerated Types and Bit Flags Enumerated Types Bit Flags Adding Methods to Enumerated Types Chapter 16 Arrays Initializing Array Elements Casting Arrays All Arrays Are Implicitly Derived from System.Array All Arrays Implicitly Implement IEnumerable, ICollection, and IList Passing and Returning Arrays Creating Non-Zero–Lower Bound Arrays Array Access Performance Unsafe Array Access and Fixed-Size Array Chapter 17 Delegates A First Look at Delegates Using Delegates to Call Back Static Methods Using Delegates to Call Back Instance Methods Demystifying Delegates Using Delegates to Call Back Many Methods (Chaining) Enough with the Delegate Definitions Already (Generic Delegates) C#'s Syntactical Sugar for Delegates Delegates and Reflection Chapter 18 Custom Attributes Using Custom Attributes Defining Your Own Attribute Class Attribute Constructor and Field/Property Data Types Detecting the Use of a Custom Attribute Matching Two Attribute Instances Against Each Other Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects Conditional Attribute Classes Chapter 19 Nullable Value Types C#'s Support for Nullable Value Types C#'s Null-Coalescing Operator The CLR Has Special Support for Nullable Value Types Core Facilities Chapter 20 Exceptions and State Management Defining "Exception" Exception-Handling Mechanics The System.Exception Class FCL-Defined Exception Classes Throwing an Exception Defining Your Own Exception Class Trading Reliability for Productivity Guidelines and Best Practices Unhandled Exceptions Debugging Exceptions Exception-Handling Performance Considerations Constrained Execution Regions (CERs) Code Contracts Chapter 21 Automatic Memory Management (Garbage Collection) Understanding the Basics of Working in a Garbage-Collected Platform The Garbage Collection Algorithm Garbage Collections and Debugging Using Finalization to Release Native Resources Using Finalization with Managed Resources What Causes Finalize Methods to Be Called? Finalization Internals The Dispose Pattern: Forcing an Object to Clean Up Using a Type That Implements the Dispose Pattern C#'s using Statement An Interesting Dependency Issue Monitoring and Controlling the Lifetime of Objects Manually Resurrection Generations Other Garbage Collection Features for Use with Native Resources Predicting the Success of an Operation that Requires a Lot of Memory Programmatic Control of the Garbage Collector Thread Hijacking Garbage Collection Modes Large Objects Monitoring Garbage Collections Chapter 22 CLR Hosting and AppDomains CLR Hosting AppDomains AppDomain Unloading AppDomain Monitoring AppDomain First-Chance Exception Notifications How Hosts Use AppDomains Advanced Host Control Chapter 23 Assembly Loading and Reflection Assembly Loading Using Reflection to Build a Dynamically Extensible Application Reflection Performance Designing an Application That Supports Add-Ins Using Reflection to Discover a Type's Members Chapter 24 Runtime Serialization Serialization/Deserialization Quick Start Making a Type Serializable Controlling Serialization and Deserialization How Formatters Serialize Type Instances Controlling the Serialized/Deserialized Data Streaming Contexts Serializing a Type as a Different Type and Deserializing an Object as a Different Object Serialization Surrogates Overriding the Assembly and/or Type When Deserializing an Object Threading Chapter 25 Thread Basics Why Does Windows Support Threads? Thread Overhead Stop the Madness CPU Trends NUMA Architecture Machines CLR Threads and Windows Threads Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation Reasons to Use Threads Thread Scheduling and Priorities Foreground Threads versus Background Threads What Now? Chapter 26 Compute-Bound Asynchronous Operations Introducing the CLR's Thread Pool Performing a Simple Compute-Bound Operation Execution Contexts Cooperative Cancellation Tasks Parallel's Static For, ForEach, and Invoke Methods Parallel Language Integrated Query Performing a Periodic Compute-Bound Operation How the Thread Pool Manages Its Threads Cache Lines and False Sharing Chapter 27 I/O-Bound Asynchronous Operations How Windows Performs I/O Operations The CLR's Asynchronous Programming Model (APM) The AsyncEnumerator Class The APM and Exceptions Applications and Their Threading Models Implementing a Server Asynchronously The APM and Compute-Bound Operations APM Considerations I/O Request Priorities Converting the IAsyncResult APM to a Task The Event-Based Asynchronous Pattern Programming Model Soup Chapter 28 Primitive Thread Synchronization Constructs Class Libraries and Thread Safety Primitive User-Mode and Kernel-Mode Constructs User-Mode Constructs Kernel-Mode Constructs Chapter 29 Hybrid Thread Synchronization Constructs A Simple Hybrid Lock Spinning, Thread Ownership, and Recursion A Potpourri of Hybrid Constructs The Famous Double-Check Locking Technique The Condition Variable Pattern Using Collections to Avoid Holding a Lock for a Long Time The Concurrent Collection Classes