The Applied Microsoft .NET Framework Programming in C# Collection (Pro-Developer)

• #20 in Best csharp Programming Books

88 Reviews

Sort by: Most Helpful ▲ Date Rating

There's a real danger with new technologies that books about them will be shallow, simply because nobody's had time to really use them much or find out things in depth. Richter gets around that by virtue of writing for Microsoft Press, and having inside access to the .NET development team. This means that he's able to explain not only how things are in great detail, but also why they're that way. Richter displays a fine command of relevant detail; any aspiring .NET programmer will be far more grounded in the fundamentals of the .NET Framework after reading this book.

In fact, I'd go so far as to say that this book (or one very much like it) is essential reading for any real .NET programmer. You can do cargo-cult programming without understanding things at a real level, but if you want to do real programming, you need to know what's really going on. If you read this book, you'll know. The quality of information presented is excellent here -- this book is good enough that it could be published by O'Reilly, which is the highest compliment I can pay a tech book.

So, what about objectivity? This was my biggest potential worry going into the book. After all, it is a Microsoft Press book, and the author does seem to know the .NET development team, so there's definitely a potential lack of objectivity there. More, it seems like most of the books out there that cover .NET technologies do so with a complete blindness to all non-Microsoft technologies, which is patently ridiculous -- .NET owes so much to Java that it's inconceivable it'd exist as it currently exists without Java's example to look to, but authors write about .NET as the natural evolution of COM without any reference to its non-Microsoft predecessors. The creeping suspicion one gets is that the author isn't actually familiar with any non-Microsoft technologies, which makes you wonder just how much they really know.

Richter doesn't make you wonder. Somewhat frustratingly, he doesn't talk much about Java, but he does reference other technologies, and (most importantly) isn't afraid to point out shortcomings of .NET, even going so far as to highlist some aspects as egregious bugs or just poor design. There's no suspicion that Richter is in Microsoft's pocket, or that this book has been sanitized for PR purposes.

In fact, the only real fault I can find in this book is that it does neglect Java. The most irritating effect of this neglect is that the book is clearly written for an audience of Windows C++/COM programmers coming to .NET, not for Java programmers looking to .NET. In large part, this isn't a big deal, but it does lead to unnecessarily long and introductory chapters on strings, exceptions, and garbage handling (I wondered at first why Richter spent so much time on these topics, which are very familiar to Java programmers, before remembering that C++ programmers wouldn't be nearly as familiar with them).

Still, that's not a big deal, and it probably had to be written that way, as there's a huge audience of C++ programmers out there, and they need to know this stuff. It leads to a few skimmable chapters for the Java programmer, but the rest of the book more than makes up for it; and even the Java-similar chapters contain enough .NET-specific stuff that Java programmers could stand to learn a bit from them.

If you're a real programmer (say, someone who knows what polymorphism is, which excludes most VB monkeys) and are, or expect to be, programming with the .NET Framework, buy this book and read it.

As a highly experienced VB/COM developer, I have been making the move over the C# and .NET. I have spent hours at the book stores looking over nearly every book available. I have bought a bunch of books as well, but none have come close to this book as far as insight, depth of knowledge, and .NET fundamentals. Mind you, this book is by no means for programming or object oriented beginners. It is meant for programmers who really know their stuff, but now want to know their stuff on .NET. Expecting to create a .NET solution without thorough knowledge of the material in this book would be seriously shortchanging your app.

Each chapter of this book covers a different fundamental piece of .NET -- Methods, Events, Shared Assemblies, Exceptions, etc. Without getting too language specific, he writes thoroughly about how these fundamentals were meant to be used. It is clear that he spent a lot of time with the Microsoft .NET team, as much of the material in this book is unavailable elsewhere, to my knowledge. But this book is far from a Microsoft infomercial, as so many are. For example, he talks about C# primitive types and actually disagrees with Microsoft's C# language spec with regard to their usage.

In summary, I would highly recommend this book to any experienced programmer who is serious about getting up to speed with .NET.

As a C++ programmer moving into the C#/.NET world, I found this book essential to good .NET program design. With VS 7, Intellisense and MSDN samples it's possible to just "jump in" and start writing Windows apps in C#, but I wouldn't recommend it if you have the time to read this book first. Richter describes in detail the intricacies of compilation, IL, value types, boxing, interfaces, the garbage collector, and other things that work slightly different from how they did in the C++ world. It WILL help you know where to expect those subtle bugs and how to avoid them.

In addition, Richter covers a lot of the new features built in the language that will save you development time. He doesn't tackle most of the specialized classes in the .NET Framework like other books (e.g. the Wrox one) does, but he does go in depth into the ones that will be used by most programmers - for example, the new things you can do with strings (all Unicode, with built in text conversion routines and methods for locale-sensitive comparisons), the new type objects that all objects expose (not just strong typing, you can query the inheritance model and all sorts of good stuff), and some delightful tricks you can do with enums that will make you fall in love with them all over again.

If you tried to read Advanced Windows and were scared off or bored, I want to reassure you that Applied Microsoft .NET Framework Programming is more readable than Advanced Windows was - you can actually hole up in a little cafe and read it from end to end if you want to, in about a day and a half. It's also a little more accessible to people without a theoretical background or college degree in computer science. But rest assured, Richter goes into quite enough detail for the compiler geeks among us.

Understanding of COM, object-oriented programming, interfaces, stack vs. heap memory, etc. is required. I thought I would be dragged into .NET kicking and screaming, but I've become quite the evangelist - partially due to this book.

I have been working with .NET for almost two years now and had extremely high expectations for this book. Not only have they been met but far surpassed! This book is absolutely amazing and full of detailed information unavailable anywehere else. Even people that have worked with .NET for 2 years struggle over how JIT of methods really works: Does it JIT each method and then cache or JIT each time? Richter shows you on page 15 in detail. By page 9, he is already on a detailed explanation of how the CLR loads and the JMP _CorExeMain mechaism. I read the first 70 pages last night and I can say with confidence that I learned something new every page! How rare that is for a technical book and how rare especially for a .NET book. Assemblies and how they are made up internally are covered in Chapter 2, Shared Assemblies in 3, then types. But the crown jewel, IMHO, of this book, is Chapter 19, on Garbage Collection, which is the best darn detailed explanation of GC in .NET anywhere and finalization. This book is a *must* have for any serious .NET programmer.

This book is an excellent inside look to programming with the .Net Framework. It is a good start to anyone who wishes to familiarize himself with it . This book is all about the small stuff that many .Net programming books tend to ignore . What I particularly liked in this book are the following:
- How the Compiler assembles C# code into IL code . In many chapters this is done to show performance impact on doing thing one way not the other way
- Working with CLR Types : comparison between types, and how to perform casting, boxing, and unboxing
- Events and Delegates and how to use them
- Exception was covered in more details than the typical ( try - catch) explanations that I found in most other .Net books. I particularly liked the talk about unhandled exception and non CLS compliant exceptions.

I read the book from cover to cover and used some techniques in terms of delegates and exception handling in my application. I just found the chapter on "Garbage Collection" little confusing. Also it doesn't have a lot of programming examples, and all the programming examples are in C#.

ONE FINAL THING to add is that this book is mainly about programming with Common Language Runtime. It is not a reference book that covers the different class libraries that .Net framework offers and how to use them, for that you probably need to buy other books to cover topics such as : ASP .Net, ADO.NET, Web Services, Remoting, etc.. .

This book is an absolute necessity for anyone serious about writing programs targeting the .NET Framework. The author delves far deeper into the inner workings of this new platform then any I've encountered so far. It is not intended to be a tutorial, especially for a particular programming language. Instead, it's an in depth discussion on how the basic framework classes operate internally and how best to manipulate them efficiently and expertly. Virtually all the examples are in the C# language, but this does not prevent VB.NET and Managed C++ users from following the material. In fact, he does point out when the different languages utilize the framework differently and/or how these languages map into the framework. Chapters 2 & 3 did require my reading them more than once. The material is complicated and dense, but he covers it with great clarity and expertise. Just expect to return to it several times. He covers a lot of ground in great detail in these chapters on assemblies and the various strategies available for deploying programs and components. Also, the chapters on manipulating text and the garbage collection facilities are the best and the most detailed I've encountered. Many lights will go off in your mind as you're reading this book. I highly recommend this book to anyone AFTER learning the syntax of their chosen .NET language.

This is an excellent book like other books from the same author. The book is detailed and makes complex concepts simple. However, the more appropriate title for the book should be "Inside CLR" since the book almost exclusively discuss how CLR works and how C#/VB.NET type/syntax would map to CLR. The book talked little about the classes in the huge .NET Framework Class Library. Saying that, I still give 5 starts to this book because it is a must have for any serious .NET programmer. A solid understanding of CLR is essential to reliable, high performance .NET applications. The book has excellent discussions are how boxing/unboxing works, everything you want to know about methods, memory allocation/garbage collection and CLR hosting. Of course, since .NET is huge, I do not expect a single book to cover every espect of .NET. You probably need to put, in your library, a few more books on various part of the FCL, such as Windows Forms, ASP.NET, ADO.NET, Threading and remoting. However, this book is the foundation and the place to get started.

As another reader stated, this book IS NOT what the title suggests. I also purchased this book for it's "Applied .NET Framework Programming" title to find that it doesn't go into programming applications at all! Instead it is mainly Trivial Pursuit-like information on the lower level structures used to support various C# constructs.

Who cares? The whole point of the BCL and C# is that I don't have to know about this stuff. I'm paid to deliver applications - not tell my management how cool .NET is internally. And we programmers wonder why management won't buy into this stuff :( Until we learn to focus on how a framework results in faster time to market with more bullet-proof applications instead of the "gee-whiz" factor, how can we hope that our managers will ever care?

Microsoft-begrudged developers beware, .NET is actually pretty cool. I am typically wary of any technology or claim that Microsoft makes (being a Borland fan), but I am impressed with the .NET Framework and the thought that went into its design. After reading Advanced Windows (3rd) by Jeff in the past, I knew that this .NET book would be well written and informative. He did not let me down. This is a GREAT starting point for C# and VB.NET developers (note that most examples are in C#). I would strongly suggest that you have a good grasp of OO programming before you read this. His explanations are well thought out and the end result is that you too will be excited (and well informed) about .NET.

Don't be dismayed if at first you don't grasp Chap 2 & 3, assemblies & packaging are strange beasts at first. Things get much easier after that and you soon find yourself comfortable with the chap 2/3 material.

I bought this book because of all the good reviews...but. This book looks at .NET from a very low leverl. I just wanted to be able to write programs with .NET. I didn't really care about how it works and why it does things. I wanted a little bit of a higher view of things. Perhaps I didn't understand the reasons behind starting at this level. It was a good book for C#, but not for general .NET programming. The new Visual Studio was not touched at all. It was basically about writing your code for optimum use for the .NET platform. I found the information not very useful because I wanted a book that would immerse me in the environment and help me to use the tools, not look at how the compiler interprets the code and how to look at it. My 2 cents.

As most of the reviews suggest, it is a great book and I highly recommend you to buy it.

There is a cheaper alternative to buying this though. Search for The Applied Microsoft .NET Framework Programming in C# Collection by the same author (Jeffrey Richter). That edition contains this book with lots of additional materials (CDs, Class Library posters etc) and surprisingly its MUCH cheaper than buying this by itself.

this book is a complete 'under the covers' look at .net, which is a fine goal in and of itself. however, applied to me means means 'applying .net towards accomplishing a given programming goal', which this book will *not* help you with at all. If you want to know all the underlying details (which is sometimes useful) this may be a good book, but if you want to learn new tricks and techniques for actually using .net in your daily programming work or to program something, this book is a huge detour.
Just wanted to make people aware that the title is totally incorrect for what the contents are, I'm returning it since it wasn't what i thought it was.

I well remember Richter's previous Win32 book, "Programming Application for Microsoft Windows", and its precise and detailed treatment of low-level windows functioning (but, unfortunately, I recall its dry, non-imaginative and sometimes unclear stile, as well!).

When .NET appeared, I was looking for a book that would treat .NET and CLR in the same in-depth manner. Richter's book seamed the natural choice, knowing him as an author far from being shallow.

But, after reading "Applied Microsoft .NET Framework Programming" I have to confess It didn't meet my expectations. Even though this book does treat .NET and CRL in sufficient detail, some things were not even mentioned: nothing is said about multithreading, thread pool, or asynchronous delegates, their creation and usage; you can't read anything regarding serialization and its functioning (while in the Exceptions chapter an example of exception-derived type - for understanding of which serialization knowledge is important - emerges out of blue).

Therefore, I can't help asking myself how is it possible to call this book ".NET bible" (as some guys at Amazon.com like to label it), when such important things that themselves deserve full chapters are omitted.

In short, this book is far from bad, but it is incomplete, and some important stuff is not even mentioned. Later I realized that Richter has written on some of these topics in his articles ..., but I can't figure out why he didn't put them in the book??? I hope that missing details will be included in further editions, but it pisses me off it isn't already so. As it is, clearness and usefulness of this book is diminished.

This book is a must have for any serious .NET developer. It covers the essentials, e.g. .NET runtime, how virtual methods are called, inheritance, indexers, interfaces, string manipulations, events, value and reference types and their representation in IL, IL itself, and Reflection. Everything is explained in-depth. This is _not_ another cheesy "Learn C# in 20 hours" brochure but a well written reference.

Jeffrey Richter is certainly a man to write a book about the core workings of .NET. As a core member of the .NET team at Microsoft, he understands tyhe inner workings better than most. As such, this book is a great value for those who really want to understand how the CLR and .NET Framework classes work, and how to apply the knowledge to your own programming.

Note that this is a book on C#, or at least the programming is done in C#. If you are interested in Visual Basic .NET, you would be better to pick up the "companion" book "Applied Microsoft .NET Framework Programming in Microsoft Visual Basic .NET" by Balena and Richter.

The book is divided into 5 parts:

The first part deals with the CLR and .NET Framework, and, most importantly, how to set up your applications to take advantage of the .NET Framework.

Part two deals with types. It works with both value types (like structures and enumerations) and reference types (like classes and arrays). One of the most valuable chapters in this section centers around checking object equality (including overriding Equals) and identity (using Hash codes). Excellent material.

Part three deals with designing your own types. The material in this section is a gem for properly designing types, in general, and designing good types for the .NET Framework, in specific. As classes are the core of OOP, most of the types created here are classes (reference types).

Part four deals with the essential types in the .NET Framework and how to use them to your advantage.

Part five is the real gem of the book, as it deals with how to manage types in your applications. If you do not currently use finally blocks in your exception handler, this book will convince you why you should. Of great use is the info on the IDisposable interface and, as a short cut in C#, the using block.

Having had the opportunity to sit through a discourse on the Framework given by Richter on the Microsoft campus, I anxiously awaited this book's release. I must say, it did not disappoint. If you want to put power in your .NET programming, this book is an essential part of your library.

I'll simply echo what most reviewers and discussion lists state about Jeff's book: it has become the defacto Bible for this emerging technology, for all .NET developers and software engineers worth their salt.

Of the thousands of current .NET titles (many which were rushed to print to meet the demand for bootstrapping developer's knowledge of a hot new technology), this is by far the most informative, accurate, consise, and useful. It's written with a high level of detail and an obvious deep understanding of the framework, yet his delivery of the materiel is highly readable and understandable.

His insights into how the FCL (Foundation Class Libraries) in the .NET Framework work are insightful, informative, and clear; reading this book will most definitely shape your coding practices and object designs to make more effective use of the framework as the MS designers intended.

Not to write a cliche, but if you could only buy one book on the .NET technologies, buy this one. You'll read it once to get an overview understanding, and refer to it forever as a reference.

For the first 17 or so chapters I felt this was a pretty good book, giving a little more detail on many topics than what is found in the vast majority of books and articles. Then I hit the chapter on exceptions and I became more enthusiastic. This is a good explanation of exactly what is going on inside .NET exceptions with examples of how to limit performance hits that I haven't seen anywhere else. Well beyond the typical "this is the try block, this is the catch block, this is how finally works - don't catch what you don't handle" litany.

Then I got to the chapter on garbage collection. Wow. Laid the whole topic bare with deep detail and concise explanations. I am now the office guru when it comes to how garbage collection is affecting our performance. This chapter alone may be worth the price of the book.

Does "applied" in this case means applied in real-world usage, or does it means "applied study" in the framework plumbing. Unfortunately for some, this book really refers to the later - the study of .NET framework inner core.

This book mostly focuses on the plumbing of .NET framework and how it works. But unless you are interested in how the framework is doing thing behind the scenes, you may yourself very difficult to carry on reading to the end. Though I really hope you get to second last chapter "The Garbage Collector" first before it gets to the book. Believe it or not, this chapter is actually the best in the book :)

For those who must see inside the black-box before diving into .NET then you are in for a treat. The in-depth coverage of the framework is quite extensive. The sections on string and garbage collector are jewels, and you probably won't find them elsewhere. This is the reason why I had read the book twice, actually, almost twice..one and a half to be honest. Just could not bare myself to decipher some of the author writing the second time around. Overall, I think the book could have been better written, and which is why it lost one star.

It was great to read a "bottom-up" book after having read so
many "top-down" books.... I can heartily recommend this
book to anyone interested in learning about the
*nuts-and-bolts* of things such as the CLR, Framework and the Common Type system.

The book clearly explains what assemblies are, how they are structured, and how they are used by the runtime to enforce strong versioning and allow such things as side-by-side execution of assemblies of the same name.

In short: this book has totally blown my mind!

After you read this book, you will have an abundant understand the *entire* architecture of .NET, including such things as:

o Assemblies
o Intermediate Language
o Common Language Infrastructure
o Structure of an Assembly
o Various deployment tools including csc.exe, AL.exe, GACUtil.exe, etc.

Others have said it all really. This excellent volume explains everything you need to know about the framework and the CLR. If, like me, you've been scratching your head about some of the things VS.NET does for you, the meaningless errors you sometimes get, the performance aspects of boxing and unboxing if you don't fully understand the implications of what you're doing... this is the book to turn lots of lightbulbs on. I've bought somewhere in excess of 20 different .NET books over the last 6 months. This is the first one I feel represents real value for money and would be the one I know I will refer to again and again in future. Buy it!

In ".NET Framework Programming", Jeffrey Richter deals with the obvious and subtle features of C# programming in an intelligent and helpful manner. He has an excellent sense of knowing when to slow down and go into depth on a topic, such as when describing the subtleties of reference vs. value types.

Although I had been programming in C# for several months before encountering this book, reading this book greatly added to my appreciation and understanding of the .NET framework and C# programming language features.

The insights in this book go far beyond what is available in MSDN on-line documentation.

This book is a "MUST OWN" for a C# programmer. It is certainly one of the best programming references that I've encountered in 20 years of programming.

This book is in no way "the bible of .NET" as one reviewer stated. In fact, the book doesn't even live up to it's title of being an applied book for programming .net applications. It's simply a hodgepodge of internals of the .net runtime with a heavy slant towards c# (did the author really just want to write a c# book) with nothing at all to contribute to people actually developing day-to-day apps. This is your typical situation of the emporer has no clothes so I'm certain that my review will not impact anyone's buying decision, but trust me. Buy this at your own peril as the book will NOT make you a better .net programmer!

This book really gets to the core of the .NET FCL and CLR. Jeffrey writes with a no nonsense, down to business style that gets right to the heart of the topic. He covers all the different parts of C#, he tells you how they relate to the CLR, and he shows you the ILASM that is generated as a result of your code. Along the way he points out opportunities for optimization and shows you why some parts of the language may make it difficult for your assemblies to interact with different languages that use them.

This book was written for the programmer who already understands OO programming. I have found this book to be quite insightful on helping me understand what goes on inside the .NET FCL and CLR when writing C# code.

At first, I couldn't understand why this book had been so recommended by someone I trust (nor why it gets such good reviews, here). It seemed grossly padded with gratuitous screen shots, and ridiculous long IL disassemblies. There were all sorts of pointless low-level details - it was as if Richter was unable to forgo telling us about any detail that had taken him time to master.

Then I got to Part II, and everything got much better. The number of words per page shot way up, and the screen shots and code listings were much better chosen. The writing is limpid and unaffected; the detail level is just about right. I agree with those who point out that the title is misleading - this book is much more about the CLR and CLS than the FCL - but I did learn quite a bit from it, and think it was time and money well spent.

I don't know why Part I is so bad. Perhaps he actually wrote it in a rush, at the end. Perhaps it's just cobbled together from magazine articles he wrote while .Net was in beta. (Chapter 19's discussion of garbage collection, for example, is very similar to his November 2000 "MSDN Magazine" article that's available online.) It doesn't matter why, though - you'll appreciate this book a lot more if you read the first three chapters last, or not at all.

I noticed two reviewers below gave extremely poor ratings due to the fact that they wanted a "quick and dirty" tutorial on programming for .NET; I guess they are unfamiliar with Jeffrey Richter's previous books. Unfortunately, there are a lot of programmers in the industry but only a few of them are really any good. Anyone can fire up VS.NET and make an application but few truly understand the internal workings of what they created. It is hard to fault them - technology changes so quickly that it is hard to invest time in learning any one technology in-depth. Still, if you are programming for .NET it is very important that you understand how that technology works.

For those who haven't had the pleasure of reading Jeffrey Richter's other indpeth books (Programming Server-Side Applications and Programming Applications For Windows 4th ed) let me say that this guy knows his material. His books are about understanding the technology you are working with in order to better exploit it. This is not a "for dummies" or "Learn x in 24 hrs" book. The .NET framework is a vast shift for many programmers. "Applied Microsoft .NET Framework Programming" will guide you through the foundations of this wonderful new technology and *will* make you a better .NET programmer if you put the effort in.

BTW Being a C++ programmer I just wanted to take a friendly jab at Mike Kozlowski's comments below:

C++ Programmers do know about strings, exceptions, AND templates/operator overloading (hah) :)

Its one of the best books, but surely not a Bible and Not a 5*. It DOES NOT cover all topics. Most importantly, Threads and Asynchronous calls are missing. No remoting or web stuff either, and not much on security.
In essense, this is a very good book to get started but not as a reference for 'everything in .Net'. This covers basic types, text, strings, enums, exceptions, arrays, memory management..you get the idea, right?
We at work, read through the entire book - and in the end, had to go to the O'Reilly book by Juwal Lowy for Threading, thread synchronization and async calls... So, If you are a Backend or middle layer developer, get Juwal Lowy and Richter. Between the two you will have most of .NET programming covered (other than web specific stuff)

This book is a must-have in learning .NET because of its in-depth coverage, tips, and great examples. Its discussions on exceptions and garbage collection are the best I've seen anywhere! *Note that an understanding of C# is helpful to get more out of the book since almost all of the examples are in C#. Although this book does a great job at covering the fundamentals and internals of the CLR, I was surprised by the lack of interop and Framework Class Library coverage. Therefore, I must say that this is one of *three* essential .NET Framework books that you should buy. So if you have this book for CLR coverage, ".NET and COM: The Complete Interoperability Guide" (by Adam Nathan) for COM interop and P/Invoke coverage, and "Developing Applications with Visual Studio .NET" (by Richard Grimes) for FCL and VS.NET coverage, you'll have all the materials necessary to be a .NET expert!

Since the launch of .NET the market has been flooded with .NEt books by wannabes. This is essentially because of the relative simplicity of the platform over the DNA architecture. But none taught you the basics they only skimmed past showing you How-tos. This is the only one that delves deep into .NET. Mind it never teaches you .NEt. If you are a absolute fresher stay away. If you had been coding for a while and asking yourself the 'Whys' and 'Hows' well Jeff has all the answers for you in this relatively easy going lucid coverage. His explanation of delegates and events and the Garbage collection is mind blowing. None, I repeat none has taken the pain Jeff had to bring .NET to your backdoors. An absolutely fascinating book ever written on .NET

This book is the real Bible in .NET Framework.

¡¾1¡¿ Jeff stands on both a depth and a high level about .NET Framework. We can draw this from the parts of this book. Jeff partitions the .NET Framework into four parts: "Basics of the Microsoft .NET Framework","Working with Types and the Common Language Runtime", "Designing Types", "Essential Types", "Managing Types". This vision is unique, and of course gives me very good understanding to .NET Framework . And I have never seen a DonNet writer have this vision.

¡¾2¡¿ It is not a reorganization of MSDN doc( To tell the truth,many "excellent books' do in this way). Instead, it is an important complement to the MSDN doc, especially in the Chapter 2 ,Chapter 3,Chapter 5, Chapter 6, Chapter 15, Chapter 18, and Chapter 19.

The Chapter 6 , Chapter 18 and Chapter 19 are so excellent that I don't think there is another will exceed this. Oh, Don Box seems to be making efforts :)

They give me many important things that I don't find in some other books and MSDN. I think even Microsoft staffs need to get this book¡ª¡ªJeff recommanded many good techniques for .NET Framework Architecture,and found some bugs in .NET Framework.

¡¾3¡¿ Jeff has abundant programming experiences in programming , especially in Microsoft platform. And he give many good guidelines ,and even some patterns in this book. Especially for the Equality of value types and reference types(box/unbox), the Exception Handling, and the Garbage Collection.

¡¾4¡¿ There are so many good points that I can not write them all in one review.

¡¾5¡¿ By the way, this book is not for the .NET application( Windows Forms,ASP.NET,Web Services), but this a must-base for them

To summarize , this is a unique£¬classic£¬and excellent book for .NET Framwork. A real Bible in .NET Framework.

This is an excellent book on the .NET framework. The author explains the internals of the framework very well. I am primarily a VB developer. Although, the code samples are in C#, it is fairly simple to understand the code. The chapters on Packaging & Deployment, Shared Assemblies, Types, Exceptions, and CLR Hosting, AppDomains, and Reflection are written very well.

Now that I have read the book once, I understand the framework better. During the first read, some of the things just went over my head. I'm sure I'll be reading it again one more time to better understand the framework, which is the MEAT & POTATOES of the .NET buzz.

Although, the .NET tool shields the programmers from all the framework intricacies, I highly recommend this book to anyone who wants to know how the CLR functions.

To date, I have not been impressed with Microsoft's in-house imprint, but this title may force me to reconsider. This book is a full exposition of the .Net platform, focusing on the CLR, CTS, IL and other technologies that lie under the hood. This is a dense book - there is a lot to digest and you will need to set aside a couple of weeks to read it. That said, Richter clearly understands the topic matter, and he has no problems conveying the information to the reader in a clear fashion.

Note that this is not a book on C# programming. Also note that this book is far superior to the ".Net Framework Eseentials" from O'Reilly. Finally note that there is a lot of free documentation in the .Net SDK, and you may want to look into it before buying any book.

A Must Read!! This is by far the best book on Common Language Runtime that is out in the market. This book treats the reader to an indepth, accurate coverage of the fundamentals of CLR.

I have been working on the CLR for the past 1 1/2 years and I thoroughly enjoyed reading the book!!

Ravi

This book is the real Bible in .NET Framework.

¡¾1¡¿ Jeff stands on both a depth and a high level about .NET Framework. We can draw this from the parts of this book. Jeff partitions the .NET Framework into four parts: "Basics of the Microsoft .NET Framework","Working with Types and the Common Language Runtime", "Designing Types", "Essential Types", "Managing Types". This vision is unique, and of course gives me very good understanding to .NET Framework . And I have never seen a DonNet writer have this vision.

¡¾2¡¿ It is not a reorganization of MSDN doc( To tell the truth,many "excellent books' do in this way). Instead, it is an important complement to the MSDN doc, especially in the Chapter 2 ,Chapter 3,Chapter 5, Chapter 6, Chapter 15, Chapter 18, and Chapter 19.

The Chapter 6 , Chapter 18 and Chapter 19 are so excellent that I don't think there is another will exceed this. Oh, Don Box seems to be making efforts :)

They give me many important things that I don't find in some other books and MSDN. I think even Microsoft staffs need to get this book¡ª¡ªJeff recommanded many good techniques for .NET Framework Architecture,and found some bugs in .NET Framework.

¡¾3¡¿ Jeff has abundant programming experiences in programming , especially in Microsoft platform. And he give many good guidelines ,and even some patterns in this book. Especially for the Equality of value types and reference types(box/unbox), the Exception Handling, and the Garbage Collection.

¡¾4¡¿ There are so many good points that I can not write them all in one review.

¡¾5¡¿ By the way, this book is not for the .NET application( Windows Forms,ASP.NET,Web Services), but this a must-base for them

To summarize , this is a unique£¬classic£¬and excellent book for .NET Framwork. A real Bible in .NET Framework.

This book is really excellent to learn low level .net framework features and any .net developer should have it.
Only one note, why not a chapter on multi-threading ?

This is not the kind of book where you will immediately be copying code and being instructed to follow basic instructions to achieve a task. Rather this is a deeply rich book on the internals of the .NET architecture. I consider it required reading for anyone serious about moving towards .NET Mastery. Is it completely comprehensive? No. There are areas missing. Are these areas covered extensively in books that are more 'follow the instructions' type, absolutely.

I would add Juval Lowy's new book (2nd edition) to this, and you will know more then most in my experience. For more book recommendations see my 'so you want to' list under 'Damon Carr'.

An indispensable complement to the "how-to" books of Wrox and O'Reilly, this book covers the fundamentals of the .NET framework with impressive detail and expertise.

The focus is on understanding the fundamentals of .NET and how they bear on your own programs. This book neither overwhelms you with technical detail nor baffles you with unexplained "how-to" instructions. In an admirably balanced fashion it tells you both what you need to do and why you need to do it.

The author has an insider's knowledge of how the .NET framework works and why it has been designed to work like that. He is also a very good teacher. I found this book invaluable and recommend it wholeheartedly.

I can strongly recommend this (the C# edition of this book), as it comes with many great posters and fixes all the errata from the earlier edition. In my opiniion, this is one of the best C#/.NET books ever released (I would put Juval Lowey's latest book up there as well).

I can say from experience that many of the interviews I have done for contracts for my .NET Consulting company have been largely out of this book. I would imagine the same would hold for individuals, and I certainly borrow some concepts in my interviews (which only one in 100 can pass).

There is little not to like about this book, but I would of liked to have seen more on Threading and more of the FCL, but the goal of the book was to give you the foundation not so much the practical 'do this and this and this' without knowing why. For people who want to be above average this is almost certainly a must read and for technical leaders you must know this information somehow, by reading this book or some other way.

Kind Regards,
Damon Carr, CEO and Chief Technologist
agilefactor
http://www.agilefactor.com

This book is a wonderful peek under the hood of many of the parts of the .NET framework and IL. If you are like me and easily overwhelmed by all you need to know to code at the next level in .NET and get confused by some of the parts. Look no further. This books breaks down all of the code and provides excellent insite overall all in C#. Mr. Richter should be giving classes on technical education writing to the many guys out there that have published lackluster .Net books. This book should not be the first .Net book you read but it should definitely be in the first three.

Read this book. I had done some C# coding even before I read it, but in hindsight I realize how little I knew until I read Richter's book. It tells you how the CLR works, how to use its constructs, and avoid common but subtle mistakes.

This book goes into some of the important details of the CLR and how they are exposed through C#. Examples include how the garbage collector works, intricacies of non-deterministic finalization, reflection, boxing/unboxing, using interfaces, etc. Jeffrey Richter emphasizes the subtle points and provides C# code that really helps you understand what is going on.

The title, however, is misleading - the book is more conceptual than applied. It won't show you how to use the .Net libraries, write web services, GUI, or whatever "applied" stuff you may be dealing with.

Well-paced for somebody familiar with C++ or Java. Unlike other books, there are no brain-dead code examples or drills on what OO programming is etc. If you are a decent programmer, you can get up to speed with .Net fast using this book.

Richter knows his subject and writes well. But, like previous reviewers, I found the use of "Applied" in the title deceptive. Most programmers would never apply this low level stuff. As an experienced programmer, I found "Microsoft .NET for Programmers" by Fergal Grimes to be a much more useful (applied!) book. ...

This book is an excellent overview of the .Net Framework from an experienced programmer's point of view. If you're looking for a how-to-program-.net bok, then you're better off purchasing a different title. If you want to know how and why .Net works, then this book is for you.

Don't go here if you are trying to find a good book on VB.Net or C#.net. Before reading about the Languages around the .Net Framework one should gain an understanding of the framework as a whole. I have bought many books (50+) and this book is the best book that I have read so far about the .Net framework. It is very comprehensive and describes in detail about the types and classes that make up the framework. If your a .Net programmer have fun with it. A MUST BUY!

I am a little over half way through this book and must say that the way the author relates the concepts to practical examples is pure genius. I beleive the key to a great teacher is the ability to break down difficult concepts into understandable clear pieces that mere mortals can understand. The author has achieved this difficult task. I read the reviews here before I bought the book and even though there are so many, I still feel compelled to add my praise also.

I wouldn't exactly call this book an introductory level look into .Net. In fact, I'd recommend that you already be familiar with most of the core concepts of .Net before you try reading it. As a consultant to the .Net development staff, Jeff gives the details of .Net like very few other people can. Some parts of the book go well beyond what a "normal" programmer would attempt to do (like create unmanaged windows handles), but the examples are clear as to how it works and what best practices should be followed. It's by far the best .Net book I've read so far. Someone asked if they could borrow it now that I'm finished with mine and I told them to go buy their own. It's a great piece of reference material and the binding is well worn already from reading and referencing during my projects. Well done, Jeff. Well done.

This book is better than most microsoft press books, but as a rule of thumb always check OReilly first. Microsoft Press is known for fluff - even books people consider the bibles are fluff when compared to OReilly. After reading a few OReilly pages you'll say 'gee that was simple'.

I don't work for OReilly, I've been a Unix programmer for 15 years and used OReilly for a long time. I am now switching to .NET. I was very disappointed when I tried to use MSFT Press books to learn anything.

Steve

You've got to love an author that can work the phrase 'ephemeral gabage collector' into a sentence. No, seriously, I think this has got to be about the best technical reference for the .NET framework currently published. In addition to providing detailed technical descriptions for the inner workings of the .NET platform (which are wonderful, albeit verbose at times) Jeffrey also does a great job providing practical examples and code for just about everything you might want to know. Moreover, the book contains a number of chapters dedicated to good coding standards (for example, Chapter 18 on Exception Handling) that are valid both inside and outside the .NET world. If I had to purchase just one book about the .NET Framework this would easily be it.

Events, delegates, interfaces, attributes, CLR and other framework aspects are arguably components that most "beginners" may not be comfortable with but are at the core to doing "non-visual" .NET development.

For most code writing activities, this book may not be the reference you would use everyday. However, if you have never used events, delegates or thought about the impact of interfaces versus native class interfaces, or the impact of garbage collection on runtime performance, then this book will help you "apply" those core .NET concerns either from a design perspective or during refactoring.

Further, a good foundational set of best practices can be found here, implied or otherwise and often intermixed with the technical discourse. I can almost guarantee that a certain type of developer won't make it through this book and will be all the more sorry for it. In short, this book successfuly guides the developer seeking to advance to a more sophisticated level of implementation and fully earns the title "Applied .NET Programming".

i've always been a fan of Jeff Richter; i make sure i go to his talks/conference whenever he's in town(Chicago). his discussion of the clr is really a mind-opening for me. i've heard him one time talked about assemblies and manifest on one of his seminars and this book really helped me digest those notes i wrote. like my title said, it's another must have! Thanks Jeff and i hope you continue to write more books. Goodluck to you.

Applied Microsoft .NET Framework Programming is a solid introduction to the CLR. Richter provides a peek under the hood of delegates, the garbage collector, finalization and application domains.

The book contains a mixture of practical advice and technical trivia. Some C# knowledge would be useful to get the most out of the numerous examples.

There is a good level of detail for such a readable book. If you want more technical information about IL and the CLR, Gough, J. "Compiling for the .NET Common Language Runtime (CLR)" might be a good follow-on from Applied .NET.

Jeffrey Richter has done it again. This book is a must for your .NET collection. Richter is without a doubt the best windows author out there.

I ready couple of chapters specially on .NET CLR and Assemblies. This is the book you want to mix with Don Box's .NET Internals to understand .NET internals ;). Trust me. You will know what goes under the hood.

Jeff really shows off his experience with consulting for and working with the .NET framework team in this book. This is one of the very best .NET books and will remain as such for the lifetime of the technology. It covers the internals of .NET, critical to a solid foundation of knowledge for a technical leader in .NET. As such, it's not a "getting started guide". There are dozens of those on the market, but few "must haves" like this one.

Jeffrey Ricther has written a very thorough yet readable book describing Microsoft's .NET Framework from both 3,000 feet and, at the same time, 1 millimeter. His direct interaction with the Microsoft team that developed .NET has proven to be a competitive edge that other .NET books currently on the market lack. If you're serious about .NET programming in any language, this is a book you need to buy and read multiple times.

This book is probably the best book I have read on software development. The author seems to anticipate whats going on in the reader's mind and provides information that is as in-depth and accurate as it is a joy to read.
In my opinion anyone who cares about development in .NET should read this book first.
It is basically more on .NET framework rather than on any programming language (and maybe for that reason leaves out Threading, IO etc) and should be complemented with a good language book like Programming C# by Jesse Liberty and of course the other goldmine .NET Remoting by Ingo Rammer

This book is the real Bible in .NET Framework.

¡¾1¡¿ Jeff stands on both a depth and a high level about .NET Framework. We can draw this from the parts of this book. Jeff partitions the .NET Framework into four parts: "Basics of the Microsoft .NET Framework","Working with Types and the Common Language Runtime", "Designing Types", "Essential Types", "Managing Types". This vision is unique, and of course gives me very good understanding to .NET Framework . And I have never seen a DonNet writer have this vision.

¡¾2¡¿ It is not a reorganization of MSDN doc( To tell the truth,many "excellent books' do in this way). Instead, it is an important complement to the MSDN doc, especially in the Chapter 2 ,Chapter 3,Chapter 5, Chapter 6, Chapter 15, Chapter 18, and Chapter 19.

The Chapter 6 , Chapter 18 and Chapter 19 are so excellent that I don't think there is another will exceed this. Oh, Don Box seems to be making efforts :)

They give me many important things that I don't find in some other books and MSDN. I think even Microsoft staffs need to get this book¡ª¡ªJeff recommanded many good techniques for .NET Framework Architecture,and found some bugs in .NET Framework.

¡¾3¡¿ Jeff has abundant programming experiences in programming , especially in Microsoft platform. And he give many good guidelines ,and even some patterns in this book. Especially for the Equality of value types and reference types(box/unbox), the Exception Handling, and the Garbage Collection.

¡¾4¡¿ There are so many good points that I can not write them all in one review.

¡¾5¡¿ By the way, this book is not for the .NET application( Windows Forms,ASP.NET,Web Services), but this a must-base for them

¡¾To summarize¡¿ this is a unique£¬classic£¬and excellent book for .NET Framwork. A real Bible in .NET Framework.

It was the first .NET book I read, and I must say it wasn't easy at all. It took me quite a while to fully understand all the concepts given since all the examples were in C#.
I had worked a lot with VB6, but never before with C nor with C++. If you are like I was, maybe it's a good idea to read a little bit about OOP (Object Oriented Programming) and C or C++ before reading this book. Otherwise, as you are reading the book, besides learning the .NET Framework, you also have to learn C# programming from 0 at the same time, which is not as easy as it looks.
Despite of these details, the book is excellent. You can tell how much the author has been working with .NET. He gives amazing tips to write robust and fast code.
After reading the book, you'll have a DEEP understanding of the .NET, that will help you to write better code.

While this book may not be aptly named (the term 'applied' is a bit misleading as it implies 'real-world application' - this is an intermediate level discussion of the .NET platform), it certainly should be considered mandatory reading for anyone venturing into the domain of .NET. You simply cannot be an effective engineer without having some grasp of the platform you're developing for and hold at least a cursory understanding of how it all works. This book gives you that detailed look at .NET and the CLR from the inside-out (mostly in the context of C#, however, this is by no means a definitive C# reference). While not a definitive reference, this is a great book to whet your appetite on IL fundamentals and metadata - the lifeblood of .NET. This was not one of Richter's strongest works (such as Advanced Windows) as he spends a little too much time on the soapbox lobbying Microsoft for his pet-.NET features in this book, but if you can overlook these intermittent fits of angst, you'll come away with a solid understanding of what makes .NET tick.

Since 99% of the examples in this book are in C#, I highly recommend reading this book in conjunction with a solid C# programming/reference at your side such as Programming C# Second Edition by Jesse Liberty (O'Reilly).

This simply belongs in your library. It's not just another book on the FCL, but rather a nice look into how the CLR works internally. I've only read the first chapter (browsed the others for now) and can already tell this is chock full of info. The first chapter already answered many questions I had (how does IL compilation work, mscoree.dll, etc...). This is a must have. Don't think twice. Haven't checked out the other CLR book another reviewer mentioned. That's next.

This is the best book I could find on Common Language Runtime (CLR) programming concepts. Richter really goes into detail on garbage collection, boxing model, and other important "under the covers" topics/gotchas. I would definitely recommend this book to anyone looking to learn more about the CLR.

If you want to understand fundamental topics like boxing, unboxing, or disposing better or understand what is really happening when an event gets raised, this is the best book you will find. Richter's knowledge is impeccable, and his writing style is clear. If an experienced developer wants to understand the inner-workings of the .NET framework, this is the first book he/she should read.

Excellent book.Anybody who wants to understand the underlying concepts of .Net must read this book.

I've really enjoyed this title. This is a great book. Ease to read, the examples are clear, it does an excellent work in explaining the subject matter. I've rated 5 stars event though I was disappointed for not seeing any coverage of subjects like threading or serialization.

You have to love this book. Simply a must read for any .NET software developer. It does a fairly good job of staying language neutral, but you will get the most out of the book if you are comfortable with C#.

No other book I have read comes close to explaining the CLR in such a graspable way. There are six or seven different sections of the book I find myself pointing colleagues to everyday. One of the most overlooked, misunderstood and necessary topics has to be boxing and unboxing. This is explained extraordinarily well. I still find myself reading this section over, pleading with my brain to commit some of the trickery of the compiler to memory. Another favorite section is Chapter 11 - Events. Nobody could possibly read this chapter and not feel completely comfortable with designing a type that exposes an event. And then, the cherry on top, he walks you through explicitly controlling event registration... WOW! Great stuff.

This book is packed with all the core concepts you need to know to be a successful programmer. The longer you go without it, the more of injustice you do to yourselves and your clients.

Covers .NET framework architecture in well written chapters and code. Very good for developers who are new to .NET world.

If you look at all the book reviews, there are a few people who groaned that the title is misleading (which it can be - but please read the table of contents people), and one guy who is religious about his OReilly books. EVERYONE ELSE (including myself) agrees that this is simply the best "under the covers" look at .Net out there. Get a GOOD grasp on .Net first, then pick up this book and hang on. I'd rate it a 7 if that were an option.

This book is amazing! It contains great advanced samples and information. If you look Microsoft Intermediate Language (MSIL) opcodes while you are reading this book, you can easily understand what it is going under the hood.

This book serves as a great introduction to the building blocks of the .NET Framework. I've always enjoyed Richter's professional, competent writing style and would definitely recommend this book to anyone looking to find out what the .NET Framework is all about, how it works, and how best to utilize it in your own .NET development.

I can't remember how I chose this book but I am sure glad I did. I have been postponing learning the framework for a long time cos I was hoping it won't get industry approval( no such luck!).

First of all, this is not a book for beginners. There are tons of books out there for beginners and this is not one of them.

However if your are an experienced programmer and you care about how efficient your programs run, then this is the book for you. I have not read the book to the end but it has been really valuable. It breaks down different parts of the .NET framework and shows how things work.

I really enjoyed the chapters on boxing, object equality and shared assemblies.

It should be noted that most people will get by without knowing a lot of the stuff that is covered in this book but for programmers who are interested in the hows and whys in .NET, and how efficient IL code runs, this book has to "hang out" on your shelf.

I was fascinated by some parts of the book(the chapters on delegates, exceptions & GC are really good), but some of it left me saying "duh". Richter does state the obvious at times, but all-in-all this book has a lot of info that you just can't find elsewhere. I think that the complaint of some reviewers dealing with the "trivial" nature of some of the info is valid, but some of the info is essential for writing tight code(the boxing info. for instance). Richter always brings good common sense to the table, and has a gift for explaning things clearly. I've read other .NET authors who don't.

This book deserves all the praise given by other reviewers. All I can add is a run down of some of the answers this book provides to questions that should be asked by all .NET developers: (1) in-depth understanding of versions, versioning, and AssemblyInfo.cs, (2) thorough understanding of the GAC, public/private keys, etc., (3) excellent, low level coverage of Attributes, (intra-language) data-types, delegates, events, exceptions, etc.

All the examples are provided in C#, which I'm happy for, but VB developers need this knowledge too. Perhaps more than C# developers because it differs from what they've known. It seems C# is becomming Microsoft's language of choice, so VB developers should take advantage of this opportunity to jump in head first ... before Microsoft pushes you in.

...for professional .Net programmers, wanting to move on to the next level. The "advanced .Net programmer"-level!

This book might very well earn the same status in the .Net-community as Bruce McKinneys "Hardcore Visual Basic"-books did in the Visual Basic-community. Not for beginners though...

/Per Hultqvist

If you are a beginner in .NET ( not to be confused with a beginner programmer ) this book is excellent. Unfortunately for me, I have been using .NET for several years. SO there we're only pieces here and there that I could use. But, he goes into extreme detail on every aspect for .NET. I love the book.

Its a must for at least a reference book. At the very least.

And by the way I dont do practice examples, I make my own. So if there are examples I have no idea if they work or not. And a books weight has nothing to do with some examples that the author thought up, while cashing his check!

Nick

This is one of those very few fat books that i'll read again and again. I recommend this book for anyone who aspires to better his/her existing knowledge about the .NET framework in a very clear and crisp manner.

This is one of the few classics, programmers should get and learn from it. The easy reading(keeps refreshing the reader on earlier concepts) style makes learning enjoyable and exciting.

Even after finishing the book, I still can't help but wonder why System.Threading wasn't covered. Maybe Jeffery should include this topic in his next edition of the book.

After finishing the book, the reader should find the concepts covered in other areas of .net easy to handle and understand. After all that's the objective of the book.

Five stars from me.

I have been from Java background and earlier experience was with core C++ on unix and little bit of Visual C++ coding. This book is a great book to understand the .NET internals.
Even though it takes sometime to come to C# language syntax, it is worth to read the first half.
I would definitely buy Jeffrey's other books for reading..

I got this book as a gift from microsoft , i have found it very informative but only for those who already have knowledge about programming other wise you will got confused.

If you wondering about what it's gc,or attirbutes,assembly
...just read this book

This book was great in tuning my skills in .Net. I found the chapter about error trapping to be the most useful for my needs, but over all, I would say that this is a most have for all .NET Developers - from beginner to advanced. Get this book!!!

I found this book to be thorough and an excellent insight into the .NET world, a must for anyone developing with .NET

Actually this is the best .NET Framework book I have ever read...CLEAR, IN DEPTH and PRACTICAL. Thanks to the author, he knows what the developers really need.

This is a very good book. I would recomend reading it to anyone who wants to learn how the .net framework works.

So many other reviewers have said it already, so I'll be brief. This wonderful book presents the internals of the CLR and CLS in a concise, comprehensive and easy to read format that I found difficult to put down. I've read almost a dozen hald-baked books on various aspects of .NET programming (yes, we know that it's ok to use data binding...) and was ready to give up on the whole lot of them when a friend reccommended this one. This book is everything to c sharp and .NET that Ted Pattison's classics are to VB 6 and COM. If you're looking for an incredible book (with the funniest introductory quotes you're likely to ever read) that shows you the what, why and how, buy this book. If you want to know how to bind a DataGrid server control to a DataSet object, go buy some [stuff] from wrox...

This is a must have for every serious .net developer. It goes into the lower level stuff, which helps you understand the technology way better. The code examples are writen mostly in C#, but it isn't hard to follow since the book is about the technology and not any language in particular. After reading this book, you'll feel like you know the clr almost as well as windows :). Enough of me, get the book and see for yourself.

Jeffrey Richter in his book takes a closer look at .NET framework and what's going on behind the scenes. If you want to understand 'why' and 'how' of the framework you need to read this book.
This book is not an overview or an introduction and is written for experienced programmers who want to understand and master the tools available to them.
To all those people who say that they don't care how it works as long as it works: Too bad you feel that way. The understanding of how it works will give you better leverage to apply it to real problems. And just wait until you have to develop and debug something more complex than couple ASP pages.

I've bought this book originally because I heard it has a good overview of GC. But it's so much more.

Of over a dozen books I've read on .NET this is the one I would recommend the highest. It goes over all the basics you should know, clears up all the assumptions you will have and explains how .NET functions behind the scenes. Everything from Delegates, Events, Assembly layout to GC is covered in exhausting detail. You really don't understand .NET if you don't know these things to the level they are given here.

Very hard to put down book, and is an absolute must-read for .NET developers.

This book gets you down to the IL code to show you how your code really behaves behind the curtain. Every developer should know this if they want to be effective programmers in .NET

Before you even write a line of code, start reading this book. .Net is not just a Java clone as some have declared. It is a far more encompassing development platform and this book is a great introduction to the technology.

I just wish there was a chapter on resources, as VS.Net leaves the Framework's rich support for resources out in the cold and many people do not realize it is there.

Unparalleled .NET coverage, authoritative, basic but critical. Basic does not mean simple - this is not a book to learn programming, but for experienced programmers who know their OO. This is not like anything you would have read about .NET. The book draws a clear distinction between what the CLR can do and what the languages present (so far) can do. At times it makes for dry reading but then it is close to a reference, like Richter's earlier works. This book is not for first exposure to .NET either, one should have some exposure to programming against the CLR. Missing stuff - remoting for one! No .NET library is complete without this book.