Customer Reviews

CLR via C#

5 star:		(24)
4 star:		(1)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

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.