Customer Reviews

Applied Microsoft .NET Framework Programming (Pro-Developer)

5 star:		(72)
4 star:		(10)
3 star:		(1)
2 star:		(2)
1 star:		(4)

 

 

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.

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.. .

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 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.

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.

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 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.

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.

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.

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!