- Series: Developer Reference
- Paperback: 704 pages
- Publisher: Microsoft Press; 3 edition (February 20, 2010)
- Language: English
- ISBN-10: 0735627045
- ISBN-13: 978-0735627048
- Product Dimensions: 7.4 x 1.5 x 9 inches
- Shipping Weight: 2.8 pounds (View shipping rates and policies)
- Average Customer Review: 45 customer reviews
- Amazon Best Sellers Rank: #1,175,921 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
CLR via C# (3rd Edition) (Developer Reference) 3rd Edition
Use the Amazon App to scan ISBNs and compare prices.
Top 20 lists in Books
View the top 20 best sellers of all time, the most reviewed books of all time and some of our editors' favorite picks. Learn more
Customers who bought this item also bought
Customers who viewed this item also viewed
About the Author
Jeffrey Richter is a cofounder of Wintellect (www.wintellect.com)-a training, debugging, and consulting firm dedicated to helping companies build better software faster. He is the author of the previous editions of this book, Windows via C/C++, and several other Windows-related programming books. Jeffrey has been consulting with the Microsoft .NET Framework team since October 1999.
Browse award-winning titles. See more
Top customer reviews
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:
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
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
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.
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.
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.
Most recent customer reviews
This is the best .NET book I ever read, by far.Read more