Rating: 
Summary: A must read for CLR Insight
Review: If you havn't read this book, Buy it! I really enjoyed the style, flow, and great insight into the CLR.
Rating: 
Summary: Educationally poor, technically unimpressive
Review: If you want to be expert in any of the fields that this book purports to clarify, I suggest you consult the experts.
Rating: 
Summary: A Dense Book Full Of Nuggets
Review: In a world where developers are baying for customers' attentions, very few people can claim to command that of the developer. Their blogs may be the only clue to the higher level of thinking that they operate at, creating the answers to why and when 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 comes out, people pay attention and read. His first foray into text, Essential COM, was the book to explain how COM worked, and his latest, Essential .NET, takes the .NET Framework's Common Language Runtime (CLR), and does exactly the same. After chapter one'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 two begins with assemblies, the programmatic units in 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 next 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 thirty 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 lifecycle 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 very proper way and set of rules for doing things, there will always be circumstances in application development which call for exceptions to be made to those rules and made possible by .NET. This is true at a small scale and, as chapters six and seven 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 too. 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 be done in v2 and beyond. Chapter eight'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 being included, we also see how objects references are marshaled across AppDomains for inter-application communication if this is required. The last two chapters look at wider topics around the CLR in as much detail as they can for topics which have entire books dedicated to just them. Chapter nine covers code-access security and chapter ten topics which are not of the CLR but which be 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 nine 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 and 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 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 reposte, you can honestly say that no volume details the CLR and its potential so well and that is worth its cover price alone.
Rating:
Summary: 35 days of insights
Review: In my POV this is a masterpiece! I read both (Don Box's book and Stutz's Book)! Stutz's book has an "inside-out POV" to expose the CLR features,
Don Box's book has an "outside-in POV" to expose the CLR features. These two books are really cool... Any review less than 3 stars must be ignored!
Rating:
Summary: This book is outstanding.
Review: It reads very clearly considering the compexity of the topic, goes into detail while remaining concise and puts each topic in proper perspective, keeping the reader grounded as to not only how to use cetain technologies but also when and why to use them. I've read 5 other books on various aspects of .Net and countless articles and this is by far the best work I've come across. -Cheers to Don Box :)
Rating: 
Summary: 35 days of nothing
Review: It's arrived, finally. I've been waiting for this book for 35 days. Rubish. Anyway, Ive read a good chnuk of this book and well it's similar to my dads stained y fronts, really not good. The only reason that I don't send it back is becasue it's required reading on my course. If this is a book that you're thinking about buying, try reading it in your local library first.
Rating:
Summary: Excellent but
Review: only for advanced readers. If you are a beginner, you may get lost. I had to read a couple of times to get 100%. Excellent. Some concepts are pretty difficult to understand.
Rating: 
Summary: The author doesn't explain clearly.
Review: The author doesn't explain clearly nor provide good examples. The author assumes the readers had experience with the Framework. The book is quite poorly written and has no comprehensible flow. I learned very little from this book. You should choose another book.
Rating:
Summary: Very big disappointment
Review: The author takes a reasonably understandable subject and makes it unbelievably complex, vague and abstract. This book is poorly organized and rife with errors. I was not able to complete the first few chapter of this book. You should read the reviews carefully before possibly wasting you time on this one, but if you want to talk philosophy and examine odd insights, buy this book.
Rating:
Summary: Many subject are not illustrated in a coherent way
Review: The book covers a lot of subjects, but it makes even the simplest thing complex. In the end, you don't get much by reading the book.
| 
