CLR via C#, Second Edition

CLR via C# is an excellent look into the finer details of the .Net Framework. It is not really a book on how to program in C# per se (there are many excellent books on this subject, such as Programming Microsoft Visual C# 2005: The Base Class Library by Francesco Balena) but more a book on how to get the most out of the .Net Framework while using the C# language as your vehicle. If you are new to programming or to C#, this should probably not be your first or even second book on the subject.In this 648 page journey through the CLR, Mr. Richter covers such subjects as how code is converted from high level C# to MSIL, Types, Generics, Events, and Asynchronous programming, to name just a few. The book assumes some level of knowledge not just of C# but of programming in general. The author does assume that you, as the reader, are familiar with some common data structures and programming best practices. Mr. Richter also interjects his own opinion at various times on why certain features work the way they do, or how they would/should work were he in charge of creating the CLR.If you are already a competent C# or VB.Net developer who is ready to take your development skills to the next level, I highly recommend this book. At 648 pages long, it may take some time to get through, but I can guarantee it will be time well spent.

the first edition was better. this edition is more about Jeffery Richter fluffing his feathers than it is about the CLR...kind of hard to someone seriously when they take themselves so seriously.

At the heart of Microsoft .NET is the CLR. .NET development is primarily about directing the CLR. But how can you do that if you don't really know what the CLR is or what it can do?Most .NET programming books are language centric. The capabilities of the CLR are implied based on the description of the language. Jeffery Richter's book is CLR centric. It describes what the CLR can do and how it does it. C# is used to provide practical examples of how to direct the CLR.The book clearly and efficiently presents vital information that you'd spends days trying to discover by either pouring over MSDN or writing test applications. Highlights include:* how source code is converted to IL, stored, managed, and executed* a description of the code metadata available at run time and how it is used* how data is classified, organized, and managed* a description of the members that make up a class (fields, methods, etc.)* how to handle exceptions* how garbage collection works* how reflection works* how to write multi-threaded applicationsThroughout the book there are many warnings about pitfalls and gotchas. The execution efficiency of different approaches is explained for many situations.I urge any .NET developer who doesn't really understand the CLR to read this book.

The book is very clearly written, and I typically have issues with code samples showing nuances of languages and environments, but they are quite clear here.This was recommended reading that I did before beginning a dev job out of school since I had worked almost exclusively in a *nix environment, but would have to at least be able to read (and eventually write a bit of) managed code for the Windows CLR. It is a thorough introduction to the necessities of CLR coding and gives very useful analogies/similarities with other languages that I found quite useful (especially C++).Without this, I would have spent a LOT of time on my own writing various test programs and not fully understanding what was going on under the covers. There is also quite a bit of code samples showing the IL generated for the runtime that is quite useful.Other reviews cover the topics etc., and all I'll say about them is that they are all applicable and clearly written.

The title really isn't completely honest...while we get a little ILDasm IL code, this text will not replace Lidin's book on IL Assembler in any way. It isn't really about IL and CLR, but rather about C# in the context of thinking about CLR.That is, if one thinks of IL or metadata tables as central to CLR and hopes to be tearing down C# compiled code to explore these, forget it. If, on the other hand, one is thinking about garbage collection, threading, and exception handling, and how the context of the CLR affects program performance, then definitely this text comes through on the title's promise...especially garbage collection. Wow.To smooth over this dichotomy better, let me give the example of exception handling. Here Richter is very specific about details of CLS (the common language specification) vs. C#, and very specific about throw alone vs. throw with the exception object, etc. But there is no discussion of the IL generalized concept of exception blocks or how IL frames blocks. Stack unwinding is mentioned at a level fairly normal for high-level language texts, but there really isn't anything about how the CLR builds or unwinds frames. (I'm still looking for that book!)Read this book with Lidin's IL Assembler, and then you have a fantastic triangulation on the theme of the CLR.Or, if you want to understand garbage collection, read Richter. Wow!

As most software developers know books like these are seldom an end-to-end read. They are usually kept on a shelf and pulled out when the need arises. That's why I was surprised to find myself continuing to turn page after page of Jeff's book. As usual, his writing style is concise, but has just the right amount of humor injected to keep it readable. What's more, his books tend to remain relevant long after they have gone out of print. I still pull out Advanced Windows NT Programming on a regular basis to reference. CLR via C# is chock full of the juiciests bits of .NET & C# 2.0. You'll learn tons, and be able to impress your programming buddies over lunch with your in depth knowledge of nullable types, generics and thread locking mechanisms.

Well, you wouldn't expect less from Mr. Ritcher, would you?First things first. This is not a book for the novice. While some of the initial chapters explain basic details of .NET and the CLR (being experienced, you can safely peruse past them quickly), most of the chapters explore the different topics in a clear, concise and, at the same time, deep enough way. The chapter on CLR Hosting is a good example of this. This chapter, as a representative sample of the rest of the book, delivers some deep geek CLR knowledge that most average developers are not aware of at all, with a highly praisable clearness and quality.Mr. Ritcher manages to make you understand the topics, provides useful examples and, to sum it up, thus makes of his book a very good guideline repository to be kept at hand when developing. Keep in mind, though, this is not a reference book that explains all .net namespaces or anything like that. It is, however, a reference book on some topics, a few of them quite advanced, that any serious developer should review from time to time.Richter and Petzold are the best!!! ;-)

Best first book for .Net Framework 1.1 ‾ 3.5, 4.0, 5.0 ...The careful reading of this book can abbreviate a long time in the learning of the ". NET Framework."This book is for all of the versions of ". Net", besides the future versions.Antonio H. Lopes

As others have noted: if you're a beginning C# programmer, look elsewhere. Right from the first chapter (which includes IL disassembly!) Richter doesn't compromise.This is a great thing for more experienced developers. Highlights include the (outstanding) chapter on exceptions, explict interface method implementations and threading.Best of all, despite this being a Microsoft Press book, he's not afraid to say that Microsoft was wrong. EIMIs, for instance, have several issues which he discusses in depth. Likewise the approach to exception handling preferred by FxCop isn't quite the same as the one he prefers.Now that .NET 3.5 / Visual Studio 2008 is on the horizon, I'd like to see edition 3: I'd be willing to bet that there's subtleties in LINQ and some of the other new C# syntaxes that need his clarity. A supplement might be best, though, as I'd not want to see any material removed from this outstanding book.

I had the Framework 1.1 version of this book and this new version is just as good. The book should be purchased just for the exception handling section alone.This is an invaluable reference for developers.

very good book, cover basic fundamentals for c#, must have book.