CLR via C# by Richter, Jeffrey -- Read -- Imperial Library of Trantor

Index

CLR via C#

SPECIAL OFFER: Upgrade this ebook with O’Reilly Foreword Introduction

Who This Book Is For Dedication Acknowledgments Support for This Book We Want to Hear from You

I. 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

IL and Verification Unsafe 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

Response Files

A Brief Look at Metadata Combining Modules to Form an Assembly

Adding Assemblies to a Project by Using the Visual Studio IDE Using the Assembly Linker Adding Resource Files to an Assembly

Assembly Version Resource Information

Version Numbers

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)

Publisher Policy Control

II. Designing Types

4. Type Fundamentals

All Types Are Derived from System.Object Casting Between Types

Casting with the C# is and as Operators

Namespaces and Assemblies How Things Relate at Runtime

5. Primitive, Reference, and Value Types

Programming Language Primitive Types

Checked and Unchecked Primitive Type Operations

Reference Types and Value Types Boxing and Unboxing Value Types

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

Object Hash Codes The dynamic Primitive Type

6. Type and Member Basics

The Different Kinds of Type Members Type Visibility

Friend Assemblies

Member Accessibility Static Classes Partial Classes, Structures, and Interfaces Components, Polymorphism, and Versioning

How the CLR Calls Virtual Methods, Properties, and Events Using Type Visibility and Member Accessibility Intelligently Dealing with Virtual Methods When Versioning Types

7. Constants and Fields

Constants Fields

8. Methods

Instance Constructors and Classes (Reference Types) Instance Constructors and Structures (Value Types) Type Constructors

Type Constructor Performance

Operator Overload Methods

Operators and Programming Language Interoperability

Conversion Operator Methods Extension Methods

Rules and Guidelines Extending Various Types with Extension Methods The Extension Attribute

Partial Methods

Rules and Guidelines

9. Parameters

Optional and Named Parameters

Rules and Guidelines The DefaultParameterValue and Optional Attributes

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

Automatically Implemented Properties Defining Properties Intelligently Object and Collection Initializers Anonymous Types The System.Tuple Type

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

Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification Step #2: Define the event member Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred Step #4: Define a method that translates the input into the desired 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 Wintellect's Power Collections Library Generics Infrastructure

Open and Closed Types Generic Types and Inheritance Generic Type Identity Code Explosion

Generic Interfaces Generic Delegates Delegate and Interface Contravariant and Covariant Generic Type Arguments Generic Methods

Generic Methods and Type Inference

Generics and Other Members Verifiability and Constraints

Primary Constraints Secondary Constraints Constructor Constraints Other Verifiability Issues

Casting a Generic Type Variable Setting a Generic Type Variable to a Default Value Comparing a Generic Type Variable with null Comparing Two Generic Type Variables with Each Other Using Generic Type Variables as Operands

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?

III. Essential Types

14. Chars, Strings, and Working with Text

Characters The System.String Type

Constructing Strings Strings Are Immutable Comparing Strings String Interning String Pooling Examining a String's Characters and Text Elements Other String Operations

Constructing a String Efficiently

Constructing a StringBuilder Object StringBuilder Members

Obtaining a String Representation of an Object: ToString

Specific Formats and Cultures Formatting Multiple Objects into a Single String Providing Your Own Custom Formatter

Parsing a String to Obtain an Object: Parse Encodings: Converting Between Characters and Bytes

Encoding and Decoding Streams of Characters and Bytes Base-64 String Encoding and Decoding

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 Access Performance 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)

C#'s Support for Delegate Chains Having More Control over Delegate Chain Invocation

Enough with the Delegate Definitions Already (Generic Delegates) C#'s Syntactical Sugar for Delegates

Syntactical Shortcut #1: No Need to Construct a Delegate Object Syntactical Shortcut #2: No Need to Define a Callback Method 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

Boxing Nullable Value Types Unboxing Nullable Value Types Calling GetType via a Nullable Value Type Calling Interface Methods via a Nullable Value Type

IV. Core Facilities

20. Exceptions and State Management

Defining "Exception" Exception-Handling Mechanics

The try Block The catch Block The finally Block

The System.Exception Class FCL-Defined Exception Classes Throwing an Exception Defining Your Own Exception Class Trading Reliability for Productivity Guidelines and Best Practices

Use finally Blocks Liberally Don't Catch Everything Recovering Gracefully from an Exception Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining State Hiding an Implementation Detail to Maintain a "Contract"

Unhandled Exceptions Debugging Exceptions Exception-Handling Performance Considerations Constrained Execution Regions (CERs) Code Contracts

21. Automatic Memory Management (Garbage Collection)

Understanding the Basics of Working in a Garbage-Collected Platform

Allocating Resources from the Managed Heap

The Garbage Collection Algorithm Garbage Collections and Debugging Using Finalization to Release Native Resources

Guaranteed Finalization Using CriticalFinalizerObject Types

SafeHandle and Its Derived Types

Interoperating with Unmanaged Code by Using SafeHandle Types

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

22. CLR Hosting and AppDomains

CLR Hosting AppDomains

Accessing Objects Across AppDomain Boundaries

Demo #1: Cross-AppDomain Communication that Uses Marshal-by-Reference Demo #2: Cross-AppDomain Communication Using Marshal-by-Value Demo #3: Cross-AppDomain Communication Using Non-Marshalable Types

AppDomain Unloading AppDomain Monitoring AppDomain First-Chance Exception Notifications How Hosts Use AppDomains

Executable Applications Microsoft Silverlight Rich Internet Applications Microsoft ASP.NET Web Forms and XML Web Services Applications Microsoft SQL Server Your Own Imagination

Advanced Host Control

Managing the CLR by Using Managed Code Writing a Robust Host Application How a Host Gets Its Thread Back

23. Assembly Loading and Reflection

Assembly Loading Using Reflection to Build a Dynamically Extensible Application Reflection Performance

Discovering Types Defined in an Assembly What Exactly Is a Type Object? Building a Hierarchy of Exception-Derived Types Constructing an Instance of a Type

Designing an Application That Supports Add-Ins Using Reflection to Discover a Type's Members

Discovering a Type's Members BindingFlags: Filtering the Kinds of Members That Are Returned Discovering a Type's Interfaces Invoking a Type's Members Bind Once, Invoke Multiple Times Using Binding Handles to Reduce Your Process's Memory Consumption

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

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

Streaming Contexts Serializing a Type as a Different Type and Deserializing an Object as a Different Object Serialization Surrogates

Surrogate Selector Chains

Overriding the Assembly and/or Type When Deserializing an Object

V. Threading

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?

26. Compute-Bound Asynchronous Operations

Introducing the CLR's Thread Pool Performing a Simple Compute-Bound Operation Execution Contexts Cooperative Cancellation Tasks

Waiting for a Task to Complete and Getting Its Result Cancelling a Task Starting a New Task Automatically When Another Task Completes A Task May Start Child Tasks Inside a Task Task Factories Task Schedulers

Parallel's Static For, ForEach, and Invoke Methods Parallel Language Integrated Query Performing a Periodic Compute-Bound Operation

So Many Timers, So Little Time

How the Thread Pool Manages Its Threads

Setting Thread Pool Limits How Worker Threads Are Managed

Cache Lines and False Sharing

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

Using the APM Without the Thread Pool Always Call the EndXxx Method, and Call It Only Once Always Use the Same Object When Calling the EndXxx Method Using ref, out, and params Arguments with BeginXxx and EndXxx Methods You Can't Cancel an Asynchronous I/O-Bound Operation Memory Consumption Some I/O Operations Must Be Done Synchronously FileStream-Specific Issues

I/O Request Priorities Converting the IAsyncResult APM to a Task The Event-Based Asynchronous Pattern

Converting the EAP to a Task Comparing the APM and the EAP

Programming Model Soup

28. Primitive Thread Synchronization Constructs

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

Volatile Constructs

C#'s Support for Volatile Fields

Interlocked Constructs Implementing a Simple Spin Lock The Interlocked Anything Pattern

Kernel-Mode Constructs

Event Constructs Semaphore Constructs Mutex Constructs Calling a Method When a Single Kernel Construct Becomes Available

29. Hybrid Thread Synchronization Constructs

A Simple Hybrid Lock Spinning, Thread Ownership, and Recursion A Potpourri of Hybrid Constructs

The ManualResetEventSlim and SemaphoreSlim Classes The Monitor Class and Sync Blocks The ReaderWriterLockSlim Class The OneManyLock Class The CountdownEvent Class The Barrier Class Thread Synchronization Construct Summary

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

Index About the Author SPECIAL OFFER: Upgrade this ebook with O’Reilly

← Prev
Back
Next →

← Prev
Back
Next →