CLR via C#

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

......(更多)