CLR via C# pdf epub mobi txt 电子书 下载 2025

想要找书就要到 图书目录大全

立刻按 ctrl+D收藏本页

你会得到大惊喜!!

Your essential guide to developing applications with the common language runtime (CLR) and Microsoft® .NET Framework 4.0, with examples in Microsoft® Visual C#® 2010.

Dig deep and master the intricacies of the common language runtime (CLR) and the .NET Framework 4.0. 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 C# code samples to help you tackle the tough topics and develop high-performance applications.

Jeffrey Richter is a cofounder of Wintellect—a training, debugging, and consulting firm dedicated to helping companies build better software faster. He is the author of several well-known programming books on Windows and the Microsoft .NET Framework, including CLR via C#. Jeffrey is a contributing editor and columnist for MSDN Magazine and a popular speaker at industry conferences, such as VSLive! and Tech*Ed.

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
· · · · · · (收起)