Customer Reviews

Programming .NET Components, Second Edition

5 star:		(57)
4 star:		(6)
3 star:		(1)
2 star:		(0)
1 star:		(2)

 

 

This book is about half the size of many of my other .NET programming books, and yet I've used about twice as many concepts from it than the bigger books. Computer books are just bloated today because publishers know we knowledge hungry programmers are drawn to the supersized books. Well, this book breaks the mold. It is clear, concise, potent and modestly sized. For example, chapter 11 on context and interception and the logging component example is awesome. If you want to take the next step as a .NET programmer, read this book.

When I was reading the first three chapters of this book I could have sworn that it was miss-titled; it should have been called Component Oriented Programming in .NET. Just so we get this straight, this is not a book about the wonderful components in the .NET Framework that Microsoft has provided -- this is a book about CREATING components in the .NET Framework.

The next item that needs to be clarified: What is a component? If you are from the Delphi/VCL world, a component is a non-visual object that can be manipulated in design-time with the mouse and the property browser, while usually being dragged onto a form (TTimer, TDatabase, TSession, TTable, etc). But in this book a component is a class -- the simpler the class, the better. No inheritance unless absolutely necessary, no class hierarchies, but interfaces are cool.

Now, once you get beyond the philosophy lessons of the first three chapters, you are left with one outstanding book on practical .NET development. The chapter on Events is worth the price of admission alone. The chapter on Versioning is excellent as well, but the rest of the sections are every bit as good.

Many of the topics covered in the book are not things you will find in the help files, or if they are, they are too scattered to be useful. What is covered: a large number of best practices, defensive coding techniques (again the chapter on Events is gold), and general you-really-need-to-know-this topics.

One note, some of the topics covered are very large (Remoting and Security are two examples), and if you are interested in those topics, there are other books that deal with them individually.

Summary: if you are into creating top-quality .NET software you should own this book.

Juval Lowy's Programming .Net Components is the Harry Potter for .Net developers. I usually read technical books a chapter at a time, over the course of a month or two; I found .Net Components, however, to be a real page turner. Seriously! I ran through it in a week, devoting any extra time to the text, and I find myself revisiting the chapters that are most relevant to the work I'm tackling. This book includes material on OO design, threading, Remoting, security, versioning, and other advanced topics that you won't find MSDN discussing in this detail or with this practicality. Lowy's combination of .Net framework insight combines with implementation best practices to produce a book for sophisticated software development with .Net. I consider it the best .Net book I've read, and I've read a lot of them.

I'm an MCSD, MCSE, and an MCDBA who owns many, many technical books. This is one of the very best technical books that I ever seen. The writing is extremely clear and goes into good depth. The book is dense with information and code samples are excellent. Throughout the book, the author offers many helpful hints and potential traps. Also, the comparisons between .NET and COM add a lot. The clarity of the writing slips a bit in chapter 10 (Remoting), but the author still does a fine job of explaining this intense subject.

The adulations from the previous reviewers here are all well earned. In my opinion, this is well beyond just a great book; it's a must-have! The writing is very clear without being verbose; and it's depth is better than anything I've seen anywhere on .NET. The author not only provides many new insights, but refines and corrects existing ones found elsewhere, even correcting some guidelines from MSDN. For instance he advises in favor of using "lock" to make methods thread-safe, which MSDN does not advise. Given any doubt, I'd trust this author over MSDN.

I just wish the book was longer, and covered more relevent topics. It's so good that I want more!

I have been a consultant for years (almost decades) now. It's always been surprising to see how folks struggled to implement COM. I think the reason was there lack of understanding Component Oriented Programming but mostly how MS implemented COM. To save yourself the frustration, I thought you needed to know what happens at compile time and what at runtime. How the interface id are implemented, the SCM, ..... Most folks got COM on there resume and don't even understand the concept of an interface. A good book can change all of that, it can make you the guru playing golf on weekends while the other "pleps" sit in the office praying for that miracle compilation that will free them from dll hell. Although .Net components makes life easier, there is still room for the guru and the plep:)

This book is one of those that create gurus out of pleps. It's not just like most tech books where authors hastily gathered information to write on a subject. Juval knows his subject and he knows what's best for the reader to know. The book is well organized, systematic and compact (422+ pages). Where needed, the author always presides with an excellent background.

I have read a lot of tech books in my life, and this one stands out.

The whole goal of .NET is "Do more with less". After a developer works through the initial learning curve of .NET, they'll usually want to learn how to do things better. If 'better' is defined as coding totally reusable code, then this book is for you.

It might sound silly, but a lot of time you think you are reusing code only to learn that you really aren't.

Three parts really stick out about this book (but that's not to say that the other chapters aren't as good).

1) Security - Yes, the ultimate pain in the butt for developers but an increasingly important topic these days. In all honesty, if you don't want to pay attention to security, then you probably will end up with some serious egg on your face at some point. This alone justifies the price of the book.
2) Events- You can't do much in .NET without getting into events. I will say that his discussion probably caters to more advanced developers, but Events are not a topic for beginners. I really loved this section and I think he makes some superb points and makes them very clearly.
3) Threading- Threading isn't for the weak of heart, and you will not learn how to use it effectively without making a few messes first. However, he does a great job of warning you of the pitfalls and explaining why they are pitfalls. If you are going to do any serious development in .NET, you'll need to understand the threading library. If you are coming from VB 6 (where writing good multithreaded apps was VERY PAINFUL) this will really help you with it.
4)Remoting - This subject has entire books written on it. While this book is by no means the definitive guide on Remoting, it's discussion is very relevant and will definitely pique your interest in the subject. To be honest, I was 'too busy' learning other stuff to worry about remoting until I read this book. Then I felt like an idiot for ignoring it for so long. This book made me want to learn it and got me through the rough part of my learning curve, particularly in respect to component development.

Well, there's 30 other reasons to buy this book, but I only have 1,000 words..... but I can assure you that if you buy it, you'll be glad you did.

I guess this entry is kind of late: I've been meaning to write it ever since I got my copy of this book several weeks ago. Let me tell you that Juval has a deep understanding of the .NET Framework, he's also an accomplished teacher and this shows in his writing: detailed yet readable. One pearl: it's easy to say you never have to (actually you can't) destroy an object instance, you just loose all references to it and wait until the garbage collector does its thing, the truth of course is darker and more convoluted, you have to understand things like finalizers (or destructors), the IDisposable interface, the Dispose pattern, the GC passes, etc. Fear not, in Section 4.5 Deterministic Finalization, Juval masterly explains the why's and how's of a bullet-proof object disposal implementation (by the way, do yourself a favor and read the whole Chapter 4. Life Cycle Management). This book will especially appeal to people creating a business layer but have information valuable for programmers working in any other layer. I think that it will be particularly illuminating for Java experts trying to understand the inner guts (as they very much like doing) of the .NET Framework. Highly recommended.

After a very long time I have come across a book that is really fabulous. Most of the programming books are too bulky and they waste all the pages in explaining only the documentation rather than the architecture. Most of this documentaion can be obtained on the web. This book explains the principles and the architecture behind all the commonly used .net concepts. I highly recommend this book. However, do not buy this book if you are planning to learn .net and have never used it before. This book caters to programmers who have had at least some programming experience in .net previously.

If you want a real reference book for .Net programming, this is it. He goes into depth in explaining how things work. Especially liked his chapter on Multithreading. It is a gold-mine for a professional C# programmer.

PS. The guy who gave this book a low rating, probably hasn't done anything sophisticated with .Net yet. Hey, its a reference book and his writing style is clear and to the point.