CLR via C# 3e Paperback – 19 Feb. 2010

I have been doing C# for five years and I thought I knew it all, and boy I was wrong. This is by far one of the most intense reading about C# (definitely for total beginners), it will take your knowledge of C# from a "user" level to someone who really knows what goes under the hood, for me personally, it opened new doors in terms of how I code..NET makes it far too easy to start developing applications without real in-depth knowledge, the entry barrier is much much lower than C++ (and dare I say Java), this comes with a drawback. The average programmer - like me - knows much less than the average programmer in those other languages. This book helps you take a step to separate yourself from the average knowledge. It goes into deep details of what goes in the CLR, the IL produced when you write code, performance issues, new constructs in C#4 etc... The result is a huge mindset shift, you don't simply write code that works but you actually think about how is it compiled and JITed, and you start thinking of using tools like the disassembler for the first time! Highly recommended.

In this book, Jeffrey Richter unpeels the CLR like an onion to reveal details that are strangely useful. I found it to be a fascinating read, but thought it all might be a bit academic - until I suddenly realised how much it helped me to understand what was actually going on under-the-hood.The book was recommended to me after I read C# in Depth and I congratulate James Lanng as this is a perfect next stage in your C# reading list!

There is not much to add to what other reviewers have already said. This is an excellent book for those with some experience wanting to know in-depth details about how the CLR works, using C# as a tool. Because of this, it's neither a book for programming newbies or those who just want their first introduction to .NET and C#.The third edition has been updated to include .NET 4.0, specially on the chapters dealing with concurrency.Get this book if you're already familiar with the .NET framework and C# and want to expand your knowledge on advanced topics, you won't be disappointed.

This book goes into excellent detail of what is actually happening at a low level when you write C#. A lot of things I knew I should be doing in C# however now I know why I should be doing them. This book has improved my coding and has changed the way I write certain parts of applications. In my view anybody who views themselves as a proficient C# developer should have read this book.

This is one of the best books about C# and CLR I every read; it gives you a very good and clair inside of how the CLR handles the code (C#). It's not a book for beginners, but if you want to know how the CLR (computer) handles code and how you can improve your code regarding the working of the CLR, it's a must. It's a book you can read over and over again; each time you understanding will grow.

The most valuable book about .NET! If you are intermediate to advanced developer this book is a must read. 3rd edition is greatly enhanced compring to 2nd with huge emphasis on multithreading. Book is worth much more than asked price!

Really, it's that good. Take the time to read it and you're C# will be beyond guru level. I've coded c# since the beta days in 2001 and I can't believe how much I didn't know.

I sadly made the assumption that Jeffrey Richter (JR) would be writing about the CLR in such low level, that this book would be more use to a device driver programmer, than a generic .NET developer. I saw 'CLR' and thought "oh-god - a book dedicated to MSIL (with C# code examples)" - I WAS VERY VERY WRONG!There isn't a single book I have read on the subject of .NET that comes close to explaining how it really-really! does work.When working with C# for a couple of years, having no C or C++ background, you start asking questions like- What is the CLR?- How does the Garbage Collector work?- Why should I declare classes as virtual?- Whats the actual difference between declaring something static, and assigning it in a static constructor?- What are the best practices for locking and multi-threading?- Is an array of value types (like int[]) a value type, or a reference type?Ok - you may have not asked these questions, but I certainly had! With the vastness of material on the internet, conflicting opinions on Google vs the wealth of information on MSDN, I certainly found it very difficult to nail down an exact explanation in sufficient detail to keep me happy. Whats more, it left me asking more questions, doing more research and again, finding that the detail on the Internet is overwhelming.What CLR via C# does do is give you an in-depth explanation of why C# is the way it is. It takes you through the components of the language and explains the semantics around why it is implemented in a particular way. But it isn't just a regurgitation of the CLS (Common Language Specification). This book explains WHY it is that way.Since reading this book, I have become extremely confident in my approach to development practices. Naively, I always assigned variables to null, just to "free up space more quickly" - that doesn't happen. I pre-maturely optimised code - no need. I called GC.Collect() when I wanted more memory, because I wanted it! Bad idea. But I also learned about correct usage of constructs, which is something I was still unsure about.I also want to emphasise JR isn't bowing at Microsoft's knees and praising every single features implemented. He does have his reservations on certain features of the language and has good reasoning behind doing it a different way.Finally, although this book does go into the depths of the C# language, it isn't inaccessible as a general read. Each chapter covers a completely different feature of the language, so it has been easy to skip back and forward between chapters. The book is well cross-referenced should you need to revisit a chapter to improve your understanding.I would like to also convey that this book has changed my understanding of C#, cleared up bad assumptions made and also gave a central resource for me to go back to again and again.I have also e-mailed the author a few times and he has been extremely helpful and thorough in answering my questions.

Excellent book. Even the best .NET programmers will find it difficult to not learn a new tidbit every page. This really is one of the most cram-packed books I own... which is quite the feat at nearly 900 pages. I honestly felt he could have made this into two books and still legitimately sold them as complete works... glad he didn't, but just saying "there's that much info!" This guy really knows his stuff. Then again, why wouldn't he? He's played a big role in the entire .NET universe.Making it short... can't recommend this book enough for the intermediate to expert level programmer. For the beginner I'd buy this PLUS something from Andrew Troelsen. Either way, if you program for .NET then buy this.

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 IIChapter 4 - Type FundamentalsChapter 5 - Primitive, Reference, and Value TypesChapter 6 - Type Member BasicsChapter 7 - Constants and FieldsChapter 8 - MethodsChapter 9 - ParametersChapter 10 - PropertiesChapter 11 - EventsChapter 12 - Generics (yes advanced but mid-level devs should be reading this)Chapter 13 - InterfacesPart IIIChapter 14 - Chars, String, and Working with TextChapter 15 - Enumerated Types and Bit FlagsChapter 16 - ArraysChapter 17 - DelegatesChapter 18 - Custom AttributesChapter 19 - Nullable Value TypesPart IVChapter 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 thisChapter 22 - CLR Hosting and App Domains (yes, you should know what an AppDomain is, even mid-level devs)Chapter 23 - Assembly Loading and ReflectionChapter 24 - Runtime SerializationIf 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.

Eines der besten Bücher zum Thema am Markt. Auch für erfahrene Entwickler noch eine Bereicherung. Das Buch wurde mir von einem Kollegen empfolen, als es dann begann zu lesen dachte ich mir als erstes "Bitte nicht schon wieder so ein C# for Dummies" wo mit den Basics begonnen wird. Doch nach kurzer Zeit war klar, dass das Buch selbst bei diesen Dingen noch Wisssen vermitteln kann, dass man in anderen Büchern vermisst. Z.B. das Kapitel zum Typsystem hält einige Überraschungen bereit. Abgerundet wird das Buch durch sehr gute Codebeispiele die immer die richtige größe haben um das Problem sehr gut zu illustrieren. Sehr gut gelungen ist auch, dass man das Buch einerseits sehr gut am Stück lesen kann, andererseits auch hervorragend als Nachschlagewerk funktioniert, bei mir steht es immer auf dem Schreibtisch um es griffbereit zu haben.Trotz das es mit den Basics beginnt, ist das Buch nur bedingt für Einsteiger geeignet, da es im Verlauf stellenweise seht tief in die CLR eintaucht und sich Anfänger davon Überfordert fühlen könnten. Für alle mit mindestens 1-2 Jahren C# Erfahrung ist es aber sicher ein Augenöffner.

La guida è eccellente, dettagliata e omnicomprensiva.Di certo il target non è lo sviluppatore alle prime armi, ma qualcuno che già ha le basi di c# e vuole approfondire il linguaggio per avere migliori idee per sviluppare in maniera ottimale e per avere prestazioni sempre migliori per le proprie applicazioni.Ogni argomento viene spiegato compiutamente, dalle basi fino alle applicazioni più avanzate e rare.Viene mantenuto sempre un occhio sull'efficienza e sul CLR, in particolare per gestire dal punto di vista prestazionale il codice.Questa guida non ha pari.

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.