In a world where developers are baying for the attention of customers, very few people can claim to command that of the developer. Their blogs may be the only clue to the higher level of thinking at which they operate, creating the answers to when and why code works - in addition to the perennial how. Whether he likes it or not, Don Box is one such system-meister. He may dislike writing books, but when one of his comes out, people pay attention and read. His first foray into the field, Essential COM, was the book that explained how COM worked, and his latest, Essential .NET, does exactly the same for the .NET Framework's Common Language Runtime (CLR).

After the first chapter's history of the evolution from COM to the CLR, the book takes a bottom-up approach to the CLR, starting with a deep and detailed six-chapter look into the core elements of the platform. Chapter 2 begins with assemblies - the programmatic units of the CLR - and the implications of their construction. We learn how they are versioned, loaded, and built; and why, therefore, they may be written in as many .NET languages as required. There's real depth to the material here - you really do touch the bottom of the abyss, so to speak - but it's countered with occasional levity that keeps it a readable book instead of a dense reference manual. The same is true of all the text. To whit, there's even some irony: "to allow old dogs to avoid learning new tricks, there is finalization," he declares in the section on the Common Type System.

It's here that we discover how different types and interfaces are distinguished from themselves and from one another, and how their variations and relationships are kept separate by the CLR. It's refreshing to note that the proverbial big picture is never very far away from the commentary. After taking time to explore the avenues for types and interfaces, Box notes that types themselves aren't very interesting until you start working with instances of those types, and we're off again working through another 30 pages on how object instances preserve a sense of identity, how they are cast into other types, and how they incorporate themselves into the concepts of reflection and metadata. Only then do we look at the actual life cycle of an object, its creation, modification, and disposal. The attention to detail is great, and there's pretty much no ambiguity in the text at all, but with that comes a slowness to this section that may have readers floundering in its wash.

One recurring theme of the book is the idea that while there is a set of rules for doing things, there will always be circumstances in application development that call for exceptions to be made to those rules. This is true at a small scale and - as Chapters 6 and 7 prove - at a large one too, covering as they do how the CLR calls and runs methods first on a single machine and then over a wire. How does the runtime treat methods called explicitly, implicitly through a delegate, asynchronously, or as a combination of the three? How do remote calls and types bridge whatever gaps they must cross and activate the remote objects and methods they're targeting? The answers are here.

Essential .NET reflects Box's pride in .NET and also his slight dissatisfaction with it. You can sense that while he knows .NET version 1 is an improvement over COM, it's not as good as it could be, and things are still to be done in v2 and beyond. Chapter 8's look at AppDomains - and in particular its discourse on threading within and through AppDomains - is a good example of this. Meanwhile, we finally come full circle in our investigation of the CLR, seeing how the assemblies we built in Chapter 2 are resolved and executed within AppDomains. Exceptions to rules included, we also see how object references are marshaled across AppDomains for interapplication communication if required.

The last two chapters look at wider topics around the CLR in as much detail as they can for topics that have entire books dedicated to them. Chapter 9 covers code-access security and Chapter 10 covers topics that are not of the CLR but which can be addressed from within a .NET application: explicit memory management, using p/invoke to import COM methods from DLLs, and so on. Both are concisely written and to the point, but unsurprisingly leave you feeling like there's more to these topics than is covered here. Chapter 9 is a great and clear introduction to code-level security, for example, but you'll get a lot more out of Michael Howard's book, Writing Secure Code, if you want to know more.

Essential .NET isn't an easy read, but everyone should try to read it at least once. Focusing on the CLR itself and how it deals with the components of an application means that it truly is aimed at .NET developers as a whole (including those building and using alternate implementations of the CLR). What code examples there are, are given in C#, but this is incidental really and won't stop VB.NET, J#, or any other developers from getting a great deal out of this book.

It's a dense, complex volume that requires a fair amount of effort to understand and use, and to some extent this may put people off. On the other hand, it is so packed with great nuggets of information that they may be inspired to keep reading. Of course, there is the question of whether this book will actually improve your .NET development skills, but in riposte, you can honestly say that no volume details the CLR and the potential so well - and that alone is worth its cover price .

Authors: Don Box with Chris Sells
Publisher: Addison Wesley
ISBN: 0201734117
List Price: $49.99
Rating: *****
Reviewer: Dan Maharry