Misplaced Pages

#843156

53-684: Component Object Model ( COM ) is a binary-interface technology for software components from Microsoft that enables using objects in a language-neutral way between different programming languages , programming contexts, processes and machines . COM is the basis for other Microsoft domain specific component technologies including OLE , OLE Automation , ActiveX , COM+ , and DCOM as well as implementations such as DirectX , Windows shell , UMDF , Windows Runtime , and Browser Helper Object . COM enables object use with only knowing its interface; not its internal implementation. The component implementer defines interfaces that are separate from

106-560: 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 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 ( WinRT ) is a COM-based API, albeit an enhanced COM variant. Because of its COM-like basis, WinRT supports interfacing from multiple programming contexts, but it

159-495: A class rather than an instance. They are typically used as part of an object meta-model . I.e, for each class, defined an instance of the class object in the meta-model is created. Meta-model protocols allow classes to be created and deleted. In this sense, they provide the same functionality as constructors and destructors described above. But in some languages such as the Common Lisp Object System (CLOS)

212-448: A bank-account class provides a getBalance() accessor method to retrieve the current balance (rather than directly accessing the balance data fields), then later revisions of the same code can implement a more complex mechanism for balance retrieval (e.g., a database fetch), without the dependent code needing to be changed. The concepts of encapsulation and modularity are not unique to object-oriented programming. Indeed, in many ways

265-478: A coclass named SomeClass which implements an interface named ISomeInterface . Application Binary Interface In computer software , an application binary interface ( ABI ) is an interface between two binary program modules. Often, one of these modules is a library or operating system facility, and the other is a program that is being run by a user. An ABI defines how data structures or computational routines are accessed in machine code , which

318-510: A given class. One of the most important capabilities that a method provides is method overriding - the same name (e.g., area ) can be used for multiple different kinds of classes. This allows the sending objects to invoke behaviors and to delegate the implementation of those behaviors to the receiving object. A method in Java programming sets the behavior of a class object. For example, an object can send an area message to another object and

371-469: A portable C++ header file. Nano-COM extends the native ABI of the underlying instruction architecture and OS to support typed object references – whereas a typical ABI focuses on atomic types, structures, arrays and function calling conventions. A Nano-COM header file defines or names at least three types: Many uses of Nano-COM define two functions to address callee-allocated memory buffers as results: Some implementations of Nano-COM such as Direct3D eschew

424-462: A programming language independent syntax. IDL is similar to C++ with additional syntax for defining interfaces and coclasses. IDL also supports bracketed attributes before declarations to define metadata such as identifiers and relationships between parameters. An IDL file is compiled via the MIDL compiler. For use with C/C++, the MIDL compiler generates a header file with struct definitions to match

477-467: A separation of interface from implementation. This distinction is especially strong in COM where an object has no default interface. A client must request an interface to have any access. COM supports multiple implementations of the same interface, so that clients can choose which implementation of an interface to use. A COM type library defines COM metadata, such as coclasses and interfaces. A library can be defined as Interface definition language (IDL);

530-638: A similar purpose and function to destructors, but because of the differences between languages that utilize garbage-collection and languages with manual memory management, the sequence in which they are called is different. An abstract method is one with only a signature and no implementation body . It is often used to specify that a subclass must provide an implementation of the method, as in an abstract class . Abstract methods are used to specify interfaces in some programming languages. [REDACTED] The following Java code shows an abstract class that needs to be extended: The following subclass extends

583-659: A stable application binary interface (ABI) that is unaffected by compiler differences. This makes using COM advantageous for object-oriented C++ libraries that are to be used by clients compiled via different compilers. Introduced in 1987, Dynamic Data Exchange (DDE) was one of the first interprocess communication technologies in Windows . It allowed sending and receiving messages in so-called conversations between applications. Antony Williams, involved in architecting COM, distributed two papers within Microsoft that embraced

SECTION 10

#1732772673844

636-408: A subset of the whole COM interface. Over time, COM is being replaced with other technologies such as Microsoft .NET and web services (i.e. via WCF ). However, COM objects can be used in a .NET language via COM Interop . COM is similar to other component technologies such as SOM , CORBA and Enterprise JavaBeans , although each has its strengths and weaknesses. Unlike C++ , COM provides

689-400: Is a low-level, hardware-dependent format. In contrast, an application programming interface (API) defines this access in source code , which is a relatively high-level, hardware-independent, often human-readable format. A common aspect of an ABI is the calling convention , which determines how data is provided as input to, or read as output from, computational routines. Examples of this are

742-408: 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, with Windows 3.1 , Microsoft released OLE 2 with its new underlying object model , COM. The COM application binary interface (ABI) was the same as

795-585: Is an unmanaged, native API. The API definitions are 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 metadata format allows for significantly lower overhead than P/Invoke when WinRT is invoked from .NET applications. Nano-COM is a subset of COM focused on the application binary interface (ABI) aspects of COM that enable function and method calls across independently compiled modules/components. Nano-COM can be expressed in

848-683: Is compatible with code generated by other such compilers, allowing developers to link libraries generated with one compiler with object code generated with another compiler. Developers writing their own assembly language code may also interface with assembly generated by a compliant compiler. EABIs are designed to optimize for performance within the limited resources of an embedded system. Therefore, EABIs omit most abstractions that are made between kernel and user code in complex operating systems. For example, dynamic linking may be avoided to allow smaller executables and faster loading, fixed register usage allows more compact stacks and kernel calls, and running

901-446: Is currently in use as the base ABI technology for DirectX / Direct3D / DirectML . Since an ActiveX control (any COM component) runs as native code, with no sandboxing protection, there are few restrictions on what it can do. Using ActiveX components, as Internet Explorer supported, in a web page lead to problems with malware infections. Microsoft recognized the problem as far back as 1996 when Charles Fitzgerald said, "We never made

954-502: Is just a special case of overloading where the selection is based only on the first argument. The following simple Java example illustrates the difference: Accessor methods are used to read the data values of an object. Mutator methods are used to modify the data of an object. Manager methods are used to initialize and destroy objects of a class, e.g. constructors and destructors. These methods provide an abstraction layer that facilitates encapsulation and modularity . For example, if

1007-467: The IUnknown interface, which exposes methods for reference counting and for accessing the other interfaces of the object – similar to type conversion , a.k.a. type casting. An interface is identified by an interface ID (IID), a GUID. A custom interface , anything derived from IUnknown , provides early bound access via a pointer to a virtual method table that contains a list of pointers to

1060-611: The System.Transactions namespace provides the TransactionScope class, which provides transaction management without resorting to COM+. Similarly, queued components can be replaced by Windows Communication Foundation (WCF) with an MSMQ transport. 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

1113-695: The Windows Registry to call the MTS software, and not the component directly. Windows 2000 included Component Services control panel updates for configuring 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

SECTION 20

#1732772673844

1166-470: 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. MIDL can generate a binary type library (TLB) that can be used by other tools to support access from other context. The following IDL code declares

1219-424: The x86 calling conventions . Adhering to an ABI (which may or may not be officially standardized) is usually the job of a compiler , operating system, or library author. However, an application programmer may have to deal with an ABI directly when writing a program in a mix of programming languages, or even compiling a program written in the same language with different compilers. Details covered by an ABI include

1272-481: The ARM EABI . Method (computer science) Data is represented as properties of the object, and behaviors are represented as methods. For example, a Window object could have methods such as open and close , while its state (whether it is open or closed at any given point in time) would be a property. In class-based programming , methods are defined within a class , and objects are instances of

1325-574: The MAPI ABI (released in 1992), and like it was based on MSRPC and ultimately on the Open Group 's DCE/RPC . COM was created to replace DDE since its text-based conversation and Windows messaging design was not flexible enough to allow sharing application features in a robust and extensible way. In 1994, the OLE custom control (OCX) technology, based on COM, was introduced as the successor to VBX. At

1378-879: The Windows desktop, to activating objects running under different security contexts, and on different machines across the network. With this were added necessary features for configuring which users have authority to create, activate and call objects, for identifying the calling user, as well as specifying required encryption for security of calls. Microsoft introduced Microsoft Transaction Server (MTS) in Windows NT 4 in order 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. Renamed to COM+ in Windows 2000,

1431-524: The Windows scripting contexts. Component access is via interface methods . This allows for direct calling in-process and via the COM/DCOM sub-system access between processes and computers. A coclass , a COM class, implements one or more interfaces. It is identified by a class ID, called CLSID which is GUID , and by a human-readable programmatic identifier, called ProgID . A coclass is created via one of these identifiers. Each COM interface extends

1484-400: The allocator functions and restrict themselves to only use caller-allocated buffers. Nano-COM has no notion of classes, apartments, marshaling, registration, etc. Rather, object references are simply passed across function boundaries and allocated via standard language constructs (e.g., C++ new operator). The basis of Nano-COM was used by Mozilla to bootstrap Firefox (called XPCOM ), and

1537-499: The application in privileged mode allows direct access to custom hardware operation without the indirection of calling a device driver. The choice of EABI can affect performance. Widely used EABIs include PowerPC , Arm EABI and MIPS EABI. Specific software implementations like the C library may impose additional limitations to form more concrete ABIs; one example is the GNU OABI and EABI for ARM, both of which are subsets of

1590-422: The appropriate formula is invoked whether the receiving object is a rectangle , circle , triangle , etc. Methods also provide the interface that other classes use to access and modify the properties of an object; this is known as encapsulation . Encapsulation and overriding are the two primary distinguishing features between methods and procedure calls. Method overriding and overloading are two of

1643-594: The average price of all products. A static method can be invoked even if no instances of the class exist yet. Static methods are called "static" because they are resolved at compile time based on the class they are called on and not dynamically as in the case with instance methods, which are resolved polymorphically based on the runtime type of the object. In Java, a commonly used static method is: This static method has no owning object and does not run on an instance. It receives all information from its arguments. Copy-assignment operators define actions to be performed by

Component Object Model - Misplaced Pages Continue

1696-451: The benefits of object-oriented development. Perhaps the most well-known example is C++ , an object-oriented extension of the C programming language. Due to the design requirements to add the object-oriented paradigm on to an existing procedural language, message passing in C++ has some unique capabilities and terminologies. For example, in C++ a method is known as a member function . C++ also has

1749-684: The claim up front that ActiveX is intrinsically secure". Later versions of Internet Explorer prompt the user before installing an ActiveX control, allowing them to block installation. As a level of protection, an ActiveX control is signed with a digital signature to guarantee 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 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

1802-421: The compiler generates code to call them at appropriate times. Static methods are meant to be relevant to all the instances of a class rather than to any specific instance. They are similar to static variables in that sense. An example would be a static method to sum the values of all the variables of every instance of a class. For example, if there were a Product class it might have a static method to compute

1855-409: The compiler when a class object is assigned to a class object of the same type. Operator methods define or redefine operator symbols and define the operations to be performed with the symbol and the associated method parameters. C++ example: Some procedural languages were extended with object-oriented capabilities to leverage the large skill sets and legacy code for those languages but still provide

1908-488: 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 DDE and designed specifically for compound documents . It

1961-429: The feature set was incorporated into the operating system as opposed to the series of external tools provided by MTS. At the same time, Microsoft de-emphasized DCOM as a separate entity. Components that used COM+ 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

2014-530: The following example in Java: A Destructor is a method that is called automatically at the end of an object's lifetime, a process called Destruction . Destruction in most languages does not allow destructor method arguments nor return values. Destructors can be implemented so as to perform cleanup chores and other tasks at object destruction. In garbage-collected languages, such as Java , C# , and Python , destructors are known as finalizers . They have

2067-581: The following: A complete ABI, such as the Intel Binary Compatibility Standard (iBCS), allows a program from one operating system supporting that ABI to run without modifications on any other such system, provided that necessary shared libraries are present, and similar prerequisites are fulfilled. ABIs can also standardize details such as the C++ name mangling , exception propagation, and calling convention between compilers on

2120-426: The functions that implement the functions declared in the interface, in the order they are declared. An in-process invocation overhead is, therefore, comparable to a C++ virtual method call. Dispatching, a.k.a. late bound access, is provided by implementing IDispatch . Dispatching allows access from a wider range of programming contexts than a custom interface. Like many object-oriented languages, COM provides

2173-620: The implementation. Support for multiple programming contexts is handled by relying on the object for aspects that would be challenging to implement as a facility. Supporting multiple uses of an object is handled by requiring each object to destroy itself via reference-counting . Access to an object's interfaces (similar to Type conversion ) is provided by each object as well. COM is available only in Microsoft Windows and Apple's Core Foundation 1.3 and later plug-in application programming interface (API). The latter only implements

Component Object Model - Misplaced Pages Continue

2226-459: 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. COM is supported via bindings in several languages, such as C , C++ , Visual Basic , Delphi , Python and several of

2279-408: The internals of the object can be made with minimal impact on the other objects that use it. This is known as encapsulation and is meant to make code easier to maintain and re-use. Method overloading, on the other hand, refers to differentiating the code used to handle a message based on the parameters of the method. If one views the receiving object as the first parameter in any method then overriding

2332-508: The main class: If a subclass provides an implementation for an abstract method, another subclass can make it abstract again. This is called reabstraction . In practice, this is rarely used. In C#, a virtual method can be overridden with an abstract method. (This also applies to Java, where all non-private methods are virtual.) Interfaces' default methods can also be reabstracted, requiring subclasses to implement them. (This also applies to Java.) Class methods are methods that are called on

2385-500: The meta-model allows the developer to dynamically alter the object model at run time: e.g., to create new classes, redefine the class hierarchy, modify properties, etc. Special methods are very language-specific and a language may support none, some, or all of the special methods defined here. A language's compiler may automatically generate default special methods or a programmer may be allowed to optionally define special methods. Most special methods cannot be directly called, but rather

2438-410: The most significant ways that a method differs from a conventional procedure or function call. Overriding refers to a subclass redefining the implementation of a method of its superclass. For example, findArea may be a method defined on a shape class, triangle , etc. would each define the appropriate formula to calculate their area. The idea is to look at objects as "black boxes" so that changes to

2491-414: The network with DCOM . The COM IDL is based on the feature-rich DCE/RPC IDL, with object-oriented extensions. Microsoft's implementation of DCE/RPC, MSRPC , is used as the primary inter-process communication mechanism for Windows NT services and internal components, making it an obvious choice of foundation. DCOM extends COM from merely supporting a single user with separate applications communicating on

2544-467: The object-oriented approach is simply the logical extension of previous paradigms such as abstract data types and structured programming . A constructor is a method that is called at the beginning of an object's lifetime to create and initialize the object, a process called construction (or instantiation ). Initialization may include an acquisition of resources. Constructors may have parameters but usually do not return values in most languages. See

2597-415: The publisher or subscriber and the event system. .NET is Microsoft's component technology that supersedes COM. .NET hides many details of component creation and therefore eases development. .NET provides wrappers to commonly used COM controls. .NET can leverage COM+ via the System.EnterpriseServices namespace, and several of the services that COM+ provides have been duplicated in .NET. For example,

2650-450: The same platform, but do not require cross-platform compatibility. An embedded-application binary interface (EABI) specifies standard conventions for file formats , data types, register usage, stack frame organization, and function parameter passing of an embedded software program, for use with an embedded operating system . Compilers that support the EABI create object code that

2703-555: The same time, Microsoft stated that OLE 2 would be known simply as "OLE". In early 1996, Microsoft found a new use for OCX – extending their web browser's capability. Microsoft renamed some parts of OLE relating to the Internet as ActiveX , and gradually renamed all OLE technologies to ActiveX, except the compound document technology that was used in Microsoft Office . Later in 1996, Microsoft extended COM to work across

SECTION 50

#1732772673844

2756-584: Was introduced with Word 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 document. As changes are made to the spreadsheet in Excel, they appear automatically in the Word document. In 1991, Microsoft introduced the Visual Basic Extension (VBX) technology with Visual Basic 1.0. A VBX

2809-476: 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 (a technology that provides 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

#843156