Designing Solutions with COM+ Technologies

Author Ray Brown, Wade Baron, William D. Chadwick III Pages 928 Disk 1 Companion CD(s) Level Intermediate Published 12/19/2000 ISBN 9780735611276 ISBN-10 0-7356-1127-0 Price(USD) $69.99 To see this book's discounted price, select a reseller below.	More Information About the Book Table of Contents Sample Chapter Index Related Series Related Books About the Author Support: Book & CD Rate this book

Index

Note: Italicized page references indicate figures, tables, or code listings.

Special Character

A
A (function name suffix)  61
A2T and A2CT macros  65
abandoned rings  483–87, 484, 486
accessor methods  45
accessors  850
ACF (application configuration file)  364, 366–70
ACID properties  673, 777, 788
_acp variable  65
AcquireReadLock and AcquireWriteLock methods  582–83
activation just-in-time  102, 102, 206, 782–83
Active Directory Service Interfaces. See ADSI (Active Directory Service Interfaces)
Active Server Pages. See ASP (Active Server Pages)
Active Template Library. See ATL (Active Template Library)
ActiveX controls  150, 171, 208, 486–87, 486, 494–95
ActiveX Data Objects. See ADO (ActiveX Data Objects)
ActiveX projects Visual Basic  185, 186
activities MTS  82, 92
actor attribute  705
Ada language  523
adaptability
    aggregation and  245
    containment and  243
    implementation inheritance and  249
    of interface implementations  240
adapters
    C++ IOStream encoder and  341–62
    CSB (see adapters CSB)
    CTypeStreamOnIStream  334–40
encoders and, 325–28, 326, 327, 328 (see also encoders)
    for generic algorithms  533
    interface implementation class as  250
    IPersistStream  279–80
    lock management template and  127–30
adapters CSB  572–82
    cache policies  577–82
    container  572
    iterator  542, 572–77
    iterator implicit configuration for  589
AddRef method  33, 479
ADO (ActiveX Data Objects)
    C++ data access and  847–48, 857–59
    MBV and  412
OLE DB data access and  811, 813, 834–42, 835, 836, 859
    SOAP and  731
ADO Extensions for Data Definition Language and Security (ADOX)  851
ADSI (Active Directory Service Interfaces)  764
Advanced Data Tablegram (ADTG)  820
Advise method  176–77, 487, 495–96
AfxConnectionAdvise and AfxConnectionUnadvise functions  176
aggregation reuse and  243–46
agile objects  103 n.6
algorithms
    CSB  543
    generic  520–21, 524–25
    STL generic  431–34
_AlignSize functions  365
AllocResource method  804–5
American National Standards Institute (ANSI)  56–57, 64, 75
amortization point  758
ANSI. See American National Standards Institute (ANSI)
Apache Software Foundation  702, 724–25, 726–27, 732
apartments. See also threading models; threads
    COM+ model  82
    interception and  85–89, 87, 89
    in local servers  113–14
Apartment threading model  86
API provider-specific  808
application configuration file (ACF)  364, 366–70
application protection IIS  773
applications
architecture (see four-tier enterprise application architecture)
clients (see clients)
    library  771
    OLTP  734, 749, 801
    server  113, 770–71
servers (see servers)
    server-to-server  728, 729
    SOAP  727–32, 727, 729
Web-based (see Web-based applications)
application state ASP  110
AppWizard  62, 181–82
architectural patterns and solution reuse. See reuse
arrays
    C++  528
    conformant  71–72, 155, 156, 386
ASCII character set  56, 57
ASP (Active Server Pages). See also Microsoft Internet Information Services (IIS); Web-based applications
    application objects and state management  763–64
    concurrency  110
    script  218
    self-tuning  770
    SOAP listener  722–23
    string literals  58
    user interface tier  796–97
    Variants and interoperation leaks  53
AspThreadGateEnabled property  770
assembly language interception and  84
assertions  6
ATL (Active Template Library)
    AppWizard  62, 181–82
    BSTR wrapper class comparisons  76–78, 77–78
    class factories  178–79
    as COM component layer  548
    considerations for larger projects  181–82
    data access technology  811
    event support  173–77, 174, 175
    implementing COM+ objects  167–71, 168, 169
    interoperation leaks  52–53
    lock management template  124–30
    macros  6, 170, 261, 262, 855
    MBV and  431–32, 453
    multiple implementation inheritance  256–57, 259
    multiplexing  91
Object Wizard (see Object Wizard)
    OLE DB consumer templates and C++ data access  849–59
    OLE DB consumer templates and provider-specifics  859–65
    smart pointer templates  39, 39–40, 45
    SOAP vs.  697–98
    string conversion macros  64–65
    TCHAR type and Unicode  62
    as Visual C++ framework  157
AtlAdvise and AtlUnadvise functions  176
AtlReportError function  585
AtlSupport.h file  583
atomic transactions  673, 777
Automation-compatible types  152
Automation objects  177–78
Automation specification  485–86
Automation types Visual Basic types and  190

B
back pointer objects  504–6
bad_alloc error  7, 15
base classes
    implementation inheritance  247–54
    type parameterization  269–71, 270, 271
    virtual  256
base functionality set  814, 816
basic_iostream template  341
basic_string template
    BSTR strings and  70
    CString class vs.  72–76
begin method  529, 572
behavior object  236
bidirectional iterators  530
binary and source hybrid techniques  250
binary compatibility  4–5, 103, 151, 191
binary data  68–69
binders  533
BindIoCompletionCallback function  774
BindToRecordset method  859
bonding routines  591
Both threading model  87, 88, 103–4, 112
bottlenecks  735–36. See also scalability
Bring Your Own Transaction. See BYOT (Bring Your Own Transaction) feature
browse isolation level  826
BSTR data type
    alternatives  70–72
    basic_string template  74
    BSTR wrapper classes  76–80, 77–78
    CSB  558, 560, 562, 564
    marshaling  68
    Standard C++ Library  70
    string conversion macros  64
    strings  67–70
    type stream shift operators  318
    Visual J++  201
_bstr_t wrapper class  76–78, 77–78
buffers, serialization, 365, 396, 401–2, 426–27,
426, 427
business logic
    portable formats and  299
    synchronization and  112
business objects  623–26, 638
business services layer  622, 623
business-to-business applications  728
BYOT (Bring Your Own Transaction) feature  828

C
C++. See Microsoft Visual C++
C++ Primer   526
C++ Programming Language The, 526
CAccessorBase class  850
CAccessorRowset template  851
cached tear-off interface implementation  259, 460
cache manager templates  544
cache policies  577–82
caching scalability and  761–62
callbacks  83
CArchive class  284–85
catalog COM+, 113, 188, 515, 766
catch-handler macros  27–28
causality-based locking  119–24, 126
CCmdTarget class  156–57, 171
CComBSTR wrapper class  76–80, 77–78
CCommand template  851
CComObject class  269
CComObjectRootEx class  118
CComQIPtr template  39, 39–40, 50, 52–53
CCSBLock template  583
CCSBStdException class  585
CCWs (COM callable wrappers), 197, 202–6, 203, 204, 207–8
CDataSource class  850
CDBErrorInfo class  856
Change method  567
channel hook facility  11
character encoding. See also strings
    ANSI  56–57
    DBCS  57
    EBCDIC  56 n1.
    Unicode  57–58
character trait class  72–73
charset property  60
char_traits template  73 n.8
char type  61, 63, 66–67
Cheshire Cat pattern  14
child objects on-demand fetching of  667–68
classes. See also objects; templates
base (see base classes)
    BSTR wrapper  76–80, 77–78
    C++ exception  20–27
    character trait  72–73
collection (see collections)
    CString  72–76
    CTypeStreamImpl  303–15, 367–68
    CTypeStreamOnIStream  334–40, 370–71
    derived class type parameterization  264–69
    determining string output buffer size  75
factories (see class factories)
    hook  201, 513
    leaf  256, 260–61
    object orientation and  236
    protocol  247
smart pointer (see smart pointers)
    string templates and  72–76
    Visual Basic coclasses  188
wrapper (see wrapper classes)
class factories
    STA concurrency and  91
    Visual C++  177–79
    Visual J++  216
Class_Terminate method  495
ClassView  173, 174, 175, 181–82
ClassWizard  163–67, 163, 171–73, 172
CLB (COM+ Load Balancing)  747–48
Clear method  650
clients. See also servers
    business objects and  625
    co-locating objects with  470–72
    cursor engine  817, 832
    cursors  832
    notification and concurrency  111
    single concurrent model  743–50, 745, 746
    SOAP applications  727–28, 727
CMarshalByTypeStream class  425–53, 426, 427
CMarshalVBDelegate class  454–70
CMemFile class  285
CMemoryException errors  7
CNDRStream class  371–402
CoAddRefServerProcess function  115
coarse-grained locks  117–30
    causality-based  119–24
    lock management  124–30
    lock types  117–18
    on STA threads  118–19
coclasses Visual Basic  188
CoCreateFreeThreadedMarshaler function  104
code pages  56, 65
CoFreeUnusedLibraries function  115
CoGetCurrentLogicalThreadId function  120
CoGetMarshalSizeMax function  442
CoGetStandardMarshal function, 414, 415, 422, 481–82
cohesion  239
CoInitialize and CoInitializeEx functions  82, 86
COleControl class  171, 173
COleObjectFactory class  177
CollectionImpl.h header file  548
collection objects  631–35, 632, 638
collections
    explicit configuration for wrapper classes  586–89
    interface implementations  272–74
    objects  631–35, 632, 638
persistence (see object persistence)
    as STL containers  539
    wrapper classes  549–56
COM
    COM+ vs.  733
distributed (see DCOM (distributed COM))
    Internet Services  700
    maps  157, 260–61
COM+ technologies
    apartment model  85–89, 87, 89
architectural patterns and solutions reuse (see reuse)
    catalog  113, 188, 515, 766
    COM+ Load Balancing (CLB)  747–48
    COM vs.  733
concurrency (see concurrency)
    data access  808 (see also data access)
error handling (see error handling)
four-tier enterprise application architecture (see four-tier enterprise application architecture)
generic programming (see generic programming)
implementation environments (see implementation environments)
marshal-by-value (see marshal-by-value (MBV))
MTS revolution (see Microsoft Transaction Server (MTS))
    object orientation  237–38
objects (see objects)
reference cycle management (see reference cycle management)
smart pointers (see smart pointers)
SOAP (see SOAP (Simple Object Access Protocol))
    STL tension with  534–35
streaming and persistence (see persistence; streaming)
strings (see strings)
transactions (see transactions)
CoMarshalInterface function  104, 414
CoMarshalInterThreadInterfaceInStream function  109
COM callable wrappers. See CCWs (COM callable wrappers)
COMClassObject class  216
@com directives  203, 205–6
COM Internet Services  700
command creation OLE DB  823–24
command objects
    ADO  837
    OLE DB  823–24
COM maps  157
Commit method  860
communication heterogeneous network  729
compatibility
    binary  4–5, 103, 151, 191
    Visual Basic settings  190–91
Compensating Resource Manager. See CRM (Compensating Resource Manager)
compiler MIDL. See MIDL (Microsoft IDL) compiler
compiler support for CSB  590–91
complex objects retrieving  656–67, 657
component layer CSB and  548
components. See also objects
    as component objects  235
    SOAP support for existing  731
Component Services tool  673, 674, 699, 766
_com_ptr_t template  39, 39–40, 50, 52–53
COM STL Bridge. See CSB (COM STL Bridge)
COM thread safety  82
concurrency  81–147
    ASP  110
    C++ garbage collection  508–12
    client notification  111
    context neutrality  103–9
    design guidelines  109–13
interception (see interception)
    local server  113–16
location and synchronization transparency and, 81–82
locking (see locking)
    MBV  425–26
    multiple implementation inheritance  262
    no concurrency as best  109
    OLE DB  846
    RDBMS  743, 749, 801
    reentrancy vs.  83
scalability and, 740–43 (see also Microsoft Transaction Server (MTS); scalability)
    single concurrent client model  743–50, 745, 746
    STA  89–91
    standard synchronization settings  112–13
    STL  591
    templates and  267–68
threading model and synchronization
interaction, 95
    Visual Basic  192
    Visual J++  206
configuration
    CSB  586–90
    of firewalls to support DCOM  700
    OLE DB transaction  823
configured components  470 n.5, 629, 786–87
conformant arrays  71–72, 155, 156, 386
connectable objects  486–87, 486
connection objects  836
connection points, 150, 171, 193, 486–87, 486, 495–97, 496
connection string OLE DB  819, 840
consistent bit  686, 780, 781
consistent transactions  673, 777
Construct method  766
consumers OLE DB  834. See also ADO (ActiveX Data Objects)
consumer templates ATL OLE DB  849–65, 849
container adapters CSB  539, 540, 572
containers
    dynamic  764–65, 800
    STL  527–29
containment reuse and  243
Contents property
    IObjectStream  641
    ITransStream  650
    Web-based applications  695–96
context neutrality  103–9
    CTypeStreamOnIStream  334–40
    FTM vs. TNA  107–8
    implementation  103–4
    internal object references  104–6
    NDR stream  371, 375
    object implementation  108–9
    performance  106–7
contexts
    error  10–11
    marshaling  408, 409
neutrality (see context neutrality)
    object  91–98, 93, 94, 97
    serialization  364–65
controlling unknown  244
conversion
    implicit type  33, 47
    macros for string  64–65
_CONVERSION_USES_THREAD_LOCALE symbol  65
cookies
    ASP session state  799
    registration  105
copying garbage collection and  502
CoRegisterClassObject function  114
CoRegisterMessageFilter function  98
CoReleaseMarshalData function  427
CoReleaseServerProcess function  115
CoResumeClassObjects function  114
CoTaskMemAlloc function  67, 71, 72
CoTaskMemFree function  71, 72
CoUnmarshalInterface function  414, 427
counted strings  71–72
Count property  631
coupling
    externalizing object data and  410
    frameworks and  286
    inheritance and  250–51, 252–53
    loose  621
    portable formats and  299
CoWaitForMultipleHandles function  119, 120
cpp_quote feature  156, 341, 591–92
CPU
    resources and scalability  736–37, 754–56
    type  276
CreateChildInstance method  638–39
CreateErrorInfo function  10
CreateNestedTrans method  646–47
CreateObject method  228
CreateResource method  805
critical sections  118, 126–30, 131
CRM (Compensating Resource Manager)  785
CRowset class  850
CSB (COM STL Bridge)
    architecture  538–47, 540, 543, 545
    collection wrappers  549–56
    compiler and STL support  590–91
    customizability  548
    ease of use through default functionality  548–49
    guide  547–91
    internal type safety  591–92
    persistence support  568–72
    philosophy  547–49
predefined interface method implementations, 566–68
    predefined traits  556–66
    project configuration  589–90
    selecting functionality  585–89
    STL adapters  572–82
    support structures  582–85
    usage patterns  593–616
CSBError.h file  585
CSession class  850
c_str function  73
CString class
    basic_string template vs.  72–76
    determining string output buffer size  75
CTable template  851
CTypeStreamImpl class  303–15, 367–68
CTypeStreamOnIStream class  334–40, 370–71
cursors
    ADO and ODBC  834
    ADO recordset  412
    OLE DB  817, 829–33, 830–31
cursor stability isolation level  826
custom errors reporting  17
customizability CSB  548
custom marshaling  408, 472. See also marshal-by-value (MBV)
custom proxies  414, 415 n.3

D
data
access (see data access)
    binary  68
    externalizing object  410
    in-memory and MRSW locks  130–31
strings (see strings)
    synchronization and  112
transformations, 275–76, 281–84 (see also persistence; streaming)
types (see data types)
data access  801–65
    ADO (ActiveX Data Objects)  834–42, 835, 836
    C++  847–59, 849
OLE DB (see OLE DB)
    RDBMS  801–3
    Resource Dispenser  803–8, 805
    resource pooling  842–47
    technology  809–13, 809
Data Access Objects (DAO)  809, 810–11
Database   749 n.5
databases. See object persistence; RDBMSs (relational database management systems)
data links component  818–19, 818, 819
data services layer  622, 623, 630
data shaping service  820
data source objects  822
data transformation manual  281–84
data types
    Automation and Visual Basic  190
BSTR (see BSTR data type)
    DATE  317
    frameworks and  286
    generic programming and  521
    IDL and Java  207–8
    IMarshal and Visual Basic  455
    implicit type conversions  33, 47
    internal type safety  591–92
    OLECHAR  64, 66–67, 318, 354–55
    string conversion macros and  64–65
Variant (see Variant data type)
DATE data type  317
DBCS (double-byte character set)  57, 64, 74
DCOM (distributed COM)
    configuring firewalls to support  700
    disabling heartbeat (pinging)  480–82
interface methods vs. RPC remote procedures,
364 n.5
    NDR and  362
    SOAP and  697
    Unicode support  59
DcomCnfg.exe utility  699
deadlocks
    level 2 scalability and  742
    RDBMSs and  749
    synchronization implementation by  96–98, 97
debugger
    Visual Basic  188, 192–93
    Visual J++  217
DECLARE_CLASSFACTORY_AUTO_THREAD
macro, 91
_declspec keyword  41, 45, 84
decode attribute  364
decoding  371. See also encoders
default functionality CSB  548–49
default interfaces  239
deferred update mode  832
delegates Visual J++, 211
Delete method  478, 691–92
deleting objects  691–95, 692
delinearization  736–37, 748–49
delta pinging  480–81
deque  528
derived class type parameterization  264–69
design pattern architecture, 619–31. See also four-tier enterprise application architecture
    business objects  623–26
    concepts  619–26
    data services layer  630
    n-tier application architecture  621–23, 623
    object services layer  628–29
    presentation services layer  628
    simplifying object persistence  630–31
    transaction services layer  629–30
using, to implement Web-based applications, 695–96
destructors class  35–36
DevelopMentor  702, 725, 732
DICollectionImpl template  538, 549
DICollection interface  538–39
diminishing returns point of  735
directional attributes
    BSTR wrapper classes and  78
    smart pointers and  45
    Visual Basic and  183–85, 189
    Visual J++ and  207
directory objects creating  667–73
dirty reads  826
Disabled synchronization setting  96, 778–79
disabling DCOM heartbeat  480–82
DISCO (Discovery of Web Services)  717
DisconnectObject method  417, 422
Discovery of Web Services. See DISCO (Discovery of Web Services)
dispatch interfaces MFC  157
dispinterfaces
    ATL  157
    IDispatch and  150
    MFC  156–57, 160–61
DispMan  805–6
distributed business systems. See four-tier enterprise application architecture
distributed COM. See DCOM (distributed COM)
distributed transactions  825
DllCanUnloadNow function  115
Document Object Model (DOM)  XML  288
domain experts  231, 497
domains synchronization
    configurable  82
    contexts and  92–96, 93, 94
    locking and  118
    transaction domain and  782–83
domains transaction  778, 782–83
done bit  686, 780, 781
double-byte character set. See DBCS (double-byte character set)
doubly linked lists  528
dual attribute  66, 153
dual interfaces. See also multi-dual inheritance
    IDispatch and  150
    MFC  157, 167–71, 168, 169
    Visual Basic  188
durable transactions  673, 777
dynamic buffer serialization  365
dynamic containers  764–65, 800
dynamic cursors  829

E
ease of use CSB  548–49
EBCDIC (Extended Binary Coded Decimal Interchange Code)  56 n.1
ECMAScript  218
EnableAutomation method  171
EnableCommit method  482
EnableConnections method  171
encapsulation  236, 410–11, 477
encode attribute  364
encoders
adapters and, 325–28, 326, 327, 328 (see also adapters)
    C++ IOStream adapter and  341–62
    CTypeStreamOnIStream  334–40
    IPersistTypeStream interface and  329–32, 333
    ITypeStream interface and  303
    NDR stream  371–402
encoding character. See character encoding
encoding affiliation  61
end method  529, 572
EnlistResource method  805
enterprise application architecture. See four-tier
enterprise application architecture
enumerators CSB  539–42, 540, 591–92
environments. See garbage collection environments; implementation environments; languages,
programming; platforms
Err object  12–13
error context  10–11
error context object transmission  11
error handling  3–30. See also exceptions
    ATL and OLE DB  856
    benefits  3–4
    C++ (see error handling C++)
COM+ errors and structured exception handling,    4–5
    COM+ model  5–11
    CSB  585
    CTypeStreamImpl class  315
    error context  10–11
    error context object transmission  11
    error-reporting functions  17–20
    error types  6–7
    NDR stream  376–77, 401
    result codes  8–10, 8
    SOAP faults  707–9, 707
    Visual Basic environment considerations  12–13
    Visual C++ environment considerations  13–15
error handling C++, 16–30
    considerations  13–15
    error-reporting functions  17–20
    exception class  20–27
    exception-processing macros  27–29
    exception specifications  15
    result code framework  16–17, 16
    usage pattern  29–30
error types  6–7
Essential COM   82 n.1, 92
E_UNEXPECTED code  9
event distribution objects  111
Event statement  194
event support
    implementation environment  150
    script  226–28
    Visual Basic  193–94, 195
    Visual C++  171–77, 172, 174, 175
    Visual J++  208–15, 209
EXCEPTION_RECORD structure  5
exceptions. See also error handling
    C++ class  20–27
    C++ specification  15
    as error condition  7
    extended interfaces and  41–42
    macros for processing  27–29
    smart pointers and  38
exclusive locks  757
ExecDelete method  647
ExecInsert method  648
ExecUpdate method  648
executed state command object  824
Execute method  836, 837
existing objects
    saving changes to  675–85, 676
    SOAP support for  731
expected errors  6–7
explicit configuration for collection wrappers  586–89
explicit_handle attribute  364
Extended Binary Coded Decimal Interchange Code. See EBCDIC (Extended Binary Coded Decimal Interchange Code)
extended characters  56
extended interfaces  41–47
    exceptions  41–42
    [in out] parameters  45
    interoperation leaks  52–53
    OLE DB  814
    return values  42–44
    smart pointer parameters and  47–49
    syntactic properties  45–47
    UUID type binding  41
Extensible Markup Language. See XML (Extensible Markup Language)
externalizing object data  410
external types  539

F
factories class. See class factories
failure interception problem  84–85
failures. See error handling; exceptions
fast loading OLE DB provider-specific  859–65
faults SOAP  707–9, 707
fetching child objects on demand  667–68
fields ASP hidden  798
files
header (see header files)
    help  10
    formats  277
filters message  98–100
FinalRelease method  522–23
find algorithm  532
FindConnectionPoint function  487
find_if algorithm  532
fine tuning MBV  470–72
firewalls
    DCOM and  697–98, 699–701
    SOAP and  728, 729
FireX methods  172
fixed buffer serialization  365
fonts  56. See also character encoding; text
for_each algorithm  531, 532
foreign key values  687–88
foreign languages  55–56
fork function  737–39, 738
Format and FormatV methods  75
FormatMessage function  18
formats
    choosing portable data  287–99
    file  277
forward iterators  530
forward-only cursors  829
four-tier enterprise application architecture  619–96
    design pattern architecture  626–31, 627
    design pattern concepts  619–26
    hierarchical object model  631–35, 632
object persistence (see object persistence; transactions)
    optimizing transaction objects  674
    using design pattern to implement Web-based application  695–96
fragile base class problem  251
frameworks
ATL (see ATL (Active Template Library))
    C++ reference cycle management  501–12, 504
MFC (see Microsoft Foundation Class Library (MFC))
    persistence and  284–87
    result code  16–17, 16
    type stream architecture and  333–34
    Visual C++  156–57
free-threaded marshaler. See FTM (free-threaded marshaler)
Free threading model  87
FTM (free-threaded marshaler)
    context neutrality and  104–6
    MBV and  422
    synchronization settings  112
    TNA vs.  107–8
FTP servers  728
functionality CSB
    default  548–49
    selecting  585–89
functionals  533
function pointer adapters  533
functions
    advise  176–77
    C++ error-reporting  17–20
    CSB error-reporting  585
    implementation inheritance and virtual  247–54
    marshaling  105
    provider-specific API  808
    Unicode  60
wrapper (see wrapper functions)

G
Garbage Collection   502
garbage collection. See also reference cycle
management
    C++ framework  501–12, 504
    environments  491–501
    reference counting separate interfaces and  505
    resource management and  477–79
    technology  502–3
garbage collection environments  477–78, 491–501
    Visual Basic  492–97, 496
    Visual J++  497–501
generational garbage collection  502
generic algorithms STL  531–34
generic interception  84–85
generic programming  517–616. See also templates
ATL (see ATL (Active Template Library))
CSB (see CSB (COM STL Bridge))
    overview  517–18
    power of  518–26
    smart pointers and  53–54
    STL  517–18, 526–34
    STL tension with COM+  534–35
    template begetting templates  536–38
generic vs. specific solutions  488–91
GetBuffer method  73
GetBy methods  634, 656, 667–68, 674
GetErrorInfo function  11
GetIDsOfnames function  183–84, 196
GetMarshalSizeMax method, 415, 421, 423–24,
425–26
GetQueuedCompletionStatus function  771
GetSizeMax method  421, 423
GetTarget method  510–11, 512–15
GetUnmarshalClass method  415, 425
global interface table (GIT)  105, 108 n.7, 338
glyphs  56
group locks. See MRSW (multi-read single-write) locks

H
handles serialization  364–65
hardware, scalability and, 734–43, 735, 738, 740, 748–49
header files
    CollectionImpl.h  548
    CSB  590
    IDL  153
    Platform SDK  156
    RpcNdr.h  362
    TCHAR.H  61, 63–64
    type declaration  151
heartbeat disabling DCOM  480–82
help files  10
heterogeneous network communication  729
hidden fields ASP  798
hierarchical object model  631–35, 632
hierarchical relationships  631
hierarchical reuse  239–40
hooks  201, 513
HRESULT type  8–10, 8, 585
HTTP
    SOAP and  697, 702–9
    status codes  707–9, 707
hybrid source and binary reuse  250, 453–70, 471–72