Inside Com (Microsoft Programming Series)

by Dale Rogerson

Shows developers just how critical and accessible COM can be. This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 1572313498
• ISBN13: 9781572313491
• Release Date: January 1997
• Publisher: Microsoft Press
• Length: 416 Pages
• Weight: 2.02 lbs.
• Dimensions: 9.2" x 1.3" x 7.4"

Customer Reviews

Great description of how COM works, and why

This book starts out with a simple C++ class called by some other code, and works to encapsulate it into a component, basically implementing COM from scratch. This really lets you understand how it works and why. It's well written and does a good job describing all the details.As others have mentioned, this is not a book about ActiveX, OLE, ATL, or any of that, and it doesn't pretend to be. This book just describes COM, the basis for those technologies. If you want to really understand what's going on with COM, I highly recommend this book.

An excellent book on the topic

This is much more than a COM book. The book spends a lot of time in the first half talking about the more general concept of interfaces, which is more of a software design topic. Then he shows how to implement those interfaces using C++ abstract classes and gives a very good discussion of inheritence, polymorphism, and virtual function tables. Everything is done in pure C++ so you can see what is going on. No wizards or macros to hide the details. The diagrams were very helpful.Even if you choose to not use the COM architecture for your software the discussion of interfaces will help you write software of much higher quality. Seeing how the interfaces are implemented and the discussion of inheritence and virtual function tables gave me a much better understanding of the C++ language.The key to understanding COM is understanding interfaces and this book does a very good job explaining them. Eventually when the author gets into the Microsoft specific COM library you can see how those chapters build on the earlier chapters. You can see how a program can evolve from a set of inflexible C++ classes, to some compile-time flexible C++ classes that use interfaces, to run-time flexible components using DLLs, and finally a full blown COM component.Near the end of the book it is not as thorough with the examples but that is because the topics presented there are too large to fit in a single chapter. The first 8 chapters are worth the price of the book.

An Excellent Introduction To COM...

If you are new to COM or know very little about it, this is the place to start. It explores the infrastructure without overwhelming the newcomer and gives very convincing arguments about why a specific component is there and how it ended up so.Keep in mind that one way of looking at this technology is to see it as an improvement on C++. (For this I call Don BOX to witness stand [1st chapter of 'Essential COM']) Also, don't forget that C++ is the implementation language of MFC and ATL frameworks. Hence the tendency to emphasize C++ in such technologies and (Micosoft Press) books.If you can't stand C/C++, I suggest that you grab one of those 'Active ... with Visual Basic/ Visual J++' books. These languages make the use of some aspects much easier, e.g. garbage collection, exception handling. But then again can you claim to know an architecture without getting your hands dirty with its assembler? I guess not!When you finish reading this book, if you think you can take more serious stuff, make sure you check out Don BOX's books: 'Essential COM' and 'Effective COM.'

It makes you a better C++ developer

This is a remarkable book for those who do not want to feel like a dummy looking at the stuff produced by a code generator (a so-called Wizard). This books explains everything, from why a C++ generated virtual table complies with COM specifications to the threading models of COM. This book will serve you best if you follow it letter by letter and develop base classes for your development according to the author. Then try to use standard ATL Wizard from VC++, compare its output to what you have learned and you will say to yourself: Ha! I know what is done and why! You will also get a feel that the author could have been the one who created the ATL Wizard. Even a complete example from this book, TANGRAM, bears the same name as a VC++ example. However unless you really have to develop very customized stuff I would recommend Wizard since it does all the work of the numerous component registrations for you and handles all compiler and linker switches. Also the book uses makefiles, so if you like IDE, you will feel slightly uncomfortable. It is also an excellent C++ tutorial on multiple inheritance and class libraries. A lot of C++ details are explained along the way. You will be a much better C++ programmer after you are done with the book

Ok, this is the skinny on COM...

Ok, this is the skinny on COM: 1) COM is hard 2) you will not learn COM by reading only one book 3) attempt COM in stages: read about it, use someone elses servers, write your own servers, write your own servers in a multi-threaded environment To learn COM you must take weeks of expensive courses or read these books in this order: 1) "Understanding ActiveX and OLE": optional; easy read but recommended 2) "Inside COM": strongly recommended; if you really appreciate "Essential COM" without reading this first you are smarter than I am 3) "Multithreading Applications in Win32": strongly recommended 4) "Essential COM": essential; once you have your COM bearings read this book, then read it again in 6 months to realize how many details you missed the first time 5) "Beginning Atl Com Programming": recommended 6) "Effective COM": optional 7) "Essential ATL": optional 8) "Inside OLE2": optional, for brave souls only Whew! That is a lot but it all really is required. If you attempt shortcuts or read the books out of order, you risk being crushed by someone who really knows COM. Oh yeah, you must also know C++ cold, suspend your beliefs about C++ objects, and be open to the idea of distributed components. Good luck!