There is no doubt that this is a classic  - and it has reached its third edition. But as with all classics it still isn't perfect.

What would you expect a book called CLR via C# to be about? Presumably the CLR with illustrations of how it works in C#. In many ways what the book is really all about is illuminating the way C# works via an understanding of how its facilities are implemented by the CLR.Thus the book is primarily about C#.

The book starts off with the CLR execution model and works its way through the usual C# topics of type, methods, parameters , properties, events, generics, interfaces, arrays, delegates and so on. It tackles advanced topics such as custom attributes, nullable types, exceptions, garbage collection,. CLR hosting, AppDomains, serialization, threading and synchronisation.

Many of these topics would be covered in any book on C# but without the digging down to see how the CLR handles the tasks. It isn't about advanced CLR and it isn't about Intermediate Language IL code - although there is a fair bit of IL used to explain what is going on. After reading this book you will understand C# at a deeper level and appreciate how it is implemented by the CLR.

One problem with the book is that its focus is generally on low-level implementation details and sometimes this means that you can miss the bigger picture. For example, in discussing delegates we have an account of how the variables declared in the same scope as an anonymous delegate are accessible from the delegate. This is an example of capture of the delegate's outer variables, more commonly described as closure but these higher-level facts are never mentioned. There are other places where the level of detail means that you miss the high-level view, which is fine if you already have the hlgh-level view but if not it can all seem very arbitrary.

As well as explaining how the CLR implements various aspects of C# the author also makes comments and asides about which features of C# don't sit well with practice. For example, auto-generated properties, language based primitive type names and so on. This is all good stuff and the book is packed with suggestions about how you should do something and what you should avoid. What you won't find is lots of waffle about object-oriented design or indeed any formal design or development methodologies.

This is a book in the old style, focused on the mechanics of how things work and how to get things done, and as such it should be on the shelf of every C# programmer.