CLR Via C#深度学习笔记

DOC文件

3星 · 超过75%的资源 | 下载需积分: 19 | 201KB | 更新于2024-08-01 | 37 浏览量 | 举报收藏

立即下载

"CLR Via C# 读书笔记" 在阅读 Jeffrey Richter 的《CLR Via C#》第二版后，一位程序员记录并分享了他的学习心得，形成了这份深入的读书笔记。笔记主要以作者自己的语言总结了书中的核心见解，旨在与.NET开发者社区分享他从书中汲取的知识，并希望读者能从中受益，将这些学习指导付诸实践。作者有着超过20年的软件工程师经验，自Windows 3.1以来就开始进行Windows平台的开发工作，并在.NET平台（包括Windows Forms、Web Forms和Web Services）从v1.1起进行应用构建，涉猎多个行业。他在1990年创立了Ivden Technologies, Inc.，专注于开发和推广开发者工具及生产力工具。笔记中首先提到了CLR（公共语言运行时）的执行模型。NGen是一种可以减少应用程序工作集的技术，通过它，相同的程序集可以在多进程中实现共享，从而降低内存占用。当预期一个程序集可能在多个进程中同时加载时，使用NGen可以提升性能。接着，笔记可能会涵盖CLR的其他关键特性，如垃圾回收（Garbage Collection），这是.NET框架自动管理内存的主要机制。GC会跟踪对象的生命周期，当对象不再被引用时，GC会释放其所占用的内存，以防止内存泄漏。作者可能会详细解释如何理解引用计数、代际理论以及GC的工作过程。此外，笔记可能会讨论类型系统，包括值类型和引用类型的区别，以及装箱和拆箱的概念。这部分内容对于理解和优化.NET代码的性能至关重要。还有可能是对托管代码和非托管代码的对比，以及如何通过互操作性（如P/Invoke和COM Interop）在两者之间通信。作者可能还会深入到CLR的异常处理机制，包括try-catch-finally语句块和异常过滤器，以及如何正确地抛出和捕获异常。此外，线程管理和同步原语（如Mutex、Semaphore和Monitor）可能也是笔记的重要部分，这对于编写多线程应用至关重要。此外，笔记可能还涉及了元数据、反射和动态类型的使用，这些都是.NET开发中的强大工具，允许程序在运行时检查和操作类型信息，创建动态对象。最后，笔记可能会讨论CLR的模块和程序集的概念，以及强命名和版本控制策略，这些都是.NET部署和重用组件的基础。这份《CLR Via C#》的读书笔记是一份宝贵的资源，涵盖了.NET开发中的诸多关键概念和技术，对于提升.NET开发者对CLR的理解和应用能力大有裨益。通过深入阅读和理解，开发者可以更好地优化代码，设计出更高效、更可靠的.NET应用程序。

Study Guide to CLR via C#, 2

Edition, by Jeffrey Richter Phil Grenetz January 25, 2007

Always avoid writing any code that requires type constructors to be executed in a specific

order. You cannot guarantee the order in which the CLR will invoke them. Also, avoid

circular dependencies among type constructors, e.g., a class whose type constructor

references a class whose type constructor references the first class. The CLR cannot

guarantee correct behavior. See pp. 191.

Note that types are unloaded only when the AppDomain shuts down. To intercept this

shutdown, register a delegate for the System.AppDomain.DomainUnload event.

See p. 192.

Inline initialization of static fields is preferable to defining an explicit type constructor.

The inline approach results in the BeforeFieldInit metadata flag being store in the

TypeDef metadata table. The explicit type constructor approach causes the Precise flag

to be stored instead. Precise semantics assume that an explicit type constructor may need

at a precise time because of its possible side effects. BeforeFieldInit semantics assume

that the CLR can perform the static initialization any time before the static fields are read.

BeforeFieldInit semantics result in faster initialization by a factor of 3-4! If you do not

have any important work to do during type initialization, use static field initialization and

do not define a type constructor. See pp. 193-195.

Operators are not a CLR construct. C# and other languages are free to define operator

syntax and emit code defining and invoking the methods to which the operators resolve.

C# emits methods with names with the following format: op_<Operation>, e.g.,

op_Addition.

See Tables 8-1 and 8-2 for all the operators supported by C#, the names emitted by the

compiler, and the Common Language Specification (CLS) names suggested for language

interoperability.

The core numeric types of the Framework Class Library do not define operator overloads.

Method calls for these common operations would hurt performance substantially.

Compilers emit code that directly manipulates the values of these types. See pp. 195-198.

Conversion constructors, as in C++, are simply constructors that take an instance of a

different type as an argument. Conversion methods are simply methods on source types

that return an instance of a target type. By convention, these methods are named ToXxx,

wher “Xxx” is the target type name, as with ToString, defined as a virtual method by

System.Object.

Beyond this, casting from a source to a target type can be enabled by defining conversion

operator overloads. The CLR requires that they be static and public. The compiler for

C# and other languages requires the type in which the operator is defined to be either the

parameter type or return type of the operator method.

Study Guide to CLR via C#, 2

Edition, by Jeffrey Richter Phil Grenetz January 25, 2007

The syntax is either:

public static explicit operator <TargetType>(SourceType>);

or public static implicit operator <TargetType>(SourceType>);

Explicit requires an explicit cast. Implicit allows casting without use of the cast operator.

Use the explicit keyword if the cast may result in loss of precision or magnitude.

See pp. 199-201.

The CLR and C# accept overloads that differ only in the use of the out or ref modifier.

The out and ref modifiers are treated as identical in this regard because from the CLR’s

perspective, they are the same. See pp. 202-204.

Objects passed by reference to a method must be of the same type that the method’s

argument is declared to be. To achieve polymorphic behavior of a method that takes a

base class instance, upcast the argument to the base class type before invoking the

method. Defining the method as a generic method that which takes a generic parameter

may also achieve the desired result. Note the generic Exchange and CompareExchange

methods of System.Threading.Interlocked. See pp. 206-207.

When defining a method that has a variable length parameter list, alleviate the

performance hit by also defining overloads that have explicit parameter lists of lengths

likely to be used. The method that has the variable length parameter list should just be

for the unusual case. See p. 210.

The CLR does not support const parameters or methods as C++ does. Reasons include

complexity of enforcement, runtime performance, and the ability to circumvent const

guarantees. One can create an immutable class, like String, by defining no methods that

change an instance’s state. See p.212.

Chapter 9. Properties

There are numerous problems with properties, stemming from the fact that they appear to

a programmer as a field, but can have any behavior with which the class developer

chooses to endow it. See pp. 217-218.

The indexers offered by C# – array like accessors – are implemented via parameterful

properties. Parameterful properties can have one or more parameters, but indexers have

exactly one parameter – the index.

An indexer property uses the “this” keyword as its name. The syntax of the header of an

indexer property is:

public <ReturnType> this[<IndexDataType> <IndexVarName>]

Although the CLR supports static parameterful properties, C# does not support static

indexers.

剩余41页未读，继续阅读

大Super

粉丝: 57

CLR Via C#深度学习笔记

CLR via C#笔记：类型基础与对象创建解析

《CLR via C#》：深度掌握.NET开发基石指南

掌握.NET框架设计：CLR via C# 英文版教程

带着问题读CLR via C#(笔记一)CLR的执行模型

重温C# clr 笔记总结

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

CLR通过C#深度解析：执行模型与核心概念

CLR via Csharp 3rd

Microsoft Edge Flash Player 浏览器插件

python-批量重命名脚本

最新资源