Volume 1 provides everything developers need to take full advantage of the power of Microsoft .NET. Describes in depth, the glue of the .NET Framework:the Common Language Runtime (CLR). Softcover.

Don Box is an architect at Microsoft working on next-generation Web service protocols and programming models. Don is an authority on software integration technologies and spent much of the 1990s preparing the Component Object Model (COM) community for the CLR. Chris Sells is an independent consultant specializing in COM and .NET and an instructor for DevelopMentor

List of Figures

ix

List of Tables

xiii

Foreword

xv

Preface

xvii

The CLR as a Better COM

1

(12)

COM Revisited

1

(5)

The Common Language Runtime

6

(3)

The Evolution of the Programming Model

9

(2)

Where Are We?

11

(2)

Components

13

(36)

Modules Defined

13

(4)

Assemblies Defined

17

(6)

Assembly Names

23

(4)

Public Keys and Assemblies

27

(4)

The CLR Loader

31

(7)

Resolving Names to Locations

38

(6)

Versioning Hazards

44

(4)

Where Are We?

48

(1)

Type Basics

49

(28)

Type Fundamentals

49

(11)

Types and Initialization

60

(4)

Types and Interfaces

64

(5)

Types and Base Types

69

(6)

Where Are We?

75

(2)

Programming with Type

77

(36)

Types at Runtime

77

(9)

Programming with Metadata

86

(10)

Special Methods

96

(8)

Metadata and Extensibility

104

(8)

Where Are We?

112

(1)

Instances

113

(40)

Objects and Values Compared

113

(6)

Variables, Parameters, and Fields

119

(5)

Equivalence Versus Identity

124

(6)

Cloning

130

(3)

Boxing

133

(1)

Arrays

134

(9)

Object Life Cycle

143

(4)

Finalization

147

(5)

Where Are We?

152

(1)

Methods

153

(54)

Methods and JIT Compilation

153

(5)

Method Invocation and Type

158

(8)

Interfaces, Virtual Methods, and Abstract Methods

166

(7)

Explicit Method Invocation

173

(6)

Indirect Method Invocation and Delegates

179

(10)

Asynchronous Method Invocation

189

(10)

Method Termination

199

(6)

Where Are We?

205

(2)

Advanced Methods

207

(46)

Motivation

207

(2)

Messages as Method Calls

209

(6)

Stack and Message Transitions

215

(6)

Proxiable Types

221

(8)

Message Processing (Revisited)

229

(7)

Objects and Context

236

(9)

Contexts and Interception

245

(7)

Where Are We?

252

(1)

Domains

253

(30)

Execution Scope and the CLR

253

(5)

Programming with AppDomains

258

(4)

AppDomain Events

262

(5)

AppDomains and the Assembly Resolver

267

(5)

AppDomains and Code Management

272

(4)

AppDomains and Objects (Revisited)

276

(5)

Where Are We?

281

(2)

Security

283

(46)

Components and Security

283

(2)

Evidence

285

(8)

Policy

293

(13)

Permissions

306

(8)

Enforcement

314

(13)

Where Are We?

327

(2)

CLR Externals

329

(52)

Memory

329

(13)

Modes of Execution

342

(5)

Unmanaged Modules

347

(16)

Loading the CLR

363

(7)

The CLR as a COM Component

370

(9)

Where Are We?

379

(2)

Glossary

381

(4)

Index

385

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

What Happened? In 1998, Microsoft held a Professional Developer's Conference (PDC) in San Diego. COM luminary Charlie Kindel stood up in a general session and proclaimed "no more GUIDsno more HRESULTsno more IUnknown." He and Mary Kirtland proceeded to show the basic architecture of the CLR, then known as the COM+ Runtime. Later in the session, Nat Brown and David Stutz stood up and demonstrated cross-language inheritance using Visual Basic and Java. Attendees actually went home with CDs containing primitive versions of compilers that could reproduce this very odd demonstration. It is now February 2002, and this technology has finally shipped in release form. There are two days that will forever demarcate the evolution of the Microsoft platform. On July 27, 1993, Windows NT 3.1 was released, marking the end of the DOS era. On February 13, 2002, the Common Language Runtime (CLR) was released as part of the .NET Framework, marking the end of the COM era. The .NET Framework is a platform for software integration. Fundamentally, the .NET Framework provides two core integration technologies. The Common Language Runtime (CLR) is used to integrate software within a single operating system process. XML Web Services are used to integrate software at Internet scale. Both rely on similar ideas, that is, strongly typed contracts and encapsulation. Fundamentally, though, they are two distinct technologies that one can elect to adopt independently of one another. It is completely reasonable to adopt XMLWeb Services prior to the CLR (in fact, many production Web services have already done this). It is also reasonable to adopt the CLR in the absence of XMLWeb Services in order to access CLR-specific features such as code access security or superior memory management facilities. Going forward, however, both the CLR and XML Web Services will be central to the Microsoft development platform, and it is only a matter of time before both of these technologies play a role in everyone's development experience. The CLR and XML Web Services are both focused on strongly typed contracts between components. Both technologies require developers to describe component interactions in terms of type definitions or contracts. In both technologies, these contracts share two key ideas that tend to permeate their use: metadata and virtualization. Both the CLR and XMLWeb Services rely on high-fidelity, ubiquitous, and extensible metadata to convey programmer intention. Metadata conveys the basic structure and type relationships to the developers who will consume a CLR component or XMLWeb Service. Equally important, ubiquitous metadata informs the tools and underlying platform of what the component developers had in mind when they were authoring the code. This metadata-directed "clairvoyance" allows the platform to provide richer support than would be possible if the component were completely opaque. For example, various aspects of object-to-XML mapping are captured in metadata for use by the CLR's XML serializer. How the developer intended the XML to look is conveyed through declarative metadata extensions rather than through explicit labor-intensive coding. The second key idea that permeates CLR and XML Web Service contracts is the notion of virtualization. Both technologies emphasize the separation of semantic intentions from physical implementation details. Specifically, the metadata for both technologies work at an abstract structural level rather than in terms of low-level data representations and implementation techniques. When developers specify intercomponent contracts at this "virtual" level, the underlying platform is free to express the contracts in the most appropriate manner available. For example, by expressing Web Service contracts in terms of an abstract data model, the plumbing is free to use an efficient binary data representation for performance or to use the text-based XM