Home - Languages & Tools

The first thing I'd like to say is this book rocks. It should be one of the first books you open up if you want to really be good at OOP. Because first you have to learn what the CLR is doing and why because the code you write directly relates to it by performance, and expected behavior. If you don't know this, then you end up with more ?? than anything when coding because you really don't understand HOW things are being done under the covers and even though you can still code and code even simple or advanced, you are sort of coding blind and you are winging it no matter how good you think you are.

Second, let me say that I strongly disagree with many who say this book as a whole should ONLY be ready by experienced / advanced programmers. Ok, yes the some of this book gets really advanced (i.e. threading, etc.). However there are a lot of just fundamentals here that are critical parts in this book that EVERY developer needs to grasp and memorize fully in order to be an effective programmer.

Here are some of the sections I'm talking about that apply to all developers of all levels of programming:

Part II
Chapter 4 - Type Fundamentals
Chapter 5 - Primitive, Reference, and Value Types
Chapter 6 - Type Member Basics
Chapter 7 - Constants and Fields
Chapter 8 - Methods
Chapter 9 - Parameters
Chapter 10 - Properties
Chapter 11 - Events
Chapter 12 - Generics (yes advanced but mid-level devs should be reading this)
Chapter 13 - Interfaces

Part III

Chapter 14 - Chars, String, and Working with Text
Chapter 15 - Enumerated Types and Bit Flags
Chapter 16 - Arrays
Chapter 17 - Delegates
Chapter 18 - Custom Attributes
Chapter 19 - Nullable Value Types

Part IV

Chapter 20 - Exceptions and State Management
(all about exceptions here. i.e. he talks about try/catch and best practices using it and much more on the fundamentals of exception handling)
Chapter 21 - Automatic Memory Management (Garbage Collection) - Every developer needs to know about this
Chapter 22 - CLR Hosting and App Domains (yes, you should know what an AppDomain is, even mid-level devs)
Chapter 23 - Assembly Loading and Reflection
Chapter 24 - Runtime Serialization

If every developer were to pick up this book simply to read those chapters above, you are pretty much guaranteed to have a much more confident grasp on what is actually going on other than syntax when you program. It's important to know what is going on.

The thing I like about this book is it's not just a dry read, plain technical book. Yea some of it is very technical and can be considered a reference but it's sort of a hybrid to me, not just a reference. You also have the author's thoughts, reasoning, etc. behind the vanilla hard core concepts of what's going on in the CLR. He's able to articulate what's going on and able to explain it in simple terms even though what he's talking about has a lot of detail and is very in depth. So in other words, this is a much more "modern" developer book. Modern is by my definition those authors who can teach you when you read their books. They are not just dry technical text that bore you to death and leave out reality or real-world examples. They engage you, and they stick in your head because the author knows how to communicate not only in one way but usually able describe a topic from many ways...saving you a lot of headaches because you're learning from Lead developers.

This book should be on EVERY developers shelf. It's one of those books that you'll use over and over again throughout your career and it will really save you a lot of pain. And you should be reading at least the fundamentals above...find the time. Other books for example may talk about value and reference types but they fail to really give you a grasp of WHY you need to know about this and really explain what's going on in detail in a way that you can understand clearly and simply. And there are a lot of things in here that even Sr. or Architect level devs may think they know but they don't, even in the fundamental sections. Everyone can learn a lot from this book. I too am still learning a lot from this book.

There's a lot to read even in the sections I listed above, but you should really get this book and find a way to read every page of those sections.

There are plenty books that show you what you can do with C#. This book shows how C# does what it does and tells you why. There is no better advanced C# book available on the market.

If you want to learn the CLR, this is the way to do it. There is no better way.

You will not find a better treatment of threading. This book covers threading in great detail.

The author's style of writing makes the book very easy to read, and he is able to present complex topics in an easy to learn format.

The only part of the book I can't stand is the Forward. There Jeffrey's wife tells us that this is his last book. That would be understandable, but ashame.

All the code in the book is in one solution and is easy to use.

All in all, this is an absolute must read for any C# developer. The understanding of C# you gain from this book will take you too the next level, no matter what level of programmer you are today.

I have been programming for over 10 years now, this book is filled with great information about the CLR. If you ever wanted to know the details behind the code generated from your .NET language, this is the book to read. So far from what I have read it already is already effecting the way I code.
It is a dense book, so don't try to absorb all of the material very quickly. Enjoy this over a cup of coffee.
I read around 20 pages a day for no brain overload. I wish I had gotten this book sooner.
I will keep this around for a great reference when finished.

I've been developing in C# for 8 years, and this book is the most clear, in-depth book on how the CLR works I have ever read. It starts from the bottom, by explaining what the CLR is, how it works, and how to best use it. The best section is the Threading section. It goes over the different models of threading, how they work internally, and when to use them. I've been able to immediately apply what I've learned in this book to my current work.

WOW.

All I can say is WOW to this book.

You could slap a price 3-4x more on this text and it would still be a bargain. There simply is no other text on the market that hits this niche and smashes a home run out of the park.

Buyer beware, this is NOT the book for the casual programmer who is doing basic app/form/web/database development. This is a VERY specific niche of developer that is looking to get into and understand the guts of the magic of CLR. The writing is slick, tight, and intelligent. At 800+ pages, this seems like a huge amount, but there is magic throughout this book.

Let's take a look at the Table Of Contents:

01. CLR Execution Model
02. Building, Packaging, Deploying, and Administering Applications and Types
03. Shared Assemblies and Strongly Named Assemblies
04. Type Fundamentals
05. Primitive, Reference, and Value Types
06. Type and Member Basics
07. Costants and Fields
08. Methods
09. Parameters
10. Properties
11. Events
12. Generics
13. Interfaces
14. Chars, Strings, and Working with Text
15. Enumerated Types and Bit Flags
16. Arrays
17. Delegates
18. Custom Attributes
19. Nullable Value Types
20. Exceptions and State Management
21. Automatic Memory Management (Garbage Collection)
22. CLR Hosting and AppDomains
23. Assembly Loading and Reflection
24. Runtime Serialization
25. Thread Basics
26. Compute-Bound Asynchronous Operations
27. I/O-Bound Asynchronous Operations
28. Primitive Thread Synchronization Constructs
29. Hybrid Thread Synchronization Constructs

There's a lot there isn't there?

I don't need to say much more, if you need to get into the guts of the CLR or you are just looking to learn more about the inner workings, pick up this book immediately. It's one of the best computer-niche books I have ever had the pleasure to come across.

***** HIGHEST POSSIBLE RECOMMENDATION

I bought this book last year. I was a C++ developer and wanted to lean C#. I bought this book after some research. Its an amazing book. Evenyone who wants to learn .net / C# internal its a must buy. It covers almost everything and explains with examples. Even if someone if expert in .net should read this book.

I highly recommend this book and shipping was good. It reached on time.

I owe my C# expertise to this book. It led me to deep knowledge on the language and the inner workings of the .Net framework. It's not a book for begginners, but once you get some experience in C# this book is a MUST read if you plan to develop your career as a C# developer.

This book allows you to code the right way, to make use of the best APIs available in .Net and shows you things you might have thought it wasn't possible before.

This book doesn't only show you C# features, it also shows you how to avoid many pitfalls using it. It shows how to get better performance and how to squeeze all the juice available in the .Net Framework.

If you are serious about C# development, do yourself a favor. Buy this book.

The book is excellent (like all Jeff Richter books) and I believe is a must read for any .NET developer.
The only thing I think this book is lacking is a chapter about CLR Security (Code Access security, trust levels, etc) and a chapter about Interop. These topics are discussed briefly throughout the book and some code examples in the book use interop and security attributes. In my humble opinion, I think these two topics deserve two extra chapters with more details.

Another note, if you are expecting full coverage of ASP.NET, Windows Forms, WPF, Workflows, etc, you will not find it in that book. However everything in that book applies to all these technologies. So it is best to combine this book with another book that focuses on a specific technology. It's also not an introduction to C#.

The extra information in this edition is worth it, even though I already had the first and second editions.

I can't give enough praise to this book. If you write C# professionally, please do yourself and your coworkers a favor and purchase this title, no matter your level of "expertise" you will almost definitely become a more efficient .NET developer.

The third updated edition of CLR Via C# provides an important, definitive guide to mastering CLR and .NET development, and comes from a programming expert and longtime consultant to Microsoft's .NET team. It shows how to build, share and use version applications, assemblies, and more, using generics and interfaces and working with special CLR types. From exceptions to dynamic applications using CLR hosting, this is a powerful pick for any serious C# programmer's library.

Without this book, we .NET programmers must continue to operate on a very fuzzy "abstraction" layer. We must accept the obtuse generalities of the countless programming books that treat the CLR as a sort of known and accepted capability that needs no further explanation. The result is that as we create our .NET programs, we are always uneasy not knowing the actual effect or internal implementation of a particular construct or feature.

Let's face it: to the average .NET programmer, the CLR is a very weird animal. Let's see - you write a program in a familiar high-level language (like C# or VB). Then this source code is "compiled" into a strange byte-coded intermediate language that is an actual functional assembler language for a theoretical stack-based virtual machine that could if asked actually execute this code. But during execution, just before this happens (that is, the execution of the intermediate language on the virtual machine), the intermediate language is compiled into the native machine language of the target computer and executed in the usual way. Oh, by the way, all those external references from your C# or VB code to mundane capabilities like writing a line on the console are magically resolved because your program is actually a "managed module", part of an "assembly" that is somehow embedded in a vast sea of capabilities known as the "common language runtime" or CLR for short. Huh?

In all other .NET books I have read, this bizarre execution model is presented as if it were a well known and accepted extension of normal practices. I can imagine being in a C# classroom and when the students say "Huh?", the instructor gets impatient and belittles them for wasting valuable classroom time asking dumb questions and not recognizing the obvious. Now we .NET programmers are saved from our frustrations by this book. It is as if well-known super-author Jeffrey Richter was saying "No - you're not the only one that's crazy."

This book could be called "Deconstructing the CLR." It is a fantastically clever, extremely well-written, and very thorough coverage of the CLR. It has the very pleasing characteristic of never generalizing. In the very thorough text of the book, the author knows just what question the reader will have at each point and then gives a comprehensive explanation of the reader's exact question at that point. This is real talent.

"Applied Microsoft .NET Framework Programming" by Jeffrey Richter was the first .NET book that I truly loved. The version 3 of this book, now called #CLR via C#" is essentially the same and brings the book up-to-date with version 4 of the .NET framework. It also includes quite a few chapters on Threading, something that wasn't present in the previous versions. I found the writing style of Jeffery very pleasing and this is possibly one of the new technical books I can read cover to cover.

This book is definitely not for the impatient, and it won't get you up and running in a jiffy. It is a great book if you are a beginner in .net and are looking for a deeper understanding or an expert in another language and now are shifting into the .net world.

I was hoping that version 3 of this book covered a few more topics like LINQ but since the book is more about the CLR and less about C# I guess they decided against it. Maybe I got a little lazy, hoping to have everything served on my plate! The internet does have a lot of information, but for me it is a little too much searching and putting together and its nice when an author like Jeffrey does that for you! Especially since he does it so beautifully!

If you don't know Jeffrey Richter, you should. Read his books, his blogs, his MSDN articles. This book is a sample of what you need to know to program using the CLR.

Especially (it's all good) well-written are the chapters on threading. If you manage software projects- you had better understand the chapters on threading. Everyone wants multi-processing, few know how to do it correctly.

Anyone can make something difficult, Richter makes sense of the complex world of CLR. You need to read (study) this book.

I have gone through at least 4 dozen books on programming, C#, ASP.NET, etc. I wish I found this book first because it would have answered many questions from the start. This book presents subject matter from the ground up, unlike the majority of related books out there. Very complex topics are discussed in a way that makes them both interesting and accessible - particularly the chapter on threading. I cannot speak highly enough about the author. Fantastic job!

I'm new to the programming field. My intern supervisor recommended this book to me. It is a really great in depth book on the subject to programming. I suggest as a supplement you read the ECMA-334 C# standard

I have to say that I did learn so many new things from this book. , I was only interested in reading about the .NET threading model and how the framework handle thread scheduling . but I ended up reading many other chapters too.

The book does focus on how the C# codes becomes CLR code and how can you optimize your code for it .
I did skip some chapters as I did my share of reading from other resource , but all in all , it is a great reference if you want to start C# and in need of a Bible.

But as with many Microsoft programming books it is in need for more colors and graphics , but I am still satisfied with the content.

Thank you Jeffery Richter for such great effort.

Also to be noted , that Jefferey Richter is / was working on the SideShow framework.
[...]
[...]
Thank you

As much as I enjoyed reading the book, i also thought that there are a lot of details which I wouldn't need to know nor i will remember while developing a system. It would be nice to see a chapter related to Collections.

Overall, It's a great book on C# and CLR.

Wow, the fundamentals are so important for being a great programmer. If you want to make the leap from being a good programmer to being a great one, you must have a good grasp on the nitty gritty stuff that a lot of the time feels boring. I work with several people whose idea of solving a problem is to read a tutorial on the internet for the exact solution. If you need to look online for a solution every time you run into a problem, you will only be as creative as other people. You will be limited to what has already been done. Understanding the founding principles of .NET and its inner workings allows you to take things to a whole new level. You will start to really understand WHY things work and how you can combine several simple concepts together to create something that is far from simple. As an engineer I must understand how things work. It is simply not good enough to be content with mystery black boxes. I must know why it works underneath the hood. This is my particular learning style and it is not the best for everyone, but all I can say is that it feels right. And this book is perfect for that.

Read this book. And when you run into stuff that feels boring, do not skip it. It may not apply to a project you are working on right now and it may not seem like it is something that will matter down the road, but the information is fundamental. It will inspire new ideas and ways of doing things more efficiently. Remember: everything else in .NET builds off this. It's a wise investment in your career.

To me and a lot of developers CLR is a black box, we know it's there, but we don't know what's its job and what it's doing, and how it works ?. "CLR via C#" is a great book on the subject, it show how the CLR works with C# examples and covers a lot of interesting topics. I am interested in CLR because i want to write compilers that targets the CLR, so i wanted to know more info about it and how it works, and this book is very satisfying. The author writing style is very clear, complex topics are illustrated in interesting ways. The book is organized into 5 parts. Part 1 (CLR Basics) covers CLR's execution model, building, packing, deploying, administering applications, shared assemblies and strong named assemblies. Part 2 (Designing Types) covers type fundamentals, primitives, references, value types, types and member basics, constants and fields, methods and parameters, properties and events, generics and interfaces. Part 3 (Essential Types) covers chars, strings, enums, arrays, delegates, custom attributes, nullable value types. Part 4 (Core Facilities) covers exceptions and state management, garbage collection, hosting, AppDomains, assembly loading and reflection, and Runtime serialization. Part 5 (Threading).

Recommended for all C# programmers and anyone interested in CLR.

This is one of those books that every programmer should own. Well written, fun to read, and filled to the brim with useful and practical information. Richter really knows what he's doing, and his bottom up approach to learning C# completely changed my view of programming languages.

The best book I have read since another Richter's gem - Windows via C/C++ (Pro - Developer). Richter's ability to explain even the hardest things is absolutely unique. It doesn't matter if it's about threading, or CLR internal stuff. After reading his books everything is like piece of cake.

First edition of this book was my first book I read about .NET, and it was really a great choice. The book delves into CLR so deeply but it's still easy to follow. Now after 6 years of professional development with C#, I took this edition and I still was able to learn 'tons' of new things. It was not just helpful for my profession, but it was also a big fun.

The book covers CLR in great depth. It's not C# tutorial but if you have already worked with similar language like C++ or Java you get everything you need (and much more). 3rd edition was extended with threading support in .NET 4.0.. Those chapters at the end of the book are brilliant. Much better than other books about parallel programming with .NET (with one exception of Joe Duffy's Concurrent Programming on Windows). Richter's text doesn't cover any specialized libraries like WPF, ADO.NET or WCF, but it provides inevitable base you need when you want to write programs with .NET. Highly recommended.

I'm relatively new to .NET. This book has been a fantastic resource. I recommend it to anyone developing .NET applications.

Jeff shows how C# and CLR work together in a way no other book does. The book show the entire C# and .NET ecosystem in broad context and helps to understand it.

I read the book from cover to cover and I could not stop. It is fun to read and easy to understand. All chapters and examples are very explanatory and fit well together.

Everybody who is serious about being good in C# and .net should read this book and try out all examples provided.

This book goes faaaar beyond MSDN documentation.

Definitely recommended!!!!

I'm very glad with that book. The richness of details is amazing! The book is good to read.
It has a well coverage of the .net CLR and your details

I am a big fan of Jeffery Richter, having read 3 of his books. This one is a great update to the second edition of his book. I was somewhat surprised that he did not cover LINQ, but perhaps the focus of the book being CLR not C# per se, it was left out on purpose.

I bought the 2nd version of this book. Then, I opened Safari account. I read this version through Safari.
I honestly said this book is not for professional developers. It covers almost all the aspects of CLR the same as MSDN.
I don't know if the book is paraphrased from MSDN. It does not provide any thoughtful explanation out of the author's personal experience.
It seems to me that the author did not work as a developer for a long time.
I don't recommend the books to any of my friends.