CLR Via C#

Introduction

Part 1: CLR Basics
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

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)

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)

Part 2: Designing Types
4 Type Fundamentals
-All Types Are Derived from System.Object
-Casting Between Types
-Namespaces and Assemblies
-How Things Relate at Runtime

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

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

7 Constants and Fields
-Constants
-Fields

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

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

10 Properties
-Parameterless Properties
-Parameterful Properties
-The Performance of Calling Property Accessor Methods
-Property Accessor Accessibility
-Generic Property Accessor Methods

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

12 Generics
-Generics in the Framework Class 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

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?

Part 3: Essential Types
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

15 Enumerated Types and Bit Flags
-Enumerated Types
-Bit Flags
-Adding Methods to Enumerated Types

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 Internals
-Unsafe Array Access and Fixed-Size Array

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
-Syntactical Shortcut #3: No Need to Wrap Local Variables in a Class -Manually to Pass Them to a Callback Method
-Delegates and Reflection

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

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

Part 4: Core Facilities
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

21 The Managed Heap and Garbage Collection
-Managed Heap Basics
-Generations: Improving Performance
-Monitoring and Controlling the Lifetime of Objects Manually

22 CLR Hosting and AppDomains
-CLR Hosting
-AppDomains
-AppDomain Unloading
-AppDomain Monitoring
-AppDomain First-Chance Exception Notifications
-How Hosts Use AppDomains
-Advanced Host Control

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

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

25 Interoperating with WinRT Components
-CLR Projections and WinRT Component Type System Rules
-Framework Projections
-Defining WinRT Components in C#

Part 5: Threading
26 Thread Basics
-Why Does Windows Support Threads?
-Thread Overhead
-Stop the Madness
-CPU Trends
-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?

27 Compute-Bound Asynchronous Operations
-Introducing the CLR's Thread Pool
-Performing a Simple Compute-Bound Operation
-Execution Contexts
-Cooperative Cancellation and Timeout
-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

28 I/O-Bound Asynchronous Operations
-How Windows Performs I/O Operations
-C#'s Asynchronous Functions
-How the Compiler Transforms an Async Function into a State Machine
-Async Function Extensibility
-Async Functions and Event Handlers
-Async Functions in the Framework Class Library
-Async Functions and Exception Handling
-Other Async Function Features
-Applications and Their Threading Models
-Implementing a Server Asynchronously
-Canceling I/O Operations
-Some I/O Operations Must Be Done Synchronously
-FileStream-Specific Issues
-I/O Request Priorities

29 Primitive Thread Synchronization Constructs
-Class Libraries and Thread Safety
-Primitive User-Mode and Kernel-Mode Constructs
-User-Mode Constructs
-Kernel-Mode Constructs

30 Hybrid Thread Synchronization Constructs
-A Simple Hybrid Lock
-Spinning, Thread Ownership, and Recursion
-Hybrid Constructs in the Framework Class Library
-The Famous Double-Check Locking Technique
-The Condition Variable Pattern
-Asynchronous Synchronization
-The Concurrent Collection Classes

Index