COM+ from Design to Implementation

Need to hit the ground running on technologies like COM+ and SOAP? Start with Microsoft Press' Designing Solutions with COM+ Technologies.

• By Paul G. Brown
• 04/01/2001

Open just about any developer magazine and you'll see some mention of n-tier design, object programming and scalable solutions. Everyone either is doing it or wants to do it, and you can't live without it. A lot of hype? Yes, but there is also a lot of truth behind it.

For Windows developers, Microsoft provides COM+ (Component Object Model) standard as a way of developing language-neutral, re-usable components. Microsoft Press's Designing Solutions with COM+ Technologies is a solid guide to the strategies, implementation and traps involved in COM+. The first thing to understand is that this book is not for beginners.

The target audience is specifically developers who plan to develop or implement COM components. From the first chapter, Error Handling, the author delves into the details with little preface or background and immediately assumes you know specific concepts or practices. That he doesn't offer referential information can be a little disconcerting at first, but you'll quickly appreciate the benefits as you see how much detail is available.

Part 1, Fundamentals, is somewhat of a misnomer. You'll be disappointed if you expect to see the definition of COM and its place in the overall strategy. Instead the author covers error handling, concurrency, implementation environments and strings. If you're a C developer, the error handling section offers valuable tips on different types to use for passing errors. If you want to get up to speed on apartments, threads and transparency in 66 pages or less, start with Chapter 4, Concurrency. For a section on fundamentals, this book's five chapters has more descriptive information than what you might find in most books devoted to those topics.

The conceptual side of COM design is the domain of Part 2, Architectural Patterns and Solution. The word architecture is apt - this is where you develop the blueprint for developing components. Reuse, streaming and persistence are all topics that you should familiarize yourself with before you write a line of code. When you do write code, you'll have the tools to insure consistency and stability. You'll even learn how to take out the trash (without the smell). By the end of the chapter you'll have all the tools needed to build a framework upon which to build your applications. Successful application development begins and ends with planning. Plan everything.

Part 3, COM+ in the Enterprise, moves up another level so that we are looking at the whole picture and can plan accordingly. This part explores mapping n-tier applications to COM and also presents a four-tier transactional design. Look to Chapters 11 and 14 for much of the data access side of things including many important interfaces. There, you'll also find more than adequate coverage of SOAP and integration of MTS into COM+.

One gripe: This book could use a better glossary. Depending on your background and skill level you may not catch the precise meaning of some terms immediately. I thought the order of presentation of some topics seemed a bit out of order. Some of the most basic concepts, such as what COM is, aren't covered until chapter 6. Plan on rereading sections to fully assimilate the information.

Overall, this is one of the strongest programming books available and probably should be in every developer's library. It manages to strike a nice balance between high-level concepts and fine-grain details. There is value for just about all developers regardless of tool or background. Don't be surprised if your friends don't want to lend out this one.