Programming Distributed Applications with Com+ and Microsoft Visual Basic 6.0 Book

Index

Page numbers in italics refer to figures or tables.

Special Characters
* (asterisk), 145, 146, 149
_ (underscore), 59, 147

A
abstract base classes, 51, 53
abstract data types, 37
access permissions, 375, 383-84. See also security
accounts database, 373. See also security
ACID rules, 232-33, 233
Activate method, 253-54
activation, 55, 64-65
    client-side, and QueryInterface method, 73-74
    just-in-time, 221, 221, 247
    location transparency and, 85-86, 85
    out-of-process, 162-64
    QC recorder objects, 354-55
    remote, 164-66, 166
active attacks, 384
Active Directory, 323, 325, 350, 373
Active Directory Services Interface (ADSI), 279, 282
Active Server Pages. See ASP (Active Server Pages)
Active Template Library (ATL), 225
ActiveX DLLs, 85-86, 85, 90-91. See also servers
ActiveX EXEs, 89, 90, 91. See also servers
activities
    apartment-threaded objects and, 201-4, 202, 203
    COM+ thread pooling and, 191 (see also thread pooling)
    concurrency model, 199-200
    contexts and, 200, 201 (see also contexts)
    MTS and, 15
    MTS objects and, 201
    STA threads and, 205-7, 206
AddRef method, 70-72
Administrator account, 376
Administrators group, 376
ADO (ActiveX Data Objects), 18. See also connections, ADO; recordsets, ADO
Advanced Visual Basic 6: Power Techniques for Everyday Programs (Curland, -Storage), 199
aliases, 75
anonymous access, 290, 377-78, 412-13, 414-15
Anonymous Access mode, 412-13
apartments
    COM+ and, 200
    contexts and, 83, 171 (see also contexts)
    single-threaded (see STAs (single-threaded apartments))
    standard module variables and, 207-8, 208
    threading and, 194-96
    thread-neutral, 196-97
apartment-threaded objects
    activities and, 201-4, 202, 203
    lifecycle requirements for ASP, 285-86
    registering, 197-98, 197
    STAs and, 195, 198 (see also STAs (single-threaded apartments))
APIs (application programming interfaces)
    attribute-based programming vs., 16, 154
    ISAPI, 19, 277
    MSMQ, 325
AppCenter Server, 424
AppIDs (Application IDs), 155
application programming interfaces. See APIs (application programming interfaces)
applications
    AppIDs, 155
    application proxies, 167-68
    ASP, 278, 301, 314-15, 446-48
    COM+ (see applications, COM+)
    distributed (see distributed applications)
    IIS, 278-79
    interfaces and designing, 45-47
    listener, 21, 336, 348-49, 352
    messaging, 318-19, 319
    monolithic, 12
    multitier (see multitier applications)
applications, COM+, 155-57. See also -configured components
    COM+ registration database and, 155-57, 156
    configured vs. nonconfigured, 157
    creating, 157-60, 158, 159
    library vs. server, 161, 162 (see also library applications, COM+; server applications, COM+)
    MTS packages and, 155
    resource sharing (see resource sharing)
    type library registration, 150
    Web-based (see Web-based applications)
arrays, 146, 435
ASP (Active Server Pages). See also Web-based applications
    authentication, 415-16
    caching application-wide state, 314-15
    creating user interfaces, 295-96
    creating Visual Basic objects, 283-86
    debugging Visual Basic components created from pages, 290
    disabling session management, 313-14
    framework, 277-78
    IIS and, 19-20, 277 (see also IIS (Internet Information Services))
    isolated applications and, 291-93, 292, 293
    lifecycle requirements for apartment-threaded objects, 285-86
    mixing components and pages, 300
    objects, 274, 295, 296-97
    partitioning applications into separate processes, 287-91, 287, 288, 289
    processing requests, 279-83, 280, 281
    replacing scripts with Visual Basic -components, 283-85
    splitting code between components and pages, 293-300
ASP file extension, 281
AspProcessorThreadMax key, 281-83
AspRequestQueueMax key, 282-83
asterisk (*), 145, 146, 149
asymmetric-key encryption, 409
asynchronous communication, 10, 21, 23. See also messaging
asynchronous firing of events, 366-67
atomic transactions, 232
attributes
    attribute-based programming, 16-17, 17
    declarative, 153-54 (see also configured components)
    procedure, 100-101, 100
    projectwide type library, 96-97, 96
auditing, 404-6, 405
Authenticated Users SID, 377-78
authentication
    IIS modes, 412-16, 413
    mutual, 386
    network (see network authentication)
    Windows 2000, 373
authorities, 373
authorization, COM+, 395-96, 396
    enforcing, at runtime, 398-401, 400, 401
AutoComplete attribute, 252-54
auto-enlistment of database connections, 259-61, 260
automation, 69, 74. See also IDispatch interface
automation marshaler. See universal marshaler

B
Basic Authentication, 414
batch files, 237, 267
batch logon sessions, 381, 382-83
BEGIN TRAN, 261
bidirectional communication, 329, 356-57
BigIP router, 306, 309
Binary Compatibility setting
    component versioning and, 130-33, 130, 132, 133
    debugging configured components, 184
    direct vTable binding, 128
    limitations of, 137-39
    type libraries and, 151-52
binary components
    COM and, 12-13, 49
    creating, with C++, 51-53
binary reuse, 13, 50
binding
    ASP scripts vs. Visual Basic code, 284
    dual interfaces and, 77-79, 77
    dynamic, vs. static, 35, 54
    late, 75-77, 75
    types of, 78-79
    vTable, 54-55, 55 (see also direct vTable binding)
black-box reuse, 36-37, 38
boundaries, security, 374
browsers. See also Web-based applications
    as clients, 8
    passing state between IIS and, 311-12
    supporting, 9
bugs. See also debugging; error handling
    application proxy, 168
    SetAbort method, 258
business logic, 266-67, 294
business objects, 3, 5, 6, 7
ByRef keyword, 103, 105, 145, 146, 433, 435
ByVal keyword, 84, 351, 367, 433, 435

C
C++ language
    as COM-enabled, 13
    creating binary components, 51-53
    custom marshaling, 82, 84-85
    debugger, 185
    free-threaded components, 196
    listener applications, 336
    pointer syntax, 145
    poolable objects, 225
    Visual Basic vs., 24-25
    vTables, 54-55, 55
caching
    application-wide state, 314-15
    data in middle tiers, 446-48
call contexts, 177, 180-81, 181
CanBePooled method, 254
Catalog Manager, 155, 156, 157, 163, 383
causality, 181, 181, 406
certificate authorities (CAs), 410-11
Certificate-Based authentication, 413
certificates, digital, 410-12
CGI (Common Gateway Interface), 277
circular references, 71-72
class-based references, 29, 31, 42-43
classes. See also components; projects
    abstract base, as interfaces, 53 (see also interfaces)
    avoiding mapping Visual Basic, to tables, 267
    class factories, 67-68, 68, 164
    class modules, 39-42, 42
    CLSIDs, 62, 65-66, 65, 68 (see also GUIDs (globally unique identifiers))
    coclasses, 55, 90, 141
    COM and, 12-13
    event, 22, 360-61, 362-64, 364
    exception, 359
    extending, with user-defined interfaces, 45-46 (see also user-defined interfaces)
    implementation inheritance and, 31-32
    Instancing properties, 39, 97-100, 102
    problems with changing public interfaces of, 30-31
    relationships between clients and, 28-30
clients
    activities and, 203
    application proxies, 167-68
    browsers as, 8 (see also browsers)
    certificates, 411-12
    compatibility between components and, 137
    configuring DCOM, 275
    direct vTable-bound (see direct vTable binding)
    languages and types of, 95-96, 95
    MSMQ, 323-24
    object activation, 73-74
    as presentation tier, 5-6, 6
    programming queued components from, 354-57
    restricting number of, 223-24
    scripting (see scripting clients)
    server design and, 95-96, 96 (see also servers)
    storing state on, with cookies, 301, 309-10, 311-12
    two-tier, 3-4, 5
    user interfaces (see user interfaces)
Close method, 216, 217
CLSIDs (class IDs), 62, 65-66, 65. See also GUIDs (globally unique identifiers)
Cluster Service, 424
coclasses, 55, 90, 141
CoCreateGUID function, 61-62, 129
CoCreateInstance(Ex) function, 64-65, 69, 73-74, 80, 151, 172
CoInitialize(Ex) function, 198
COM (Component Object Model), 49-87
    abstract base classes as interfaces, 53
    CLSIDs and Windows Registry, 65-66, 65
    COM+ vs., 86 (see also COM+)
    component architecture requirements, 50-51
    COM Specification, 55
    creating binary components with C++, 51-53
    Distributed (see DCOM (Distributed COM))
    dual interfaces, 77-79, 77
    evolution of, 2, 50-55
    evolution of, to MTS, 14-17, 17
    evolution of MTS and, to COM+, 17-18
    exceptions, 117-20
    as foundation of multitier platform, 11-14
    IDispatch interface and automation, 74-77
    interface-based programming, 13-14, 47 (see also interface-based programming)
    IUnknown interface, 69-72, 70
    loading component code dynamically, 63-69, 64
    MTS vs., 17
    object activation, 64-65
    out-of-process, 79-86, 80 (see also out-of-process COM)
    passing data using, 432-34
    ProgIDs and CreateObject function, 68-69
    QueryInterface method, 72-74
    Queued Components and, 345-46
    scalability and, 421-22, 421
    SCM and, 67-68, 68
    threading models, 194-207, 196 (see also thread pooling)
    type libraries and language independence, 56-63 (see also type libraries)
    vTable binding, 54-55, 55
COM+, 1-25
    applications (see applications, COM+)
    building distributed applications with Visual Basic and, 23-25, 24 (see also distributed applications)
    call contexts and, 180-81, 181
    COM+ Events, 22-23 (see also COM+ Events)
    COM vs., 86 (see also COM (Component Object Model))
    configured components (see configured components)
    context-related interfaces, 178
    evolution of COM and MTS to, 17-18
    evolution of multitier platform and, 2-3, 11-18
    IIS, 19-20 (see also IIS (Internet Information Services))
    MSMQ, 20-21 (see also MSMQ (Microsoft Message Queuing))
    MTS and, 15 (see also MTS (Microsoft Transaction Server))
    multitier applications and, 3-10, 3, 5
    packaging components for, 92
    programming against object contexts, 178-80, 178
    programming model, 177-81, 178
    Queued Components, 21-22
    reasons for using, 2-10
    registration database, 18, 155-57, 156, 165
    resource sharing (see resource sharing)
    security (see security, COM+)
    services, 18-23
    Web-based applications, 8-10, 9
COM+ Events, 18, 22-23, 360-68
    architecture, 360-61, 361
    configuring persistent subscriptions, 364-65
    creating event classes, 362-63
    creating publishers, 366
    deciding between MSMQ, QC, and, 368-69
    filtering of events, 368
    firing events asynchronously, 366-67
    installing and configuring event classes, 363-64, 364
    transient subscriptions, 367-68
COM+ Services Type Library, 154, 159-60, 159, 177, 178, 209, 296, 297
COMAdmin Library, 156, 158
CoMarshalInterface function, 199
COM library, 63, 64
command-line switches, 66, 93
COMMIT TRAN, 261
Common Gateway Interface (CGI), 277
communication. See messaging
compatibility. See version compatibility
compilation
    options, 94-95
    servers, 90-95
    type libraries, 57-58, 141, 149
Component Load Balancing (CLB), 424-25
Component Object Model. See COM (Component Object Model)
components
    activation (see activation)
    configured, vs. nonconfigured, 18, 157 (see also configured components)
    creating binary, with C++, 51-53
    creating user interfaces with compiled, 296-300
    creating Visual Basic, from ASP pages, 283-86
    debugging Visual Basic, created from ASP pages, 290
    defined, 55, 155
    mixing ASP pages and, 300
    partitioning Web applications with, 294
    queued (see Queued Components (QC))
    servers (see servers)
    splitting code between ASP pages and, 293-300
    versioning (see component versioning)
    wrapper, for scripting clients, 110-12
Component Services Administration (COMAdmin) Library, 156, 158
Component Services administrative tool, 155-56, 158-59, 158, 167, 352, 353, 361, 363, 389
component versioning, 125-52
    Binary Compatibility, 130-33, 130, 132, 133
    in COM, 126-39
    compatibility between clients and -components, 137
    creating user-defined interfaces, 140-52 (see also user-defined interfaces)
    for direct vTable-bound clients, 128-39, 130, 131
    extending class definitions, 45-46, 47
    extending default interfaces, 133-37, 134, 135, 137
    problems, 30
    ProgIDs and, 68-69
    for scripting clients, 127-28
    using IDL, 137-39
Computer Management administrative tool, 325-26, 326
concrete classes, 55
concrete data types, 37
concurrency
    activity-based model, 199-200
    MTS and, 15
    property groups and, 211
    STAs and, 195-96, 196
    synchronization and, 193-94
configuration
    clients of Web-based applications, 9
    computers with MTS, 16
    DCOM clients, 275
    declarative security, 396-98, 398
    event classes, 363-64, 364
    object pooling, 223-24, 223
    persistent subscriptions, 364-65
    queued components, 351-54, 352, 353
    type libraries, 150
configured components, 153-87. See also components
    application proxies, 167-68
    benefits of, 154
    call contexts, 180-81, 181
    COM+ applications, 155-57 (see also applications, COM+)
    COM+ programming model, 177-81, 178
    contexts, 171-77, 171
    contexts and object references, 175-77, 176
    creating and deploying, 157-61, 158, 159
    creation of contexts, 172-74, 173
    distributed garbage collection, 168-69
    event classes as, 363
    friend methods and, 101
    messaging, 342 (see also messaging)
    moving from MTS to, 155, 156, 162, 163-64, 172, 174, 177
    New operator problems, 174-75
    nonconfigured components vs., 18, 157
    out-of-process activation, 162-64
    partitioning distributed applications, 169-70, 170
    programming against object contexts, 178-80, 178
    QC and, 350 (see also Queued Components (QC))
    remote activation, 164-66, 166
    running, in Visual Basic debugger, 182-85
    testing and debugging COM+ components, 182-86
    thread-switching proxies vs. lightweight proxies, 171-72
connection-oriented communication, 320-21, 320. See also database connection pooling
connections, ADO, 216-20, 236-37
consistent transactions, 232
constants. See enumerations
Construct method, 160
constructor strings, object, 160-61
ContextInfo interface, 179-80
contexts, 171-77, 171
    activities and, 200, 201 (see also activities)
    apartments and, 83 (see also apartments)
    call, 177, 180-81, 181
    context-related interfaces, 178
    context switches, 171, 171
    creation of, 172-74, 173
    interception and, 154
    MTS context wrappers, 172
    MTS CreateInstance calls, 174
    MTS SafeRef calls, 177
    New operator problems, 174-75
    object, 177, 178-80, 180
    object references and, 175-77, 176
    thread-switching proxies vs. lightweight proxies, 171-72
    types of, 177
contracts, interfaces as, 37
cookies, HTTP, 301, 309-10, 311-12
coordinated transactions, 339, 341-42
coordinating transaction manager (CTM), 240
correlating messages, 332, 337, 350
CoUnmarshalInterface function, 199
coupling, tight, 35, 37, 38
CreateErrorInfo function, 117
CreateInstance method, 174
CreateObject function, 65
    contexts and, 172, 174, 175-76
    debugging and, 184
    late binding and, 79
    ProgIDs and, 68-69
    remote activation and, 166
CreatePropertyByPosition method, 212
CreatePropertyGroup method, 210
CreateProperty method, 212
CreateThread function, 193, 198-99
credentials, principal, 373
custom interfaces, 77-78, 77
custom marshaling, 84-85, 433
cyclic deadlocks, 268-69

D
DACLs (discretionary access control lists), 372, 383-84, 398-99
data
    access code, 5-6, 7, 266-67, 294
    corruption, 193
    data-driven Web framework, 300
    data members, interfaces and, 40
    passing (see data, passing)
    sharing (see database connection pooling; memory sharing; parameters)
    types (see data types)
data, passing, 431-48
    caching data in middle tiers, 446-48
    packing message bodies using PropertyBag objects, 436-37
    read-only recordsets vs. updatable recordsets, 444-46
    recordsets using COM, 434
    recordsets using HTTP, 441-44
    recordsets using MSMQ, 439-40
    using COM, 432-34
    using HTTP, 440-44
    using MSMQ and QC, 435-40
    using persistable objects, 437-39
database connection pooling, 214-20
    enlisted connections, 260-61
    impersonation and, 393-94
    need for, 214-16, 215, 216
    object pooling vs., 224-25
    operations of, 216-17
    using, 217-20
database connections
    auto-enlistment of, 259-61, 260
    configured components and, 158
    pooling (see database connection pooling)
database management system (DBMS), 228, 230-31, 300, 310-11
data types. See also variables
    COM, 90, 433
    IDL, 147
    interfaces as, 13, 37
    message bodies, 435
    Object, and late binding, 76-77, 78-79
    runtime type inspection, 28, 44-45, 47
    scripting languages and, 105, 284
    Variant, 105, 435
    Visual Basic-to-IDL mappings, 145
DBMS (database management system), 228, 230-31, 300, 310-11
DCOM (Distributed COM)
    COM and, 421-22, 421
    HTTP vs., 274-76
    multitier platform and, 14
    passing data using, 432-34
    remote activation and, 165
DCOMCNFG.EXE utility, 290, 389, 391
DDE (Dynamic Data Exchange), 50
Deactivate method, 254
deactivation, 221
deadlock management, 268-70
debugging. See also bugs
    ASP pages and objects, 293
    COM+ components, 182-86, 383
    running configured components in Visual Basic debugger, 182-85
    techniques, 185-86
    Visual Basic components created from ASP pages, 289, 290
declarative attributes, 16-17, 153-54. See also configured components
declarative security, 394, 396-98, 398
declarative transactions, 243-64, 244, 245. See also online transaction processing (OL