COM programming by example using MFC, ActiveX, ATL, ADO, and COM+

357 Pages·4.838 MB·English

by  John E Swanke

COM Programming
by Example
Using MFC, ActiveX, ATL, ADO, and
COM+
R&D Books
CMP Media, Inc.
1601 W. 23rd Street, Suite 200
Lawrence, KS 66046
USA
Designations used by companies to distinguish their products are often claimed as trade-
marks. In all instances where R&D is aware of a trademark claim, the product name
appears in initial capital letters, in all capital letters, or in accordance with the vendor’s
capitalization preference. Readers should contact the appropriate companies for more
complete information on trademarks and trademark registrations. All trademarks and
registered trademarks in this book are the property of their respective holders.
Copyright © 2000 by John Swanke, except where noted otherwise. Published by R&D
Books, CMP Media, Inc. All rights reserved. Printed in the United States of America. No
part of this publication may be reproduced or distributed in any form or by any means, or
stored in a database or retrieval system, without the prior written permission of the pub-
lisher; with the exception that the program listings may be entered, stored, and executed in
a computer system, but they may not be reproduced for publication.
The programs in this book are presented for instructional value. The programs have been
carefully tested, but are not guaranteed for any particular purpose. The publisher does
not offer any warranties and does not guarantee the accuracy, adequacy, or completeness
of any information herein and is not responsible for any errors or omissions. The pub-
lisher assumes no liability for damages resulting from the use of the information in this
book or for any infringement of the intellectual property rights of third parties that
would result from the use of this information.
Cover art created by Robert Ward.
Distributed in the U.S. and Canada by:
Publishers Group West
1700 Fourth Street
Berkeley, CA 94710
1-800-788-3123
ISBN: 1-929629-03-6
R&D Developer Series
Section I COM Basics..................................1
COM Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
COM Communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Other COM Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2
COM+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2
Chapter 1 COM Objects. . . . . . . . . . . . . . . . . . . . . . 3
What is COM?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
Why Was COM Developed?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4
What are the Other Uses of COM?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5
How Does COM Work?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5
How Do You Create a COM Object Using C++?. . . . . . . . . . . . . . . . . . . .8
How Do You Communicate with Your COM Object Using C++? . . . . . .12
Cautions and Warnings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
How Do You Destroy Your COM Object?. . . . . . . . . . . . . . . . . . . . . . . .15
How Do You Create a COM Object Using #import and Smart
Pointers?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16
How Do You Write a COM Object Using C++?. . . . . . . . . . . . . . . . . . . 18
The IDL File. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
IUnknown . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Other COM Object Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Writing a COM Object in Straight C++ . . . . . . . . . . . . . . . . . . . . . . . . . 24
How Do You Write a COM Object Using MFC?. . . . . . . . . . . . . . . . . . 25
Custom Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
How Do You Write a COM Object Using ATL? . . . . . . . . . . . . . . . . . . 27
So How Do You Create a COM Object with Visual Basic? . . . . . . . . . . 27
So How Do You Create a COM Object with Visual J++?. . . . . . . . . . . . 28
What’s the Service Control Manager?. . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Chapter 2 COM Communication. . . . . . . . . . . . . . 31
How Do COM Objects Communicate? . . . . . . . . . . . . . . . . . . . . . . . . . 31
Basic IDL File Formats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Early-Binding Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Late-Binding Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Dual Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
The VTBL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Type Library Declaration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Simple Argument Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Structures and COM Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Encapsulated Unions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Memory Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Visual Basic Argument Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
BSTRs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
SafeArrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Variants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Reverse Communication. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Connection Points and Sinks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Early-Binding Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Late-Binding Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
ActiveX Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Chapter 3 Other COM Issues. . . . . . . . . . . . . . . . . 53
Encapsulation and Aggregation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55
Aggregation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Security. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
Activation Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58
Object Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58
CoInitializeSecurity(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60
Licensing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60
Multitasking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
Thread Safety Primer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
COM Thread Safety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
Automatic COM Thread Safety. . . . . . . . . . . . . . . . . . . . . . . . . . . . .63
Activating Thread Safety. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
Synchronization Loopholes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .69
Designing Your In-Process COM Server . . . . . . . . . . . . . . . . . . . . . .70
Designing Your Out-of-Process COM Server. . . . . . . . . . . . . . . . . . .71
Apartments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72
Chapter 4 COM+ . . . . . . . . . . . . . . . . . . . . . . . . . . 75
The Evolution of Client/Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .76
The Evolution of COM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .78
DLL Surrogates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .80
Writing Your Own DLL Surrogate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .82
Microsoft Transaction Server (MTS) . . . . . . . . . . . . . . . . . . . . . . . . . . . .82
Stateless Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .83
IObjectContext. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84
Thread Safety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85
Writing Your MTS Compliant COM Server . . . . . . . . . . . . . . . . . . .85
Registering Your MTS Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
What is COM+? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
Just-in-Time Activation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
Object Pooling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Load Balancing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
A New Threading Model. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
Event Service. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Queued Components. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .94
Security at the Method Level. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .97
Other Minor Changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .98
Attribute Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
The Component Catalog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
COM+ vs. EJB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Section II COM Examples........................101
Creating and Accessing COM Objects . . . . . . . . . . . . . . . . . . . . . . . . . 101
Writing COM Servers with MFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Writing COM Servers with ATL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Writing COM Servers with VB and VJ++ . . . . . . . . . . . . . . . . . . . . . . . 102
COM Communications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
COM+ Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Accessing Database Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Potpourri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Chapter 5 Creating and Accessing COM
Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Example 1 Creating a COM Object Using C++ and the COM API . . 104
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Example 2 Creating a COM Object Using C++ and Smart Pointers . . 110
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Example 3 Creating a COM Object Using MFC and Late Binding. . . 116
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Listings — Generated C++ Class .H File . . . . . . . . . . . . . . . . . . . . 119
Listings — Generated C++ Class .CPP File. . . . . . . . . . . . . . . . . . . 120
Example 4 Creating a COM Object Using Smart Pointers and
Late Binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
Example 5 Creating an ActiveX Control Using MFC. . . . . . . . . . . . . .123
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .124
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127
Listings — Generated C++ Class .H File . . . . . . . . . . . . . . . . . . . . .128
Listings — Generated C++ Class .CPP File. . . . . . . . . . . . . . . . . . . .130
Example 6 Creating an ActiveX Control from Visual Basic . . . . . . . . .132
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
Example 7 Creating a COM Object from Visual Basic. . . . . . . . . . . . .133
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .134
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135
Example 8 Creating a COM Object from Visual J++. . . . . . . . . . . . . .135
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .136
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .136
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .136
Listings — Interface Wrapper Class. . . . . . . . . . . . . . . . . . . . . . . . .137
Listings — Implementation Wrapper Class . . . . . . . . . . . . . . . . . . .138
Chapter 6 Writing COM Servers with MFC. . . . . 141
Example 9 Writing an Interface Server Project. . . . . . . . . . . . . . . . . . .143
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Listings — DLL Definition File . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Listings — Interface Defintion Language File. . . . . . . . . . . . . . . . . 146
Listings — Make File. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Example 10 Writing a COM DLL Server with MFC . . . . . . . . . . . . . 147
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Listings — COM Class .H File. . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Listings — COM Class .CPP File . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Example 11 Writing a COM EXE Server with MFC . . . . . . . . . . . . . 156
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Listings — COM Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Example 12 Writing a COM Server that Supports Late Binding
with MFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Example 13 Writing a COM Server with a Connection Point
with MFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Example 14 Writing a COM Client with a Sink Using MFC . . . . . . . 163
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166
Example 15 Writing a COM Singleton Server with MFC. . . . . . . . . . .166
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Listings — COM Class .H File. . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Example 16 Aggregating a COM Object with MFC. . . . . . . . . . . . . . .173
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .173
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .173
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .174
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177
Listings — Aggregating COM Class .H File. . . . . . . . . . . . . . . . . . .178
Listings — Aggregating COM Class .CPP File. . . . . . . . . . . . . . . . .180
Example 17 Writing an ActiveX Control Using MFC . . . . . . . . . . . . .184
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190
CD Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190
Chapter 7 Writing COM Servers with ATL . . . . . 191
Example 18 Writing a COM DLL Server Using ATL. . . . . . . . . . . . . .192
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .192
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .198
Example 19 Writing a COM EXE Server Using ATL. . . . . . . . . . . . . .199
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .199
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .199
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202
Example 20 Writing a COM EXE Service Using ATL . . . . . . . . . . . . .203
Objective. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203
Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207
Example 21 Extending Your ATL COM Class. . . . . . . . . . . . . . . . . . 207
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Listings — Edited Old Class’s .H File. . . . . . . . . . . . . . . . . . . . . . . 210
Listings — Edited New Class’s .H File . . . . . . . . . . . . . . . . . . . . . . 211
Example 22 Writing an ATL Server that Supports Late Binding. . . . . 212
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Example 23 Writing an ATL Singleton Server . . . . . . . . . . . . . . . . . . 213
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Example 24 Writing an ATL COM Tearoff Server. . . . . . . . . . . . . . . 214
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Listings — Example IDL File. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Listings — Example .H File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Example 25 Writing an ATL COM Server that has a Connection
Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
CD Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Listings — Tooltip Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Example 26 Aggregating a COM Object Using ATL . . . . . . . . . . . . . 226
Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Steps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Notes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230