Possess a driving license? That probably means you know the mechanics that makes cars work. Thereby the skill necessary to ferry ourselves to and from places in daily life.

Wait, what has this gotta do with reviewing a technical computing book?

Well, you knew incorrect air pressure worsens tyre grip, accelerates wear & tear, and reduces fuel efficient, right? You knew improper engine tuning may lead to unsynchronized valve and spark plug timings, resulting in severe loss of power, right? You knew air bubbles in brake fluid can result in inconsistent application of brakes and uneven deceleration, right? Ah, so many important factors of physics revolving around the science and engineering of motoring. Yet so subtle and unknown by the vast majority of motorists. And ignored. Never realising what performance-leaking sins they commit against their cars.

This very book will expose the fact that you are effectively guilty of the same level of ignorance with the .NET CLR as you go about your daily programming work.

There are tons of titles covering the use of technologies and frameworks that build on top of Microsoft's .NET Framework. By and large they are fine, fulfilling the needs of developers as they work on the real purposes of their jobs - delivering beneficial (or entertaining) value to users and industries. But so few step into that deeper realm to discuss the very thing that makes this all possible. The very heart of the .NET framework, at its core, the mighty execution engine known as the CLR. Jeffery Richter takes a different approach by removing the shroud of magic surrounding the CLR and the C# compiler, exhibiting the internals and explaining all the little crucial activitites it does behind the scenes so that programmers can carelessly forget and not bother.

He organises the book into five parts and twenty four chapters of excrutiating detail:

Part 1 CLR Basics
Chapter 1 The CLR's Execution Model
Chatper 2 Building, Packaging, Deploying, and Administering Applications and Types
Chatper 3 Shared Assemblies and Strongly Named Assemblies
Part 2 Working with Types
Chapter 4 Type Fundamentals
Chapter 5 Primitive, Reference, and Value Types
Part 3 Designing Types
Chaper 6 Type and Member Basics
Chapter 7 Constants and Fields
Chapter 8 Methods: Constructors, Operators, Conversions, and Parameters
Chapter 9 Properties
Chapter 10 Events
Part 4 Essential Types
Chapter 11 Chars, Strings, and Text
Chapter 12 Enumerated Types and Bit Flags
Chapter 13 Arrays
Chapter 14 Interfaces
Chapter 15 Delegates
Chapter 16 Generics
Chapter 17 Custom Attributes
Chapter 18 Nullable Value Types
Part 5 CLR Facilities
Chapter 19 Exceptions
Chapter 20 Automatic Memory Management (Garbage Collection)
Chapter 21 CLR Hosting and AppDomains
Chapter 22 Assembly Loading and Reflection
Chapter 23 Performing Asynchronous Operations
Chapter 24 Thread Synchronization

Take a good look at this list topics, and honestly ask yourself if you know everything about how the CLR facilitates all these? Most approach the CLR as a black box - I knew myself to be one - and in result only knew what was sufficient to work with it, which in turn developed quite a number of misconceptions about it. Jeffery Richter goes through chapter by chapter and puts me through a constant pace of surprises, shocks, and pure enlightenment. He goes as low a level as the CLR can operate, and communicates in terms of memory locations, CPU registers, and gives the repeated impression that many of the CLR automated activities we take for granted has a performance cost. The material he writes about are astounding and sometimes downright shocking. It goes an extremely long way to remove whatever misconceptions you may have about the CLR or compiler, influencing you to rethink about many of the habits and practices you have now.

Challenge some examples. Just a small number of matters. Did you know C# constants are really only good for referencing within its own assembly? Any referencing and use of constants in other assemblies are hardcoded at the MSIL level. Do you know the exact garbage collection sequence the CLR takes to identify generations of orphaned objects and housekeep the memory? What does it take to resurrect an object from the Freachable queue? Why are finalizers generally not recommended? How would you compare strings with the added dimensions of encoding and globalization cultures? How do you construct strings and convert types to and from strings? What are the implications of unboxing a Value-type object from a Reference-type variable and assigning values? Did you know an assembly need not necessarily be just a single .DLL file? How does the metadata for your types turn out in the assemblies as the compiler emits the IL equivalent of your code?

Each chapter brings to light information you never knew you needed to know. As much as possible, Jeffery Richter provides code samples and programs to demonstrate his points and prove the effect. He not only provides the information, but lists many alternative ways to achieving a said effect, along with pros and cons for each method. He is here to explain, not to sell the CLR, and does not hold back on what he honestly thinks are design flaws by Microsoft. At almost every junction, you will feel vulnerable by the knowledge he passes to you. If you ever felt snotty and arrogant over your knowledge of the .NET Framework, this book is the antidode to humble yourself. If you ever positioned yourself to learn more about .NET, you will surely rejoice with gladness.

For all the great depth to be had throughout the book, a topic that I found notably absent is how the CLR actually performs interoperability with unmanaged layers in the OS. There is only a brieft touch on it in the first chapter. The WIN32 and COM platforms are still cornerstones of Windows development; it would have been ideal for developers like myself who began development after the advent of the .NET Framework.

Even then, this is one book you'd repeatedly refer for years to come to double check you don't commit another subtle mistake. By the time you are half way or perhaps even a third way through this rich material, you would have understood the term "managed code" is a literal description and not a marketing buzzword at all.

Overall rating: 10/10
Good: In-depth tour under the hood; shocking revelations; you were wrong, and will rethink;
Bad: No true chapter and detailing of P/Invoke and COM interop mechanics; seriously, why is this not in the SDK?

If you want to know what is going on under the hood, thn this is THE book.
Every chapter is very in depth with good examples. Definite YES for the geek inside you. 5 Stars.

The book is oriented toward experienced programmers. It provides an introduction to the CLR and describes some intermediate topics in detail. Advanced topics are mentioned, but the coverage of advanced topics (such as CLR hosting) is shallow.

If you are an experienced programmer who is new to the CLR and C#, this is a great text. If you already understand the CLR and are looking for more information about advanced techniques, this book is probably not for you.

I love reading Richter's books. When you think that there's no room left for improvement you get a title like this one. Wow!
Where other books present the subject matter this one gives you knowledge. Improves on the previous one.
Covers new topics like generics or nullable types. Just can't wait to see what Richter will do with linq!

I'm more of a Java and Ruby developer, but I found this book fun to read anyway. It's a great read to understand how languages interact with core libraries and how it all fits together inside of a virtual runtime environment. Very well done.

Most of what needs to be said about this book has already been said. But I feel a need add my two cents, if only to toss another five stars out there.

Really, this one is an example of what a good technical book should be. It's style is both understandable and unpretentious and it covers topics with depth and clarity. The overall organization is such that it never seemed like that terms, ideas, and concepts were being used that had not been introduced previously. Reading this book was a true pleasue and I know I will be referring back to it many times.

The book provides a developer's view of the internals of the .Framework and its CLR. It's more than you need to know to hammer out a lot of code. But if you want to build really good apps - or just want to know what .NET is all about - buy the book, read it, and keep in at hand.

This is a good book, considering it is primarily a reference/internals book. Those are notoriously hard to write and also be easily consumed. A bit dry at times, but for the most part is readable. The book also has minimal errors and is logically structured.

A couple of observations:

1. An experienced developer will benefit more from the content that someone with less experience or someone that is new to .NET. This book covers a lot of fundamentals, but you will learn more if you have time writing code in C#/.NET 2.0.

2. The factual content is quite useful, and most other books don't even come close to this. In addition to the facts, Jeff injects some of his opinion. An experienced developer will recognize these segments as opinion and reconcile that with the realities of their own work environment.

For example, Jeff prefers using the formal CLR syntax for primitive types over the C# shorthand (e.g., "Int32" instead of "int"). This of course is a matter of preference, and will most likely be determined by the coding styles and practices at your workplace.

Jeff also does not like Properties, and wishes that Microsoft had not included them as part of the framework. Again, an experienced developer will probably not read this and immediately stop using properties. It is not inconceivable however, that an inexperienced developer may read it and develop a bias against properties, something that may not be advisable.

There's not much I can say that hasn't been said already, but this is the single-most important book for a .NET developer. The author's technical writing ability is second-to-none. I have yet to find another source that covers the same material with the level of clarity and depth as this book. Until you've absorbed the information presented in this book, you'll never be more than an intermediate developer.

The only thing I can add to the other reviews is the perspective of a professional developer and mentor for over 10 years with a library large enough to start my own book store. The is THE book that every .NET developer needs to own and STUDY. It will help keep you out of trouble and help you create better product.

You will learn important things you will not learn elsewhere and find yourself referring to it again and again. Fortunately, you'll find this a very pleasurable experience as Richter is a terrific and entertaining technical writer.

A very good book. It goes inside CLR exactly what we need to understand what we're doing. No more, no less. A must-read!!!

Jeffery Richter has done an excellent job in covering CLR. There are lots of books in market which teach you how to program in C#, but avoid details of CLR. They book is pro developers who want to gain expert level knowledge of C# and CLR. This book along with Professional .NET Framework by Duffy covers whole nine yards.

I purchased this book as a vehicle for learning about the CLR, rather than about C#. Thus I was quite pleased to find that the book's title is an accurate advertisement of its focus. The writing is clear and reasonably concise. I have found it to work well both for straight-through reading and as a reference, due to the careful mentions of important related concepts that are described elsewhere in the book.

This book may not survive on my bookshelf as long as books that focus on more timeless fundamentals, but I will certainly hold on to it as long as the CLR remains relevant.

Complete and clear with a deep level information. Very useful for trying to use all the functionality of the CLR and C#.

It is a good book, and just FYI:
There is no CLR via C#, 1st Edition. The first edition is called "Applied .NET Framework" published by MSPress in 2002.

It is a good book, and just FYI:
There is no CLR via C#, 1st Edition. The first edition is called "Applied .NET Framework" published by MSPress in 2002.

This is a great book, and I think every C# programmer should have it.

Great coverage of both the new aspects of the .Net framework 2.0 and unique features of C#. As an experienced .Net programmer I found the level of detail and examples perfect. The section on garbage collection was the most lucid I've run across.

Extremely useful. I wish I had read this book a year ago.

I like the approach of keeping focus on CLR while giving all examples in c#.

If you need to be spoon-fed with step-by-step instructions then pass on this one. But if you are like me and find yourself filtering through the chaff in such books, then you will appreciate this read. Includes all the important information concisely and coherently.

Jeffrey Richter is one of my favorite technical writers. He describes the .NET common language runtime with enormous technical detail but in a manner and style that makes it all easy to grasp.

It's a good book for university students and for who wants to developer and understand what is behind this language and way of programming.

As most software developers know books like these are seldom an end-to-end read. They are usually kept on a shelf and pulled out when the need arises. That's why I was surprised to find myself continuing to turn page after page of Jeff's book. As usual, his writing style is concise, but has just the right amount of humor injected to keep it readable. What's more, his books tend to remain relevant long after they have gone out of print. I still pull out Advanced Windows NT Programming on a regular basis to reference. CLR via C# is chock full of the juiciests bits of .NET & C# 2.0. You'll learn tons, and be able to impress your programming buddies over lunch with your in depth knowledge of nullable types, generics and thread locking mechanisms.

The MSFT folks want you to adopt CLR. The interface they want you to use is C#, which essentially is Visual Basic with smart pointers (garbage collection). What about C++? It's being deprecated.

Good for people writing books, compiler authors, and CSci university professors.

Pascal anyone?

This book is for those who want to learn CLR. C# is used just as a means to illustrate features. CLR is language agnostic.

Jeffrey Richter steers us wonderfully through CLR. Very neatly explained using various diagrams and pictures. No unnecessary prose.

If you are curious about .Net, this is a must have book.

This book is excellent for in depth knowledge on CLR issues. Use it to e.g. get more info on how to handle exceptions properly, or to reveal the secrets behind the locking mechanisms. Note that this book is referenced several times in the MCTS Exam 70-536 .NET Framework Training Kit.

As always, Jeffrey's book is worth reading very much. I have read the first version (edition), and I read this one again. If you want to know lots of inside out about CLR, this is the one to read. This is a must-read book before you go for a job interview, because you are expected to have read it by lots of interviewers.

Just a quick note ... The book gives a deep insight how the compiler work with C# code to produce CLR-conform code. It shows what impact the style of code has and which features are available only because of the compiler.

It's nice to read, but for me as a "normal" programmer not really essential.

I echo the positive reviews below. If you already know the .Net platform fairly well and want to understand the internals of the CLR, this is the best place to start. This edition is as good or better than his 1.0/1.1 version, Applied .Net Framework Programming.

This book takes you through the CLR and explains how and why it works. The aurthor teaches you about the metadata all the way down to whats inside the internal data sructures the CLR uses. You will learn about what gets put on the stack and heap and what data, and in what order things are on the stack and heap. There is so much to the CLR and its difficult to put it all down. This book does a good job at explaining it all in an orginized easy to read fasion. At first glance this book looks like its just an introduction to the .NET Framework and then a C# language tutorial starting with the primitive types and then moving on up to generics. This is not the case, it starts off explaing the what the .NET Framework is and the CLRs execution model. Then it goes into metadata and application configuration and installation. Then it gets into the nitty gritty. It starts you off explaining the types in chapter 4, this insnt just a tutorial to ints and objects, it takes you deep under the covers. You will also get a good understanding of the various tools, like NGen.exe and when and why you should and shouldnt use it. There is alot of difficult content in this book, you will atleast understand it better if you read this. There is so much about this book that I can say but all I need to say is buy it!

This book gives a deep view of the CLR and framework. You can find tips for performance, and complete description of many functionalities of the framework. The bad think of this book, is that don't come with a CD, and because this, you lost a quick find and a way to carry the book with you.

As all Ritcher's books since "Advanced Windows: the developer's guide to the Win32 API", this book is a must read. Well subdivided chapters, useful examples, fluent writing. The missing star is for the lack of more advanced topics (expecially on generics, anon delagates and concurrency).

Jeffrey Richter is my hero, he really is. This guy is simply amazing. I just cant imagine how he pulls it off - the toughest topics explained in the clearest manner.Moreover, he has achieved this feat over and over again. Any book he has written is testimony for this.
In his books, you would find information where you wouldnt find in any other place. You would also find information you can find elsewhere, but not as clear as his. He has the advantage of working closely with Microsoft and consulting with the .NET team, but I would say he would be a great author and teacher even without that advantage.
As about this book, it should not be your first C# book. I suggest you get beginner's C# book first (if you dont know any C#), I suggest Jesse Liberty's book, and then come to this book. You would get a tremendous advantage over people who havent read this book and your understanding of the building blocks of .NET platform would be in depth. His chapters on Threading alone is worth the price of the book. This book is an absolute pleasure to read, just like any other book from Richter. Grab your copy today itself ! If there really is a 5 star book, this one is it.
Nobody writes like Richter, nobody.

If you are a beginner or intermediate .Net/C# programmer, this book will change your life... I have bought several advanced level technical books in different areas. But nothing comes close to this one.. This book is so amazingly well written that you cant help but understand all the difficlt concepts and start liking them too. But beware, Mr Richter's enthusiasm is contagious and you will end up spending a lot more money and time on .Net books..

This book is all that I expected from Mr. Richter and more. His writing style is excellent, his explanations are very understandable, and above all his examples are superb. He not only illustrates a particular point -- he also shows a coding style, verbousness (is that a word?), and correctness that we should all mimic. All too often writers choose for an example the most obvious one - which is wasted if it merely echoes whats said in the text. The examples here extend, amplify, and make you think.

Yes, you can write .NET applications without reading this book. But I have to believe that your application will be much better if you take the time to learn from this book. However -- I would not recommend it as the first book about .NET programming. It (correctly) assumes you already know the basics.

This book explains the "behind the scene" details of .NET CLR. If you wan't to know evertything about how the CLR internal are and works this is the right book.

I have read Wrox Visual C# Professional 2005, C# Programming from O'Relly and finally I've got this one. That's what I was looking for. You can exactly feel a professional trainer. Book written with expection that you are going to have a specific questions, and it offers proper answers without falling into some abstractions as some other books do. Excellent book.

At the heart of Microsoft .NET is the CLR. .NET development is primarily about directing the CLR. But how can you do that if you don't really know what the CLR is or what it can do?

Most .NET programming books are language centric. The capabilities of the CLR are implied based on the description of the language. Jeffery Richter's book is CLR centric. It describes what the CLR can do and how it does it. C# is used to provide practical examples of how to direct the CLR.

The book clearly and efficiently presents vital information that you'd spends days trying to discover by either pouring over MSDN or writing test applications. Highlights include:

* how source code is converted to IL, stored, managed, and executed
* a description of the code metadata available at run time and how it is used
* how data is classified, organized, and managed
* a description of the members that make up a class (fields, methods, etc.)
* how to handle exceptions
* how garbage collection works
* how reflection works
* how to write multi-threaded applications

Throughout the book there are many warnings about pitfalls and gotchas. The execution efficiency of different approaches is explained for many situations.

I urge any .NET developer who doesn't really understand the CLR to read this book.

If you're this kind of .NET developer who understood that the more you know about the CLR the better your code will be, this book is a MUST-READ. You'll find information available nowhere else at almost every page.

I really enjoyed the numerous digressions about reasons why MS engineers designed the CLR and the Framework the way it is. For example you'll find answers to tricky questions such as:


Why the C# compiler uses a callvirt IL instruction (and not a call IL instruction) when calling a non-virtual instance method?

What are the rare cases when you should consider using the Explicit Interface Method Implementation? (EIMI)

How the underlying processor architecture and volatile memory access are related in the CLR sphere?

How .NET framework classes with many events such as System.Windows.Forms.Control are designed to save memory at runtime?

And many many many more.


I also liked the fact that J.Richter is one of the very few who has enough knowledge on the subject to criticize some design choices made by MS. Often some alternatives for future .NET releases are proposed.

Clearly, if you are a beginner this is not the first .NET book you should read. But if your goal is to become a.NET expert, then know that you'll end up by reading this book.

I have been through the book several times already and I haven't found much to not like. Chapters 23 and 24 (Threading and Asynchronous Programming) alone are worth the price of the book. (no one gets threading issues like Jeffrey Richter)

I read a lot of technical books. There are few to which I can say I enjoyed reading. Jeffrey Richter's new opus is one of them. Even at 600+ pages, it is an easy read with a ton of very important information.

Similar to his previous book applied .net framework programming but much more detailed yet easy to read and understand. Thoroughly enjoying it and also like the little sidenotes on some of his personal opinions on CLR and C#.

I read a lot of technical books, usually 30 or more a year. You'll find none better written than this, in fact, it should be the how to manuscript for all technical writers.

You get in depth discussions that are just right and lots of "I always wonder why it was done that way" type of information. In short you know a lot more about NET when you finish this book AND be able to put it to good use!

I'll admit I'm a biased Jeffrey Richter fan. I've been reading his books since the mid 90s and love everythign he writes. This book, just like each sequential book he puts out, improves on perfection. The last .NET Framework book was absolutely critical to helping me learn the .NET Framework and has saved me more times than I can count. This book is even better.

It's similar to his last book but has an in depth discussion of the new features, like Generics, and an elaboration on things he's written about previously. No stone is unturned. Nothing. And everything is covered well.

As a fellow author, I've recently written training material for a major publisher. On the subject of Globalization, I wrote over 40 pages. I honestly didn't think there was a stone I didn't turn over. Then I read Jeffrey's discussion and realized that I had overlooked two items. I went back and updated my manuscript and it's a lot better because of it.

This book, like everything he writes is beyond excellent. It's a true masterpiece. The Forework by Aiden is a cute touch too ;-)