FACTOID # 22: South Dakota has the highest employment ratio in America, but the lowest median earnings of full-time male employees.
 
 Home   Encyclopedia   Statistics   States A-Z   Flags   Maps   FAQ   About 
 
WHAT'S NEW
 

SEARCH ALL

FACTS & STATISTICS    Advanced view

Search encyclopedia, statistics and forums:

 

 

(* = Graphable)

 

 


Encyclopedia > Component Object Model

Component Object Model (COM) is a platform for software componentry introduced by Microsoft in 1993. It is used to enable interprocess communication and dynamic object creation in any programming language that supports the technology. The term COM is often used in the software development world as an umbrella term that encompasses the OLE, OLE Automation, ActiveX, COM+ and DCOM technologies. Although COM was introduced in 1993, Microsoft did not begin emphasizing the name COM until 1997. It has been suggested that this article or section be merged with Component-based software engineering. ... Microsoft Corporation, (NASDAQ: MSFT, HKSE: 4338) is a multinational computer technology corporation with global annual revenue of US$44. ... Inter-process communication (IPC) is the exchange of data between one process and another, either within the same computer or over a network. ... In strictly mathematical branches of computer science the term object is used in a purely mathematical sense to refer to any thing. While this interpretation is useful in the discussion of abstract theory, it is not concrete enough to serve as a primitive datatype in the discussion of more concrete... A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer. ... Object Linking and Embedding (OLE) is a technology that allows embedding and linking to documents and other objects, developed by Microsoft. ... OLE Automation is a late-binding extension to COM and IUnknown. ... ActiveX is Microsoft technology used for developing reusable object oriented software components. ... Distributed Component Object Model (DCOM) is a Microsoft proprietary technology for software components distributed across several networked computers to communicate with each other. ...


The essence of COM is a language-neutral way of implementing objects such that they can be used in environments different from the one they were created in, even across machine boundaries. For well-authored components, COM allows reuse of objects with no knowledge of their internal implementation because it forces component implementers to provide well-defined interfaces that are separate from the implementation. The different allocation semantics of languages are accommodated by making objects responsible for their own creation and destruction through reference-counting. Casting between different interfaces of an object is achieved through the QueryInterface() function. The preferred method of inheritance within COM is the creation of sub-objects to which method calls are delegated.


Although it has been implemented on several platforms, COM is primarily used with Microsoft Windows. COM is expected to be replaced to at least some extent by the Microsoft .NET framework, and support for Web Services through the Windows Communication Foundation (WCF). However, COM objects can still be used with all .NET languages without problems. Networked DCOM uses binary proprietary formats, while WCF encourages the use of XML-based SOAP messaging. COM also competes with CORBA and Java Beans as component software systems. Windows redirects here. ... It has been suggested that Com interop be merged into this article or section. ... A web service is a collection of protocols and standards used for exchanging data between applications. ... This subsystem is a part of . ... The Extensible Markup Language (XML) is a general-purpose markup language. ... A collection of decorative soaps used for human hygiene purposes. ... In computing, Common Object Request Broker Architecture (CORBA) is a standard for software componentry, created and controlled by the Object Management Group (OMG). ... JavaBeans are software components written in the Java programming language. ... Software component representations: above the representation used in UML, below the representation commonly used by Microsofts COM objects. ...

Contents

History

One of the first methods of interprocess communication in Windows was DDE which allowed sending and receiving messages in so-called "conversations" between applications. This technology was the base of OLE (Object Linking and Embedding) which in turn was one of the leading technologies introduced with Windows 3.0. Text conversations and Windows messages proved not to be as flexible as to allow sharing application features in a robust and extensible way. By the time version 3.1 of Windows was released, COM was created as a new foundation and OLE changed to OLE2. Dynamic Data Exchange (DDE) is a technology for communication between multiple applications under Microsoft Windows and also OS/2. ... Windows 3. ... This article does not cite any references or sources. ...


Visual Basic introduced the VBX (packaged extensions in the form of dynamically linked libraries) which allowed the creation of objects to be graphically placed in a form and manipulated by properties and methods. These were later adapted for use by other languages such as Visual C++. OLE custom controls (OCXs) would be the replacement for the widely popular VBX. This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ... In computer programming, VBX (Visual Basic eXtension), or custom controls, was the component model used in Microsoft Visual Basic versions 1. ... This article or section does not cite any references or sources. ... Object Linking and Embedding (OLE) is a technology that allows embedding and linking to documents and other objects, developed by Microsoft. ...


Antony Williams, one of the more notable thinkers involved in the creation of the COM architecture, distributed a couple of internal papers in Microsoft that embraced the concept of software components; Object Architecture: Dealing With the Unknown – or – Type Safety in a Dynamically Extensible Class Library in 1988 and On Inheritance: What It Means and How To Use It in 1990. These provided the foundation of many, if not all, of the ideas behind the basics of COM. Year 1988 (MCMLXXXVIII) was a leap year starting on Friday (link displays 1988 Gregorian calendar). ... Year 1990 (MCMXC) was a common year starting on Monday (link displays the 1990 Gregorian calendar). ...


From many of these ideas spawned Microsoft's first object-based framework, OLE, which is short for Object Linking and Embedding. OLE was built on top of dynamic data exchange (DDE) and designed specifically for compound documents. It was introduced with Word for Windows and Excel in 1991, and was later included with Windows, starting with version 3.1 in 1992. An example of a compound document is a spreadsheet embedded in a Word for Windows document; as changes are made to the spreadsheet within Excel, they appear automatically inside the Word document. Object Linking and Embedding (OLE) is a technology that allows embedding and linking to documents and other objects, developed by Microsoft. ... Dynamic Data Exchange (DDE) is a technology for communication between multiple applications under Microsoft Windows and also OS/2. ... Example of a compound document in Microsoft Office Word In computing, a compound document is a document type typically produced using word processing software, and is a regular text document intermingled with e. ...


In 1991, Microsoft introduced Visual Basic Extensions (VBX) with Visual Basic 1.0. In computer programming, a Visual Basic Extension (commonly abbreviated VBX) or custom control, was the component model used in Microsoft Visual Basic versions 1. ... This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ...


In 1993, Microsoft released OLE 2 with underlying object model. While OLE 1 was focused on compound documents, COM and OLE 2 were designed to address software components in general. In 1994 OLE controls (OCX) were introduced as the successor to VBX controls. At the same time, Microsoft stated that OLE 2 would just be known as "OLE", and that OLE was no longer an acronym, but a name for all of the company's component technologies. In the computing discipline object model has two related but distinct meanings: 1. ... In programming, the Component Object Model (COM), also known as ActiveX, is a Microsoft technology for software components. ...


In early 1996, Microsoft found a new use for OLE Custom Controls, expanding their Web browser's capability to present content, renamed some parts of OLE relating to the Internet ActiveX, and gradually renamed all OLE technologies to ActiveX, except the compound document technology that was used in Microsoft Office. Later that year, DCOM was introduced as an answer to CORBA. Year 1996 (MCMXCVI) was a leap year starting on Monday (link will display full 1996 Gregorian calendar). ... Microsoft Office is an office suite from Microsoft, which is available on the Microsoft Windows and Apple Mac OS X operating systems. ... Distributed Component Object Model (DCOM) is a Microsoft proprietary technology for software components distributed across several networked computers to communicate with each other. ... In computing, Common Object Request Broker Architecture (CORBA) is a standard for software componentry, created and controlled by the Object Management Group (OMG). ...


Related technologies

COM was the major software development platform for Windows and, as such, influenced development of a number of supporting technologies.


COM+

In order to provide developers with support for distributed transactions, resource pooling, disconnected applications, event publication and subscription, better memory and processor (threads) management, as well as to position Windows as an alternative to other enterprise-level operating systems, Microsoft introduced a technology called Microsoft Transaction Server on Windows NT Service Pack 4. A distributed transaction is an operations bundle, in which two or more network hosts are involved. ... To meet Wikipedias quality standards, this article or section may require cleanup. ...


With Windows 2000, that significant extension to COM was incorporated into the operating system (as opposed to the series of external tools provided by MTS) and renamed COM+. At the same time, Microsoft deemphasized DCOM as a separate entity. Transactional COM components were now handled more directly by the added layer of COM+. COM+ components were now added through the Component Services application interface. To meet Wikipedias quality standards, this article or section may require cleanup. ... Distributed Component Object Model (DCOM) is a Microsoft proprietary technology for software components distributed across several networked computers to communicate with each other. ...


An advantage of COM+ was that it could be run in "component farms". A component, if coded properly, could be reused by new calls to its initializing routine without unloading it from memory. Components could also be distributed (called from another machine) as was previously only possible with DCOM.


COM+ also introduced a subscriber/publisher event mechanism called COM+ Events, and provided a new way of leveraging MSMQ (inter-application asynchronous messaging) with components called Queued Components. COM+ events extend the COM+ programming model to support late-bound events or method calls between the publisher or subscriber and the event system. Microsoft Message Queuing or MSMQ is a technology developed by Microsoft and deployed in its Windows Server operating systems since Windows NT 4 and Windows 95. ...


.NET

Main article: .NET Framework

The COM platform has largely been superseded by the Microsoft .NET initiative, and Microsoft now focuses its marketing efforts on .NET. COM was often used to hook up complex, high performance code to front end code implemented in Visual Basic or ASP. It has been suggested that Com interop be merged into this article or section. ... It has been suggested that Com interop be merged into this article or section. ... For the magazine, see Marketing (magazine). ... This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ... Active Server Pages (ASP) is Microsofts server-side script engine for dynamically-generated web pages. ...


To some extent, COM is now deprecated in favor of .NET. Since .NET provides rapid development tools similar to Visual Basic for both Windows Forms and Web Forms with just-in-time compilation, back-end code can be implemented in any .NET Language including C#, Visual Basic and C++. In computer software standards and documentation, deprecation is the gradual phasing-out of a software or programming language feature. ... Microsoft Windows Forms is the name given to the GUI portion of the Microsoft . ... A webform on a web page allows a user to enter data that is, typically, sent to a server for processing and to mimic the usage of paper forms. ... For other uses, see Just In Time. ... The title given to this article is incorrect due to technical limitations. ... Visual Basic . ... C++ (pronounced see plus plus, IPA: ) is a general-purpose programming language with high-level and low-level capabilities. ...


Despite this, COM remains a viable technology with an important software base. As of this writing, Microsoft has no plans for discontinuing either COM or support for COM. COM is also ideal for script control of applications such as Office or Internet Explorer since it provides an interface for calling COM object methods from a script rather than requiring knowing the API at compile time. The GUID system developed for COM has wide uses any time a unique ID is needed. A Globally Unique Identifier or GUID is a pseudo-random number used in software applications. ...


Several of the services that COM+ provides, such as transactions and queued components, are still important for enterprise .NET applications. A transaction is an agreement, communication, or movement carried out between separate entities or objects. ... A queue (pronounced /kuː/) is a particular kind of collection in which the entities in the collection are kept in order and the principal (or only) operations on the collection are the addition of entities to the rear terminal position and removal of entities from the front terminal position. ...


There is limited support for backward compatibility. A COM object may be used in .NET by implementing a runtime callable wrapper (RCW). [1] .NET objects that conform to certain interface restrictions may be used in COM objects by calling a COM callable wrapper (CCW). [2] From both the COM and .NET sides, objects using the other technology appear as native objects.


.NET's remoting model solves a number of COM's remote execution shortcomings, allowing objects to be transparently marshalled by reference or value across process or machine boundaries. . ...


Internet security

Microsoft's idea of embedding active content on web pages as COM/ActiveX components (rather than e.g. Java applets) created a combination of problems in the Internet Explorer web browser that has led to an explosion of computer virus, trojan and spyware infections. These malware attacks mostly depend on ActiveX for their activation and propagation to other computers. Microsoft recognized the problem with ActiveX as far back as 1996 when Charles Fitzgerald, program manager of Microsoft's Java team said "If you want security on the 'Net', unplug your computer. … We never made the claim up front that ActiveX is intrinsically secure." [3] As COM and ActiveX components are run as native code on the user's machine, there are fewer restrictions on what the code can do. Many of these problems have been addressed by the introduction of "code Signing" (based on digital signatures), and later by the .NET platform as well. Also, before an ActiveX control is installed, the user is prompted whether to allow the installation or not, enabling the user to disallow the installation of controls from sites that the user doesn't trust. Additionally, it is possible to disable ActiveX controls altogether, or to only allow a selected few. Windows Internet Explorer (formerly Microsoft Internet Explorer, abbreviated MSIE), commonly abbreviated to IE, is a series of proprietary graphical web browsers developed by Microsoft and included as part of the Microsoft Windows line of operating systems starting in 1995. ... A computer virus is a computer program that can copy itself and infect a computer without permission or knowledge of the user. ... In the context of computer software, a Trojan horse is a program that installs malicious software while under the guise of doing something else. ... A large number of toolbars, some added by spyware, overwhelm an Internet Explorer session. ... It has been suggested that Grayware be merged into this article or section. ... In cryptography, a digital signature or digital signature scheme is a type of asymmetric cryptography used to simulate the security properties of a signature in digital, rather than written, form. ... It has been suggested that Com interop be merged into this article or section. ...


Technical details

COM programmers build their software using COM-aware components. Different component types are identified by class IDs (CLSIDs), which are Globally Unique Identifiers, or GUIDs. Each COM component exposes its functionality through one or more interfaces. The different interfaces supported by a component are distinguished from each other using interface IDs (IIDs), which are also GUIDs. It has been suggested that this article or section be merged with Component-based software engineering. ... A Globally Unique Identifier or GUID (IPA pronunciation: or ) is a pseudo-random number used in software applications. ... An interface defines the communication boundary between two entities, such as a piece of software, a hardware device, or a user. ... A Globally Unique Identifier or GUID (IPA pronunciation: or ) is a pseudo-random number used in software applications. ...


COM interfaces have bindings in several languages, such as C, C++, Visual Basic, and several of the scripting languages implemented on the Windows platform. All access to components is done through the methods of the interfaces. This allows techniques such as inter-process, or even inter-computer programming (the latter using the support of DCOM). In computer science, binding refers to the creation of a simple reference to something which is larger and more complicated and used frequently. ... C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ... C++ (pronounced see plus plus, IPA: ) is a general-purpose programming language with high-level and low-level capabilities. ... This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ... In object-oriented programming, the term method refers to a subroutine that is exclusively associated either with a class (called class methods, static methods, or factory methods) or with an object (called instance methods). ... Distributed Component Object Model (DCOM) is a Microsoft proprietary technology for software components distributed across several networked computers to communicate with each other. ...


Interfaces

All COM components must (at the very least) implement the standard IUnknown interface, and thus all COM interfaces are derived from IUnknown. The IUnknown interface consists of three methods: AddRef() and Release(), which implement reference counting and controls the lifetime of interfaces; and QueryInterface(), which by specifying an IID allows a caller to retrieve references to the different interfaces the component implements. The effect of QueryInterface() is similar to dynamic_cast<> in C++ or casts in Java and C#. The published COM specification mandates that COM objects must minimally implement the IUnknown interface. ... This article or section does not cite any references or sources. ... In computer science, reference counting is a technique of storing the number of references, pointers, or handles to a resource such as an object or block of memory. ... C++ (pronounced see plus plus, IPA: ) is a general-purpose programming language with high-level and low-level capabilities. ... In computer science, type conversion or typecasting refers to changing an entity of one data type into another. ... “Java language” redirects here. ... The title given to this article is incorrect due to technical limitations. ...


A COM component's interfaces are required to exhibit the reflexive, symmetric, and transitive properties. The reflexive property refers to the ability for the QueryInterface() call on a given interface with the interface's ID to return the same instance of the interface. The symmetric property requires that when interface B is retrieved from interface A via QueryInterface(), interface A is retrievable from interface B as well. The transitive property is similar to the symmetric property, but requires that if interface B is obtainable from interface A and interface C is obtainable from interface B, then interface C should be retrievable from interface A. In mathematics, an equivalence relation is a binary relation between two elements of a set which groups them together as being equivalent in some way. ...


An interface consists of a pointer to a virtual function table that contains a list of pointers to the functions that implement the functions declared in the interface, in the same order that they are declared in the interface. This technique of passing structures of function pointers is very similar to the one used by OLE 1.0 to communicate with its system libraries. A virtual method table, virtual function table, dispatch table, or vtable, is a mechanism used in programming language implementations in order to support dynamic polymorphism, i. ... Object Linking and Embedding (OLE) is a technology that allows embedding and linking to documents and other objects, developed by Microsoft. ...


COM specifies many other standard interfaces used to allow inter-component communication. For example, one such interface is IStream, which is exposed by components that have data stream semantics (e.g. a FileStream component used to read or write files). It has the expected Read and Write methods to perform stream reads and writes. Another standard interface is IOleObject, which is exposed by components that expect to be linked or embedded into a container. IOleObject contains methods that allow callers to determine the size of the component's bounding rectangle, whether the component supports operations like 'Open', 'Save' and so on. The introduction to this article provides insufficient context for those unfamiliar with the subject matter. ...


Classes

A class in COM is referred to as a coclass which is the contracted form of Component Object class. A coclass is COM's language-independent way of defining a class in the object-oriented sense.


A coclass supplies concrete implementation(s) of one or more interfaces. In COM, such concrete implementations can be written in any programming language that supports COM component development, e.g. C++, Visual Basic, etc.


One of COM's major contributions to the world of Windows development is the awareness of the concept of separation of interface from implementation. This awareness has no doubt influenced the way programmers build systems today. An extension of this fundamental concept is the notion of one interface, multiple implementations. This means that at runtime, an application can choose to instantiate an interface from one of many different concrete implementations.


Interface Definition Language and type libraries

Type libraries contain metadata that represent COM types. However, these types must first be described using Microsoft Interface Definition Language. Microsoft Interface Definition Language (MIDL) is a text-based interface description language by Microsoft, based on the DCE/RPC IDL. Its compiler is also called MIDL. MSDN Reference Category: ...


This is the common practice in the development of a COM component, i.e. to start with the definition of types using IDL. An IDL file is what COM provides that allows developers to define object-oriented classes, interfaces, structures, enumerations and other user-defined types in a language independent manner. COM IDL is similar in appearance to C/C++ declarations with the addition of keywords such as "interface" and "library" for defining interfaces and collections of classes, respectively. IDL also requires the use of bracketed attributes before declarations to provide additional information, such as the GUIDs of interfaces and the relationships between pointer parameters and length fields.


The IDL file is compiled by the MIDL compiler into a pair of forms for consumption from various languages. For C/C++, the MIDL compiler generates a compiler-independent header file containing struct definitions to match the vtbls of the declared interfaces and a C file containing declarations of the interface GUIDs. C++ source code for a proxy module can also be generated by the MIDL compiler. This proxy contains method stubs for converting COM calls into Remote Procedure Calls, thus enabling DCOM. A virtual method table, virtual function table, dispatch table, or vtable, is a mechanism used in programming language implementations in order to support dynamic polymorphism, i. ... A Globally Unique Identifier or GUID (IPA pronunciation: or ) is a pseudo-random number used in software applications. ... Remote procedure call (RPC) is a protocol that allows a computer program running on one computer to cause a subroutine on another computer to be executed without the programmer explicitly coding the details for this interaction. ...


An IDL file may also be compiled by the MIDL compiler into a type library (.TLB file). The binary metadata contained within the type library is meant to be processed by language compilers and runtime environments (e.g. VB, Delphi, the .NET CLR etc). The end result of such TLB processing is that language-specific constructs are produced that represent the COM class defined in the .TLB (and ultimately that which was defined in the originating IDL file). MIDL is Microsoft Interface Definition Language (IDL) or MIDL compiler by Microsoft. ...


COM as an object framework

The fundamental principles of COM have their roots in Object-Oriented philosophies. It is a platform for the realization of Object-Oriented Development and Deployment.


Because COM is a runtime framework, types have to be individually identifiable and specifiable at runtime. To achieve this, globally unique identifiers (GUIDs) are used. Each COM type is designated its own GUID for identification at runtime (vis compile time).


In order that information on COM types be accessible at both compile time and runtime, COM presents the type library. It is through the effective use of type libraries that COM achieves its capabilities as a dynamic framework for the interaction of objects.


Consider the following example coclass definition in an IDL :

 coclass MyObject { [default] interface IMyObject; [default, source] dispinterface _IMyObjectEvents; }; 

The above code fragment declares a COM class named MyObject which must implement an interface named IMyObject and which supports (not implements) the event interface _IMyObjectEvents.


Ignoring the event interface bit, this is conceptually equivalent to defining a C++ class like this :

 class CSomeObject : public ISomeInterface { ... ... ... }; 

where ISomeInterface is a C++ pure virtual class. In software engineering, an abstract type is a type in a nominative type system which is declared by the programmer, and which has the property that it contains no members which are also not members of some declared subtype. ...


Referring once again to the MyObject COM class: once a coclass definition for it has been formalized in an IDL, and a Type Library compiled from it, the onus is on the individual language compiler to read and appropriately interpret this Type Library and then produce whatever code (in the specific compiler's language) necessary for a developer to implement and ultimately produce the binary executable code which can be deemed by COM to be of coclass MyObject.


Once an implementation of a COM coclass is built and is available in the system, next comes the question of how to instantiate it. Now, in languages like C++, we can use the CoCreateInstance() API in which we specify the CLSID (CLSID_MyObject) of the coclass as well as the interface (specified by the IID IID_IMyObject) from that coclass that we want to use to interact with that coclass. Calling CoCreateInstance() like this:

 CoCreateInstance ( CLSID_MyObject, NULL, CLSCTX_INPROC_SERVER, IID_IMyObject, (void**)&m_pIMyObject ); 

is conceptually equivalent to the following C++ code :

 ISomeInterface* pISomeInterface = new CSomeObject(); 

In the first case, we are saying to the COM sub-system that we want to obtain a pointer to an object that implements the IMyObject interface and we want coclass CLSID_MyObject's particular implementation of this interface. In the second case, we are saying that we want to create an instance of a C++ class that implements the interface ISomeInterface and we are using CSomeObject as that C++ class.


A coclass, then, is an object-oriented class in the COM world. The main feature of the coclass is that it is (1) binary in nature and consequently (2) programming language-independent.


Registry

In Windows, COM classes, interfaces and type libraries are listed by GUIDs in the registry, under HKEY_CLASSES_ROOTCLSID for classes and HKEY_CLASSES_ROOTinterface for interfaces. The COM libraries use the registry to locate either the correct local libraries for each COM object or the network location for a remote service. The Windows registry is a database which stores settings and options for the operating system for Microsoft Windows 32-bit versions, 64-bit versions and Windows Mobile. ...


Reference counting

The most fundamental COM interface of all, i.e. IUnknown (from which all COM interfaces must be derived), supports two main concepts: feature exploration through the QueryInterface method, and object lifetime management by including AddRef() and Release(). Reference counts and feature exploration apply to objects (not to each interface on an object) and thus must have a centralized implementation.


The COM specifications require a technique called reference counting to ensure that individual objects remain alive as long as there are clients which have acquired access to one or more of its interfaces and, conversely, that the same object is properly disposed of when all code that used the object have finished with it and no longer require it. A COM object is responsible for freeing its own memory once its reference count drops to zero. In computer science, reference counting is a technique of storing the number of references, pointers, or handles to a resource such as an object or block of memory. ...


For its implementation, a COM Object usually maintains an integer value that is used for reference counting. When AddRef() is called via any of object's interfaces, this integer value gets incremented. When Release() is called, this integer gets decremented. AddRef() and Release() are the only means by which a client of a COM object is able to influence its lifetime. The internal integer value remains a private member of the COM object and will never be directly accessible.


The purpose of AddRef() is to indicate to the COM object that an additional reference to itself has been affected and hence it is necessary to remain alive as long as this reference is still valid. Conversely, the purpose of Release() is to indicate to the COM object that a client (or a part of the client's code) has no further need for it and hence if this reference count has dropped to zero, it may be time to destroy itself.


Certain languages (e.g. Visual Basic) provide automatic reference counting so that COM object developers need not explicitly maintain any internal reference counter in their source codes. Using COM in C language, explicit reference counting is needed. In C++ you can do it by yourself or choose to use a smart pointer that will manage all the reference counting for you.


The following is a general guideline calling AddRef() and Release() to facilitate proper reference counting in COM object :

  • Functions (whether object methods or global functions) that return interface references (via return value or via "out" parameter) should increment the reference count of the underlying object before returning. Hence internally within the function or method, AddRef() is called on the interface reference (to be returned). An example of this is the QueryInterface() method of the IUnknown interface. Hence it is imperative that developers be aware that the returned interface reference has already been reference count incremented and not call AddRef() on the returned interface reference yet another time.
  • Release() must be called on an interface reference before that interface's pointer is overwritten or goes out of scope.
  • If a copy is made on an interface reference pointer, AddRef() should be called on that pointer. After all, in this case, we are actually creating another reference on the underlying object.
  • Addref() and Release() must be called on the specific interface which is being referenced since an object may implement per-interface reference counts in order to allocate internal resources only for the interfaces which are being referenced.
  • Extra calls to these functions are not sent out to remote objects over the wire; a proxy keeps only one reference on the remote object and maintains its own local reference count.

To facilitate and promote COM development, Microsoft introduced ATL (Active Template Library) for C++ developers. ATL provides for a higher-level COM development paradigm. It also shields COM client application developers from the need to directly maintain reference counting by providing smart pointer objects. The Active Template Library (ATL) is a set of template-based C++ classes that simplify the programming of Component Object Model (COM) objects. ... A smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic garbage collection or bounds checking. ...


Other libraries and languages that are COM-aware include the Microsoft Foundation Classes, VBScript, Visual Basic, ECMAScript (JavaScript) and Delphi. Microsoft Foundation Classes, or MFC, is a Microsoft library that wraps portions of the Windows API in C++ classes, forming an application framework. ... VBScript (short for Visual Basic Scripting Edition) is an Active Scripting language developed by Microsoft. ... This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ... ECMAScript is a scripting programming language, standardized by Ecma International in the ECMA-262 specification. ... It has been suggested that Client-side JavaScript be merged into this article or section. ... For other uses, see Delphi (disambiguation). ...


Instantiation

COM standardizes the instantiation (i.e. creation) process of COM objects by requiring the use of Class Factories. In order for a COM object to be created, two associated items must exist :

  • A Class ID.
  • A Class Factory.

Each COM Class or CoClass must be associated with a unique Class ID (a GUID). It must also be associated with its own Class Factory (that is achieved by using a centralized registry). A Class Factory is itself a COM object. It is an object that must expose the IClassFactory or IClassFactory2 (the latter with licensing support) interface. The responsibility of such an object is to create other objects.


A class factory object is usually contained within the same executable code (i.e. the server code) as the COM object itself. When a class factory is called upon to create a target object, this target object's class id must be provided. This is how the class factory knows which class of object to instantiate.


A single class factory object may create objects of more than one class. That is, two objects of different class ids may be created by the same class factory object. However, this is transparent to the COM system.


By delegating the responsibility of object creation into a separate object, a greater level of abstraction is promoted, and the developer is given greater flexibility. For example, implementation of the Singleton and other creation patterns is facilitated. Also, the calling application is shielded from the COM object's memory allocation semantics by the factory object.


In order for client applications to be able to acquire class factory objects, COM servers must properly expose them. A class factory is exposed differently, depending on the nature of the server code. A server which is DLL-based must export a DllGetClassObject() global function. A server which is EXE-based registers the class factory at runtime via the CoRegisterClassObject() Windows API function.


The following is a general outline of the sequence of object creation via its class factory :

  1. The object's class factory is obtained via the CoGetClassObject() API (a standard Windows API).
    As part of the call to CoGetClassObject(), the Class ID of the object (to be created) must be supplied. The following C++ code demonstrates this:
     IClassFactory* pIClassFactory = NULL; CoGetClassObject ( CLSID_SomeObject, CLSCTX_ALL, NULL, IID_IClassFactory, (LPVOID*)&pIClassFactory ); 
    The above code indicates that the Class Factory object of a COM object, which is identified by the class id CLSID_SomeObject, is required. This class factory object is returned by way of its IClassFactory interface.
  2. The returned class factory object is then requested to create an instance of the originally intended COM object. The following C++ code demonstrates this:
     ISomeObject* pISomeObject = NULL; if (pIClassFactory) { pIClassFactory -> CreateInstance ( NULL, IID_ISomeObject, (LPVOID*)&pISomeObject ); pIClassFactory -> Release(); pIClassFactory = NULL; } 
    The above code indicates the use of the Class Factory object's CreateInstance() method to create an object which exposes an interface identified by the IID_ISomeObject GUID. A pointer to the ISomeObject interface of this object is returned. Also note that because the class factory object is itself a COM object, it needs to be released when it is no longer required (i.e. its Release() method must be called).

The above demonstrates, at the most basic level, the use of a class factory to instantiate an object. Higher level constructs are also available, some of which do not even involve direct use of the Windows APIs.


For example, the CoCreateInstance() API can be used by an application to directly create a COM object without acquiring the object's class factory. However, internally, the CoCreateInstance() API itself will invoke the CoGetClassObject() API to obtain the object's class factory and then use the class factory's CreateInstance() method to create the COM object.


VBScript supplies the New keyword as well as the CreateObject() global function for object instantiation. These language constructs encapsulate the acquisition of the class factory object of the target object (via the CoGetClassObject() API) followed by the invocation of the IClassFactory::CreateInstance() method.


Other languages, e.g. PowerBuilder's PowerScript may also provide their own high-level object creation constructs. However, CoGetClassObject() and the IClassFactory interface remain the most fundamental object creation technique.


Reflection

At the time of the inception of COM technologies, the only way for a client to find out what features an object would offer, was to actually create one instance and call into its QueryInterface method (part of the required IUnknown interface).


This way of exploration became awkward for many applications, including the selection of appropriate components for a certain task, and tools to help a developer understand how to use methods provided by an object.


As a result, COM Type Libraries were introduced, through which components can describe themselves. A type library contains information such as the CLSID of a component, the IIDs of the interfaces the component implements, and descriptions of each of the methods of those interfaces. Type libraries are typically used by RAD environments such as Visual Basic or Visual Studio to assist developers of client applications. This article is about the Visual Basic language shipping with Microsoft Visual Studio 6. ... Microsoft Visual Studio is a series of IDEs by Microsoft. ...


Programming

COM is a binary standard (also said to be language agnostic) and may be developed in any programming language capable of understanding and implementing its binary defined data types and interfaces.


Runtime libraries (in extreme situations, the programmers) are responsible for entering and leaving the COM environment, instantiating and reference counting COM objects, querying objects for version information, coding to take advantage of advanced object versions, and coding graceful degradation of function when newer versions aren't available. Graceful degradation is a property of a computer system whereby it reacts safely and proportionately to erroneous or unexpected circumstances. ...


Application and network transparency

COM objects may be instantiated and referenced from within a process, across process boundaries within a computer, and across a network, using the DCOM technology. Out-of-process and remote objects may use marshalling to send method calls and return values back and forth. The marshalling is invisible to the object and the code using the object. See serial publication for the term in publishing In computer science, serialization means to force one-at-a-time access for the purposes of concurrency control, or to encode a data structure as a sequence of bytes. ...


Threading in COM

In COM, threading issues are addressed by a concept known as "apartment models". Here the term "apartment" refers to an execution context wherein a single thread or a group of threads is associated with one or more COM objects.


Apartments stipulate the following general guidelines for participating threads and objects:

  • Each COM object is associated with one and only one apartment. This is decided at the time the object is created at runtime. After this initial setup, the object remains in that apartment throughout its lifetime.
  • A COM thread (i.e., a thread in which COM objects are created or COM method calls are made) is also associated with an apartment. Like COM objects, the apartment with which a thread is associated is also decided at initialization time. Each COM thread also remains in its designated apartment until it terminates.
  • Threads and objects which belong to the same apartment are said to follow the same thread access rules. Method calls which are made inside the same apartment are performed directly without any assistance from COM.
  • Threads and objects from different apartments are said to play by different thread access rules. Method calls made across apartments are achieved via marshalling. This requires the use of proxies and stubs.

There are three types of Apartment Models in the COM world: Single-Threaded Apartment (STA), Multi-Threaded Apartment (MTA), and Neutral Apartment. Each apartment represents one mechanism whereby an object's internal state may be synchronized across multiple threads.


The Single-Threaded Apartment (STA) model is a very commonly used model. Here, a COM object stands in a position similar to a desktop application's user interface. In an STA model, a single thread is dedicated to drive an object's methods, i.e. a single thread is always used to execute the methods of the object. In such an arrangement, method calls from threads outside of the apartment are marshalled and automatically queued by the system (via a standard Windows message queue). Thus, there is no worry about race conditions or lack of synchronicity because each method call of an object is always executed to completion before another is invoked. In computer science, in the context of data storage and transmission, serialization is the process of saving an object onto a storage medium (such as a file, or a memory buffer) or to transmit it across a network connection link, either in binary form, or in some human-readable text...


If the COM object's methods perform their own synchronization, multiple threads dedicated to calling methods on the COM object are permitted. This is termed the Multiple Threaded Apartment (MTA). Calls to an MTA object from a thread in an STA are also marshaled. A process can consist of multiple COM objects, some of which may use STA and others of which may use MTA. The Thread Neutral Apartment allows different threads, none of which is necessarily dedicated to calling methods on the object, to make such calls. The only proviso is that all methods on the object must be serially reentrant.


Criticisms

Since COM has a fairly complex implementation, programmers can be distracted by some of the "plumbing" issues.


Message pumping

When an STA is initialized it creates a hidden window that is used for inter-apartment and inter-process message routing. This window must have its message queue regularly pumped. This construct is known as a message pump. On earlier versions of Windows failure to do so could cause system-wide deadlocks. This problem is especially nasty because some Windows APIs initialize COM as part of their implementation, which causes a leak of implementation details. In computer science, the event loop, message loop or message pump is a programming construct that waits for and dispatches events or messages in a program. ...


Reference counting

Reference counting within COM may cause problems if two or more objects are circularly referenced. The design of an application must take this into account so that objects are not left orphaned. A circular reference, or sometimes known as a run-around by some people, is a series of references where the last object references the first, thus causing the whole series of references to be unusable. ...


Objects may also be left with active reference counts if the COM "event sink" model is used. Since the object that fires the event needs a reference to the object reacting to the event, the object's reference count will never reach zero.


Reference cycles are typically broken using either out-of-band termination or split identities. In the out of band termination technique, an object exposes a method which, when called, forces it to drop its references to other objects, thereby breaking the cycle. In the split identity technique, a single implementation exposes two separate COM objects (also known as identities). This creates a weak reference between the COM objects, preventing a reference cycle. In computer programming, a weak reference is a reference that does not protect the referent object from collection by a garbage collector. ...


DLL hell

Because the location of each component is stored in a system-wide location (the Windows registry), there can be only one version of a certain component installed. Thus, COM seriously suffers from DLL hell, where two or more applications require different versions of the same component. The Windows registry is a database which stores settings and options for the operating system for Microsoft Windows 32-bit versions, 64-bit versions and Windows Mobile. ... DLL hell is a colorful term given to any problem based on a difficulty in managing Dynamically Linked Libraries (DLLs) installed on a particular copy of an operating system. ...


Windows XP introduced a new mode of COM object registration called "Registration-free COM". This facility makes it possible for applications that need to install COM objects to store all the required COM registry information in the application's directory, instead of in the global registry, where, strictly speaking only a single application will ever use it. DLL hell can be substantially avoided using Registration-free COM, the only limitation being it requires at least Windows XP or later Windows versions and that it must not be used for EXE COM servers or system-wide components such as MDAC, MSXML, DirectX or Internet Explorer. Windows XP is a line of operating systems developed by Microsoft for use on general-purpose computer systems, including home and business desktops, notebook computers, and media centers. ... Windows XP is a line of operating systems developed by Microsoft for use on general-purpose computer systems, including home and business desktops, notebook computers, and media centers. ... MDAC, or Microsoft Data Access Components, is a group of Microsoft technologies that interact together as a framework that allows programmers a uniform and comprehensive way of developing applications for accessing almost any data store. ... Microsoft XML Core Services (MSXML) is a set of services that allow applications written in JScript, VBScript and Microsoft Visual Studio 6. ... Microsoft DirectX is a collection of application programming interfaces for handling tasks related to multimedia, especially game programming and video, on Microsoft platforms. ... Windows Internet Explorer (formerly Microsoft Internet Explorer, abbreviated MSIE), commonly abbreviated to IE, is a series of proprietary graphical web browsers developed by Microsoft and included as part of the Microsoft Windows line of operating systems starting in 1995. ...


References

is the 66th day of the year (67th in leap years) in the Gregorian calendar. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... Don Box is a technical author and one of the original four designers of SOAP, a basic messaging layer for web services. ...

See also

Distributed Component Object Model (DCOM) is a Microsoft proprietary technology for software components distributed across several networked computers to communicate with each other. ... Dynamic Data Exchange (DDE) is a technology for communication between multiple applications under Microsoft Windows and also OS/2. ... It has been suggested that Com interop be merged into this article or section. ... Object Linking and Embedding (OLE) is a technology that allows embedding and linking to documents and other objects, developed by Microsoft. ... It has been suggested that this article or section be merged with Component-based software engineering. ...

External links

  • Microsoft COM Technologies
  • Interview with Tony Williams, Co-Inventor of COM (Video Webcast, August 2006)
  • What OLE is Really About by Kraig Brockschmidt. An Overview of COM and OLE.
  • Component Application Group at Microsoft Research
  • Mozilla ActiveX Project
  • Introduction to COM – basic introduction on how to use COM-components, CodeProject
  • Info: Difference Between OLE Controls and ActiveX Controls from Microsoft
  • Understanding The COM Single-Threaded Apartment Part 1
  • Understanding The COM Single-Threaded Apartment Part 2
  • Component Object Model (COM), DCOM, and Related Capabilities A Carnegie Melon Software Engineering Institute presentation of COM, DCOM and related technologies.

Java

The BSD license is a permissive license and is one of the most widely used free software licenses. ... “Java language” redirects here. ... Component Object Model (COM) is a platform for software componentry introduced by Microsoft in 1993. ...

Other languages

  • COM in plain C a tutorial on writing COM components in the C programming language.
  • Step by Step COM Tutorial A step-by-step guide to creating COM components using Visual C++ – without the help of ATL or MFC By Saurabh Dasgupta.
  • Delphi COM Essentials at Techvanguards.
  • Building COM Servers in .NET

  Results from FactBites:
 
Component Object Model - Wikipedia, the free encyclopedia (4288 words)
COM is also ideal for script control of applications such as Office or Internet Explorer since it provides an interface for calling COM object methods from a script rather than requiring knowing the API at compile time.
COM programmers are responsible for entering and leaving the COM environment, instantiating and reference counting COM objects, querying objects for version information, coding to take advantage of advanced object versions, and coding graceful degradation of function when newer versions aren't available.
COM objects may be instantiated and referenced from within a process, across process boundaries within a computer, and across a network, using the DCOM technology.
OLE Component Object Model (4073 words)
The Component Object Model is polymorphic in the sense that what appears to be the same request can be sent to any interface supporting the requested operation; the interfaces need not refer to objects of the same class.
Object references (pointers) in Windows Objects are not references to the object itself, as in C++, but rather are pointers to one of the object's interfaces.
In the Component Object Model, inheritance is simply considered as a language-specific tool (e.g., in C++) that may be useful for implementing classes and defining interfaces in that language.
  More results at FactBites »

 
 

COMMENTARY     


Share your thoughts, questions and commentary here
Your name
Your comments

Want to know more?
Search encyclopedia, statistics and forums:

 


Press Releases |  Feeds | Contact
The Wikipedia article included on this page is licensed under the GFDL.
Images may be subject to relevant owners' copyright.
All other elements are (c) copyright NationMaster.com 2003-5. All Rights Reserved.
Usage implies agreement with terms, 1022, m