Component Object Model: Microsoft’s COM Architecture

The Component Object Model (COM) stands as a pivotal Microsoft technology, designed to enable software components to communicate seamlessly. This object-based software architecture underpins a host of Microsoft technologies, such as OLE, ActiveX, Distributed COM (DCOM), COM+, and Microsoft Transaction Server (MTS). COM’s introduction revolutionized the way applications were developed, allowing for increased modularity and reusability of binary software components.

In this article, we’ll embark on a comprehensive exploration of COM, from its inception and operational mechanics to its critical role in software development, particularly in Visual Basic. We’ll also examine the evolution of COM, its eventual deprecation, and the successor technologies that have taken its place. By delving into specific examples and components, we aim to provide a thorough understanding of COM’s impact and legacy in the realm of software engineering.

Table of Contents:

  1. What is the Component Object Model (COM)?
  2. The Birth of COM
  3. How Component Object Model Works
  4. COM Components and Technologies
  5. Component Object Model in Visual Basic Programming
  6. The Evolution of COM
  7. The Decline of COM
  8. The Successor of COM
  9. Component Object Model Today
  10. References
Component Object Model: This image encapsulates the abstract and futuristic essence of COM, highlighting the modular, interoperable nature of binary software components and their seamless communication.

1. What is the Component Object Model (COM)?

As defined by Microsoft, the Component Object Model (COM) is an object-based software architecture that allows applications to be built from binary software components. COM is the foundation for various Microsoft technologies including OLE, ActiveX, Distributed COM (DCOM), COM+, and Microsoft Transaction Server (MTS).

Component Object Model (COM)
Component Object Model (COM)

COM is not a programming language, rather it is a specification. The goal of COM is to allow applications to be built using components. These COM components can be created by different vendors, at different times, and using different programming languages. Also, COM components can run on different machines and different operating systems.

2. The Birth of COM

2.1 Historical Context

The Component Object Model (COM) was introduced by Microsoft in the early 1990s as a foundational element of its software architecture. At the time, the software industry was grappling with the complexities of developing increasingly sophisticated applications. There was a pressing need for a system that could support the reuse of software components across different applications and platforms. Microsoft’s answer to this challenge was COM, which emerged alongside other technologies such as Object Linking and Embedding (OLE) for compound documents and ActiveX controls for Internet applications. COM represented a paradigm shift, advocating for a component-based approach to application development that emphasized modularity and interoperability.

2.2 Initial Objectives and Challenges

The primary objective behind the development of COM was to create a binary standard for software components. This standard would enable components to interact within the same process, across processes, and even across network boundaries without requiring a recompilation of the application. The goals were ambitious: to facilitate component reuse, reduce software complexity, and enhance developer productivity. However, COM’s introduction was not without challenges. The foremost among these was ensuring backward compatibility with existing technologies and applications. Additionally, the complexity of COM’s architecture, particularly its reliance on precise interface definitions and reference counting for memory management, posed a steep learning curve for developers. There were also challenges related to security and efficient communication in distributed environments, leading to the development of Distributed COM (DCOM).

3. How Component Object Model Works

3.1 Basic Architecture

COM’s architecture is predicated on the concept of binary software components that can be assembled into applications. These components are essentially blocks of code that expose their functionality through interfaces. An interface in COM is a well-defined contract that specifies the functions available on a component. Interfaces are identified by unique identifiers (GUIDs), ensuring that they can be unambiguously identified across different systems. COM components are language-agnostic, meaning they can be developed in various programming languages as long as they adhere to the COM standard. This interoperability is achieved through the use of a binary standard for function calls, known as the Virtual Table (v-table), which allows for language-independent invocation of component methods.

3.2 Component Creation and Management

The creation and management of COM components are facilitated through a set of system services provided by the COM runtime environment. To instantiate a COM component, clients use the CoCreateInstance function, specifying the CLSID (Class ID) of the component they wish to create. This function is responsible for locating the binary code of the component, loading it into memory, and returning an interface pointer to the client. COM also defines a lifecycle for components, managed through reference counting. Each component keeps track of how many clients are using it, incrementing a count for each new client and decrementing it as clients release their interfaces. This reference counting mechanism ensures that components are unloaded from memory when they are no longer needed, preventing memory leaks.

3.3 Interface and Implementation

A key principle of COM is the separation of interface from implementation. Interfaces are immutable; once they are defined and published, they cannot be changed. This design ensures binary compatibility, allowing different versions of a component to coexist as long as they implement the same interfaces. When a component’s implementation changes, it can provide new interfaces or version existing ones. Clients interact with a component strictly through its interfaces, without any knowledge of the component’s internal implementation. This abstraction allows components to be updated or replaced without affecting the clients that use them, fostering a modular and flexible approach to software development.

3.4 Fundamental Concepts

The following concepts are fundamental to the way COM works:

  • COM Interfaces: A group of related functions implemented by the COM class. COM interfaces are the mechanisms by which COM objects expose their functionality to applications and other components. An interface is a table of pointers to functions that are implemented by the object. The table represents the interface and the functions to which the table points represent the methods of that interface. COM objects can expose multiple interfaces. Each interface has its unique interface ID (IID). 
  • IUnknown: This is the basic COM interface on which all other interfaces are based; it provides reference counting and interface querying mechanisms. IUnknown allows navigation to all other interfaces exposed by the object. 
  • Reference counting: This is a mechanism by which an interface determines it is no longer being used and is, therefore, free to remove itself. IUnknown uses the methods AddRef and Release to implement reference counting. 
  • QueryInterface: This is the IUnknown method used to query an object for a given interface. 
  • Aggregation: This is a technique by which one object can make use of another. 
  • Marshaling: This mechanism lets objects be used across thread, process, and network boundaries, thus providing location independence. 

3.5 Binary Standard

For any given platform (hardware and operating system combination), COM defines a standard way to lay out virtual function tables (vtables) in memory, and a standard way to call functions through the vtables. Thus, any language that can call functions via pointers (C, C++, Smalltalk, Ada, and even BASIC) all can be used to write components that can interoperate with other components written to the same binary standard. Indirection (the client holds a pointer to a vtable) allows for vtable sharing among multiple instances of the same object class. On a system with hundreds of object instances, vtable sharing can reduce memory requirements considerably, because additional vtables pointing to the same component instance consume much less memory than multiple instances of the same component.

Virtual function tables (VTBL)
Virtual function tables (VTBL)

3.6 Objects and Components

The word object tends to mean something different to everyone. To clarify: In COM, an object is a piece of compiled code that provides some service to the rest of the system. To avoid confusion, it is probably best to refer to an object used in COM as a COM component or simply as a component. This avoids confusing COM components with source-code OOP objects such as those defined in C++. COM components support a base interface called IUnknown (described later), along with a combination of other interfaces, depending on what functionality the COM component chooses to expose.

COM components usually have some associated data, but unlike C++ objects, a given COM component will never have direct access to another COM component in its entirety. Instead, COM components always access other COM components through interface pointers. This is a primary architectural feature of the Component Object Model, because it allows COM to completely preserve encapsulation of data and processing, a fundamental requirement of a true component software standard. It also allows for transparent remoting (cross-process or cross-network calling) because all data access is through methods that can be accessed through a proxy-stub pair that forward the request from the client component to the server component and also send back the response.

3.7 COM Interfaces

In COM, applications interact with each other and with the system through collections of functions called interfaces. Note that all OLE services are simply COM interfaces. A COM “interface” is a strongly-typed contract between software components to provide a small but useful set of semantically related operations (methods). An interface is the definition of an expected behavior and expected responsibilities. OLE’s drag-and-drop support is a good example. All of the functionality that a component must implement to be a drop target is collected into the IDropTarget interface; all the drag source functionality is in the IDragSource interface.

Interface names begin with “I” by convention. OLE provides a number of useful general-purpose interfaces (which generally begin with “IOle“), but because anyone can define custom interfaces as well, developers can develop their own interfaces as they deploy component-based applications. Incidentally, a pointer to a COM component is really a pointer to one of the interfaces that the COM component implements; this means that you can only use a COM component pointer to call a method, and not to modify data, as described above. Here is an example of an interface, ILookup, with two member methods:

interface ILookup : public IUnknown
virtual HRESULT __stdcall LookupByName
( LPTSTR lpName, TCHAR **lplpNumber) = 0;
virtual HRESULT __stdcall LookupByNumber
( LPTSTR lpNumber, TCHAR **lplpName) = 0;

4. COM Components and Technologies

The Component Object Model (COM) serves as the backbone for several pivotal Microsoft technologies, each building upon the core principles of COM to cater to specific application needs. These technologies include Object Linking and Embedding (OLE), ActiveX, Distributed COM (DCOM), COM+, and Microsoft Transaction Server (MTS). Each represents an evolution or extension of the fundamental COM architecture, tailored to address unique challenges in software development.

4.1 OLE (Object Linking and Embedding)

OLE was one of the first technologies built on top of COM, designed to facilitate compound document creation. It allows users to embed or link documents and other objects from different applications into a single document. For instance, OLE enables embedding a spreadsheet within a word processor document. Behind the scenes, OLE leverages COM to manage communication between the embedded objects and the container application, ensuring seamless integration and interaction. OLE was a significant step forward in making applications work together more effectively, enhancing productivity by enabling data to be reused and shared across different programs.

4.2 ActiveX

ActiveX controls are COM components that can be embedded in web pages to provide interactive content, such as videos, games, and other multimedia elements. Unlike OLE, which is primarily focused on embedding objects in documents, ActiveX controls are used to enhance web and desktop applications. These controls can be developed in various programming languages and are executed in a container, typically a web browser, which supports the ActiveX framework. Despite their powerful capabilities, ActiveX controls have faced criticism over security vulnerabilities, leading to more cautious use and stricter security measures in modern software development.

4.3 DCOM (Distributed COM)

DCOM extends COM to support communication between components that are distributed across networked environments. It allows a client application to invoke methods on a COM object located on a different machine, transparently handling the complexities of network communication. DCOM uses the same interface-based approach as COM, ensuring that the distributed nature of the application is largely abstracted away from the developer. By managing the details of remote communication, including serialization of method calls and security, DCOM enables the development of distributed applications with relative ease.

4.4 COM+

COM+ is an extension of COM that introduces additional services to support enterprise-level applications. These services include transaction processing, object pooling, and event publication and subscription, among others. COM+ simplifies the development of scalable, robust applications by providing built-in support for common requirements such as transaction management, thereby reducing the amount of boilerplate code developers need to write. COM+ components are managed by the COM+ runtime environment, which ensures that the components adhere to the configured services, such as participating in transactions managed by Microsoft Transaction Server (MTS).

4.5 MTS (Microsoft Transaction Server)

MTS is a component-based transaction processing system that integrates with COM+. It provides a framework for building, deploying, and managing server-centric applications. MTS is particularly focused on ensuring the integrity of transactions across multiple databases and other resources. It does so by managing the distribution of work and the commitment or rollback of transactions, based on the success or failure of the individual operations involved. MTS was a forerunner to .NET Enterprise Services and played a crucial role in simplifying the development of distributed, transaction-oriented applications.

5. Component Object Model in Visual Basic Programming

5.1 The Role of Component Object Model in VB

Visual Basic (VB) has been a cornerstone in the development of COM-based applications, thanks to its approachable syntax and integrated development environment. The synergy between VB and COM stems from VB’s inherent support for creating and consuming COM components, making it an ideal tool for rapid application development. VB abstracted much of the complexity associated with the Component Object Model, allowing developers to focus on the business logic of their applications rather than the intricacies of component communication and interface definition. This accessibility significantly contributed to the proliferation of COM components, as developers could easily encapsulate reusable business logic into COM components and distribute them across applications and systems.

5.2 Building COM Components with VB

Creating COM components in Visual Basic is straightforward, thanks to its built-in support for COM. Developers can create ActiveX DLLs or EXE servers with just a few clicks in the VB IDE, defining public classes and methods that automatically become COM interfaces and components. The process involves:

  1. Defining a Class Module: Developers start by creating a class module in VB, which serves as the template for the COM component. This class defines the properties, methods, and events that the component will expose.
  2. Setting Project Properties: The VB project is configured to compile as an ActiveX DLL or EXE, depending on whether the component needs to run in-process or out-of-process.
  3. Implementing Interface Methods: The methods defined in the class module are implemented with the required business logic, adhering to the COM interface specifications.
  4. Compiling the Component: Once the development is complete, the VB project is compiled, generating a COM component (DLL or EXE) registered on the system.

These components can then be utilized in other VB applications or any COM-compliant environment, showcasing the interoperability and reusability that COM offers.

6. The Evolution of COM

6.1 Enhancements and Extensions

Over the years, COM has seen numerous enhancements and extensions to address the evolving needs of software development. These enhancements have focused on improving security, simplifying component management, and enabling distributed computing. For instance, the introduction of DCOM extended COM’s capabilities to networked environments, allowing components to communicate over a LAN or the Internet. Security improvements were also significant, with COM and DCOM incorporating robust authentication and authorization mechanisms to secure component interactions in distributed applications.

6.2 COM+ and Integration with New Technologies

COM+ represented a major evolution in the COM architecture, introducing services that significantly reduced the amount of boilerplate code developers had to write for common application functionalities such as transactions, security, and object pooling. COM+ also integrated tightly with new technologies, particularly with the advent of the .NET Framework. Although .NET introduced a new model for application development, it provided interoperability with COM components through Interop services. This ensured that existing investments in COM components could still be leveraged within the .NET environment, facilitating a smoother transition for developers migrating to .NET.

COM+ played a crucial role in the transition period by providing a bridge between the traditional COM model and the modern .NET framework. This integration enabled developers to utilize the best of both worlds—leveraging the mature, stable components developed with COM while taking advantage of the modern features and improved development experience offered by .NET.

The evolution of COM, marked by enhancements, extensions, and integration with new technologies, underscores its significance in Microsoft’s software development ecosystem. Despite the shift towards newer models like .NET, the principles of component-based development established by COM continue to influence modern software architecture, highlighting COM’s enduring legacy.

7. The Decline of COM

7.1 Challenges and Limitations

While COM was revolutionary in its heyday, facilitating component-based software development and reuse, it wasn’t without its challenges and limitations. One of the main issues was its complexity, especially for developers dealing with low-level details such as reference counting, interface marshaling, and the registration of components. This complexity could lead to increased development time and a higher likelihood of errors. Additionally, COM’s reliance on binary compatibility posed challenges for versioning and updating components without breaking existing applications. Security in a distributed environment, facilitated by DCOM, also presented significant challenges, as the architecture required careful configuration to prevent vulnerabilities.

7.2 The Shift to New Architectures

The software development landscape began to shift with the advent of new programming models that promised to address some of the complexities and limitations inherent in COM. The rise of web services and the move towards service-oriented architectures (SOA) offered a more flexible and less tightly coupled approach to software development. Furthermore, the introduction of the .NET Framework by Microsoft marked a significant pivot away from COM’s binary component model to a more versatile and developer-friendly platform. This shift was driven by the need for a more manageable and secure model for building, deploying, and running applications, particularly in distributed and web-based environments.

8. The Successor of COM

8.1 Introduction to .NET Framework

The .NET Framework was introduced by Microsoft as a comprehensive platform for building and running applications, including web, Windows, and server-based applications. It brought several innovations, such as a managed runtime environment (the Common Language Runtime, or CLR), a unified class library, and support for multiple programming languages through the Common Language Infrastructure (CLI). The .NET Framework aimed to simplify development by managing memory, providing extensive libraries for common tasks, and supporting modern programming paradigms such as object-oriented programming (OOP) and asynchronous programming.

8.2 Comparison with COM

The .NET Framework differs from COM in several key aspects. Unlike COM’s language-agnostic binary standard, .NET uses a common type system and metadata to ensure interoperability among languages. Memory management in .NET is handled through automatic garbage collection, eliminating the need for manual reference counting. Additionally, .NET offers a more integrated development experience with tools like Visual Studio, simplifying tasks such as debugging and deployment. While COM focuses on binary compatibility and in-process communication, .NET emphasizes language interoperability and provides broader support for web and networked applications.

8.3 Transition Strategies for Developers

For developers moving from COM to .NET, Microsoft provided tools and guidelines to facilitate the transition. Interoperability features, such as COM Interop and the Platform Invocation Services (PInvoke), allow existing COM components to be used within .NET applications and vice versa. These mechanisms enable developers to gradually migrate applications to .NET, leveraging existing COM investments while adopting new .NET features and paradigms. Best practices for the transition include wrapping COM components in .NET assemblies for ease of use and gradually rewriting critical components in .NET to take full advantage of the platform’s capabilities.

9. Component Object Model Today

9.1 Legacy Systems and Compatibility

Despite the emergence of newer technologies, COM remains relevant in many legacy systems and applications. Its robustness and the extensive base of existing COM components ensure that it continues to be used, particularly in applications where stability and backward compatibility are paramount. Microsoft Windows still supports COM, ensuring that applications developed with COM can run on modern versions of the operating system.

9.2 Modern Alternatives and Best Practices

While COM is still supported, developers are encouraged to adopt modern alternatives for new projects. The .NET platform, including .NET Core and .NET 5 and beyond, offers a more flexible and efficient environment for application development. Best practices for working with COM in today’s context involve using COM Interop for integrating legacy components into .NET applications, securing DCOM configurations, and considering the migration of critical components to modern frameworks to benefit from improved performance, security, and development workflows.

10. References


  • Essential COM” by Don Box: Provides a deep dive into COM’s architecture and programming model.
  • COM and .NET Component Services” by Juval Löwy: Offers insights into integrating COM components with .NET and using COM+ services.

Network Encyclopedia:

External References: