1. Qisheng Hong Yani Mulyani Paul Visokey
COM/DCOM & COM+
Qisheng Hong
Yani Mulyani
Paul Visokey

2. Outline
The Component Object Model - COM
DCOM
COM+

3. What is COM? Build software from parts, not from scratch
A framework for creating and using components
Both a specification and an implementation
Makes software easier to write and reuse
Provides widest choice in services, tools, languages, and applications
Evolved from Object Linking and Embedding technology
Foundation in OLE Version 2, 1995

4. Isn’t COM about “Objects”?
No … COM sets out to solve system software problems that arise when hooking up randomly evolving combinations of binaries
Benefits stem from its design an an integration and deployment architecture for software components
Yes … from the perspective of these new kinds of objects, also called “components”
COM is about clients communicating with objects
COM based applications can be constructed using language-independent components 9

5. COM Architecture
The Model
The “ORB”
The Services

6. COM Fundamental Principles What the designers of COM were striving for...
Binary components
Any programming language
Any location (in-process, cross-process, cross-machine)
No centralized authority
Object orientation
Interoperability
Reusability
Simplest model possible
Enable extensibility, maintainability and adaptability
Multi-tier architecture

7. The Component Object Model (COM)
Components, Components, Components
Code reuse and off-the-shelf components
Language independent notion of an object
Rigorous Encapsulation at the binary level
Black box -- no leakage of implementation details
All object manipulation through strict interfaces
Polymorphism
Define several different behaviors for a single object
via multiple interfaces per class
“Discoverable”: QueryInterface()
IUnknown
IDispatch
COM Object
IRobot

8. The Component Object Model (COM)
Standard API
Binary structure for the interface between client and object
Compilers support Microsoft’s COM binary structure - language independence
The point of contact is the run-time binary representation
OS acts as central registry for objects
Applications only know the function of the object
Wire-level standard for
location transparency

9. OOD and COM Differences in design considerations between OOD and COM
Table 1: Differences in design considerations between OOD and COM
Differences in design considerations between OOD and COM
Object-Oriented Design Assumptions
Added COM Considerations
Objects typically packaged in the same application (module) as client code
Objects and clients typically in separate modules, both .EXEs and .DLLs
Objects and clients run in a single process
Objects and clients may run in different processes and on different machines
Class (implementation) inheritance
Interface inheritance (no implementation inheritance)
Single interface per object (the object's class definition)
Multiple interfaces per object
Single client per object
Multiple simultaneous clients per object
1:1 relationships between clients and objects typical
Many:Many relationships between clients and objects is common

10. The COM Object Request Broker
The “model” is about how the technology is used
The “ORB” is how it’s implemented
Microsoft calls it the COM Runtime
Secure
Security is designed and built in. Not an option.
Inherently Distributed
Pluggable
Security
Transports
Free! (Built-into Win32 Platforms)
No separate client access license or expensive “developer” version

11. Structure of the COM “ORB”
Components and Applications
The COM Runtime
Core Services (Automation, Monikers, Storage, ComCat, Data Transfer, IR)
COM and Distributed COM
Registry
Pluggable Security (SSPI)
MS-RPC
Pluggable Transports
NTLM
DCE
Kerberos
ETC.
TCP
UDP
IPX
SPX
HTTP
ETC.

12. COM Runtime Architecture Flexible and extensible
Pluggable Transports
Client Machine
Server Machine
Component
TCP, UDP
COM Client
Proxy
SPX,IPX
COM Runtime
COM Runtime
Net BUI
HTTP
Other Component
ORB
ORB

13. COM Runtime Architecture Flexible and extensible
Pluggable Security Providers
Client Machine
Server Machine
Component
NTLM
COM Client
Proxy
SSL, Certs.
COM Runtime
COM Runtime
NT Kerberos
DCE
Other Component
ORB
ORB

14. COM Runtime Architecture
provider
Security
RPC
Client
Component
Inprocess
Local
LPC
Protocol stack
DCOM network-
protocol
Remote

15. Accessing COM Services
Client
Component
In the same process
Fast, direct links to server library
Client
Component
COM
Client Process
Server Process
On the same machine
Fast, secure lightweight RPC
Across machines
Secure, reliable and flexible DCE-RPC
based DCOM protocol
COM
DCE
RPC
Client
Server Machine
Client Machine
Component

16. COM Features IDL Object Activation Object Instances QueryInterface()
Object Lifetimes
Apartments
Marshalling

17. IDL - Interface Definition Language
Language-independent means of defining interfaces.
Disambiguates parameter passing, pointers, etc.
Each interface is identified by a GUID.
Functions are broken up into:
Properties - single values with get/set calls.
Methods - more complex functions
Interfaces are logically immutable.

18. Object Activation Client wishes to create and use a COM object.
It invokes the COM API to instantiate a new COM object.
COM locates the object implementation and initiates a server process for the object.
The server process creates the object, and returns an interface pointer at the object.
The client can then interact with the newly instantiated COM object through the interface pointer.

19. QueryInterface
Multiple interfaces for objects instead of multiple inheritances
Different roles for different simultaneous clients
Each client uses a different set of interfaces
Method to navigate among interfaces
Client proxy dynamically loads multiple server stubs

20. Creating Object Instances
In C++, use CoCreateInstance()
IService *pService = NULL;
HRESULT hr = CoCreateInstance(
CLSID_MusicService, // clsid of object
NULL,
CLSCTX_LOCAL_SERVER, // server type (inproc, local, remote)
&IID_IService, // id of desired interface
(LPVOID*)&pService);
if (SUCCEEDED(hr))
{ ... }

21. CoCreateInstance – In Process
Client Process
Client
Registry
COM Runtime
SCM
{ CLSID, Server.dll }

22. CoCreateInstanceEx - Remote
Server Machine
Client Machine
Client
Surrogate Process
Client Process
COM Runtime
SCM
COM Runtime
SCM
Registry
Registry
{ AppID, RemoteServer }
{ AppID, Surrogate DLL }
{ CLSID, Server.dll }

23. Object Lifetime COM uses reference counting.
Initial reference count causes object creation.
To increment reference count:
QI on an interface.
AddRef() - implemented on IUnknown
To decrement reference count:
Release() - implemented on Iunknown
Final release causes object destruction (Garbage Collection).

24. Apartments Abstraction for dealing with threads / processes.
Single-threaded apartments (STA)
At most one thread executing at one time.
Possibly multiple STAs per process.
Objects can store state between calls safely.
Multi-threaded apartments (MTA)
Many threads processing concurrently.
Only one per process (at most).
Specify apartment with CoInitialize().

25. Marshalling Abstraction for inter-apartment communication.
Same abstraction for in-process, local, and remote communication.
Uses RPC for communication between servers.
Converts an interface pointer to a stream.

26. Marshalling - Example Client Process Local Server Process Client
In-Proc Server
COM
Local Server
Stub
Client
COM
Remote Server Process
COM
Remote Server
Stub

27. COM Limitations
Lack of a common type system, each language involved in COM had its own type system.
Architecture does not have perfect knowledge of the types.
COM is hard to use. Reference counting, Microsoft IDL, Global Unique Identifiers (GUID), etc. require deep knowledge of COM specification from developers.
COM is not robust enough for enterprise deployments. Services such as secure transactions, reliable communications, and load balancing are not integrated in COM.

28. What is DCOM? An extension to COM allowing network based component interaction
A framework for creating and using distributed components
Just COM used over a longer wire
Component interaction across heterogeneous networks
Wider choice in services, tools, languages, applications and server components from variety of vendors
All COM components communicate in the same way- ORPC
on the same machine
In-process, Out-of-process
across a Local Area Network
across a Wide Area Network
across the Internet

29. DCOM Features Services used in a standard way, regardless of location
Any Programming Language
Integrated with Development Tools
Flexible Security
Internet certificate-based security
Multiple Network Transports
Connection oriented
Connectionless
Mature specification and reference implementation
Ubiquitous

30. DCOM: Multiple Network Transports
TCP, UDP
IPX, SPX
COM
Object
Clients
HTTP
Queued
Client Machine
Server Machine

31. DCOM: Flexible Security
NT4 Security
SSL/
Certificates
Kerberos
IPSEC C O M
TCP, UDP
IPX, SPX
COM
Object
Clients
HTTP
Queued
Queued
Client Machine
Server Machine

32. What is ActiveX?
A marketing name for a set of technologies and services, all based on the Component Object Model (COM) (the model, the “ORB”, and the core services)
Microsoft’s set of components / framework that uses COM.
Provides plugin-type components for GUI applications, etc.

33. ActiveX Bridges the “Islands” Makes it easy to integrate and reuse any component
Java Applet
HTML Document
JavaScript™
Non-HTML Document
VBScript
ActiveX Control

34. User Experience: How It Works
HTTP server
HTTP
ActiveX Control or Java applet download
HTML content
(text and images)
ActiveX Control or Java applet
(D)COM
COM objects or ActiveX Controls
COM objects or ActiveX Controls
ActiveX Script
Internet Explorer 5 & 6

35. Motivation For ActiveX Bring Component-based Development to the Internet
Software Developers - want to easily create, reuse and integrate software components
Web Producers - want to build rich, engaging Web sites quickly and easily
End Users - want an intriguing, exciting experience
Developers
Web
Producers
End Users

36. ActiveX Builds on COM
COM’s initial thrust: integrating desktop applications with OLE
COM technology is generically useful, being applied to a range of other areas
Inherently distributed
ActiveX Controls
Are COM components with “design-time” UI
Can be written in C++, Java, VB, Delphi, ...
Self-registering
Optimized for download and execute
Work on both Active Client or Server
Can talk indirectly over HTTP or directly over COM

37. Elements Of ActiveX Web Pages, Documents, and Applications/Containers
Scripting
Visual Basic, Scripting Edition, JScript, Tck/Tk, etc.
Controls and Applets
C++, Delphi®, Java, Visual Basic®, etc.
Components and Services
URLs, hyperlinking, browser frame, HTML, Java VM, etc.
Component Object Model (COM)
Standard component packaging
Distributed COM
Internet/distributed computing
Windows®
UNIX®
Macintosh®

38. What’s next? COM+
Evolutionary step, making it even easier to build and use components
Infrastructure in the system, not in the application
Extensible services
Preserves current investments in COM
Provides benefits across languages and tools
Less coding, more productivity
Main point: The next evolutionary step is COM+. COM+ is designed to make it even easier to write and use software components. All of the above benefits speak for themselves.
Key insights: COM+ preserves your current investment in COM based technology. Applications written under COM will continue to work under COM+. Most importantly, the benefits provided by COM+ extend across languages and tools.

39. COM +

40. COM+ Strategy Services Runtime COM Transactions Data Binding
Persistence
Load Balancing
Security
In Memory Database
Event Infrastructure
Services
Ubiquitous Type
Description
Dynamic Invocation
“No-Leak” Memory Mgmt
Interception
Runtime
Tools
Ubiquity Market
Binary Standard
COM
Main point: The strategy for COM+ is to build on the tremendous success of COM, while providing the ability to develop more productively. This is accomplished by putting more of the infrastructure in the system, so that developers will have to write less object infrastructure code themselves. Providing a rich runtime environment which optionally hides tricky issues such as reference counting from developers essentially provides the best of all possible worlds.

41. The COM+ MODEL
COM+ is the next step in the evolution of the Microsoft® Component Object Model and Microsoft Transaction Server (MTS).
COM+ handles many of the resource management tasks such as thread allocation and security.
COM+ automatically makes applications more scalable by providing thread pooling, object pooling, and just-in-time object activation.
COM+ protects data integrity by providing transaction support, even if a transaction spans multiple databases over a network.

42. The COM+ MODEL
COM+ still provides a standard library, and objects and their clients still use it.
COM+ hides calls to this library beneath the equivalent native functions in the programming language.
C++ programmers can use the standard new operator rather than CoCreateInstance() to create a COM+ object.
COM+ developers no longer need to define interfaces using IDL.
Object's interfaces defined using their programming language's syntax.
Main Point: It has been estimated that up to 30 percent of the effort in writing component based software is spent writing “object housekeeping” software. COM+ will handle this task for developers by providing implementations of most of the code which deals with the object infrastructure, leaving the developer free to write logic which deals with the problem they are trying to solve.

43. The COM+MODEL
COM+ addresses another important but challenging problem in creating a language-independent object model: data types.
Different languages support different data types, which causes problems when passing parameters between objects written in different languages.
COM+ allows implementation inheritance between COM+ objects running in the same process.
COM objects do not support constructors, but COM+ objects do.
COM+ constructors even allow passing parameters, better integrating COM+ objects and the objects used by today's most popular object-oriented languages.

44. COM+ Philosophy Attribute-based Programming Write your Logic
Set Attributes
Runtime Does all the grungy stuff
Interceptors deal with the object based on the Attributes
Different Interceptors provide different extensible services at Runtime
Main Point: COM+ introduces the concept of attribute based programming. A developer (or an administrator for that matter) sets attributes on an object which tell the system essentially how to treat it, for example, as a transactional object.
Key insight: Interceptors deal with the object based on the attributes which are set on the object. Different interceptors will provide different extensible services at runtime.

45. “COM +” Easier Components
Type Info
DLL Register
RefCounting
Query Interface
Methods
Class Factory
Connection Points
IDispatch
Component
Meta Data
DLL Register
RefCounting
Query Interface
Methods
Class Factory
Connection Points
IDispatch
Clients
Auto *
Interception
Network
Server
Thread Pool
Queue
Connections
Context
Security
Shared Data
Receiver
Synchronization
Service Logic
Configuration
Management
Receiver
Queue
Connections
Context
Security
Management
Main point: A developer in a COM+ world will usually just provide the Meta data which is needed and provide the methods. Most of the other code dealing with things such as registering components, reference counting for memory management etc. will be handled by the system.
Configuration
Thread Pool
Service Logic
Synchronization
Shared Data
Server

46. The key to extensible services: Interception
Key concept in “COM +” run-time
Interceptors provide automatic behavior at runtime based on the attribute set
Interceptors assure that when a transactional object attempts to change data either all succeed or all fail and rollback
Interception Events
Instance creation
Method call and return, field access
Force fail pre and post call
Binding an instance to a reference
Dynamically (re)define method
Main point: A key concept of COM+ is that of interception. Interceptors provide services based on attributes which have been previously set on an object by a developer. These interceptors provide automatic behavior at runtime based on the attribute set. A list of interceptable events is provided above.

47. COM+ and Windows DNA For building next generation applications
The Web
Easy to Deploy
Graphical UI
Dynamic
Windows DNA
Integrates client/server and the web
Services that work together
Open protocols and published interfaces
COM+ Applications
Component-based
Flexible and dynamic
Built-in scalability
Preserve current investments
Extensible services
The Windows PC
Rich application services
Familiar UI for users
Consistent management
Main Point: We’ve talked quite a bit about the features which COM+ provides. It is important to note that COM+ essentially is one of the key unifying elements for Windows DNA, as it allows for the development of applications which are flexible and powerful enough to deal with the spectrum of environments found today, from three tier client server environments to web based.

48. Summary COM is the most widely adopted object model in the world
COM+ builds on the success of the Component Object Model
Provides benefits across languages and tools
Less code, more productivity
Extensible services enabled by interception
Provides the backbone to Windows DNA
COM+ is the next evolutionary step for the Component Object Model. It will expand on Microsoft’s lead in object technology by enabling next generation application development.

49. 3 Tier Client/Server
“Desktop” - Compound Documents, Controls, Scripting
C O M
H T T P
Mid-Tier - HTTP, Biz Objects, Active Server Pages, Scripting
C O M
SNA
etc...
CORBA
Third-Tier - Databases, Legacy Data

50. Questions?