CLR通过C#第三版：深入解析

需积分: 14 52 浏览量更新于2024-07-29 收藏 36.21MB PDF 举报

"CLR via C# 3rd Edition" 《CLR via C# 3rd Edition》是一本关于微软.NET Framework的权威指南，特别是针对公共语言运行时（Common Language Runtime, CLR）和C#编程语言的第三版。这本书由知名的.NET专家Jeffrey Richter撰写，深入探讨了.NET Framework的核心组件和C#语言的高级特性。在本书中，读者可以学习到以下关键知识点： 1. CLR基础：了解CLR如何作为.NET Framework的核心，为各种.NET语言提供一个统一的运行环境。它包括垃圾回收（Garbage Collection）、类型安全、异常处理和安全性模型。 2. 类型系统：深入理解.NET中的类型系统，包括值类型和引用类型的区别、结构体与类的不同、接口实现、以及泛型。 3. 动态编程：探讨C# 3.0及后续版本引入的动态类型和动态方法，以及如何使用DLR（Dynamic Language Runtime）进行动态编程。 4. 属性、事件和索引器：了解这些面向对象设计的关键元素，以及如何在C#中有效地使用它们来构建可维护和可扩展的代码。 5. 构造函数、析构函数和最终化器：研究对象生命周期管理，包括初始化、清理资源的策略，以及如何正确使用析构函数和最终化器。 6. 高级C#特性：如匿名方法、lambda表达式、linq（Language Integrated Query）以及查询表达式，这些特性极大地增强了C#的表达力和代码简洁性。 7. 异步编程：介绍C#的异步编程模型，如async和await关键字，以及如何利用Task类来实现非阻塞I/O操作。 8. 扩展方法、委托和事件：理解这些强大的工具，如何提高代码的可重用性和模块化。 9. 集合框架：学习.NET的集合库，包括ArrayList、LinkedList、Dictionary和HashSet等，以及如何选择和优化性能。 10. 泛型接口和类：了解如何使用泛型来创建类型安全且高效的数据结构和算法。 11. 序列化：探讨如何将对象状态转换为持久化格式，如XML或二进制，以便于存储和传输。 12. 自定义属性和元数据：学习如何创建和使用自定义属性，以及如何通过反射API来访问和使用元数据。 13. ADO.NET和数据库编程：介绍如何使用.NET框架与数据库交互，包括SqlCommand、SqlDataReader和Entity Framework等。 14. 应用程序域（AppDomain）：理解应用程序域的概念，它是.NET中实现隔离和安全性的基础。 15. 安全性：探讨.NET的安全模型，包括代码访问安全、角色基础的安全和策略配置。 16. 调试和诊断：学习如何使用Visual Studio和其他工具调试.NET应用程序，以及如何分析和解决性能问题。 17. 扩展性与插件架构：了解如何设计和实现可扩展的应用程序，以及如何使用MEF（Managed Extensibility Framework）来构建插件式系统。本书不仅覆盖了理论知识，还提供了丰富的示例代码，帮助读者更好地理解和应用所学概念。对于.NET开发者来说，这是一本不可多得的参考书籍，无论你是初学者还是经验丰富的开发者，都能从中受益匪浅。

xvi Introduction

Web Forms, and so on, the technologies presented in the book are applicable to all these

application types.

The book addresses Microsoft Visual Studio 2010, .NET Framework version 4.0, and version 4.0

of the C# programming language. Since Microsoft tries to maintain a large degree of back-

ward compatibility when releasing a new version of these technologies, many of the things

I discuss in this book apply to earlier versions as well. All the code samples use the C#

programming language as a way to demonstrate the behavior of the various facilities. But,

since the CLR is usable by many programming languages, the book’s content is still quite

applicable for the non-C# programmer.

Note You can download the code shown in the book from Wintellect’s Web site

(http://Wintellect.com). In some parts of the book, I describe classes in my own Power

Threading Library. This library is available free of charge and can also be downloaded from

Wintellect’s Web site.

Today, Microsoft offers several versions of the CLR. There is the desktop/server version, which

runs on 32-bit x86 versions of Microsoft Windows as well as 64-bit x64 and IA64 versions

of Windows. There is the Silverlight version, which is produced from the same source code

base as the desktop/server version of the .NET Framework’s CLR. Therefore, everything in this

book applies to building Silverlight applications, with the exception of some differences in

how Silverlight loads assemblies. There is also a “lite” version of the .NET Framework called

the .NET Compact Framework, which is available for Windows Mobile phones and other

devices running the Windows CE operating system. Much of the information presented in

this book is applicable to developing applications for the .NET Compact Framework, but this

platform is not the primary focus of this book.

On December 13, 2001, ECMA International (http://www.ecma-international.org/) accepted

the C# programming language, portions of the CLR, and portions of the FCL as standards.

The standards documents that resulted from this have allowed other organizations to build

ECMA-compliant versions of these technologies for other CPU architectures, as well as other

operating systems. In fact, Novell produces Moonlight (http://www.mono-project.com

/Moonlight), an open-source implementation of Silverlight (http://Silverlight.net) that is

primarily for Linux and other UNIX/X11-based operating systems. Moonlight is based on the

ECMA speciﬁcations. Much of the content in this book is about these standards; therefore,

many will ﬁnd this book useful for working with any runtime/library implementation that ad-

heres to the ECMA standard.

Introduction xvii

Note My editors and I have worked hard to bring you the most accurate, up-to-date, in-depth,

easy-to-read, painless-to-understand, bug-free information. Even with this fantastic team

assembled, however, things inevitably slip through the cracks. If you ﬁnd any mistakes in this

book (especially bugs) or have some constructive feedback, I would greatly appreciate it if you

would contact me at JeffreyR@Wintellect.com.

Dedication

To Kristin Words cannot express how I feel about our life together. I cherish our family and

all our adventures. I’m ﬁlled each day with love for you.

To Aidan (age 6) and Grant (age 2) You both have been an inspiration to me and have

taught me to play and have fun. Watching the two of you grow up has been so rewarding

and enjoyable for me. I am lucky to be able to partake in your lives. I love and appreciate you

more than you could ever know.

Acknowledgments

I couldn’t have written this book without the help and technical assistance of many people.

In particular, I’d like to thank my family. The amount of time and effort that goes into writing

a book is hard to measure. All I know is that I could not have produced this book without the

support of my wife, Kristin, and my two sons, Aidan and Grant. There were many times when

we wanted to spend time together but were unable to due to book obligations. Now that the

book project is completed, I really look forward to adventures we will all share together.

For this book revision, I truly had some fantastic people helping me. Christophe Nasarre,

who I’ve worked with on several book projects, has done just a phenomenal job of verifying

my work and making sure that I’d said everything the best way it could possibly be said. He

has truly had a signiﬁcant impact on the quality of this book. As always, the Microsoft Press

editorial team is a pleasure to work with. I’d like to extend a special thank you to Ben Ryan,

Valerie Woolley, and Devon Musgrave. Also, thanks to Jean Findley and Sue McClung for

their editing and production support.

Support for This Book

Every effort has been made to ensure the accuracy of this book. As corrections or changes

are collected, they will be added to a Microsoft Knowledge Base article accessible via the

Microsoft Help and Support site. Microsoft Press provides support for books, including

instructions for ﬁnding Knowledge Base articles, at the following Web site:

http://www.microsoft.com/learning/support/books/

Chapter 1

The CLR’s Execution Model

In this chapter:

Compiling Source Code into Managed Modules............................ 1

Combining Managed Modules into Assemblies ............................ 5

Loading the Common Language Runtime .................................6

Executing Your Assembly’s Code ......................................... 9

The Native Code Generator Tool: NGen.exe...............................18

The Framework Class Library............................................20

The Common Type System .............................................22

The Common Language Speciﬁcation....................................25

Interoperability with Unmanaged Code ..................................29

The Microsoft .NET Framework introduces many new concepts, technologies, and terms. My

goal in this chapter is to give you an overview of how the .NET Framework is designed, intro-

duce you to some of the new technologies the framework includes, and deﬁne many of the

terms you’ll be seeing when you start using it. I’ll also take you through the process of build-

ing your source code into an application or a set of redistributable components (ﬁles) that

contain types (classes, structures, etc.) and then explain how your application will execute.

Compiling Source Code into Managed Modules

OK, so you’ve decided to use the .NET Framework as your development platform. Great! Your

ﬁrst step is to determine what type of application or component you intend to build. Let’s

just assume that you’ve completed this minor detail; everything is designed, the speciﬁca-

tions are written, and you’re ready to start development.

Now you must decide which programming language to use. This task is usually difﬁcult

because different languages offer different capabilities. For example, in unmanaged C/C++,

you have pretty low-level control of the system. You can manage memory exactly the way

you want to, create threads easily if you need to, and so on. Microsoft Visual Basic 6, on the

other hand, allows you to build UI applications very rapidly and makes it easy for you to

control COM objects and databases.

The common language runtime (CLR) is just what its name says it is: a runtime that is usable by

different and varied programming languages. The core features of the CLR (such as memory

2 Part I CLR Basics

management, assembly loading, security, exception handling, and thread synchronization)

are available to any and all programming languages that target it—period. For example, the

runtime uses exceptions to report errors, so all languages that target the runtime also get

errors reported via exceptions. Another example is that the runtime also allows you to create

a thread, so any language that targets the runtime can create a thread.

In fact, at runtime, the CLR has no idea which programming language the developer used for

the source code. This means that you should choose whatever programming language allows

you to express your intentions most easily. You can develop your code in any programming

language you desire as long as the compiler you use to compile your code targets the CLR.

So, if what I say is true, what is the advantage of using one programming language over

another? Well, I think of compilers as syntax checkers and “correct code” analyzers. They

examine your source code, ensure that whatever you’ve written makes some sense, and then

output code that describes your intention. Different programming languages allow you to

develop using different syntax. Don’t underestimate the value of this choice. For mathemati-

cal or ﬁnancial applications, expressing your intentions by using APL syntax can save many

days of development time when compared to expressing the same intention by using Perl

syntax, for example.

Microsoft has created several language compilers that target the runtime: C++/CLI, C# (pro-

nounced “C sharp”), Visual Basic, F# (pronounced “F sharp”), Iron Python, Iron Ruby, and an

Intermediate Language (IL) Assembler. In addition to Microsoft, several other companies, col-

leges, and universities have created compilers that produce code to target the CLR. I’m aware

of compilers for Ada, APL, Caml, COBOL, Eiffel, Forth, Fortran, Haskell, Lexico, LISP, LOGO,

Lua, Mercury, ML, Mondrian, Oberon, Pascal, Perl, Php, Prolog, RPG, Scheme, Smalltalk, and

Tcl/Tk.

Figure 1-1 shows the process of compiling source code ﬁles. As the ﬁgure shows, you can cre-

ate source code ﬁles written in any programming language that supports the CLR. Then you

use the corresponding compiler to check the syntax and analyze the source code. Regardless

of which compiler you use, the result is a managed module. A managed module is a standard

32-bit Microsoft Windows portable executable (PE32) ﬁle or a standard 64-bit Windows

portable executable (PE32+) ﬁle that requires the CLR to execute. By the way, managed

assemblies always take advantage of Data Execution Prevention (DEP) and Address Space

Layout Randomization (ASLR) in Windows; these two features improve the security of your

whole system.

剩余895页未读，继续阅读

sapphirehdl

粉丝: 7
资源: 4

CLR通过C#第三版：深入解析

C#框架设计第三版03(CLR via C# 3rd Edition)-学习C#最经典的书籍-2010年2月刚出版

C#框架设计第三版04(CLR via C# 3rd Edition)-学习C#最经典的书籍-2010年2月刚出版

CLR via C# 3rd Edition - part2

CLR via C# 3rd Edition - part1

CLR via C# 3rd Edition (第三版)

CLR via C# 3rd Edition: Microsoft Press Guide

.Net Framework与CLR深度探索：CLR via C# 3rd Edition

Jeffrey Richter的CLR via C# 3rd Edition版权信息与国际版详情

CLR via C# 3rd.Edition（英文版）

CLR通过C# 3rd Edition：设计者原著解析

最新资源