Component object model - wikipedia Component object model This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. ( April 2008 ) Component Object Model ( COM ) is a binary - interface standard for software components introduced by Microsoft in 1993. It is used to enable inter-process communication object creation in a large range of programming languages. COM is the basis for several other Microsoft technologies and frameworks, including OLE, OLE Automation, Browser Helper Object, ActiveX, COM+, DCOM, the Windows shell, DirectX, UMDF and Windows Runtime. The essence of COM is a language - neutral way of implementing objects that can be used in environments different from the one in which they were created, even across machine boundaries. For well - authored components, COM allows reuse of objects with no knowledge of their internal implementation, as it forces component implementers to provide well - defined interfaces that are separated from the implementation. The different allocation semantics of languages are accommodated by making objects responsible for their own creation and destruction through reference - counting. Type conversion casting between different interfaces of an object is achieved through the QueryInterface method. The preferred method of `` inheritance '' within COM is the creation of sub-objects to which method `` calls '' are delegated. COM is an interface technology defined and implemented as standard only on Microsoft Windows and Apple 's Core Foundation 1.3 and later plug - in application programming interface ( API ). The latter only implements a subset of the whole COM interface. For some applications, COM has been replaced at least to some extent by the Microsoft. NET framework, and support for Web Services through the Windows Communication Foundation ( WCF ). However, COM objects can be used with all. NET languages through. NET COM Interop. Networked DCOM uses binary proprietary formats, while WCF encourages the use of XML - based SOAP messaging. COM is very similar to other component software interface technologies, such as CORBA and Enterprise JavaBeans, although each has its own strengths and weaknesses. Unlike C++, COM provides a stable application binary interface ( ABI ) that does not change between compiler releases. This makes COM interfaces attractive for object - oriented C++ libraries that are to be used by clients compiled using different compiler versions. Contents 1 History 2 Related technologies 2.1 COM+ and DCOM 2.2. NET 2.3 Windows Runtime 3 Security 4 Technical details 4.1 Interfaces 4.2 Classes 4.3 Interface Definition Language and type libraries 4.4 COM as an object framework 4.5 Reference counting 4.6 Programming 4.7 Registry usage 4.8 Registration - free COM 4.9 Manually instantiating COM objects 4.10 Process and network transparency 4.11 Threading 5 Criticisms 5.1 Message pumping 5.2 Reference counting 5.3 DLL Hell 6 See also 7 Notes 8 References 9 External links History One of the first methods of interprocess communication in Windows was Dynamic Data Exchange ( DDE ), first introduced in 1987, that allowed sending and receiving messages in so - called `` conversations '' between applications. Antony Williams involved in the creation of the COM architecture, later distributed two 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 of the ideas behind COM. Object Linking and Embedding ( OLE ), Microsoft 's first object - based framework, was built on top of 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. In 1991, Microsoft have introduced Visual Basic Extensions ( VBX ) with Visual Basic 1.0. A VBX is a packaged extension in the form of a dynamic - link library ( DLL ) that allows 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++. In 1992, when version 3.1 of Windows was released, Microsoft released OLE 2 with its underlying object model. The COM Application binary interface ( ABI ) was the same as the MAPI ABI, which was released in 1992. While OLE 1 was focused on compound documents, COM and OLE 2 were designed to address software components in general. Text conversations and Windows messages had proved not to be flexible enough to allow sharing application features in a robust and extensible way, so COM was created as a new foundation, and OLE changed to OLE2. In 1994 OLE custom controls ( OCXs ) 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 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. Related technologies COM was the major software development platform for Windows and, as such, influenced development of a number of supporting technologies. COM+ and DCOM In order for Microsoft to provide developers with support for distributed transactions, resource pooling, disconnected applications, event publication and subscription, better memory and processor ( thread ) management, as well as to position Windows as an alternative to other enterprise - level operating systems, Microsoft introduced a technology called Microsoft Transaction Server ( MTS ) on Windows NT 4. 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 de-emphasized DCOM as a separate entity. Components that made use of COM+ services were handled more directly by the added layer of COM+, in particular by operating system support for interception. In the first release of MTS, interception was tacked on - installing an MTS component would modify the Windows Registry to call the MTS software, and not the component directly. Windows 2000 also revised the Component Services control panel application used to configure COM+ components. An advantage of COM+ was that it could be run in `` component farms ''. Instances of a component, if coded properly, could be pooled and reused by new calls to its initializing routine without unloading it from memory. Components could also be distributed ( called from another machine ). COM+ and Microsoft Visual Studio provided tools to make it easy to generate client - side proxies, so although DCOM was used to make the remote call, it was easy to do for developers. 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 ( see Late binding ) events or method calls between the publisher or subscriber and the event system.. NET Main article :. NET Framework Microsoft. NET provides means both to provide component technology, and to interact with COM+ ( via COM - interop - assemblies ) ;. NET provides wrappers to most of the commonly used COM controls. Microsoft. NET hides most detail from component creation and therefore eases development... NET can leverage COM+ via the System. EnterpriseServices namespace, and several of the services that COM+ provides have been duplicated in recent releases of. NET. For example, the System. Transactions namespace in. NET provides the TransactionScope class, which provides transaction management without resorting to COM+. Similarly, queued components can be replaced by Windows Communication Foundation with an MSMQ transport. ( MSMQ is a native COM component, however. ) There is limited support for backward compatibility. A COM object may be used in. NET by implementing a Runtime Callable Wrapper ( RCW ). NET objects that conform to certain interface restrictions may be used in COM objects by calling a COM callable wrapper ( CCW ). From both the COM and. NET sides, objects using the other technology appear as native objects. See COM Interop. WCF ( Windows Communication Foundation ) eases a number of COM 's remote execution challenges. For instance, it allows objects to be transparently marshalled by value across process or machine boundaries more easily. Windows runtime Main article : Windows Runtime Microsoft 's new Windows Runtime ( or WinRT, not to be confused with Windows RT ) programming and application model is essentially a COM - based API, although it relies on an enhanced COM. Because of its COM - like basis, Windows Runtime allows relatively easy interfacing from multiple languages, just as COM does, but it is essentially an unmanaged, native API. The API definitions are, however, stored in ``. winmd '' files, which are encoded in ECMA 335 metadata format, the same CLI metadata format that. NET uses with a few modifications. This common metadata format allows for significantly less overhead than P / Invoke when WinRT is invoked from. NET applications, and its syntax is much simpler. Security COM and ActiveX components are run as native code on the user 's machine, with no sandboxing. There are therefore few restrictions on what the code can do. The prior practice of embedding ActiveX components on web pages with Internet Explorer did therefore lead to problems with malware infections. Microsoft recognized the problem with ActiveX as far back as 1996 when Charles Fitzgerald said, `` We never made the claim up front that ActiveX is intrinsically secure ''. Recent versions of Internet Explorer prompt the user before installing ActiveX controls, enabling the user to disallow installation of controls from sites that the user does not trust. The ActiveX controls are signed with digital signatures to guarantee their authenticity. It is also possible to disable ActiveX controls altogether, or to allow only a selected few. The transparent support for out - of - process COM servers still promotes software safety in terms of process isolation. This can be useful for decoupling subsystems of large application into separate processes. Process isolation limits state corruption in one process from negatively affecting the integrity of the other processes, since they only communicate through strictly defined interfaces. Thus, only the affected subsystem needs to be restarted in order to regain valid state. This is not the case for subsystems within the same process, where a rogue pointer in one subsystem can randomly corrupt other subsystems. 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 ( 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 GUIDs too. COM interfaces have bindings in several languages, such as C, C++, Visual Basic, Delphi, Python 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 ). Interfaces All COM components implement the IUnknown ( custom ) interface, which exposes methods for reference counting and type conversion ( casting ). A custom IUnknown interface consists of a pointer to a virtual method 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. The in - process invocation overhead is therefore comparable to virtual method calls in C++. In addition to custom interfaces, COM also supports dispatch interfaces inheriting from IDispatch. Dispatch interfaces support late binding for OLE Automation. This allows dispatch interfaces to be natively accessed from a wider range of programming languages than custom interfaces. Classes A COM class ( `` coclass '' ) is a concrete implementation of one or more interfaces, and closely resembles classes in object - oriented programming languages. Classes are created based on their class ID ( CLSID ) or based on their programmatic identifier string ( progid ). Like many object - oriented languages, COM provides a separation of interface from implementation. This distinction is especially strong in COM, where objects can not be accessed directly, but only through their interfaces. COM also has support for multiple implementations of the same interface, so that clients at runtime can choose which implementation of an interface to instantiate. Interface definition language and type libraries Type libraries contain metadata to represent COM types. These types are described using Microsoft Interface Definition Language ( MSIDL / IDL ). IDL files define object - oriented classes, interfaces, structures, enumerations and other user - defined types in a language independent manner. IDL is similar in appearance to C++ declarations with some additional keywords such as `` interface '' and `` library '' for defining interfaces and collections of classes. IDL also supports the use of bracketed attributes before declarations to provide additional information, such as interface GUIDs and the relationships between pointer parameters and length fields. IDL files are compiled by the MIDL compiler. 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 to enable DCOM for out - of - process communication. IDL files can also be compiled by the MIDL compiler into a type library ( TLB ). TLB files contain binary metadata that can be processed by different language compilers and runtime environments ( e.g. VB, Delphi,. NET etc. ) to generate language - specific constructs to represent the COM types defined in the TLB. For C++, this will convert the TLB back to its IDL representation. COM as an object framework 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. In order for information on COM types to be accessible at both compile time and runtime, COM uses type libraries. 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 SomeClass ( ( default ) interface ISomeInterface ; ) ; The above code fragment declares a COM class named SomeClass which implements an interface named ISomeInterface. This is conceptually equivalent to defining the following C++ class : class SomeClass : public ISomeInterface (... ) ; where ISomeInterface is a C++ pure virtual class. The IDL files containing COM interfaces and classes are compiled into type libraries ( TLB ) files, which can later be parsed by clients at runtime to determine which interfaces an object supports, and invoke an object 's interface methods. In C++, COM objects are instantiated with the CoCreateInstance function that takes the class ID ( CLSID ) and interface ID ( IID ) as arguments. Instantiation of SomeClass can be implemented as follows : ISomeInterface * interface_ptr = NULL ; HRESULT hr = CoCreateInstance ( CLSID_SomeClass, NULL, CLSCTX_ALL, IID_ISomeInterface, ( void * * ) &interface_ptr ) ; In this example, the COM sub-system is used to obtain a pointer to an object that implements ISomeInterface interface, and coclass CLSID_SomeClass 's particular implementation of this interface is required. Reference counting All COM objects utilize reference counting to manage object lifetimes. The reference counts are controlled by the clients through the AddRef and Release methods in the mandatory IUnknown interface that all COM objects implement. COM objects are then responsible for freeing their own memory when the reference count drops to zero. 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. In C++, a coder may either perform explicit reference counting or use smart pointers to automatically manage the reference counts. The following are guidelines for when to call AddRef and Release on COM objects : Functions and methods that return interface references ( via return value or via `` out '' parameter ) shall increment the reference count of the returned object before returning. Release must be called on an interface pointer before the 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. 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. Not all reference count calls are sent to remote objects over the wire ; a proxy keeps only one reference on the remote object and maintains its own local reference count. To simplify 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. Other libraries and languages that are COM - aware include the Microsoft Foundation Classes, the VC Compiler COM Support, VBScript, Visual Basic, ECMAScript ( JavaScript ) and Borland Delphi. Programming COM is a language agnostic binary standard that can be developed in any programming language capable of understanding and implementing its binary defined data types and interfaces. COM implementations are responsible for entering and leaving the COM environment, instantiating and reference - counting COM objects, querying objects for supported interfaces, as well as handling errors. The Microsoft Visual C++ compiler supports extensions to the C++ language referred to as C++ Attributes. These extensions are designed to simplify COM development and remove much of the plumbing code required to implement COM servers in C++. Registry usage In Windows, COM classes, interfaces and type libraries are listed by GUIDs in the registry, under HKEY_CLASSES_ROOT CLSID for classes and HKEY_CLASSES_ROOT Interface for interfaces. COM libraries use the registry to locate either the correct local libraries for each COM object or the network location for a remote service. Registration - free COM Registration - Free COM ( RegFree COM ) is a technology introduced with Windows XP that allows Component Object Model ( COM ) components to store activation metadata and CLSID ( Class ID ) for the component without using the registry. Instead, the metadata and CLSIDs of the classes implemented in the component are declared in an assembly manifest ( described using XML ), stored either as a resource in the executable or as a separate file installed with the component. This allows multiple versions of the same component to be installed in different directories, described by their own manifests, as well as XCOPY deployment. This technique has limited support for EXE COM servers and can not be used for system - wide components such as MDAC, MSXML, DirectX or Internet Explorer. During application loading, the Windows loader searches for the manifest. If it is present, the loader adds information from it to the activation context. When the COM class factory tries to instantiate a class, the activation context is first checked to see if an implementation for the CLSID can be found. Only if the lookup fails is the registry scanned. Manually instantiating COM objects COM objects can also be created manually, given the path of the DLL file and GUID of the object. This does not require the DLL or GUID to be registered in the system registry, and does not make use of manifest files. A COM DLL exports a function named DllGetClassObject. Calling DllGetClassObject with the desired GUID and IID_IClassFactory provides an instance of a factory object. The Factory object has a CreateInstance method, which can create instances of an object given an interface GUID. This is the same process internally used when creating instances of registered COM components. If the created COM object instantiates another COM object using the generic CoCreateInstance API, it will try to do so in the usual generic way, using the registry or manifest files. But it can create internal objects ( which may not be registered at all ), and hand out references to interfaces to them, using its own private knowledge. Process and network transparency COM objects can be transparently instantiated and referenced from within the same process ( in - process ), across process boundaries ( out - of - process ), or remotely over the network ( DCOM ). Out - of - process and remote objects use marshalling to serialize method calls and return values over process or network boundaries. This marshalling is invisible to the client, which accesses the object as if it were a local in - process object. Threading In COM, threading is addressed through a concept known as apartments. An individual COM object lives in exactly one apartment, which might either be single - threaded or multi-threaded. There are three types of apartments in COM : Single - Threaded Apartment ( STA ), Multi-Threaded Apartment ( MTA ), and Thread Neutral Apartment ( NA ). Each apartment represents one mechanism whereby an object 's internal state may be synchronized across multiple threads. A process can consist of multiple COM objects, some of which may use STA and others of which may use MTA. All threads accessing COM objects similarly live in one apartment. The choice of apartment for COM objects and threads are determined at run - time, and can not be changed. Apartment type Description Single - Threaded Apartment ( STA ), ( ThreadingModel = Apartment ) A single thread is dedicated 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, the COM run - time provides automatic synchronization to ensure that each method call of an object is always executed to completion before another is invoked. The developer therefore does not need to worry about thread locking or race conditions. Multi-Threaded Apartment ( MTA ), ( ThreadingModel = Free ) The COM run - time provides no synchronization, and multiple threads are allowed to call COM objects simultaneously. COM objects therefore need to perform their own synchronization to prevent simultaneous access from multiple threads from causing a race condition. Calls to an MTA object from a thread in an STA are also marshalled. Dynamically determined apartment ( ThreadingModel = Both ) In the Both apartment mode, the server auto - selects STA or MTA at object creation to match the apartment type of the calling thread. This can be useful to avoid marshaling overhead when MTA servers are accessed by a STA thread. Thread Neutral Apartment ( NA ), ( ThreadingModel = Neutral ) A special apartment without any assigned threads. When a STA or MTA thread calls a NA object in the same process, then the calling thread temporarily leaves its apartment and executes code directly in the NA without any thread switching. Therefore, one can think of NA as an optimization for efficient interapartment method calls. Threads and objects which belong to the same apartment follow the same thread access rules. Method calls which are made inside the same apartment are therefore performed directly without any assistance from COM. Method calls made across apartments are achieved via marshalling. This requires the use of proxies and stubs. 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 complicated by some Windows APIs that initialize COM as part of their implementation, which causes a `` leak '' of implementation details. 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. 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 latter '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. DLL Hell Because in - process COM components are implemented in DLL files and registration only allows for a single version per CLSID they might in some situations be subject to the `` DLL Hell '' effect. Registration - free COM capability attempts to work around this problem. See also Portable object ( computing ) cross language cross platform Object Model definition Distributed Component Object Model ( DCOM ), extension making COM able to work in networks Common Language Infrastructure current. NET cross language cross platform Object Model Windows Runtime, an application model, evolved version of COM targeting Windows 8 CORBA Common Object Request Broker Architecture, open cross language cross platform object model D - Bus open cross language cross platform Object Model KParts KDE component framework SOM IBM System Object Model, feature - rich alternative to COM XPCOM Mozilla applications cross Platform Component Object Model Enterprise JavaBeans Java Remote Method Invocation Internet Communications Engine Language binding Foreign function interface Calling convention Name mangling Application programming interface - API Application Binary Interface - ABI SWIG opensource automatic interfaces bindings generator from many languages to other languages Notes Jump up ^ ( 1 ) Jump up ^ `` Plug - ins and Microsoft 's COM ''. Apple Inc. Retrieved 2010 - 10 - 05. Jump up ^ Microsoft forum : Binary compatibility across Visual C++ versions Jump up ^ Runtime Callable Wrapper -- MSDN Library Jump up ^ COM callable wrapper -- MSDN Library Jump up ^ https://web.archive.org/web/20060810235058/http://www.javaworld.com/javaworld/jw-03-1997/jw-03-component.web97.html Jump up ^ http://docs.activestate.com/activepython/2.4/pywin32/html/com/win32com/HTML/docindex.html Jump up ^ http://www.boddie.org.uk/python/COM.html Jump up ^ `` Compiler COM Support ''. MSDN. Microsoft. Jump up ^ Microsoft MSDN : C++ Attributes Reference Jump up ^ MSDN Magazine : C++ Attributes : Make COM Programming a Breeze with New Feature in Visual Studio. NET Jump up ^ `` Assembly Manifests ''. MSDN. Retrieved 2009 - 11 - 05. ^ Jump up to : Dave Templin. `` Simplify App Deployment with ClickOnce and Registration - Free COM ''. MSDN Magazine. Retrieved 2008 - 04 - 22. Jump up ^ `` How to use an out - of - process COM server without its tlb file ''. Retrieved 2011 - 04 - 16. Jump up ^ `` Concepts of Isolated Applications and Side - by - side Assemblies ''. MSDN. Retrieved 2016 - 02 - 05. Jump up ^ Arkhipov, Mikhail ( 1 April 2005 ). `` Registration - free COM ''. MSDN Blogs. Retrieved 29 April 2016. Jump up ^ `` DllGetClassObject entry point ( COM ) ''. MSDN. If a call to the CoGetClassObject function finds the class object that is to be loaded in a DLL, CoGetClassObject uses the DLL 's exported DllGetClassObject function. Jump up ^ Microsoft MSDN : Processes, Threads, and Apartments Jump up ^ Microsoft MSDN : Single - Threaded Apartments Jump up ^ Microsoft MSDN : Multithreaded Apartments Jump up ^ Microsoft MSDN : Understanding and Using COM Threading Models Jump up ^ Codeguru : Understanding COM Apartments References `` COM : A Brief Introduction ( powerpoint ) ''. Retrieved March 7, 2006. Box, Don ( 1998 ). Essential COM. Addison - Wesley. ISBN 0 - 201 - 63446 - 5. Chappell, David ( 1996 ). Understanding ActiveX and OLE. Microsoft Press. ISBN 978 - 1 - 57231 - 216 - 6. `` Integration and Migration of COM+ services to WCF ''. Retrieved April 15, 2010. External links Component Object Model on MSDN Interview with Tony Williams, Co-Inventor of COM ( Video Webcast, August 2006 ) Info : Difference Between OLE Controls and ActiveX Controls from Microsoft TypeLib Data Format Specification ( unofficial ) with open source dumper utility. The COM / DCOM Glossary hide Microsoft APIs and frameworks Graphics Desktop Window Manager Direct2D Direct3D D3D ( extensions ) GDI / GDI+ WPF Silverlight WinRT XAML Windows Color System Windows Image Acquisition Windows Imaging Component DirectX Graphics Infrastructure ( DXGI ) Windows Advanced Rasterization Platform WinG Audio DirectMusic DirectSound DirectX plugin XACT Speech API XAudio2 Multimedia DirectX Media Objects Video Acceleration Xinput DirectInput DirectShow Image Mastering API Managed DirectX Media Foundation XNA Windows Media Video for Windows Web MSHTML RSS Platform JScript VBScript BHO XDR SideBar Gadgets TypeScript Data access Data Access Components ( MDAC ) ADO ADO.NET ODBC OLE DB Extensible Storage Engine Entity Framework Sync Framework Jet Engine MSXML OPC Networking Winsock LSP Winsock Kernel Filtering Platform NDIS Windows Rally BITS P2P API MSMQ MS MPI DirectPlay Communication Messaging API Telephony API WCF Administration and management Win32 console Windows Script Host WMI ( extensions ) PowerShell Task Scheduler Offline Files Shadow Copy Windows Installer Error Reporting Event Log Common Log File System Component model COM COM+ ActiveX Distributed Component Object Model. NET Framework Libraries Framework Class Library Microsoft Foundation Classes ( MFC ) Active Template Library ( ATL ) Windows Template Library ( WTL ) Device drivers WDM WDF KMDF UMDF WDDM NDIS UAA BDA VxD Security Crypto API CAPICOM Windows CardSpace Data Protection API Security Support Provider Interface ( SSPI ). NET ASP.NET ADO.NET Remoting Silverlight TPL WCF WCS WPF WF Software factories EFx Factory Enterprise Library Composite UI CCF CSF IPC MSRPC Dynamic Data Exchange ( DDE ) Remoting WCF Accessibility Active Accessibility UI Automation Text and multilingual support DirectWrite Text Services Framework Text Object Model Input method editor Language Interface Pack Multilingual User Interface Uniscribe hide Microsoft Windows components Management tools App Installer Command Prompt Control Panel Applets Device Manager Disk Cleanup Disk Defragmenter Driver Verifier Event Viewer IExpress Management Console Netsh Performance Monitor Recovery Console Resource Monitor Settings Sysprep System Configuration System File Checker System Information System Policy Editor System Restore Task Manager Windows Error Reporting Windows Ink Windows Installer PowerShell Windows Update Windows Insider WinRE WMI Apps Alarms & Clock Calculator Calendar Camera Character Map Cortana Edge Fax and Scan Feedback Hub File Manager Get Help Groove Music Magnifier Mail Messaging Maps Media Player Movies & TV Mobility Center Money News Narrator Notepad OneDrive OneNote Paint Paint 3D People Phone Companion Photos Quick Assist Snipping Tool Speech Recognition Skype Sports Sticky Notes View 3D Store Tips Voice Recorder Wallet Weather Windows To Go Windows Story Remix WordPad Xbox Shell Action Center Aero AutoPlay AutoRun ClearType Explorer Search Indexing Service IFilter Saved search Namespace Special folder Start menu Taskbar Task View Windows Spotlight Windows XP visual styles Services Service Control Manager BITS CLFS Multimedia Class Scheduler Shadow Copy Task Scheduler Error Reporting Wireless Zero Configuration File systems CDFS DFS exFAT IFS FAT NTFS Hard link Junction point Mount Point Reparse point Symbolic link TxF EFS ReFS UDF Server Domains Active Directory DNS Group Policy Roaming user profiles Folder redirection Distributed Transaction Coordinator MSMQ Windows Media Services Rights Management Services IIS Remote Desktop Services WSUS SharePoint Network Access Protection PWS DFS Replication Remote Differential Compression Print Services for UNIX Remote Installation Services Windows Deployment Services System Resource Manager Hyper - V Server Core Architecture Architecture of Windows NT Startup process NT Vista CSRSS Desktop Window Manager Portable Executable EXE DLL Enhanced Write Filter Graphics Device Interface hal. dll I / O request packet Imaging Format Kernel Transaction Manager Library files Logical Disk Manager LSASS MinWin NTLDR Ntoskrnl. exe Object Manager Open XML Paper Specification Registry Resource Protection Security Account Manager Server Message Block Shadow Copy SMSS System Idle Process USER WHEA Win32 console Winlogon WinUSB Security Security and Maintenance BitLocker Data Execution Prevention Family Safety Kernel Patch Protection Mandatory Integrity Control Protected Media Path User Account Control User Interface Privilege Isolation Windows Defender Windows Firewall Compatibility COMMAND.COM Virtual DOS machine Windows on Windows WoW64 Windows Subsystem for Linux API Active Scripting WSH VBScript JScript COM ActiveX ActiveX Document COM Structured storage DCOM OLE OLE Automation Transaction Server DirectX. NET Framework Universal Windows Platform Windows Mixed Reality Windows Runtime WinUSB Games Solitaire Collection Discontinued Games 3D Pinball Chess Titans FreeCell Hearts InkBall Hold ' Em Purble Place Reversi Spider Solitaire Solitaire Tinker Apps ActiveMovie Anytime Upgrade Address Book Backup and Restore Cardfile CardSpace Contacts Desktop Gadgets Diagnostics DriveSpace DVD Maker Easy Transfer Fax Food & Drink Help and Support Center Health & Fitness HyperTerminal Internet Explorer Journal Media Center Meeting Space Messaging Messenger Mobile Device Center Movie Maker MSN Dial - up NetMeeting NTBackup Outlook Express Travel Photo Gallery Photo Viewer Program Manager Steps Recorder WinHelp Write Others ScanDisk File Protection Media Control Interface Next - Generation Secure Computing Base POSIX subsystem Interix Video for Windows Windows SideShow Windows Services for UNIX Windows System Assessment Tool WinFS Spun off to Microsoft Store DVD Player Hover ! Mahjong Minesweeper Retrieved from `` https://en.wikipedia.org/w/index.php?title=Component_Object_Model&oldid=844055450 '' Categories : Component - based software engineering Inter-process communication Microsoft application programming interfaces Object models Object request broker Object - oriented programming Hidden categories : Articles needing additional references from April 2008 All articles needing additional references All articles with vague or ambiguous time Vague or ambiguous time from August 2016 Talk Search Contents About Wikipedia Azərbaycanca Čeština Dansk Deutsch Español فارسی Français 한국어 Italiano עברית Magyar Монгол Nederlands 日本 語 Polski Português Русский Slovenčina Svenska Українська 中文 12 more Edit links This page was last edited on 2 June 2018, at 08 : 56. Text is available under the Creative Commons Attribution - ShareAlike License ; additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia ® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization. About Wikipedia

Question: what is component object model in c#
Answer: a binary-interface standard for software components introduced by Microsoft in 1993