CLR via C#

出版者:Microsoft Press

作者:Jeffrey Richter

页数:704

出版时间:2010-2-20

价格:USD 59.99

装帧:Paperback

isbn号码:9780735627048

具体描述

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

读后感

本书的作者对C#的设计理念和设计细节了解透彻，他不仅教会你C#语言的各种细节，同时还把发生在背后的各种原理娓娓道来，细读本书之后，你学到的不仅仅是C#语言，同时还能够洞悉C#的本质，让你不仅仅是写出可以执行的代码，而是写出可以高效运行的代码。 本书的译者不仅是一位...  

最近工作比较闲，我把这本书看了两遍。 第一遍是从17年3月份开始，断断续续直到上周读完，翻到最后一页的时候，心里如释重负，终于看完了，虽然这本书真的很厉害，但是看这么厚的书，真的很煎熬啊！然而，过了半天，我就忘记讲了什么，只记得委托是一个类（因为我会拿来跟同事...  

.NET技术领域有两位世界级专家。 一位是Don Box。他以《Essential COM》确立了自己COM专家的地位，在.NET时代，Don Box又以《Essential .NET》（Volume I The Common Language Runtime）确立了自己.NET专家的地位。2002年，Microsoft将其招致麾下，成为.NET Architect，与Ande...  

我先看了下电子版的.. 后来我毅然决定在amazon.com上面买了这本..原版. 加邮费 一共大概340多RMB啊.....但是我都觉得值得

.NET技术领域有两位世界级专家。 一位是Don Box。他以《Essential COM》确立了自己COM专家的地位，在.NET时代，Don Box又以《Essential .NET》（Volume I The Common Language Runtime）确立了自己.NET专家的地位。2002年，Microsoft将其招致麾下，成为.NET Architect，与Ande...  

用户评价

这本书绝对是C#开发者的“圣经”之一，尤其对于那些渴望深入理解.NET运行时（CLR）底层机制的开发者而言，它更是不可或缺的。我一直以来都对C#的强大之处感到好奇，但对于它背后是如何工作的，尤其是在内存管理、类型系统以及代码执行等方面，我总是觉得不够透彻。这本书，就像一位经验丰富的向导，带领我一步步揭开了CLR的神秘面纱。作者对CLR的每个方面都进行了详尽而严谨的剖析，从IL到JIT编译，从值类型到引用类型，从垃圾回收到委托和事件，都讲解得非常到位。我印象特别深刻的是书中关于“装箱和拆箱”的讲解，它不仅解释了这些操作是如何发生的，还深入剖析了它们对性能的影响，这让我以后在编写代码时能够更加谨慎地处理值类型和引用类型之间的转换。此外，书中关于“线程和并发”的章节也为我提供了宝贵的指导。在编写多线程应用程序时，理解CLR如何管理线程、如何进行同步以及如何避免死锁，都至关重要。这本书不仅提供了理论知识，更重要的是通过大量的代码示例，让我能够将这些知识融会贯通，并应用到实际开发中。

这本书就像一位循循善诱的老师，引导我一步步揭开C#和.NET运行时（CLR）的神秘面纱。在阅读之前，我对CLR的认知仅限于它是一个“托管环境”，能够处理内存分配和垃圾回收，但具体是如何运作的，我却知之甚少。这本书的出现，彻底改变了我对.NET的看法。作者通过清晰的逻辑、丰富的示例以及对底层原理的深入挖掘，将CLR的复杂性一一呈现。我尤其喜欢书中关于“类型系统”的章节，它详细解释了CLR如何处理各种类型的定义、继承、多态以及装箱/拆箱等概念，并结合实际代码演示了这些概念是如何在CLR层面实现的。这让我对C#的面向对象特性有了更深刻的理解，也让我能够更准确地预测代码的执行行为。另外，书中对于“反射”和“泛型”的讲解也让我受益匪浅。我曾经在需要实现动态代理和元编程时遇到过困难，但通过这本书，我理解了CLR如何支持反射的强大功能，以及泛型如何在编译时提供类型安全和性能优势。这些知识不仅解决了我的燃眉之急，更拓宽了我对C#编程的视野。这本书的深度和广度都令人惊叹，它不仅仅是技术手册，更是一次对.NET技术内核的深度探索。

作为一名对计算机底层原理充满好奇的开发者，《CLR via C#》这本书简直是为我量身定做的。在阅读之前，我对CLR的理解更多停留在表面，知道它是一个运行环境，但对其内部工作的细节却知之甚少。这本书就像一本“百科全书”，将CLR的方方面面都进行了深入浅出的阐述。我印象最深刻的是关于“代码执行流程”的章节，它详细解释了IL代码如何被JIT编译器编译成机器码，以及CLR如何管理代码的执行。这让我对C#代码的性能表现有了更清晰的认识，也能够更好地进行性能调优。书中对“垃圾回收（GC）”机制的讲解更是让我佩服，它详细介绍了GC的各种算法、分代回收以及如何优化GC性能。我曾经在开发一个内存密集型应用时遇到过GC瓶颈，但在阅读了这本书之后，我得以理解GC的工作原理，并找到了相应的优化策略，大大提升了应用的性能。此外，书中关于“安全性和身份验证”的章节也让我对.NET的安全机制有了更深的理解。总而言之，这本书不仅仅是一本技术指南，更是一次对.NET技术内核的深入探索，它为我打开了通往更高级编程境界的大门。

作为一名在C#领域深耕多年的开发者，我不得不说，《CLR via C#》这本书是我职业生涯中遇到过的最具有启迪性的技术书籍之一。在接触这本书之前，我对CLR的认识仅限于它是一个“框架”，能够帮我管理内存和提供各种服务，但对于其内部的具体运作原理，我却知之甚少。这本书，就像一位博学的教授，将CLR的各个组成部分，从最底层的IL（Intermediate Language）到JIT（Just-In-Time）编译，再到类型系统、垃圾回收、安全性等方面，都进行了极其详尽且深入的阐述。我尤其赞赏书中关于“类型加载和元数据”的章节，它详细解释了CLR如何加载程序集、如何解析元数据以及这些信息如何被用于代码的执行。这让我对C#的动态性有了更深刻的理解，也能够更好地利用反射等特性。此外，书中关于“异常处理”的章节也让我受益匪浅。它不仅解释了异常是如何被抛出和捕获的，还深入分析了异常对性能的影响以及如何编写健壮的异常处理代码。这本书的价值在于，它不仅仅是告诉你“怎么做”，更重要的是告诉你“为什么这么做”，让我对C#和.NET的理解上升到了一个全新的维度。

《CLR via C#》这本书，对于我这样渴望深入理解.NET底层运作机制的开发者来说，简直是“及时雨”。此前，我虽然能够熟练地使用C#编写应用程序，但总感觉对CLR这个“幕后推手”的理解不够深入，尤其是在性能优化和问题排查方面，常常感到力不从心。这本书的出现，彻底改变了我的困境。作者以极其清晰的逻辑和丰富的示例，将CLR的方方面面都进行了深入浅出的剖析。我印象最深刻的是关于“内存模型和垃圾回收”的章节，它详细解释了托管堆、栈以及GC的工作原理，以及如何通过优化代码来减少GC的压力。我曾经遇到过一个项目，由于频繁的对象创建和销毁导致了严重的性能问题，但在阅读了这本书之后，我得以找到问题的根源，并采取了有效的措施，显著提升了应用的性能。此外，书中关于“并发和多线程”的讲解也让我受益匪浅。它详细介绍了CLR如何支持线程管理、同步机制以及如何避免常见的并发问题，这对于构建高性能、高并发的应用程序至关重要。这本书不仅仅是技术知识的传递，更是一种思维方式的引导，让我能够更深入地理解C#语言的内在机制，并写出更优、更健壮的代码。

作为一名对底层技术充满热情，并且追求卓越的C#开发者，我必须说，《CLR via C#》这本书是我学习道路上的重要里程碑。在此之前，虽然我已经掌握了C#的各种语法和常用框架，但对于CLR——这个.NET平台的核心——的理解，总觉得隔着一层薄雾。这本书，就像一把锋利的钥匙，为我揭开了这层神秘的面纱。作者以一种循序渐进、由浅入深的方式，将CLR的复杂机制一一呈现，从IL代码的生成到JIT编译的优化，从类型系统的设计到内存管理的策略，都进行了详尽的阐述。我特别喜欢书中关于“值类型和引用类型”的对比分析，它不仅解释了它们在内存中的区别，还深入探讨了它们在性能上的差异以及在实际编程中如何做出最佳选择。这让我对C#中的数据处理有了更精细化的理解，也能够避免一些常见的性能陷阱。此外，书中关于“委托、事件和匿名方法”的讲解也让我茅塞顿开。它详细解释了这些高级语言特性在CLR底层是如何实现的，这让我对C#的函数式编程能力有了更深刻的认识。这本书不仅提升了我的技术能力，更重要的是，它激发了我对.NET技术内核的更深层次的探索欲望。

这本书简直是C#开发者心中的一座灯塔，尤其是当你深入到.NET运行时（CLR）的内部运作机制时，这本书的重要性就愈发凸显。我作为一名多年C#开发者，一直以来都对CLR的底层机制充满了好奇，但苦于没有一本权威、系统且深入浅出的书籍来指引方向。市面上虽然不乏介绍C#语言的书籍，但鲜有能够如此透彻地剖析CLR这个“引擎”如何工作，又是如何驱动C#代码运行的。从内存管理、垃圾回收机制，到类型系统、托管代码的执行流程，再到线程管理、安全性等等，这本书几乎涵盖了CLR的方方面面。作者对这些复杂概念的阐述，既严谨又生动，他通过大量的代码示例、图示以及对底层原理的细致分析，让原本抽象晦涩的概念变得触手可及。我记得在学习委托和事件时，书中对CLR如何处理这些概念的底层实现进行了详尽的解释，这让我对C#的事件驱动编程有了更深刻的理解，也能够更好地预测和解决与事件相关的性能问题。再比如，在性能调优方面，书中关于对象分配、垃圾回收算法以及如何编写高效的托管代码的建议，都为我提供了宝贵的指导。我曾经遇到过一个棘手的内存泄漏问题，在阅读了这本书关于对象生命周期和GC回收机制的章节后，我得以准确地定位到问题的根源，并找到了有效的解决方案。这本书不仅仅是一本技术参考书，更像是一本引人入胜的技术探险指南，它激励我去探索C#和.NET框架的更深层奥秘。

这本书为我打开了通往C#和.NET运行时（CLR）底层世界的一扇大门，让我对这个强大的平台有了前所未有的深入理解。我一直以来都是C#的忠实用户，但每次在遇到一些奇怪的性能问题或者想优化代码时，总感觉缺少了那么一点“内功”。这本书，正是弥补了我的这一不足。作者以极其系统和严谨的方式，剖析了CLR的每一个核心概念，从IL代码的结构到JIT编译的优化，从内存分配的策略到垃圾回收的算法，都进行了详尽的讲解。我尤其喜欢书中关于“委托和事件”的章节，它详细解释了CLR是如何支持这些强大的编程模型，以及它们在底层是如何实现的。这让我对C#的事件驱动编程有了更深刻的理解，也能够更好地设计和实现可扩展的应用程序。此外，书中关于“泛型”的讲解也让我大开眼界。我以前只是知道泛型可以提供类型安全和性能优势，但通过这本书，我才真正理解了CLR是如何在编译时和运行时处理泛型的，以及如何编写高效的泛型代码。这本书不仅仅是一本技术手册，更像是一次深刻的技术哲学思考，它让我对C#的编程范式有了更全面的认知。

作为一名在.NET生态系统中摸爬滚打多年的老兵，我对《CLR via C#》这本书的评价只能用“如获至宝”来形容。坦白说，在遇到这本书之前，我一直认为自己对C#已经相当熟悉了，能够熟练运用各种语言特性来构建应用程序。然而，正是这本书，让我认识到了自己在对.NET运行时（CLR）的理解上还有着巨大的鸿沟。作者深入浅出地剖析了CLR的每一个核心组成部分，从最基础的内存模型到复杂的JIT编译过程，再到安全性、可伸缩性等方方面面，都进行了详尽而清晰的阐述。我印象最深刻的是关于“值类型与引用类型”的章节，书中不仅解释了它们在内存中的存储方式，还深入剖析了它们在性能上的差异以及在实际编程中如何做出最优选择。这让我对C#中那些看似细微的差异有了全新的认识，并能更有效地进行性能优化。此外，书中对“垃圾回收（GC）”机制的讲解更是让我茅塞顿开。之前我一直认为GC是“黑盒子”般的存在，但通过这本书，我理解了GC的工作原理、分代回收、终结器以及如何避免潜在的GC问题。这不仅提升了我编写更健壮代码的能力，也让我对.NET的内存管理有了更精细化的掌控。总而言之，这本书为我打开了一扇通往CLR世界的大门，让我对C#语言有了更深层次的理解，也为我未来的技术发展奠定了坚实的基础。

对于任何一位希望真正理解C#语言精髓的开发者来说，《CLR via C#》都是一本不可或缺的宝藏。我一直以来都对.NET Framework的强大之处感到好奇，尤其是它能够如此高效地管理内存和处理并发，这背后的运行机制是什么？这本书，正是解答了我的所有疑问。作者在书中对CLR的各个方面进行了详尽的剖析，从最底层的IL（Intermediate Language）到JIT（Just-In-Time）编译，再到类型系统、装箱拆箱、垃圾回收，无不涉及。我特别欣赏书中对“内存管理”的讲解，它详细阐述了托管堆、栈以及GC的工作流程，并提供了许多优化内存使用的技巧。我曾经遇到过一个项目，由于不当的内存使用导致了严重的性能问题，但在阅读了这本书关于GC和对象生命周期的章节后，我得以迅速找到问题的症结所在，并进行了有效的优化。此外，书中关于“并发和多线程”的章节也让我受益匪浅。它详细介绍了CLR如何支持线程管理、同步机制以及如何编写高效的并发代码，这对于构建高性能、响应迅速的应用程序至关重要。这本书不仅教会了我“如何做”，更重要的是教会了我“为什么这么做”，让我对C#和.NET的理解上升到了一个新的层次。

确实好书，对于.net框架的讲解深入，透彻。推荐想深入了解.net底层技术的筒子们阅读。

perfect

一入堆码界深似黑洞～

力荐

这本书没读过两遍，你怎么好意思说自己精通.NET?