Component Object Model

1
Component Object Model

• Shyh-Kang Jeng
• Department of Electrical Engineering/
• Graduate Institute of Communication Engineering
• National Taiwan University

2
References

• D. Chappell, Understanding ActiveX and OLE,
  Microsoft Press, 1996.
• D. Rogerson ??, ?????, ????COM, ????, 2000.
• D. J. Kruglinski, Inside Visual C, Microsoft
  Press, 1995.
• T. L. Thai, Learning DCOM, OReilly, 1999.
• A. Denning ??, ????, OLE????????, ??, 1996.

3
Component Object Model

• ActiveX and OLE rest on the foundation of COM
• Understanding COM is a prerequisite to
  understanding anything else in ActiveX or OLE

4
Components
5
Benefits of Components Flexibility
Program for User B
Program for User A
6
Benefits of Components Component Libraries
New Program
Component Libraries
7
Benefits of COM Distributed Components
Network
8
Component Object Model

• How should one chunk of software access the
  services provided by another chunk of software?
• COM A standard approach to access all kinds of
  software services, regardless of how they are
  provided
• COM is transforming the way software is
  constructed

9
Benefits of COM

• Offers the benefits of object orientation
• Provides consistency
• Is language independent
• COM defines a binary interface that objects must
  support
• Simple and efficient versioning
• Available on Windows, Windows NT, Macintosh, MVS
  up to now
• DCOM allows COM objects on all kinds of systems
  to interact

10
Communications between Software
11
Basic COM Concept
COM Library
Binary Code of a Client Class
12
Basic COM Concept
13
Basic COM Concept
14
Basic COM Concept
15
A COM Object
16
Identifying an Interface

• Human-readable name
• ISpellChecker, IThesaurs
• Globally Unique Identifier (GUID)
• Interface Identifier (IID)
• Each GUID is unique in time and space
• Timestamp
• Address on the machines network interface card
• 16 bits

17
GUID Generator
18
Interface Definition Language

• object, uuid(
• E7CD0D00-1827-11CF-
• 9946444553540000)
• interface ISpellChecker IUnknown
• import unknown.idl
• HRESULT LookUpWord(
• in OLECHAR word31,
• out boolean found )
• HRESULT AddToDictionary(
• in OLECHAR word31)
• HRESULT RemoveFromDictionary(
• in OLECHAR word31)

19
Immutability of the Interfaces

• Once an interface has been implemented in
  released software, it cannot be changed
• To add new functionality or to modify existing
  functionality requires defining an entirely new
  interface, with a new and different IID
• The creator of the software is free to stop
  supporting the original interface but is
  absolutely prohibited from changing it

20
New Version Problem

• A COM object that supports ISpellChecker
• Add support for a thesaurus function through
  IThesaurus
• Effect on the client using the old version with
  the old or new version installed
• Effect on the client using the new version with
  the new version installed
• Effect on the client using the new version with
  the old version installed

21
Changing Features to an Interface

• The objects creator must define a new interface,
  say ISpellChecker2 that includes the new or
  changed methods and the COM object continues to
  support ISpellChecker as before, but it now also
  support ISpellChecker2
• Clients that are unaware of the upgrade never ask
  for a pointer to ISpellChecker2 and so arent
  affected by the changes they continue to use
  ISpellChecker as before

22
IUnknownQueryInterface
1
A
COM object
Client
2
B
3
23
Reference Counting

• Whenever the object passes out a pointer to one
  of its interface, it adds 1 to reference count.
  If one client passes an interface pointer to
  another client, the client who receives the
  pointer must invoke the AddRef method using that
  pointer
• The client must call Release on the interface
  pointer to decrement the reference count when it
  has finished using the interface
• An object destroys itself when its reference
  count drops to 0

24
Binary Format of an Interface
Object
QueryInterface( )
Client
Pointer to Method 1
AddRef( )
Pointer to Method 2
Release( )
Pointer to Method 3
LookUpWord( )
Pointer to Method 4
AddToDictionary( )
Pointer to Method 5
Pointer to Method 6
RemoveFromDictionary( )
vtable
25
COM Classes

• Class identifier (CLSID)
• An object of a specific class supports a certain
  set of interfaces
• Adding interfaces to an object without changing
  its class is not prohibited by COM
• An objects class identifies a particular
  implementation of a group of interfaces
• Its possible to have many classes supporting the
  same set of interfaces

26
Kinds of COM Servers
Machine X
Machine Y
27
COM Library

• The COM library implements a group of functions
  that supply basic services to objects and their
  clients
• The COM librarys services are accessed through
  ordinary function calls
• The names of COM library functions usually begin
  with the prefix Co- for example, CoCreateInstance

28
System Registry

• The classes of all objects that the COM library
  will be asked to create on this machine must be
  registered
• Registry mapping includes
• CLSID
• Kinds of servers
• Pathname for the file containing the servers DLL
  or executable, or for where to find remote
  servers executable

29
Creating a Single Object
4
Client
Object
Server
3
1
2
CLSID_X
DLL
COM library
EXE
CLSID_Y

30
Class Factories

• Class factory is a kind of objects that can
  create objects of one specific class
• Class factories are COM objects in their own
  right accessed via their interfaces
• CoCreateInstance uses a class factory that it
  hides from the client
• CoCreateInstance uses the methods in the
  IClassFactory interface

31
IClassFactory Interface

• As a class factory, an object must support the
  IClassFactory interface
• IClassFactory
• CreateInstance
• LockServer
• IClassFactory2
• A client calls CoGetClassObject to get a pointer
  to a class factory

32
Using Class Factory
4
3
2
1
Server
33
Emulation

• An old class is replaced by a new class with
  different CLSID
• A COM library function CoTreatAsClass
• when used to create an object using the old
  CLSID will result in instantiating an object with
  the new CLSID
• (setting up an emulation relationship between
  the two CLSIDs in the system registry)

34
Initializing COM Objects

• A client usually asks a newly created objects to
  initialize itself
• The objects data must be stored in a persistent
  way
• The first interface pointer a client requests
  when a new object is created is usually the one
  for an interface containing the objects
  initialization function

35
Calling Sequence in VC (1/2)

• CLSID clsid
• IClassFactory pClf
• IUnknown pUnk
• CoInitialize(NULL)
• CLSIDFromProgID(LTestTools, clsid)
• CoGetClassObject(clsid, IID_IClassFactory,
• (void) pClf)

36
Calling Sequence in VC (2/2)

• pClf-gt
• CreateInstance(IID_Iunknown, (void)pUnk)
• pUnk-gt
• QueryInterface(IID_ISpellChecker,
  (void)pSpl)
• pSpl-gtLookUpWord( Test, found )
• pClf-gtRelease()
• pUnk-gtRelease()
• pSpl-gtRelease()
• CoFreeUnusedLibraries()
• CoUninitialize()

37
Reusing COM Objects

• One COM object cant reuse anothers code through
  inheritance
• Containment (delegation)
• Aggregation

38
Marshaling and Type Information

• Marshaling makes that the client can invoke the
  methods in the same way, regardless of where the
  object is implemented
• To acquire the information necessary to perform
  marshaling, and sometimes for other reasons as
  well, it can be useful to obtain type information
  about the project

39
Accessing a COM Object in an In-Process Server
Client
Client process
40
Accessing a COM Object in a Local Server
41
Accessing a COM object in a Remote Server
Stub
Client
Server Process
Client process
Machine Y
Machine X
42
Marshaling and Unmarshaling

• Marshaling
• Packaging a calls parameters into a standard
  format for transmission
• Unmarshaling
• Unpackaging from the standard format into a
  format appropriate for the receiving process
• Marshaling Code (Marshaler)
• MIDL compiler can read the IDL description of an
  interface and automatically generate the
  necessary marshalling code for this interface,
  contained in a proxy and a stub

43
Type Information

• Type information includes a description of
  everything a client needs to know to use an
  objects service. For example, the type
  information of an object includes a list of the
  interfaces methods and properties, along with a
  description of the parameters for those methods.
• All type information today should be defined
  using IDL

44
Type Library
45
IDL Example

• object,uuid(
• E7CD0D00-1827-11CF-9946- 444553540000)
• interface ISpellChecker IUnknown
• import unknown.idl
• HRESULT LookUpWord(
• in OLECHAR word31,
• out boolean found )
• HRESULT AddToDictionary(
• in OLECHAR word31)
• HRESULT RemoveFromDictionary(
• in OLECHAR word31)

46
IDL Example

• object,uuid(
• 5FBDD020-1863-11CF-9946-444553540000)
• interface IThesaurus IUnknown
• HRESULT Return Synonym(
• in OLECHAR word31,
• out OLECHAR synonym31 )

47
IDL Example

• uuid(
• B253E460-1826-11CF-9946-444553540000),
  version(1.0)
• library TextToolsLib
• importlib (stdole32.tlb)
• uuid(
• B2ECFAA0-1827-11CF-9946-444553540000)
• coclass CoTextTools
• interface ISpellChecker
• interface IThesaurus

48
Automation

• Making applications programmable
• Programmability through macro languages
• Cryptic
• No standard exists
• One choice for an application
• Automation
• General programmability with COM
• Use developers favorite programming tools to
  build applications on top of the functions
  already provided by existing software

49
Automation Example
50
IDispatch and dispinterfaces
51
Clients and Servers
Application
Client
IDispatch
IServices
IDispatch
IDispatch
52
dispinterfaces and Marshaling

• Using a dispinterface for marshaling requires
  only a single proxy and stub
• The parameters for a dispinterface method are
  packaged into a variant
• The client passes the variant along with the
  DISPID on the call to IDispatchInvoke
• The object that implements the dispinterface
  unpackages the variant
• Results are wrapped in a variant by the object
  and then returned to and unwrapped by the client

53
A Visual Basic Example

• Sub SpellCheck( )
• Dim Obj As Object
• Set Obj CreateObject(Excel.Application)
• Word InputBox(Enter word)
• If Obj.CheckSpelling(Word) Then
• MsgBox( Valid word )
• Else
• MsgBox( Word not found )
• End If
• End Sub

54
Dual Interfaces
55
Dual Interfaces

• object, uuid( E7CD0D00-1301-11CF-
• 9946-444553540000), dual
• Interface ISpellChecker IDispatch
• import unknown.idl
• import oaidl.idl
• HRESULT LookUpWord(in BSTR word,
• out boolean found)
• HRESULT AddToDictionary(
• in BSTR word)
• HRESULT RemoveFromDictionary(
• in BSTR word)

56
Dual Interfaces

• uuid(
• B623E460-1837-11CF-9946-444553540000),
  version(1.0)
• library SpellCheckerLib
• importlib (stdole32.tlb)
• uuid(
• B23EFAA0-1849-11CF-9946-444553540000)
• coclass CoSpellChecker
• interface ISpellChecker

57
Persistence and Monikers

• An objects persistent data is information about
  the objects state thats saved between
  instantiations of the object
• A mechanism that lets objects store and retrieve
  their persistent data is called a persistence
  service
• An objects client typically controls when the
  objects persistent data is loaded and saved

58
Structured Storage
Disk file (Compound file)
59
Using Structured Storage
COM object
60
Moniker

• A moniker is a name for a specific object
  instance, one particular combination of CLSID and
  persistent data
• A moniker is an object that supports the IMoniker
  interface
• Each moniker has its own persistent data, which
  contains everything the moniker needs to start
  and initialize the single object instance the
  moniker identifies

61
Using a Moniker