A Classic Book that begins it's journey, where all books end. The true difference between a casual programmer and a disciplined programmer is more prominent in his/her code when they start using advanced features of the framework. A true programmer knows his stuff in and out and knows how to leverage the features of the framework effectively in every line of code. And to get to that level of proficiency it takes reading and practicing the concepts on daily basis. And if at all, there is any book out there, that will help you, then it is this book. A definite YES. 5 Stars.

Without any second thought I will place this book among the best books on the subject ever published. I hope everybody will agree that there are only a few books that worth reading from the beginning to the end without skipping a page. To me this is one of those rare books.
The author manages to reflect on broad architectural concepts and yet be extremely specific. He was able to present the most complicated aspects of component oriented programming and the C# language in a very simple, yet concise manner. Many complex issues that may turn off even experienced programmers are described in a way that not only are very well understood, but could easily be migrated into a working program. The author has found an absolutely perfect balance of presenting general architectural aspects of the subject he is discussing and real life implementation techniques.
I truly believe that anybody who is dealing with such aspects (to name but a few) as serialization, asynchronous invocation, multithreading, reflection, events, delegates, deterministic finalization, etc., MUST read this book.
By the way, this author has published another wonderful book on Windows Communication Foundation - "Programming WCF".

Babalar bu kitap manyak pisikopat. .NET firlamaliklarini ogrenmek istiyosaniz tam sizin dalganiz. Bu kitabi alin, pisman olursaniz yanima gelin.

(Salgam icerik bici yerik...
Karpuzu kabuguyla yerik
............................)

Babalar bu kitap var ya, manyak psikopat. .NET picliklerini ogrenmek istiyosaniz tam sizin isiniz allahima kitabima. Bu kitabi alin, pisman olursaniz bende adam degilim a.q

This book is incredibilly well written and has a very comprehensive way of explaining the ways of Component oriented programing. Explains its differences betweent COP and OOP. You can easily understand what the author has in mind, BUT, I found one big flaw on this book. Not that this flaw will make the book less comprehensive, but it will make it less fun.
In all concepts it presents Examples, but not exercises. It explains the features and then give a short example to it. It doesn't stimulate the reader to actually build a code within a major context. You read, see the example and move on to the next topic. It is not fun to just stay around and read and read and read without actually working with the book. It is still a great book, but the approach to the reader could be better.

While going over component and control design, this book teaches the principles of the component-oriented design philosophy. The author doesn't pander and isn't overly verbose; getting to the point and explaining his meaning efficiently and succinctly. Definitely worth the read.

Book goes through the entire process of building controls, nothing is untouched. It dwells however much too long on the 'standard' topics of installation, distribution, setting up etc and is rather lite on the the real stuff like building controls that look and feel like commercial controls. Would be a good book if it had 20% of the pages.

Pros:
Material that was covered was done an a very concise, clear and justfied manner. More so than just about any other computer book I have read. As others have mentioned, the explanation of the mechanics of remoting are excellent. The coverage on the other topics was incredibly informative as well its just that Remoting stands out since the topic is not covered as well elsewhere. Several helper/extension class examples are included which help to enforce good practices. I found the coding practices addendum to be a helpful summary of the topics discussed in the book.

Cons:
While remoting is discussed, it defers discussion of the EnterpriseServices namespace (object pooling, transactions, lifecycling, etc) to a previously published book. I find these features a necessary consideration in component design. Instead of feeling like I know everything about dot NET components, I now feel like I have to read another book. Having said that, WCF, at least at first glance, appears to be among other things a rework of ServicedComponents into an attribute driven dot NET framework and less reliant on COM+. I hope that is the case because JEE has already proven that inhertance based component mangagement such as ServiceComponent cramp system architectures. I also feel like the book does not adequately cover the use cases appropriate for designing a distributed application. It covers the mechanics/how fine but it doesn't address the when and where portion of distributed components.

Juval's latest book covers WCF and I am looking forward to reading it and hope it will address the areas I felt still needed to be addressed by this book.

Pros:
Material that was covered was done an a very concise, clear and justfied manner. More so than just about any other computer book I have read. As others have mentioned, the explanation of the mechanics of remoting are excellent. The coverage on the other topics was incredibly informative as well its just that Remoting stands out since the topic is not covered as well elsewhere. Several helper/extension class examples are included which help to enforce good practices. I found the coding practices addendum to be a helpful summary of the topics discussed in the book.

Cons:
While remoting is discussed, it defers discussion of the EnterpriseServices namespace (object pooling, transactions, lifecycling, etc) to a previously published book. I find these features a necessary consideration in component design. Instead of feeling like I know everything about dot NET components, I now feel like I have to read another book. Having said that, WCF, at least at first glance, appears to be among other things a rework of ServicedComponents into an attribute driven dot NET framework and less reliant on COM+. I hope that is the case because JEE has already proven that inhertance based component mangagement such as ServiceComponent cramp system architectures. I also feel like the book does not adequately cover the use cases appropriate for designing a distributed application. It covers the mechanics/how fine but it doesn't address the when and where portion of distributed components.

Juval's latest book covers WCF and I am looking forward to reading it and hope it will address the areas I felt still needed to be addressed by this book.

On page 73 of this book the author wrote:

" An in-depth discussion of how to decompose a system into components and how to discover interface methods and properties is beyond the scope of this book".

I would encourage the author to write a book that discusses specifically about interface factoring and to provide more examples on how components should be decomposed and organized in large scale applications.

Yes, I am always very demanding on programming books and this title taught me more of all the others.

I definitely suggest it.

This is the my first review on Amazon. This book is so nicely written. The examples are short and precise. All the Advanced topics are covered in a great way. Highly recommend it to all developers who want to gain more expertise.

The book is good if you want to have a solid information about the .net Assemblies,Remoting, Async. Programming, Delegates. The best thing I like about this book is that every line has a lot of weight. You can read about remoting in say 30 - 50 pages and will get a deep insight of remoting. Then you can read a advanced book on remoting to get the fine details. If you directly read the advanced book on remoting it would take a while to get an idea about the complete picture of remoting..

This is the my first review on Amazon. This book is so nicely written. The examples are short and precise. All the Advanced topics are covered in a great way. Highly recommend it to all developers who want to gain more expertise.

this book brought me out of the darkness into the light. this is a fairly small book with a lot of info
It explains how and why thing are done...interface base programming brilliant !! go and buy this book and your competition will be saying "thats very difficult to accomplish" and you leave them saying.."how you do that??"

this book brought me out of the darkness into the light.
It explains how and why thing are done...interface base programming brilliant, clear go and buy this book and your competition will be saying thats not possible and you leave them saying.."how you do that??"

L�wy's book does a great job covering some complex, arcane topics. He nicely lays out fundamentals on interface-based design and development, then moves on to clearly cover tough topics like remoting and multithreading.

There's a wealth of information on implementing .NET 2.0's generics throughout the book, including a nice introductory appendix.

I also liked L�wy's emphasis on identifying potential error conditions and discussing how to deal with those conditions. This seems especially strong in the sections on remoting and threading.

L�wy discusses pros and cons of various choices one might have to make; something I think is great since it's critical to make informed decisions for design and implementation.

A great book!

Lýwy's book does a great job covering some complex, arcane topics. He nicely lays out fundamentals on interface-based design and development, then moves on to clearly cover tough topics like remoting and multithreading.

There's a wealth of information on implementing .NET 2.0's generics throughout the book, including a nice introductory appendix.

I also liked Lýwy's emphasis on identifying potential error conditions and discussing how to deal with those conditions. This seems especially strong in the sections on remoting and threading.

Lýwy discusses pros and cons of various choices one might have to make; something I think is great since it's critical to make informed decisions for design and implementation.

A great book!

This book is just excellent. With only 500 pages, it covers many advanced topics and explains each topic really well. I am impressed by both the depth of the coverage and the excellent writing style. If you want to be an advanced .NET developer, you don't want to miss this book.

Besides, my advice to those authors who do not know how to write effectively and constantly produced books inundated with confusion and errors: before you write the next book, make sure you read this book from cover to cover and learn how to write from Juval Lowy.

At first I was a bit put off with this book, the first three chapters seemed elementary, slow, and redundant. Also just a bit too much of the "beauty of .NET for .NET's sake" garbage. The discussion in chapter 1 about components / Interfaces vs. object heierarchies / inheritance is overdone, and gee, yah, I get the Microsoft Mantra, Dude. Save it for the computer science academic wannabes -- you know, the same weenies that were all excited beyond reality about OOP and C++ just a few years ago. A few years from now the weenies will be telling us how components and interfaces miss the boat, and come up with a new bunch of terms using English words twisted beyond meaning.

I decided to hope this book was at least another "one chapter wonder", and skipped to chapter 10 on remoting. That was a far more valuable read, and convinced me to back track and pick off the other chapters.

After finishing the book in it's entirety, I feel it is one of the most worthwhile .NET programming books I've read (which is a couple dozen in the last 6 months as I'm finally moving more into C#/.NET instead of C++/Win32 SDK/MFC.) It's saying a lot that I read the entire book, as there are not many I've bothered to complete among the hundreds I've read over the years. I'd say 1/3 get tossed aside after a quick review terminating in disgust.

The pace is a bit slow throughout the book, but I consider this a justifiable side effect of Mr. Lowy's style, which is extremely clear. You'd have to be a complete moron to not understand the points he makes. A number of the items covered in the book are a bit arcane and not something you're likely to make use of everyday, and the repetition can be helpful when doing quick re-reads of parts of chapters later on when using the book as a reference.

I bought the book mainly for the information on remoting, and would have been happy enough with it for just that chapter as I needed to get up to speed on it fast. Chapter 10, on remoting, is the best description of the three I read this week. I was pleasantly surprised to also get the lucid review on assembly versioning and delegates, plus clear information on some new .NET 2.0 API's and language elements, plus a nice treatment of programmatic role and component based security. Turned out the book wasn't a "one chapter wonder" after all.

I do NOT feel this is an "advanced" programming book, and no one with lesser experience should be put off by reviews saying that. This book has fairly broad coverage, with simplistic and easy to understand source code examples for illustration of the topics covered. Between the simplicity of the examples, and the clarity of text, I think relatively inexperienced .NET programmers would have few problems with the content. It is a good intermediate book that provides a very lucid treatment of exactly the topics presented in the table of contents. I think any programmer who has gotten past the total .NET newbie phase will benefit from this book as they find need for full information on any of the topics it presents. It's also a great book for people in my situation, with 30 years programming experience, 20 in Windows, needing to get up to speed fast on some .NET topics.

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.

This is an excellent book. It covers many of the more advanced features of .NET and C#. The presentation is always crystal clear and augmented with code samples that are not only illustrative, but also useful in their own right.

Do you have the skills to design and develop component-based .NET applications? If you don't, this book is for you! Author Juval Lowy, has done an outstanding job of writing a great book that teaches you the skills you need to understand .NET component programming and related system issues; as well as, information that is relevant to design options, tips, best practices, and pitfalls.

Lowy begins by providing the basic terminology used throughout the book. Next, the author describes the elements of .NET. such as the Common Language Runtime (CLR), .NET programming languages, the code-generation process, assemblies, and building and composing those assemblies. Then, he examines working with interfaces. The author continues by dealing with the way .NET manages objects, and the good and bad implications this has for the overall .NET programming model. In addition, the author next describes the .NET version-control policy and the ways you can deploy and share its components. He also shows you how to publish and subscribe to events in a component-based application. Next, the author describes .NET's built-in support for invoking asynchronous calls on components, the available programming models, their trade-offs, when to use them, and their pitfalls. Then, he explains in depth how to build multithreaded components. The author continues by showing you how to persist and serialize an object's state. In addition, the author demystifies .NET support for remote calls. He also describes a powerful and useful facet of .NET: its ability to provide ways to define custom services via contexts and call interception. Finally, he addresses the rich topic of .NET code-access security.

With the preceding in mind, the author has also done an excellent job of writing a book that helps you start developing .NET components immediately, taking full advantage of the .NET development infrastructure and application frameworks. In other words, this book takes advantage of what both .NET 1.1 and .NET 2.0 have to offer.

One of the benefits of .NET is that is makes component-oriented programming much easier and efficient, building on previous technologies that were forbidding in complexity and limited in scope. Programming .NET Components by Juwal Lýwy from the fine O'Reilly publishing house provides an excellent guide through the intricacies of component programming in .NET.

It begins with a look at the differences between component-oriented versus object-oriented programming. The author then addresses the principles of component-oriented programming such as binary compatibility, language independence and location transparency, showing how .NET adheres to these principles. He discusses .NET basics from a detailed perspective, covering assemblies, deployment and metadata, providing a Visual Studio 2005 perspective.

Next, aspects of interface-based programming are considered with VS2005 features like the ability to generate skeletal implementations and refactoring. Interfaces are collections of methods that provide access points to the component from external clients. Components can implement any number of interfaces, providing the ability to extend functionality easily without breaking existing clients. Again, generics provide a means of defining an abstract template for an interface and using it on multiple components with different specifications. This reduces code bloat while preserving type-safety.

The next chapter looks at the niceties of garbage collection in .NET, which deals with the disposal of managed objects created while a program is run. Pre-managed code, memory leakage was commonplace because of programs that did not clean up after themselves. The garbage collector takes care of that for the programmer, although abstruse features such as non-deterministic finalization mean that one cannot be really sure when the garbage collector will come around, although patterns to mitigate this are covered.

After an overview of versioning, including a look at side-by-side execution of multiple .NET CLR versions, the book moves into a set of chapters dealing with critical elements of component-oriented programming - events, asynchronous calls and multi-threading. Events and asynchronous calls are mechanisms to allow components to notify their clients when a specified condition occurs. These could be Windows-type events like Mouse-clicks or custom events. The introduction of generic delegates opens new vistas for event management. Some of the concepts presented here should be part of the .NET framework for their simplicity and brilliance.

Since all .NET programs are multi-threaded, they allow concurrent execution of multiple code contexts. A multi-threaded application is more responsive to users. In the past, development of such applications has not been a task for the faint-hearted. Tthis thorny problem is mitigated in .NET by a number of convenient features for concurrency management, increasing developer productivity. The book looks at the various elements of synchronization, even providing a convenient helper class.

Subsequent chapters cover serialization, remoting and security, with weighty appendices on generics, web services and a C# Coding Standard based on the best practices in this book, itself the de facto standard for C# coders. This is a book with much meat, enough to serve a feast of ravenous developers, starved from nights of toil at the desktops of the giant software factories. The author was recognized by Microsoft as a Software Legend - one of the world's top .NET experts.

This is a must read for every .NET architect and developer that is doing any type of Product Line Engineering or Framework building. Component-oriented development is the heart of both and this book teaches you how to do it correctly.

Mr. Lowy has done a great job of putting everything you need to know about how to do Component-oriented development in .NET 2.0 into one place. I highly recommend this book.

This book is a must have for your collection on the study of .Net 2.0. Juval is a super resource on all subjects covered in this book and backs them up with clear examples. He is a well respected and often quoted expert in his field. I would highly recommend this book to all those who are serious about mastering the more lofty concepts of this technolgy.

I used to carry two or three books in my pack along with my laptop. Now I only carry this book. It is an outstanding resource for advanced .NET programming.

Item delivered on time in a very good condition

I liked the original and this a good update that covers the migration requirements and new language features. This book will walk you through everything you need to know to build a well designed .NET component with C#. Visual Basic isn't covered. There is a little reference to that in the beginning which is disparaging to VB.NET. But that's ok. I'm sure that anyone doing this type of work in VB will get a lot from this book and can do the language translation.

Juval Lowy is not a Microsoft Legend just by name.
His Clarity in the contents and to the point concepts are outstanding.
His book reflects, his extensive experience in COM , COM +
.Net Components and all the related technologies in a seamless manner the same way he explained it.

10 out of 10 , just go for it

Programming .NET Components
Author: Juval Lowy
Published by O'Reilly Press
ISBN: 0-596-00347-1

Reviewed by Andre Beier, HuNTUG Member

A lot of computer books nowadays teach you how to program, but they hardly ever give an explanation why things should be done in a certain way. This book starts right at the point where other books usually end.

It has in-depth chapters about Interfaces, Lifecycle Management, Version Control, Asynchronous Calls, Multithreading, and many other commonly used .NET technologies. The author has done a really good job explaining even some of the most advanced .NET features.

I would give this book 4.5 (out of 5) stars. My only real criticism is that some concrete programming examples would have made it easier to understand some of the more complex parts of the book. Altogether you can say that this book is an excellent reference of best practices for the advanced programmer. I definitely would not recommend this book for .NET beginners. However, if you ever got frustrated with books that were only scratching the surface, this book is for you. It might be especially useful for former COM programmers since the author takes the time to point out the differences between COM and .NET.

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.

Programming .NET Components is a rare gem of .NET programming books. I found the content in this book to provide much-needed perspective related to general .NET programming tasks, answering questions like: best practices for interface and class heirarchy design, in-depth coverage of the .NET garbage collector and how to prevent it from hurting your application's performance, and a thorough explanation of delegates and their more evolved counterparts called events.

Many .NET texts explain "how" to do things, but generally don't explain "why" things are done a certain way. This text gives you the breadth of knowledge you need to make optimal use of .NET technologies, and to understand when to use a particular approach to solve a problem when there is more than one possible option.

I have not read all chapters of this book, but what I have read so far has already more than justified its purchase price. And I know it will be a valuable reference book for me in the future, as I explore threads, remoting, etc.