i486 Microprocessor hardware reference manual

chapter 1: introduction to com

traditional software development

the traditional approach

problems with the traditional approach

problems of traditional software development

object-oriented techniques

limitations of using c++

example of converting a class to a component

component implementation

software development with com

com defined

the goals of com

com and activex

self-check questions


chapter 2: creating a client of a com object

how com uses strings

steps for creating a client

initializing the com libraries

getting the clsid of an object

.creating an instance of an object

using a com object

uninitializing the com libraries

self-check questions


chapter 3: creating a com object

com interfaces

interface fundamentals

identifying interfaces

using guids in c++

the iunknown interface

overview of iunknown

reference counting

discovering the functionality of a com object

com objects and com object servers

creating a com object

deriving a c++ class from an interface

implementing the methods of an interface

controlling the lifetime of a com object

creating a com object server

overview of class factories

implementing a class factory

com object servers as executable files

com object servers as dlls

registering a com object server

registering clslds

using the .reg file

self-check questions


chapter 4: implementing multiple interfaces

overview of multiple interfaces

multiple interfaces with multiple inheritance

overview of multip1e inheritance

using multiple inheritance

queryinterface changes for multiple inheritance.

queryinterface requirements

multiple interfaces with embedding

overview of embedding.

global classes

nested classes

queryinterface changes for embedding

self-check questions


chapter 5: introduction to atl

overview of atl

overview of template libraries

features of atl

base classes provided by atl

creating an atl project

using the atl com appwizard

results of the atl com appwizard

adding a simple com object

the com object header file

results of building an atl project

adding an interface

modifying the com object header file

implementing the methods

registering an atl com object

creating a client by using c++ extensions

using the afxoleinit function

importing a type library

overview of smart pointers

handling smart pointer exceptions

self-check questions


chapter 6: automation

introduction to automation

benefits of automation

terminology

features of automation

methods

properties

dispatch interfaces

idispatch

using variant data types

dispinterface memory layout

implementing idispatch

introduction to type libraries

creating type libraries with idl

introduction to idl

idl file structure

dispinterface definitions

library and coclass definitions

dispinterfaces and atl

structures in automation

self-check questions


chapter 7: dual interfaces

limitations of automation


benefits of dual interfaces

limitations of dual interfaces

creating a dual interface with atl

creating a com object with a dual interface

adding properties

adding methods

automation from the client side

using standard automation

using a dual interface

self check questions

chapter 8: adding events

overview of events

adding a connection point

adding a source interface

using the atl proxy generator

modifying the com object header file

firing an event

adding a sink

creating a client project

adding an event interface

creating a sink object

removing a sink object

modifying the server for a visual basic client

adding a dispinterface

running the atl proxy generator

modifying the com object header file for a visual basic client

firing an event for a visual basic client

visual basic client code

self-check questions

chapter 9: creating an activex control

introduction to activex controls

history of activex controls

using mfc or atl to create an activex control

features of activex controls

building an activex control

creating the control

stock properties

custom properties

reusing window classes

creating a property page

implementing a property page

container functionality

ambient properties

container requirements

self-check questions

chapter l0: object reuse in com

com and inheritance

benefits of object reuse

role of inheritance in object reuse

binary reuse options in com

com containment

com aggregation

benefits and issues of aggregation


chapter 11: custom interfaces

introduction to custom interfaces

benefits and issues of custom interfaces

creating a proxy/stub dll

remoting efficiency

marshaling

locality and com

standard marshaling

custom marshaling

self-check questions

chapter 12: threading models

single-threaded applications

apartment models

overview of apartment models

single-threaded apartments.

multi-threaded apartments

in-process servers

registry keys

mixed threading models

self-check questions

chapter 13: collections

overview of collections

collections and object models

enumerators in atl

creating a collection.

creating a root object

creating a collection object

creating an item object

implementing a collection

implementing a root object

implementing a collection object

implementing an item object

using a collection

using a collection with a visual c++ client

using a collection with a visual basic client

self-check questions