The Community for Technology Leaders
RSS Icon
Subscribe
Issue No.05 - May (2006 vol.7)
pp: 6
Published by the IEEE Computer Society
Tim Bond , Navimedix
ABSTRACT
A review of Programming .NET Components by Juval Lowy.

    Programming .NET Components

    Juval Lowy

    480 pages

    US$44.95

    O'Reilly 2003

    ISBN: 0-596-00347-1

I chose to review Programming .NET Components because, like its author Juval Lowy, I've been involved with component-oriented programming for many years. This book gives a .NET spin on COP, which is such a wide-ranging concept that the book ends up a tutorial of many core .NET capabilities. It provides a good perspective on how .NET language features and libraries support COP. The book is well organized and flows logically from one chapter to the next. My only criticism is that I would have liked to see more comparisons with other component technologies such as CORBA.
The book aims to enable the reader to build .NET components. It focuses on developers with experience in Microsoft technologies. To evaluate the book's effectiveness, we must first understand what COP means and why it's different from other forms of programming. Lowy helps us here by summarizing COP into seven principles, which form the book's skeleton:

    • separation of interface and implementation,

    • binary compatibility,

    • language independence,

    • location transparency,

    • concurrency management,

    • version control, and

    • component-based security.

These principles have very different characteristics. Some significantly impact the developer, and others are only significant during installation and maintenance. The book addresses each, emphasizing the former.
In the book's early chapters, Lowy introduces COP and covers the separation of interface and implementation. Developers must take this principle to heart. The description is heavily biased toward the .NET implementation, but this is probably to be expected in a book titled Programming .NET Components. The framework (rather than the developer) handles the binary-compatibility and language-independence principles, but this section explains how these principles lead to modules that are truly components in that they can be composed in different ways, like building blocks.
This section also includes background information that leverages the reader's existing knowledge by highlighting the similarities between .NET and previous technologies such as COM (Component Object Model). In many cases, this historical perspective makes understanding the .NET approach easier.
I have some reservations about one of the book's core principles: location transparency. While I agree that this is a powerful feature, it's a double-edged sword. The article "Errant Architectures" ( http://www.sdmagazine.com/ documents/s=7897/sdm0304a/sdm0304a.htm)by Martin Fowler says it more eloquently than I could. The essence is that remote interactions must be designed as such; the granularity must be much larger than for a local interaction.
The book's most useful portion covers .NET support for location transparency and concurrency management. The chapters on events, asynchronous calls, multithreading, serialization, and remoting are excellent tutorials on the .NET libraries that cover these topics. I have referred back to this valuable section on several occasions since I first read the book. The material is laid out logically, with each piece following naturally from the previous one. Multithreading is one of the most complex concepts to implement correctly. The .NET library simplifies these concepts with a mixture of language features and class libraries. The book overlays .NET functionality with explanations and patterns that will help readers implement the code correctly.
The book also has chapters on version control and security that I haven't used much. These topics are important when deploying applications "in the wild," but I've been deploying to a more controlled environment with different requirements. The chapter on version control again compares .NET to COM, explaining how the COM version policies lead to the problem of "DLL hell" and how .NET tries to avoid these issues.
The book uses C# as its primary language, which works in most cases because a one-to-one mapping to VB.NET (Visual Basic) generally exists. The one exception is that VB provides some simpler constructs that handle the common use of events, although the underlying mechanism is the same. Here Lowy provides some additional guidance from the VB perspective.
One significant topic that the book neglects is enterprise component services, such as transaction management. .NET provides this functionality through integration with COM+ that they call enterprise services, but if you're interested in this, you'll need another book by the same author: COM and .NET Component Services (O'Reilly, 2001).
Conclusion
Overall, Programming .NET Components provides an excellent overview of the features of .NET that make it attractive for developing enterprise-class software. I'd recommend it to anyone moving to the .NET environment.
Tim Bond is a principle software engineer at Navimedix. Contact him at tbond@navimedix.com.
73 ms
(Ver 2.0)

Marketing Automation Platform Marketing Automation Tool