CLR via C#

Larger Cover

CLR via C#, 2nd Edition

By Jeffrey Richter

Publisher: Microsoft Press

Released: March 2006

Pages: 736

Dig deep and master the intricacies of the common language runtime (CLR) and the .NET Framework. Written by a highly regarded programming expert and consultant to the Microsoft .NET team, this guide is ideal for developers building any kind of application—including Microsoft ASP.NET, Windows Forms, Microsoft SQL Server, Web services, and console applications. You’ll get hands-on instruction and extensive code C# code samples to help you tackle the tough topics and develop high-performance applications.

Discover how to:

Build, deploy, administer, and version applications, components, and shared assemblies
Design types using constants, fields, constructors, methods, properties, and events
Work effectively with the CLR’s special types including enumerators, arrays, and strings
Declare, create, and use delegates to expose callback functions
Define and employ re-usable algorithms with interfaces and generics
Define, use, and detect custom attributes
Use exception handling to build robust, reliable, and security-enhanced components
Manage memory automatically with the garbage collector and work with native resources
Apply CLR Hosting, AppDomains, assembly loading, and reflection to build dynamically extensible applications

PLUS—Get code samples on the Web

CLR Basics
1. Chapter 1 The CLR's Execution Model
  1. Compiling Source Code into Managed Modules
  2. Combining Managed Modules into Assemblies
  3. Loading the Common Language Runtime
  4. Executing Your Assembly's Code
  5. The Native Code Generator Tool: NGen.exe
  6. Introducing the Framework Class Library
  7. The Common Type System
  8. The Common Language Specification
  9. Interoperability with Unmanaged Code
2. Chapter 2 Building, Packaging, Deploying, and Administering Applications and Types
  1. .NET Framework Deployment Goals
  2. Building Types into a Module
  3. A Brief Look at Metadata
  4. Combining Modules to Form an Assembly
  5. Assembly Version Resource Information
  6. Culture
  7. Simple Application Deployment (Privately Deployed Assemblies)
  8. Simple Administrative Control (Configuration)
3. Chapter 3 Shared Assemblies and Strongly Named Assemblies
  1. Two Kinds of Assemblies, Two Kinds of Deployment
  2. Giving an Assembly a Strong Name
  3. The Global Assembly Cache
  4. Building an Assembly that References a Strongly Named Assembly
  5. Strongly Named Assemblies Are Tamper-Resistant
  6. Delayed Signing
  7. Privately Deploying Strongly Named Assemblies
  8. How the Runtime Resolves Type References
  9. Advanced Administrative Control (Configuration)
Working with Types
1. Chapter 4 Type Fundamentals
  1. All Types Are Derived from System.Object
  2. Casting Between Types
  3. Namespaces and Assemblies
  4. How Things Relate at Run Time
2. Chapter 5 Primitive, Reference, and Value Types
  1. Programming Language Primitive Types
  2. Reference Types and Value Types
  3. Boxing and Unboxing Value Types
  4. Changing Fields in a Boxed Value Type by Using Interfaces (And Why You Shouldn't Do This)
  5. Object Equality and Identity
  6. Object Hash Codes
Designing Types
1. Chapter 6 Type and Member Basics
  1. The Different Kinds of Type Members
  2. Type Visibility
  3. Member Accessibility
  4. Static Classes
  5. Partial Classes, Structures, and Interfaces
  6. Components, Polymorphism, and Versioning
2. Chapter 7 Constants and Fields
  1. Constants
  2. Fields
3. Chapter 8 Methods: Constructors, Operators, Conversions, and Parameters
  1. Instance Constructors and Classes (Reference Types)
  2. Instance Constructors and Structures (Value Types)
  3. Type Constructors
  4. Operator Overload Methods
  5. Conversion Operator Methods
  6. Passing Parameters by Reference to a Method
  7. Passing a Variable Number of Arguments to a Method
  8. Declaring a Method's Parameter Types
  9. Constant Methods and Parameters
4. Chapter 9 Properties
  1. Parameterless Properties
  2. Parameterful Properties
  3. The Performance of Calling Property Accessor Methods
  4. Property Accessor Accessibility
  5. Generic Property Accessor Methods
5. Chapter 10 Events
  1. Designing a Type That Exposes an Event
  2. How Events Are Implemented
  3. Designing a Type That Listens for an Event
  4. Events and Thread Safety
  5. Explicitly Controlling Event Registration and Unregistration
  6. Designing a Type That Defines Lots of Events
Essential Types
1. Chapter 11 Chars, Strings, and Working with Text
  1. Characters
  2. The System.String Type
  3. Dynamically Constructing a String Efficiently
  4. Obtaining a String Representation of an Object
  5. Parsing a String to Obtain an Object
  6. Encodings: Converting Between Characters and Bytes
  7. Encoding/Decoding Streams of Characters and Bytes
  8. Secure Strings
2. Chapter 12 Enumerated Types and Bit Flags
  1. Enumerated Types
  2. Bit Flags
3. Chapter 13 Arrays
  1. Casting Arrays
  2. All Arrays Are Implicitly Derived from System.Array
  3. All Arrays Implicitly Implement IEnumerable, ICollection, and IList
  4. Passing and Returning Arrays
  5. Creating Non-Zero–Lower Bound Arrays
  6. Array Access Performance
  7. Unsafe Array Access and Fixed-Size Array
4. Chapter 14 Interfaces
  1. Class and Interface Inheritance
  2. Defining an Interface
  3. Inheriting an Interface
  4. More About Calling Interface Methods
  5. Implicit and Explicit Interface Method Implementations (What's Happening Behind the Scenes)
  6. Generic Interfaces
  7. Generics and Interface Constraints
  8. Implementing Multiple Interfaces That Have the Same Method Name and Signature
  9. Improving Compile-Time Type Safety with Explicit Interface Method Implementations
  10. Be Careful with Explicit Interface Method Implementations
  11. Design: Base Class or Interface?
5. Chapter 15 Delegates
  1. A First Look at Delegates
  2. Using Delegates to Call Back Static Methods
  3. Using Delegates to Call Back Instance Methods
  4. Demystifying Delegates
  5. Using Delegates to Call Back Many Methods (Chaining)
  6. C#'s Syntactical Sugar for Delegates
  7. Delegates and Reflection
6. Chapter 16 Generics
  1. Generics in the Framework Class Library
  2. Wintellect's Power Collections Library
  3. Generics Infrastructure
  4. Generic Interfaces
  5. Generic Delegates
  6. Generic Methods
  7. Generics and Other Members
  8. Verifiability and Constraints
7. Chapter 17 Custom Attributes
  1. Using Custom Attributes
  2. Defining Your Own Attribute Class
  3. Attribute Constructor and Field/Property Data Types
  4. Detecting the Use of a Custom Attribute
  5. Matching Two Attribute Instances Against Each Other
  6. Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects
  7. Conditional Attribute Classes
8. Chapter 18 Nullable Value Types
  1. C#'s Support for Nullable Value Types
  2. C#'s Null-Coalescing Operator
  3. The CLR Has Special Support for Nullable Value Types
CLR Facilities
1. Chapter 19 Exceptions
  1. The Evolution of Exception Handling
  2. The Mechanics of Exception Handling
  3. Common Language Specification (CLS) and Non-CLS Exceptions
  4. What Exactly Is an Exception?
  5. The System.Exception Class
  6. FCL-Defined Exception Classes
  7. Throwing an Exception
  8. Defining Your Own Exception Class
  9. How to Use Exceptions Properly
  10. Performance Considerations
  11. Unhandled Exceptions
  12. Exception Stack Traces
  13. Debugging Exceptions
2. Chapter 20 Automatic Memory Management (Garbage Collection)
  1. Understanding the Basics of Working in a Garbage-Collected Platform
  2. The Garbage Collection Algorithm
  3. Garbage Collections and Debugging
  4. Using Finalization to Release Native Resources
  5. Using Finalization with Managed Resources
  6. What Causes Finalize Methods to Be Called
  7. Finalization Internals
  8. The Dispose Pattern: Forcing an Object to Clean Up
  9. Using a Type That Implements the Dispose Pattern
  10. C#'s using Statement
  11. An Interesting Dependency Issue
  12. Manually Monitoring and Controlling the Lifetime of Objects
  13. Resurrection
  14. Generations
  15. Other Garbage Collection Features for Use with Native Resources
  16. Predicting the Success of an Operation that Requires a Lot of Memory
  17. Programmatic Control of the Garbage Collector
  18. Other Garbage Collector Performance Topics
  19. Monitoring Garbage Collections
3. Chapter 21 CLR Hosting and AppDomains
  1. CLR Hosting
  2. AppDomains
  3. AppDomain Unloading
  4. How Hosts Use AppDomains
  5. Advanced Host Control
4. Chapter 22 Assembly Loading and Reflection
  1. Assembly Loading
  2. Using Reflection to Build a Dynamically Extensible Application
  3. Reflection Performance
  4. Designing an Application That Supports Add-Ins
  5. Using Reflection to Discover a Type's Members
5. Chapter 23 Performing Asynchronous Operations
  1. How the CLR Uses Windows Threads
  2. Pontificating about Efficient Thread Usage
  3. Introducing the CLR's Thread Pool
  4. Limiting the Number of Threads in the Thread Pool
  5. Using the Thread Pool to Perform an Asynchronous Compute-Bound Operation
  6. Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation
  7. Periodically Performing an Asynchronous Compute-Bound Operation
  8. Introducing the Asynchronous Programming Model
  9. Using the APM to Perform an Asynchronous I/O-Bound Operation
  10. The APM's Three Rendezvous Techniques
  11. Using the APM to Perform an Asynchronous Compute-Bound Operation
  12. The APM and Exceptions
  13. Important Notes about the APM
  14. Execution Contexts
6. Chapter 24 Thread Synchronization
  1. Memory Consistency, Volatile Memory Access, and Volatile Fields
  2. The Interlocked Methods
  3. The Monitor Class and Sync Blocks
  4. The ReaderWriterLock Class
  5. Using Windows Kernel Objects from Managed Code