Symbols
- .NET
- accessing the COM+ Catalog, Programming the COM+ Catalog
- attribute-based programming, Attribute-based programming
- COM and Windows interoperability with, COM and Windows Interoperability
- components
- creating, Developing .NET Components, Using Interfaces
- inheritance, Component inheritance
- simplified deployment of, Simplified Component Deployment
- simplified development of, Simplified Component Development, Component-oriented security
- visibility of, Component visibility
- interfaces in, Using Interfaces
- introduction to, Introduction to .NET, Assembly Files
- namespaces in, Using Namespaces
- nondeterministic finalization, Nondeterministic Finalization
- nonserviced components and transactions, COM+ Transactions and Nonserviced Components, ASP.NET and transactions
- object life cycle management, simplified, Simplified Object Life Cycle Management
- programming languages, .NET Programming Languages
- role-based security in, COM+ Security
- security, component-oriented, Component-oriented security
- writing client-side code, Writing .NET Client-Side Code
- writing managed clients for queued components, A Queued Component’s Managed Client
- .NET assemblies, Packaging .NET Components: Assemblies
- adding roles to COM+ applications, Adding Roles to an Application
- ApplicationID attribute and, The ApplicationID Attribute
- composing, Composing Assemblies, Assembly Files
- Description attribute and, The Description Attribute
- files in, Assembly Files
- manifests, Packaging .NET Components: Assemblies, Assembly Manifest
- mapping to COM+ applications, .NET Assemblies and COM+ Applications
- metadata in, Packaging .NET Components: Assemblies, Assembly Metadata
- registering, Registering Assemblies, The ProgId Attribute, Adding Roles to an Application, COM+ Loosely Coupled Events
- dynamically, Dynamic Registration
- manually, Manual Registration
- programmatically, Programmatic Registration
- relationship between assembly version and COM+ components, Understanding Serviced Component Versions
- sharing, Sharing Assemblies
- signing, Registering Assemblies
- .NET attributes
- ApplicationActivation, Application Activation Type
- applying to .NET serviced components, Developing Serviced Components
- configuring serviced components, Configuring Serviced Components
- context-related, COM+ Context Attributes
- specifying application IDs, The ApplicationID Attribute
- .NET clients and dynamic registration of assemblies, Dynamic Registration
- .NET serviced components, .NET Serviced Components, Summary
- application names, specifying, Specifying Application Name
- applying special attributes to, Developing Serviced Components
- AutoComplete attribute and, The AutoComplete Attribute
- configuring, Developing Serviced Components , Configuring Serviced Components
- designating as event classes, COM+ Loosely Coupled Events
- disposing of objects, COM+ Object Pooling
- IObjectControl interface and, Using IObjectControl
- JITA (Just-in-Time Activation) and, COM+ Just-in-Time Activation, IObjectControl, JITA, and Deterministic Finalization
- loosely coupled events (LCE) and, COM+ Loosely Coupled Events, COM+ Loosely Coupled Events
- mapping assemblies to COM+ applications, .NET Assemblies and COM+ Applications
- object pooling and, COM+ Object Pooling, COM+ Object Pooling
- private components in COM+ 1.5, Private Components
- queued components and, COM+ Queued Components, The MessageMover class
- registering assemblies, Registering Assemblies, The ProgId Attribute, Adding Roles to an Application, COM+ Loosely Coupled Events
- dynamically, Dynamic Registration
- manually, Manual Registration
- programmatically, Programmatic Registration
- security and, COM+ Security, Verifying Caller’s Role Membership
- specifying CLSIDs with Guid attribute, The Guid Attribute
- specifying names with ProgId attribute, The ProgId Attribute
- synchronization and, COM+ Synchronization
- transactional isolation levels in COM+ 1.5, Configurable Transaction Isolation Level
- transactions and, COM+ Transactions, The TransactionContext Object
- voting on transactions, Voting on the Transaction, Voting on the Transaction
- vs. managed components, .NET Serviced Components
A
- aborting transactions, The Atomic Property, Voting on a Transaction, Voting on the Transaction, Voting on the Transaction
- access checks
- COM+ events and role-based security, Subscribers and Role-Based Security
- disabling/enabling component-level, Component-Level Access Checks
- library applications and, Securing a Library Application
- server applications and, Setting the Security Level
- access control, Authorization
- (see also authorization)
- disabling application-level authorization, Disabling Application-Level Authorization
- role-based security and, Role-Based Security, Component-Level Access Checks
- AccessChecksLevel property, Configuring Application-Level Security Settings
- AccessChecksLevelOption enum parameter, Configuring Application-Level Security Settings
- ACID properties, Transaction Properties, The Durable Property
- Activate(), Object Pooling and Context, Using IObjectControl
- JITA (Just-in-Time Activation) and, JITA and IObjectControl
- transactions and pooled objects, Transactions and Object Pooling, Transactions and Object Pooling
- activation mode, COM+ Application Types, Just-in-Time Activation
- (see also JITA)
- changing, Changing Application Activation Mode
- instance management, Instance Management and Scaling
- activation type of applications, specifying, Application Activation Type
- ActivationOption parameter, Application Activation Type
- Active Directory, Application Partitioning
- activities, Activities: The COM+ Innovation, COM+ Synchronization
- contexts and, Activities and Contexts
- JITA and, Activities and JITA
- synchronization settings and, COM+ Configuration Settings, Required Versus Requires New
- tracing, Tracing Activities
- transactions and, Activities and Transactions
- activity IDs, Activities and Contexts
- retrieving, The Context Object
- activity-based synchronization, COM+ Concurrency Model
- Add(), The ICatalogCollection Interface
- AddFilter(), Transient subscriber-side filtering
- advising objects (sink interfaces), Classic COM Events
- affinity
- logical thread, Activities: The COM+ Innovation
- object-to-thread, Apartments: The Classic COM Solution
- aggregation and object pooling, Pooled Object Design Requirements, Pooled Objects and Aggregation
- aliasing components in COM+ 1.5, Aliasing Components
- AllowInprocSubscribers property (event class attribute), COM+ Loosely Coupled Events
- Anonymous impersonation level, Impersonation = Anonymous, Configuring Application-Level Security Settings
- Any isolation level, Configurable Transaction Isolation Level
- apartments, Encapsulation via Marshaling in COM, The Neutral Threaded Apartment
- (see also MTA; NTA; STA)
- activation policy for, The NTA and Other COM Threading Models
- hosting nonconfigured components, Assigning Objects to Contexts
- lightweight proxies and, Lightweight Proxies
- problems with, Apartments: The Classic COM Solution
- threading models for, Pooled Object Design Requirements, Apartments: The Classic COM Solution
- Application Export Wizard, Deploying COM+ Applications , Deploying and Administering Role-Based Security
- Application IDs, Creating a COM+ Application
- Application Install Wizard, Configuring the Server Application Identity
- application-level authorization, disabling/enabling, Enabling Authorization, Securing a Library Application, Disabling Application-Level Authorization, Configuring Application-Level Security Settings, Configuring Application-Level Security Settings
- ApplicationAccessControl attribute, Configuring Application-Level Security Settings, Configuring Application-Level Security Settings
- ApplicationActivation attributes, Application Activation Type
- ApplicationID attribute, The ApplicationID Attribute
- ApplicationName attribute, Specifying Application Name
- ApplicationQueuing attribute, COM+ Queued Components
- applications (see COM+ applications)
- Applications collection, The Catalog Programming Model, Catalog Structure
- accessing, The Catalog Root Object
- creating catalog objects, Programming the COM+ Catalog
- /appname: switch, Manual Registration
- architecture, COM+ transactions, COM+ Transactions Architecture, COM+ Transactions Architecture Benefits
- ASP.NET and transactions, ASP.NET and transactions
- assemblies (see .NET assemblies)
- AsyncCallback class, COM+ Queued Components
- asynchronous COM+ (see queued components)
- asynchronous events, Asynchronous Events
- asynchronous vs. synchronous components, Synchronous Versus Asynchronous Components, Changes in Workflow
- ATL 7.0
- generating
- classic COM components, Building a COM Component
- type libraries, Supplying the Event Class Definition
- object pooling design requirements, Pooled Object Design Requirements
- queuing attribute, Designing Queued Component Interfaces
- transaction support for projects, Transaction Support IDL Extension
- atomicity (transaction property), The Atomic Property
- enforcing with two-phase commit protocol, The Two-Phase Commit Protocol
- attributes (see .NET attributes)
- authentication, Authentication
- application-level, enabling/disabling, Configuring Application-Level Security Settings, Configuring Application-Level Security Settings
- IClientSecurity interface and, Programmatic Client-Side Security
- setting correct level of, Deciding on the authentication level
- setting levels for
- library applications, Securing a Library Application
- queued calls, Queued Calls Authentication
- server applications, Setting the Authentication Level, Client authentication level compatibility
- vs. authorization, Authorization
- Authentication property, Configuring Application-Level Security Settings
- AuthenticationOption enum parameter, Configuring Application-Level Security Settings
- authorization, Authorization
- (see also access control)
- application-level, disabling/enabling, Enabling Authorization, Securing a Library Application, Disabling Application-Level Authorization, Configuring Application-Level Security Settings, Configuring Application-Level Security Settings
- enabling for
- library applications, Securing a Library Application
- server applications, Enabling Authorization
- problems with IsCallerInRole(), IsCallerInRole( ) Returns TRUE When Security Is Not Enabled
- auto-deactivating methods, Method Auto-Deactivation, COM+ Just-in-Time Activation
- AutoComplete attribute and, The AutoComplete Attribute
- logbook components and, How Does the Logbook Work?
- auto-enlisting resources, Resource Managers
- MSMQ and queued components, MSMQ Participates in Transactions, Queued Components and Transactions, Queued Components and Transactions
- not possible with transactions and pooled objects, Transactions and Object Pooling
- auto-retry mechanism and queued components, Auto-Retry Mechanism
- AutoComplete attribute, The AutoComplete Attribute
- automation-compliant interfaces, COM+ Configured Components
B
- base partitions (COM+ 1.5), Application Partitioning
- BeginInvoke(), COM+ Queued Components
- BeginTransaction(), Single Object/Single Resource Transaction
- BindToMoniker(), writing managed clients for queued components with, A Queued Component’s Managed Client
- boundaries, security, Security Boundaries
- buffering workload and queued components, Workload Buffering
C
- /c switch, Manual Registration
- C++ and CLR-compliance, .NET Programming Languages
- C++ clients and queued components, Invoking Queued Components on the Client Side
- Call authentication level, Authentication = Call, Configuring Application-Level Security Settings
- call objects, The Call Object
- verifying callerÕs role programmatically, Programmatic Role-Based Security, Verifying Caller’s Role Membership
- caller identity, authenticating, Authentication, Setting the Authentication Level, Client authentication level compatibility
- CanBePooled(), Object Pooling and Context
- JITA (Just-in-Time Activation) and, JITA and IObjectControl
- logbook components and, How Does the Logbook Work?
- overriding ServicedComponent implementation of IObjectControl, Using IObjectControl
- transactions and pooled objects, Transactions and Object Pooling, Transactions and Object Pooling
- catalog collections, The Catalog Programming Model
- (see also top-level collections)
- accessing remote, Features of COMAdminCatalog
- committing/discarding changes to, Saving Changes
- creating catalog objects, Programming the COM+ Catalog
- retrieving, The ICatalogCollection Interface
- catalog objects, The Catalog Programming Model, The Catalog Programming Model
- accessing related collections, Using the Catalog Interfaces, Using the Catalog Interfaces
- adding, The ICatalogCollection Interface
- collections associated with, Catalog Structure
- disabling/enabling applications, Disabling Applications and Components
- ICatalogObject interface and, The ICatalogObject Interface
- named properties, The ICatalogObject Interface
- interdependencies of, Object Properties Interdependencies
- removing, The ICatalogCollection Interface
- causality IDs/causality locks, Activities: The COM+ Innovation, Causality-Based Lock, COM+ Synchronization
- CEventLogger class, How Does the Logbook Work?
- CGenericFilter helper class, The CGenericFilter helper class, The CGenericFilter helper class
- CGlobalInterfaceTable wrapper class, The GIT Wrapper Class
- challenge/response protocol, Authentication, Authentication = Connect
- class-IDs (see CLSIDs)
- client types, Client Types, Scaling Up with Internet Clients
- client workflow and queued components, Changes in Workflow
- clients
- .NET and dynamic registration of assemblies, Dynamic Registration
- authenticating queued calls, Queued Calls Authentication
- avoid passing subroot objects to, Passing Subroot Objects to Clients
- creating queued components, Invoking Queued Components on the Client Side, Invoking Queued Components on the Client Side, A Queued Component’s Managed Client
- disconnected work, Disconnected Work
- exception handling on client side, Client-side exception handling
- IDisposable interface and, COM+ Object Pooling
- impersonating, Server-Side Impersonation, Server-Side Impersonation
- nontransactional, Nontransactional Clients, Nontransactional Clients
- TransactionContext class and, The TransactionContext Object
- receiving events from objects in classic COM, Classic COM Events
- security for queued components, Queued Components Security
- setting security attributes, Programmatic Client-Side Security
- using response objects, Receiving Output from a Queued Component, Receiving Output from a Queued Component
- writing .NET client-side code, Writing .NET Client-Side Code
- writing test code, Writing a Test Client
- cloaking, Impersonation = Delegate
- cloning the COM+ Catalog, Features of COMAdminCatalog
- CLR (Common Language Runtime) environment, Introduction to .NET
- exception classes and, .NET Programming Languages
- unreachable objects and the garbage collector, Simplified Object Life Cycle Management
- CLSIDs (class-IDs)
- generating for serviced components, Understanding Serviced Component Versions
- specifying using Guid attribute, The Guid Attribute
- CLSID_CatalogWrapper, Adding a Transient Subscription
- CLSID_COMAdminCatalog
- adding transient subscriptions, Adding a Transient Subscription
- creating root object with, The Catalog Root Object
- CLSID_MessageMover, The MessageMover class
- CLSID_StdGlobalInterfaceTable, The Global Interface Table
- CoClass definitions for event classes, Supplying the Event Class Definition, Supplying the Event Class Definition
- CoCopyProxy(), Programmatic Client-Side Security
- CoCreateInstance()
- assigning objects to contexts, Assigning Objects to Contexts
- moving messages between queues, The MessageMover class
- new moniker, alternative to, Invoking Queued Components on the Client Side
- object pooling and, Configuring Pool Parameters
- CoGetCallContext(), The Call Object , Programmatic Role-Based Security, Server-Side Impersonation
- CoGetInterfaceAndReleaseStream(), Cross-Context Manual Marshaling
- CoGetObject(), Invoking Queued Components on the Client Side
- CoGetObjectContext(), The Context Object, Using JITA, Tracing Activities
- CoImpersonateClient(), Server-Side Impersonation
- CoInitializeSecurity(), Calling CoInitializeSecurity( )
- collection names, The Catalog Programming Model
- COM components
- adding to COM+ applications, Adding a Component to a COM+ Application
- building, Building a COM Component
- encapsulation via marshaling, Encapsulation via Marshaling in COM, Encapsulation via Marshaling in COM
- passing in as method parameters, Designing Queued Component Interfaces
- vs. .NET framework, COM+ Component Services
- COM events, Classic COM Events, Classic COM Events
- COM interface types, COM+ Configured Components
- COM+ 1.5, COM+ Component Services, COM+ 1.5, Summary
- applications
- disabling, Disabling Applications and Components
- memory dumps, configuring, Application Dump
- partitioning, Application Partitioning, Application Partitioning
- pausing, Pausing Applications
- pooling, Application pooling
- recycling, Application Recycling
- shutting down processes, Application Recycling
- Catalog root object, Legacy Components
- components
- aliasing, Aliasing Components
- disabling, Disabling Applications and Components
- enabling, Disabling Applications and Components
- context activation setting improvements, Improved Context Activation Setting
- context objects and partition properties, Application Partitioning
- ICOMAdminCatalog2 interface and, Legacy Components
- icons of application types, assigning, Improved User Interface Usability
- legacy applications
- cannot be disabled, Disabling Applications and Components
- managing, Legacy Applications
- legacy components
- disabling, Disabling Applications and Components
- managing, Legacy Components
- private components, Private Components
- queuing support improvements, Improved Queuing Support
- recycling parameters, configuring programmatically, Programmatic Recycling
- server applications, configuring to run as system service, Service Activation Type
- transaction isolation in, The Isolated Property
- transaction isolation levels, configuring, Configurable Transaction Isolation Level, Configurable Transaction Isolation Level
- user interface usability, Improved User Interface Usability
- web services support, Web Services in COM+ 1.5
- COM+ Admin type library, Programming the COM+ Catalog
- COM+ applications, The Component Services Explorer
- activating listeners for, Application Configuration
- activation type, specifying, Application Activation Type
- adding components to, Adding a Component to a COM+ Application, Adding an Event Class
- administrators and
- queued component exceptions, The MessageMover class
- role-based security, Deploying and Administering Role-Based Security
- application IDs, specifying, The ApplicationID Attribute
- application types, COM+ Application Types
- configuring, Configuring COM+ Applications, Idle Time Management
- configuring queued component hosting, Application Configuration, COM+ Queued Components
- creating, Creating a COM+ Application, Creating a COM+ Application
- debugging, Debugging COM+ Applications
- deploying, Deploying COM+ Applications , Summary
- disabling changes to settings, Disabling Changes to the Application Configuration
- enabling queuing for, Handling Poison Calls
- installing/uninstalling exported, Installing and Uninstalling an Exported Application
- launching options for, The Listener
- legacy applications in COM+ 1.5, Legacy Applications, Legacy Components
- mapping .NET assemblies to, .NET Assemblies and COM+ Applications
- names, specifying, Specifying Application Name
- object pooling and, Object Pooling
- physical vs. logical packaging, Applications, DLLs, and Components
- proxy, Proxy COM+ Applications
- roles, adding to, Configuring Role-Based Security, Adding Roles to an Application
- security checked at boundaries, Security Boundaries
- surrogate processes, COM+ Surrogate Processes
- COM+ Catalog, COM+ Component Services
- accessing from within .NET components, Programming the COM+ Catalog
- Component Services Explorer and, The Catalog Programming Model
- Dead Letter Queue Monitor (DLQM) and, Client-side exception handling
- examples of using interfaces, Using the Catalog Interfaces, Using the Catalog Interfaces
- interacting with the, Interacting with the Catalog, Object Properties Interdependencies
- interdependencies of object properties, Object Properties Interdependencies
- interfaces, limitations of, Adding a Transient Subscription
- programming the, Programming the COM+ Catalog, Summary
- registering transient subscriptions with, Adding a Transient Subscription, Adding a Transient Subscription
- RegSvcs adding serviced components to, Manual Registration
- replicating, Features of COMAdminCatalog
- root object (see root object of COM+ Catalog)
- structure of, Catalog Structure, Catalog Structure
- transactions and, The COM+ Catalog and Transactions
- transient subscriptions and, Adding a Transient Subscription
- COM+ component services, COM+ Component Services, COM+ Component Services
- configured components (see configured components, COM+)
- encapsulation via interception, Encapsulation via Interception in COM+, Assigning Objects to Contexts
- COM+ context, COM+ Context , Summary
- accessing, Accessing the COM+ Context
- EventTrackingEnabled attribute and, COM+ Context Attributes
- MustRunInClientContext attribute, COM+ Context Attributes
- COM+ events service (see events service)
- COM+ logbooks (see logbooks)
- COM+ security (see security)
- COM+ transactions (see transactions)
- COMAdmin namespace, Programming the COM+ Catalog
- COMAdmin.COMAdminCatalog, creating root object with, The Catalog Root Object
- COMAdminActivationInproc enum value, The ICatalogObject Interface
- COMAdminActivationLocal enum value, The ICatalogObject Interface
- CoMarshalInterface(), Cross-Context Manual Marshaling
- global interface table (GIT) and, The Global Interface Table
- CoMarshalInterThreadInterfaceInStream(), Cross-Context Manual Marshaling
- command-line switches, Manual Registration
- Commit(), Nontransactional Clients
- committing
- changes to catalog collections, Saving Changes
- transactions, The Atomic Property
- Common Language Runtime environment (see CLR environment)
- compensating transactions, Compensating Transactions
- Component Install Wizard, Adding a Component to a COM+ Application, Adding an Event Class, Supplying the Event Class Definition
- Component Services Explorer, The Component Services Explorer
- adding event classes to, Adding an Event Class
- COM+ Catalog and, The Catalog Programming Model
- configuring, Component Services Explorer Configuration
- access control, Authorization
- transactions, Configuring Transactions, Transaction Support IDL Extension
- deactivating objects with JITA, Using JITA, COM+ Just-in-Time Activation
- enabling construction string support, COM+ Constructor String
- importing
- components into, Designing Queued Component Interfaces
- components with IDL extensions, Transaction Support IDL Extension
- logbooks, configuring, Configuring the Logbook, Configuring the Logbook
- registering components with, Dynamic Registration
- requesting JITA objects in callerÕs context, Requesting a JITA Object in the Caller’s Context
- resolving in-doubt transactions, In-Doubt Transactions
- setting global configurations, Machine-Wide Security Settings
- tracing transactions, Tracing Transactions
- tracking instance activity, Tracking Instance Activity
- vs. using attributes, Developing Serviced Components
- component-level
- disabling/enabling access checks at, Component-Level Access Checks
- transaction timeouts, Transaction Execution Time
- ComponentAccessControl attribute, Component-Level Access Checks
- Components collection, Catalog Structure, The ICatalogCollection Interface
- COMREPL utility, Features of COMAdminCatalog
- COMSVCSLib namespace, The TransactionContext Object, Queued component exception class
- concurrency model
- Concurrency tab, COM+ Configuration Settings
- ConcurrentApps property, Application pooling
- configured components, COM+, COM+ Configured Components
- aliasing in COM+ 1.5, Aliasing Components
- combining JITA with object pooling, Combining JITA with Object Pooling
- instance management services and, Instance Management and Scaling
- tracking instance activity, Tracking Instance Activity
- promoting legacy components to, Legacy Components
- relationship between assembly version and, Understanding Serviced Component Versions
- surrogate processes and, COM+ Surrogate Processes
- transactional objects and, Transactions and JITA
- Connect authentication level, Authentication = Connect, Configuring Application-Level Security Settings
- Connect(), Features of COMAdminCatalog
- connection points, Classic COM Events
- establishing, Classic COM Events
- consistency (transaction property), The Consistent Property
- compensating transactions and, Compensating Transactions
- enforcing, Transactional Object Life Cycle
- jeopardized by nontransactional clients, Nontransactional Clients
- setting consistency bit, Voting on a Transaction
- threatened by nontransactional objects, Transaction Disabled
- consistency bit
- auto-deactivating methods, The AutoComplete Attribute
- SetComplete() and, The IObjectContext Interface
- setting, Voting on a Transaction
- voting on transactions without exception handling, Voting on the Transaction
- Construct(), Object Constructor String
- logbook components and, How Does the Logbook Work?
- overriding by serviced components, COM+ Constructor String
- ConstructionEnabled attribute, COM+ Constructor String
- constructor string objects, Object Constructor String
- .NET serviced components and, COM+ Constructor String
- logbook components and, How Does the Logbook Work?
- context activation settings, improvements in COM+ 1.5, Improved Context Activation Setting
- context IDs. retrieving, The Context Object
- context objects, The Context Object, The Context Object
- accessing with ContextUtil class, Accessing the COM+ Context
- disposing of, COM+ Object Pooling
- IObjectContextInfo2 interface (COM+ 1.5) and, Application Partitioning
- IServerSecurity interface and, Server-Side Impersonation
- security boundaries and, Security Boundaries
- setting consistency bit, Voting on a Transaction, Voting on the Transaction
- context-specific initialization and objects, Object Pooling and Context, JITA and IObjectControl, Using IObjectControl
- contexts
- activities and, Activities and Contexts
- assigning objects to, Assigning Objects to Contexts
- placing pooled objects in, Object Pooling and Context, Object Pooling and Context
- transactions and, Transactions and Context, Transactions and Context
- ContextUtil helper class, Accessing the COM+ Context
- voting on transactions, Voting on the Transaction, Web services and transactions
- CONTEXT_E_ABORT error code, Nontransactional Clients
- CONTEXT_E_ABORTING error code, Voting on a Transaction
- CONTEXT_E_NOTRANSACTION error code, Voting on a Transaction
- CONTEXT_E_OLDREF error code, Passing Subroot Objects to Clients
- copying components in COM+ 1.5, Aliasing Components
- CopyProxy(), Programmatic Client-Side Security
- CoRevertToSelf(), Server-Side Impersonation
- CoSetProxyBlanket(), Programmatic Client-Side Security
- CoUnmarshalInterface(), Cross-Context Manual Marshaling
- Count property of ICatalogCollection interface, The ICatalogCollection Interface
- CO_E_ACTIVATIONFAILED_TIMEOUT error code, Configuring Pool Parameters
- CO_E_ATTEMPT_TO_CREATE_OUTSIDE_CLIENT_CONTEXT error code, Requesting a JITA Object in the Caller’s Context
- CO_E_INITIALIZATIONFAILED error code, JITA and IObjectControl
- CO_E_ISOLEVELMISMATCH error code, Configurable Transaction Isolation Level
- CreateInstance(), Nontransactional Clients
- CreateObject()
- moving messages between queues, The MessageMover class
- new moniker, alternative to, Invoking Queued Components on the Client Side
- CreateServiceForApplication(), Service Activation Type
- CreationTimeout property (ObjectPooling attribute), COM+ Object Pooling
- criteria, filtering (see filtering, criteria)
- cross-context manual marshaling, Cross-Context Manual Marshaling, The GIT Wrapper Class
- CurrentCall property (SecurityCallContext class), Verifying Caller’s Role Membership
- custom interfaces, COM+ Configured Components
- custom subscription properties, defining, Custom subscription properties
D
- data integrity, authenticating, Authentication, Setting the Authentication Level, Client authentication level compatibility
- DCOM (Distributed COM), COM+ Component Services
- DCOM Config folder (COM+ 1.5), Legacy Applications
- DCOMCNFG, managing legacy components with, Legacy Applications and Components
- DCOMCNFG.EXE utility, Machine-Wide Security Settings
- Deactivate(), Object Pooling and Context
- JITA (Just-in-Time Activation) and, JITA and IObjectControl
- overriding ServicedComponent implementation of, IObjectControl, JITA, and Deterministic Finalization
- transactions and pooled objects, Transactions and Object Pooling, Transactions and Object Pooling
- DeactivateOnReturn property, COM+ Just-in-Time Activation
- deactivating JITA objects, Using JITA, Using JITA, Transactions and JITA, COM+ Just-in-Time Activation
- Dead Letter Queue Monitor (DLQM), Client-side exception handling
- dead queues, Handling Poison Calls
- deadlocks, The Isolated Property
- acquiring resources and, Acquiring Resources
- multithreaded apartment objects, Apartments: The Classic COM Solution
- preventing with transaction timeouts, Transaction Execution Time
- declarative attributes, COM+ Security
- DECLARE_NOT_AGGREGATABLE(), Pooled Object Design Requirements
- decoupling components, COM+ Event Service, COM+ Event Model
- asynchronous events and, Asynchronous Events
- security issues with, COM+ Events and Security
- Default authentication level, Configuring Application-Level Security Settings
- default context of apartments, Assigning Objects to Contexts
- Default impersonation level, Configuring Application-Level Security Settings
- Default Properties tab, Machine-Wide Security Settings
- Default Security tab, Machine-Wide Security Settings
- Delegate impersonation level, Impersonation = Delegate, Configuring Application-Level Security Settings
- DeleteServiceForApplication(), Service Activation Type
- delivering events, Delivering Events
- deploying COM+ applications, Deploying COM+ Applications , Summary
- deploying role-based security, Deploying and Administering Role-Based Security
- Description attribute, The Description Attribute
- Description property (SecurityRole attribute), Adding Roles to an Application
- designated users, running server applications as, Configuring the Server Application Identity, Configuring the Server Application Identity
- designing role-based security, Designing Role-Based Security
- destructors, using instead of Finalize() in C#, Nondeterministic Finalization
- deterministic finalization, provided by COM+ JITA, IObjectControl, JITA, and Deterministic Finalization
- Disabled synchronization setting, Synchronization Disabled
- Disabled transaction support, Transaction Disabled
- Disabled value, COM+ Transactions
- activity-based synchronization and, COM+ Synchronization
- web services and transactions, Web services and transactions
- disconnected work
- classic COM event model and, Classic COM Events
- MSMQ and, Disconnected Work
- not supported by .NET, COM+ Queued Components
- DisposeObject(), COM+ Object Pooling, IObjectControl, JITA, and Deterministic Finalization, A Queued Component’s Managed Client
- Distributed COM (DCOM), COM+ Component Services
- distributed COM+ events, workarounds for allowing, Distributed COM+ Events, Solution 3: COM+ Routing
- Distributed Transaction Coordinator (see DTC)
- DLLs, Building a COM Component
- .NET assemblies and, Packaging .NET Components: Assemblies
- adding components to COM+ applications, Adding a Component to a COM+ Application, Supplying the Event Class Definition
- assembly files and, Assembly Files
- COM interface types and, COM+ Configured Components
- installing components in applications, Applications, DLLs, and Components
- proxy/stub, COM+ Configured Components
- server applications and, Proxy COM+ Applications
- registering components in, Supplying the Event Class Definition
- DLQM (Dead Letter Queue Monitor), Client-side exception handling
- done bit
- auto-deactivating methods, The AutoComplete Attribute
- JITA objects and, Using JITA, COM+ Just-in-Time Activation
- SetComplete() and, The IObjectContext Interface
- SetDeactivateOnReturn() and, Transactions and JITA
- doomed flag, Collecting Objects’ Votes
- dot (.) operator, Writing .NET Client-Side Code
- DTC (Distributed Transaction Coordinator), The Distributed Transaction Coordinator
- in-doubt transactions, In-Doubt Transactions
- isolation levels in COM+ 1.5, Configurable Transaction Isolation Level
- viewing transaction IDs, Tracing Transactions
- dual directive, COM+ Configured Components
- dump files, generating in COM+ 1.5, Application Dump
- DumpEnabled property, Application Dump
- DumpOnException property, Application Dump
- DumpPath property, Application Dump
- DumpProcess(), Application Dump
- durable storage
- committing transaction changes to, The Durable Property
- JITA objects and, Using JITA
- resource managers and, Resource Managers
- dynamic association of publisher filters with event classes, Installing a publisher filter
- dynamic registration of assemblies, Dynamic Registration
E
- Enabled property
- ApplicationQueuing attribute, COM+ Queued Components
- InterfaceQueuing attribute, Configuring Queued Interfaces
- ObjectPooling attribute, COM+ Object Pooling
- encapsulation
- via interception in COM+, Encapsulation via Interception in COM+, Assigning Objects to Contexts
- via marshaling in COM, Encapsulation via Marshaling in COM, Encapsulation via Marshaling in COM
- EndInvoke(), COM+ Queued Components
- EndTransaction(commit/abort), Single Object/Single Resource Transaction
- enlisting resources, Single Object/Single Resource Transaction, Multiple Objects/Multiple Resources Transaction, Transactions and Object Pooling, Transactions and Object Pooling
- EnlistResource(), Transactions and Object Pooling
- error handling
- .NET serviced components and, Voting on the Transaction
- events service and, Error Handling
- queued components and, Queued Component Error Handling, The MessageMover class, Queued Component Error Handling
- response objects and, Receiving Output from a Queued Component
- ErrorInfo collection, Catalog Structure
- event classes, The Event Class, Event Class Interface Design Guidelines
- adding, Adding an Event Class
- adding transactions to, COM+ Events and Transactions, Transient Subscribers and Transactions
- associating publisher filters with, Installing a publisher filter
- dynamically, Installing a publisher filter
- statically, Static association of a publisher filter with an event class
- copying components in COM+ 1.5, Aliasing Components
- designating serviced components as, COM+ Loosely Coupled Events
- distributed events workaround and, Solution 1: One Machine for All the Subscribers and Event Classes
- generating skeleton implementation, Supplying the Event Class Definition
- implementing, Supplying the Event Class Definition, Supplying the Event Class Definition
- interface design guidelines for, Event Class Interface Design Guidelines
- logbook components, Configuring the Logbook
- machine-specific, Solution 2: Machine-Specific Event Classes
- role-based security and, The Event Class and Role-Based Security
- type libraries and, Supplying the Event Class Definition
- event filtering, Event Filtering, Transient subscriber-side filtering
- event notification, COM+ Component Services
- EventClass attribute, COM+ Loosely Coupled Events
- events service
- CGenericFilter helper class and, The CGenericFilter helper class, The CGenericFilter helper class
- for classic COM, Classic COM Events, Classic COM Events
- for COM+, COM+ Event Model, Summary
- controlling publishing order, Publishing Order
- decoupling components, COM+ Event Service, COM+ Event Model
- asynchronous events and, Asynchronous Events
- security issues with, COM+ Events and Security
- delivering events, Delivering Events
- error handling for, Error Handling
- EventTrackingEnabled attribute and, COM+ Context Attributes
- limitations
- for distributed events, Distributed COM+ Events, Solution 3: COM+ Routing, COM+ Events Limitation
- on number of subscribers, COM+ Events Limitation
- on rate of event publishing, COM+ Events Limitation
- logbooks and, How Does the Logbook Work?, How Does the Logbook Work?
- security and, COM+ Events and Security
- transactions and, COM+ Events and Transactions, Transient Subscribers and Transactions
- workarounds for allowing distributed events, Distributed COM+ Events, Solution 3: COM+ Routing
- EventTrackingEnabled attribute, COM+ Context Attributes
- EVENT_E_ALL_SUBSCRIBERS_FAILED error code, Error Handling
- EVENT_S_NOSUBSCRIBERS error code, Error Handling
- EVENT_S_SOME_SUBSCRIBERS_FAILED error code, Error Handling
- exception classes for queued components, Queued Component Exception Classes, The MessageMover class, Queued component exception class
- exception handling
- .NET serviced components and, Voting on the Transaction
- client-side, Client-side exception handling
- server-side, Server-side exception handling
- ExceptionClass attribute, Queued component exception class
- execution time of transactions, Transaction Execution Time
- E_ACCESSDENIED error code, Authorization
- E_NOINTERFACE error code, Object Constructor String, IDispatch Considerations
F
- /fc switch, Manual Registration
- FilterCriteria property, Transient subscriber-side filtering
- filtering
- criteria, Implementing a publisher filter
- CGenericFilter implementation and, The CGenericFilter helper class
- subscriber-side filtering and, Subscriber-Side Filtering, Transient subscriber-side filtering
- events, Event Filtering, Transient subscriber-side filtering
- publisher (see publisher filtering)
- subscriber-side, Subscriber-Side Filtering, Transient subscriber-side filtering
- persistent, Persistent subscriber-side filtering
- transient, Transient subscriber-side filtering
- FinalClientRetry(), Queued Component Exception Classes
- Finalize(), IObjectControl, JITA, and Deterministic Finalization
- use destructors instead in C#, Nondeterministic Finalization
- FinalServerRetry(), Queued Component Exception Classes
- ÒFire in parallelÓ checkbox, Serial Versus Parallel Publishing
- FireInParallel property (EventClass attribute), COM+ Loosely Coupled Events
- firewalls and rich clients/Internet clients, Client Types
- forms, transaction support for, ASP.NET and transactions
G
- GAC (global assembly cache), installing serviced component assemblies in, Registering Assemblies
- garbage collector, Simplified Object Life Cycle Management
- GetActivityId(), Tracing Activities
- GetCollection(), The Catalog Root Object, The ICatalogCollection Interface
- adding transient subscriptions, Adding a Transient Subscription
- GetInterfaceFromGlobal(), The Global Interface Table
- GetObject(), Invoking Queued Components on the Client Side
- GetPublisherProperty(), Custom subscription properties
- GetSubscriptions(), Implementing a publisher filter
- GetTransaction(), Transactions and Context
- GetTransactionId(), Transactions and Context, Transactions and Object Pooling, Transactions and Object Pooling
- tracing transactions, Tracing Transactions
- GIT (see Global Interface Table)
- global assembly cache (GAC), installing serviced component assemblies in, Registering Assemblies
- Global Interface Table (GIT), The Global Interface Table , The GIT Wrapper Class
- manually marshalling objects outside the NTA, The NTA and Other COM Threading Models
- pooled object data members and, Failing to Release Pooled Object Data Members
- global transaction timeouts, Transaction Execution Time
- Guid attribute, The Guid Attribute
H
- helper macros for logging, Using the Logbook
- HRESULT codes
- deciding on transaction outcomes, Voting on the Transaction
- using standard instead of custom, Designing Queued Component Interfaces
- HTML logger components, Configuring the Logbook
- IObjectControl interface, implementing, How Does the Logbook Work?
- HTTP-POST/HTTP-GET protocols, Web services and transactions
- hub machines and distributed events, Solution 2: Machine-Specific Event Classes
I
- ICatalogCollection interface, The Catalog Programming Model, The ICatalogCollection Interface
- ICatalogObject interface, The Catalog Programming Model, The ICatalogObject Interface
- adding transient subscriptions, Adding a Transient Subscription
- IClientSecurity interface, Programmatic Client-Side Security
- ICOMAdminCatalog interface, The Catalog Programming Model, Features of COMAdminCatalog, Features of COMAdminCatalog
- root object and, The Catalog Root Object
- ICOMAdminCatalog2 interface (COM+ 1.5), Legacy Components
- configuring a service programmatically, Service Activation Type
- dump files, generating, Application Dump
- partitions, managing, Application Partitioning
- pausing/resuming applications programmatically, Pausing Applications
- IConnectionPoint interface, Classic COM Events
- IConnectionPointContainer interface, Classic COM Events
- IContextState interface, The Context Object
- setting consistency bit and, Voting on a Transaction
- setting done bit for JITA objects, Using JITA
- vs. IObjectContext interface, The IObjectContext Interface
- Identify impersonation level, Impersonation = Identify, Configuring Application-Level Security Settings
- Identity tab, Configuring the Server Application Identity
- IDispatch() and queued components, IDispatch Considerations
- IDisposable interface, COM+ Object Pooling, A Queued Component’s Managed Client
- IDL extensions
- designing queued component interfaces, Designing Queued Component Interfaces
- transaction support and, Transaction Support IDL Extension
- IDL files
- building COM components, Building a COM Component
- defining event classes, Supplying the Event Class Definition
- idle time management issues, Idle Time Management
- IEnumEventObject interface, Implementing a publisher filter
- IEventObjectCollection interface, Implementing a publisher filter
- IEventSubscription interface, Implementing a publisher filter
- custom properties and, Custom subscription properties
- IFilterInstaller interface, Static association of a publisher filter with an event class
- IFireControl interface, Parameters-based publisher filtering
- IFiringControl interface, Implementing a publisher filter
- IGlobalInterfaceTable interface, The Global Interface Table
- (see also Global Interface Table)
- IL (intermediate language), .NET Programming Languages
- ILogbook interface, Configuring the Logbook, How Does the Logbook Work?
- IMessage interface, Writing .NET Client-Side Code
- IMessageMover interface, The MessageMover class, The MessageMover class
- Impersonate impersonation level, Impersonation = Impersonate, Configuring Application-Level Security Settings
- ImpersonateClient(), Server-Side Impersonation
- impersonation, Impersonation
- calling clients, Server-Side Impersonation, Server-Side Impersonation
- IClientSecurity interface and, Programmatic Client-Side Security
- library applications and, Securing a Library Application
- scalability issues with, Server-Side Impersonation
- server-side, Server-Side Impersonation, Server-Side Impersonation
- setting levels for server applications, Setting the Impersonation Level, Impersonation = Delegate
- Impersonation property, Configuring Application-Level Security Settings
- ImpersonationLevelOption enum parameter, Configuring Application-Level Security Settings
- ImportComponentAsLegacy(), Legacy Components
- IMultiInterfaceEventControl interface, Implementing a publisher filter, Dynamic association of a publisher filter with an event class
- IMultiInterfacePublisherFilter interface, Implementing a publisher filter
- in-doubt transactions, In-Doubt Transactions
- in-process subscribers, In-Process Subscribers
- loosely coupled events and, COM+ Loosely Coupled Events
- infinite timeouts, Transaction Execution Time
- inheritance, component, Component inheritance
- inherited roles, Configuring Role-Based Security
- Initialize() and publisher filtering, Implementing a publisher filter
- InstallAssembly(), Programmatic Registration
- instance management, COM+ Instance Management, Tracking Instance Activity
- JITA (Just-in-Time Activation), Just-in-Time Activation, JITA and IObjectControl
- object pooling, Object Pooling, Object Pooling and Context
- pitfalls of, COM+ Instance Management Pitfalls, Tracking Instance Activity
- scaling and, Instance Management and Scaling
- tracking instance activity, Tracking Instance Activity
- Integrity authentication level, Configuring Application-Level Security Settings
- interactive users, running server applications as, Configuring the Server Application Identity, Configuring the Server Application Identity
- interception
- encapsulation via, Encapsulation via Interception in COM+, Assigning Objects to Contexts
- JITA (Just-in-Time Activation) and, How JITA Works
- interdependencies of object properties, Object Properties Interdependencies
- interface design
- for event classes, Event Class Interface Design Guidelines
- for queued components, Designing Queued Component Interfaces, Designing Queued Component Interfaces
- for queued components, Configuring Queued Interfaces
- for transaction support, Designing Transactional Interfaces, Designing Transactional Interfaces
- interface types, COM, COM+ Configured Components
- InterfaceQueuing attribute, Configuring Queued Interfaces
- interfaces in .NET, Using Interfaces
- InterfacesForComponent collection, Catalog Structure
- intermediate language (IL), .NET Programming Languages
- internal keyword, Component visibility
- internal objects, Transaction Root
- Internet clients, Client Types
- scaling up with, Scaling Up with Internet Clients
- intranet clients (see rich clients)
- IObjectConstruct interface, Object Constructor String
- .NET serviced components and, COM+ Constructor String
- logbook components and, How Does the Logbook Work?
- IObjectConstructString interface, Object Constructor String
- logbook components and, How Does the Logbook Work?
- IObjectContext interface, Using JITA, Programmatic Role-Based Security
- voting on transactions, The IObjectContext Interface
- IObjectContextActivity interface, Tracing Activities
- IObjectContextInfo interface, The Context Object, The Context Object
- collecting client-side information for logbooks, How Does the Logbook Work?
- ITransaction interface and, Transactions and Context
- IObjectContextInfo2 interface (COM+ 1.5), Application Partitioning
- IObjectControl interface, Object Pooling and Context
- .NET serviced components and, Using IObjectControl
- JITA (Just-in-Time Activation) and, JITA and IObjectControl
- transactions and pooled objects, Transactions and Object Pooling
- IPersistStream interface, Designing Queued Component Interfaces
- Visual Basic persistable objects and, Visual Basic Persistable Objects
- IPlaybackControl interface, Queued Component Exception Classes, Queued component exception class
- IPublisherFilter interface, Implementing a publisher filter
- IRegistrationHelper interface, Programmatic Registration
- IsCallerInRole()
- implementing publisher-side filters, The Event Class and Role-Based Security
- queued components and, Queued Components and Role-Based Security
- returning TRUE when security is not enabled, IsCallerInRole( ) Returns TRUE When Security Is Not Enabled
- verifying caller role membership, Programmatic Role-Based Security, Verifying Caller’s Role Membership
- ISecurityCallContext interface, The Call Object , Programmatic Role-Based Security, Security Boundaries, Verifying Caller’s Role Membership
- implementing publisher-side filters, The Event Class and Role-Based Security
- verifying security is enabled, IsCallerInRole( ) Returns TRUE When Security Is Not Enabled
- IServerSecurity interface, The Call Object , Server-Side Impersonation
- IsInTransaction(), Transactions and Context, Transactions and Object Pooling
- isolation (transaction property), The Isolated Property
- enforcing, Transactional Object Life Cycle
- resource managers and, Resource Managers
- threatened by nontransactional objects, Transaction Disabled
- isolation levels, configuring for transactions in COM+ 1.5, Configurable Transaction Isolation Level, Configurable Transaction Isolation Level
- IsProcessDumpSupported(), Application Dump
- IsProcessPaused(), Pausing Applications
- IsPropertyReadOnly(), The ICatalogObject Interface
- IsPropertyWriteOnly(), The ICatalogObject Interface
- IsResourceOK(), Transactions and Object Pooling
- IsSecurityEnabled property, Verifying Caller’s Role Membership
- IsSecurityEnabled(), IsCallerInRole( ) Returns TRUE When Security Is Not Enabled
- Item property of ICatalogCollection interface, The ICatalogCollection Interface
- ITransaction interface, Transactions and Context
- ITransactionContext interface, Nontransactional Clients
- ITransactionContextEx interface, Nontransactional Clients
- ITransientSubscription interface, Adding a Transient Subscription
- subscriber-side filters and, Transient subscriber-side filtering
J
- JITA (Just-in-Time Activation), COM+ Component Services, Just-in-Time Activation, JITA and IObjectControl, COM+ Just-in-Time Activation, IObjectControl, JITA, and Deterministic Finalization
- activating/deactivating objects, Using JITA, Using JITA
- activities and, Activities and JITA
- context activation settings, improvements in COM+ 1.5, Improved Context Activation Setting
- deterministic finalization provided by, IObjectControl, JITA, and Deterministic Finalization
- done bit, setting, Using JITA
- enabling support for serviced components, COM+ Just-in-Time Activation, IObjectControl, JITA, and Deterministic Finalization
- IObjectControl and, JITA and IObjectControl
- logbook components and, How Does the Logbook Work?
- object pooling and, Combining JITA with Object Pooling, COM+ Object Pooling, How Does the Logbook Work?
- performance vs. scalability, Using JITA
- requesting objects in callerÕs context, Requesting a JITA Object in the Caller’s Context
- transactions and, Transactions and JITA
- Just-in-Time Activation (see JITA)
- JustInTimeActivation attribute, COM+ Just-in-Time Activation
K
- Kerberos
- authentication service and queued components, Queued Components Security Limitations
- Delegate impersonation level and, Impersonation = Delegate
L
- launch security, Launch Security
- layouts, transaction, Transactional Object Life Cycle
- LCE (loosely coupled events), COM+ Event Service
- (see also events service)
- .NET serviced components and, COM+ Loosely Coupled Events, COM+ Loosely Coupled Events
- asynchronous events and, Asynchronous Events
- logbooks and, Configuring the Logbook
- legacy applications
- cannot be disabled in COM+ 1.5, Disabling Applications and Components
- managing under COM+ 1.5, Legacy Applications
- legacy components
- disabling in COM+ 1.5, Disabling Applications and Components
- managing under COM+ 1.5, Legacy Components
- Legacy Components folder (COM+ 1.5), Legacy Components
- LegacyComponents collection, Legacy Components
- LegacyServers catalog collection (COM+ 1.5), Legacy Applications
- library applications, Creating a COM+ Application
- activating, COM+ Application Types
- ApplicationAccessControl attribute and, Configuring Application-Level Security Settings
- ApplicationActivation attribute and, Application Activation Type
- cannot contain queued components, Application Configuration
- configuration mechanisms for, Securing a Library Application
- debugging, Debugging COM+ Applications
- global authentication with no role-based security, Global Authentication Without Role-Based Security
- impersonation levels and, Securing a Library Application
- in-process subscribers and, In-Process Subscribers
- no role-based security or global authentication, Neither Role-Based Security nor Authentication
- role-based security and global authentication, Both Role-Based Security and Global Authentication
- role-based security with no global authentication, Role-Based Security Without Global Authentication
- securing, Securing a Library Application
- surrogate processes and, COM+ Surrogate Processes
- life cycle of pooled objects, Pooled Object Life Cycle
- lightweight proxies, Lightweight Proxies
- listener objects, Queued Components Architecture
- local servers, contained in DCOM Config folder (COM+ 1.5), Legacy Applications
- location transparency, Encapsulation via Marshaling in COM
- locks, causality, Activities: The COM+ Innovation, Causality-Based Lock
- logbook components
- using Both threading model, How Does the Logbook Work?
- configured to use JITA, How Does the Logbook Work?
- object pooling and, How Does the Logbook Work?
- persistent subscribers, Configuring the Logbook
- logbooks, The COM+ Logbook, Summary
- collecting client-side information, How Does the Logbook Work?
- configuring, Configuring the Logbook, Configuring the Logbook
- how they work, How Does the Logbook Work?, How Does the Logbook Work?
- installing, Using the Logbook
- JITA (Just-in-Time Activation) and, How Does the Logbook Work?
- object pooling and, How Does the Logbook Work?, How Does the Logbook Work?
- requirements of, Logbook Requirements
- LOGERROR() macro, Using the Logbook
- LOGERROR_AND_RETURN() macro, Using the Logbook
- LOGEVENT() macro, Using the Logbook
- implementation of, How Does the Logbook Work?
- logging, macros for, Using the Logbook, Using the Logbook
- logical thread affinity, Activities: The COM+ Innovation
- logical vs. physical packaging, Applications, DLLs, and Components
- LOGMETHOD() macro, Using the Logbook
- LOG_ENTRY structure, How Does the Logbook Work?
- loosely coupled events (LCE), COM+ Event Service
- (see also events service)
- .NET serviced components and, COM+ Loosely Coupled Events, COM+ Loosely Coupled Events
- asynchronous events and, Asynchronous Events
- logbooks and, Configuring the Logbook
M
- machine-specific
- event classes, Solution 2: Machine-Specific Event Classes
- persistent subscriptions, Solution 3: COM+ Routing, Solution 3: COM+ Routing
- managed clients, writing for queued components, A Queued Component’s Managed Client
- managed vs. serviced components, .NET Serviced Components
- manifests, assembly, Packaging .NET Components: Assemblies, Assembly Manifest
- manually enlisting resources, Transactions and Object Pooling, Transactions and Object Pooling
- manually registering assemblies, Manual Registration
- Marshal class, A Queued Component’s Managed Client
- marshaling
- cross-context interception via, Cross-Context Manual Marshaling, The GIT Wrapper Class
- encapsulation via, Encapsulation via Marshaling in COM, Encapsulation via Marshaling in COM
- type library, Event Class Interface Design Guidelines
- MaxDumpCount property, Application Dump
- MaxPoolSize property (ObjectPooling attribute), COM+ Object Pooling
- MB_DEFAULT_DESKTOP_ONLY attribute, Configuring the Server Application Identity
- memory dumps of applications, configuring in COM+ 1.5, Application Dump
- memory leaks and application recycling (COM+ 1.5), Application Recycling
- MessageMover class, The MessageMover class, The MessageMover class
- messages
- moving between queues, The MessageMover class, The MessageMover class
- retrying, Handling Poison Calls, Queued Component Error Handling
- metadata in .NET assemblies, Packaging .NET Components: Assemblies, Assembly Metadata
- method parameters, passing in COM objects as, Designing Queued Component Interfaces
- methods
- assigning roles to, Configuring Role-Based Security, Assigning Roles to Component, Interface, and Method
- auto-deactivating, Method Auto-Deactivation, COM+ Just-in-Time Activation
- AutoComplete attribute and, The AutoComplete Attribute
- logbook components and, How Does the Logbook Work?
- implementing on transactional objects, State-Aware Objects
- MethodsForInterface collection, Catalog Structure
- Microsoft Message Queue (see MSMQ)
- Microsoft Transaction Server (MTS), COM+ Component Services
- middle-tier objects
- role-based security and, Designing Role-Based Security
- server-side impersonation and, Server-Side Impersonation
- MinPoolSize property (ObjectPooling attribute), COM+ Object Pooling
- monikers, Invoking Queued Components on the Client Side, A Queued Component’s Managed Client
- MoveMessages(), The MessageMover class
- MSMQ (Microsoft Message Queue), COM+ Queued Components
- (see also queued components)
- auto-retry mechanism and, Auto-Retry Mechanism
- disconnected work and, Disconnected Work
- domain server installation needed for adequate security, MSMQ Setup
- installing, Component Services Explorer Configuration
- queued components and, COM+ Queued Components
- security services for, Queued Components Security
- supporting asynchronous calls with COM, COM+ Queued Components
- transfer transactions and, Queued Components and Transactions, Queued Components and Transactions
- MSMQ Explorer, bringing up, Application Configuration
- MTA (multithreaded apartment) model, Pooled Object Design Requirements, Apartments: The Classic COM Solution
- deadlock potential with, Apartments: The Classic COM Solution
- NTA (neutral threaded apartment) and, The Neutral Threaded Apartment, COM+ and Threading Model
- MTS (Microsoft Transaction Server), COM+ Component Services
- mtxattr.h header file, Designing Queued Component Interfaces
- MultiInterfacePublisherFilterCLSID property, Static association of a publisher filter with an event class
- multiple threads and object-oriented programming, Object-Oriented Programming and Multiple Threads, Object-Oriented Programming and Multiple Threads
- multithreaded apartment (MTA) model, Pooled Object Design Requirements, Apartments: The Classic COM Solution
- deadlock potential with, Apartments: The Classic COM Solution
- NTA (neutral threaded apartment) and, The Neutral Threaded Apartment, COM+ and Threading Model
- multitier vs. two-tier architecture, COM+ Instance Management
- MustRunInClientContext attribute, COM+ Context Attributes
N
- named properties of catalog objects, The ICatalogObject Interface
- comprehensive list of, Using the Catalog Interfaces
- interdependencies of, Object Properties Interdependencies
- namespaces in .NET, Using Namespaces
- .NET
- migrating to with COM+, COM+ Component Services
- vs. COM components, COM+ Component Services
- neutral threaded apartment (NTA) model, Pooled Object Design Requirements, The Neutral Threaded Apartment
- new moniker, Invoking Queued Components on the Client Side
- New Subscription Wizard, Adding a Persistent Subscription
- nonconfigured components, COM+ Configured Components
- nondeterministic finalization in .NET, Nondeterministic Finalization
- None authentication level, Authentication = None, Configuring Application-Level Security Settings
- nontransactional clients, Nontransactional Clients, Nontransactional Clients
- TransactionContext class and, The TransactionContext Object
- nontransactional objects
- AutoComplete attribute and, The AutoComplete Attribute
- vs. transactional objects, Transaction Disabled
- Not Supported synchronization setting, Synchronization Not Supported
- Not Supported transaction support, Transaction Not Supported
- NotSupported value, COM+ Transactions
- activity-based synchronization and, COM+ Synchronization
- web services and, Web services and transactions
- NTA (neutral threaded apartment) model, Pooled Object Design Requirements, The Neutral Threaded Apartment
O
- object constructor strings, specifying, Object Constructor String, COM+ Constructor String, How Does the Logbook Work?
- object constructor, avoiding sensitive work at, Avoid Sensitive Work at the Object Constructor
- object identifiers, State-Aware Objects
- object pooling, COM+ Component Services, Object Pooling, Object Pooling and Context
- .NET serviced components and, COM+ Object Pooling, COM+ Object Pooling
- aggregation and, Pooled Object Design Requirements
- problems with, Pooled Objects and Aggregation
- configuring parameters for, Configuring Pool Parameters, Configuring Pool Parameters
- context and, Object Pooling and Context, Object Pooling and Context
- design requirements, Pooled Object Design Requirements
- DisposeObject() and, COM+ Object Pooling
- failing to release data members, Failing to Release Pooled Object Data Members
- JITA (Just-in-Time Activation) and, Combining JITA with Object Pooling, COM+ Object Pooling, How Does the Logbook Work?
- logbook components and, How Does the Logbook Work?, How Does the Logbook Work?
- threading models for, Pooled Object Design Requirements
- transactions and, Transactions and Object Pooling
- object starvation, Apartments: The Classic COM Solution
- object-oriented programming
- multiple threads and, Object-Oriented Programming and Multiple Threads, Object-Oriented Programming and Multiple Threads
- object-to-thread affinity, Apartments: The Classic COM Solution
- ObjectPooling attribute, COM+ Object Pooling, COM+ Object Pooling
- objects
- activating/deactivating with JITA, Using JITA, Using JITA, Transactions and JITA
- assigning to contexts, Assigning Objects to Contexts
- associating with causality locks, Activities: The COM+ Innovation, Activities and Contexts
- catalog (see catalog objects)
- configured transaction support of, Configuring Transactions, Transaction Support IDL Extension
- context-specific initialization and, Object Pooling and Context, JITA and IObjectControl
- created by nontransactional clients, Nontransactional Clients, Nontransactional Clients
- encapsulating
- via interception in COM+, Encapsulation via Interception in COM+, Assigning Objects to Contexts
- via marshaling in COM, Encapsulation via Marshaling in COM, Encapsulation via Marshaling in COM
- JITA (Just-in-Time Activation), Just-in-Time Activation, JITA and IObjectControl
- life cycle example, Object Life Cycle Example
- NTA (neutral threaded apartment) model and, The Neutral Threaded Apartment, COM+ and Threading Model
- state-aware, State-Aware Objects, State-Aware Objects
- synchronization support for, COM+ Configuration Settings, Required Versus Requires New
- transaction root, Transaction Root
- transactional vs. nontransactional, Transaction Disabled
- voting on transactions, Voting on a Transaction, Voting on a Transaction
- oleautomation directive, COM+ Configured Components
- OLEView, managing legacy components with, Legacy Applications and Components
- outgoing parameters, avoiding on interface methods, Designing Queued Component Interfaces
P
- Packet authentication level, Authentication = Packet , Configuring Application-Level Security Settings
- Packet Integrity authentication level, Authentication = Packet Integrity
- Packet Privacy authentication level, Authentication = Packet Privacy
- Page base class, ASP.NET and transactions
- parallel vs. serial publishing, Serial Versus Parallel Publishing
- parameterized constructors, not allowed with serviced components, Developing Serviced Components
- parameters-based publisher filtering, Parameters-based publisher filtering
- partitioning applications, Application Partitioning, Application Partitioning
- PauseProcess(), Pausing Applications
- peak load, handling with queued components, Workload Buffering
- per-user subscriptions, Per-User Subscriptions
- performance
- logbook applications and, How Does the Logbook Work?
- server-side impersonation and, Server-Side Impersonation
- threading models, Pooled Object Design Requirements
- vs. authentication level, Deciding on the authentication level
- vs. scalability with JITA, Using JITA
- persistent subscriptions, The Event Class, Subscription Types
- adding, Adding a Persistent Subscription
- logbook components, Configuring the Logbook
- loosely coupled events and, COM+ Loosely Coupled Events
- machine-specific, Solution 3: COM+ Routing, Solution 3: COM+ Routing
- queued components and, Asynchronous Subscribers
- routing solution for distributed events, Solution 3: COM+ Routing, Solution 3: COM+ Routing
- subscriber-side filtering and, Persistent subscriber-side filtering
- transactions and, Persistent Subscribers and Transactions
- physical vs. logical packaging, Applications, DLLs, and Components
- Platform SDK documentation, Using the Catalog Interfaces
- player objects, Queued Components Architecture
- poison message syndrome, Handling Poison Calls
- pool parameters, Configuring Pool Parameters
- (see also object pooling)
- configuring, Configuring Pool Parameters, Configuring Pool Parameters, Application pooling
- ObjectPooling attribute and, COM+ Object Pooling
- setting too large a minimum pool size, Too Large a Minimum Pool Size
- Pooling & Recycling tab (COM+ 1.5), Application pooling
- pooling applications (COM+ 1.5), Application pooling
- Populate(), The ICatalogCollection Interface, Saving Changes
- PrepareToFire(), Implementing a publisher filter
- CGenericFilter implementation of, The CGenericFilter helper class
- parameters-based filtering and, Parameters-based publisher filtering
- Privacy authentication level, Configuring Application-Level Security Settings
- private components in COM+ 1.5, Private Components
- PrivateComponent attribute, Private Components
- ProgId attribute, The ProgId Attribute
- programmatic
- registration of assemblies, Programmatic Registration
- role-based security, Programmatic Role-Based Security
- programming languages in .NET, .NET Programming Languages
- PromoteLegacyComponent(), Legacy Components
- properties page, Creating a COM+ Application
- PropertyInfo collection, Catalog Structure
- proxies, lightweight, Lightweight Proxies
- proxy applications, Proxy COM+ Applications
- generating for distributed events workaround, Solution 1: One Machine for All the Subscribers and Event Classes
- proxy/stub
- DLLs, COM+ Configured Components, Proxy COM+ Applications
- encapsulating objects
- via interception in COM+, Encapsulation via Interception in COM+, Assigning Objects to Contexts
- via marshaling in COM, Encapsulation via Marshaling in COM, Apartments: The Classic COM Solution
- propagating activities across contexts, Activities and Contexts
- public keyword, Component visibility
- publisher filtering, Publisher Filtering, Dynamic association of a publisher filter with an event class
- associating with event classes, Installing a publisher filter
- dynamically, Installing a publisher filter
- statically, Static association of a publisher filter with an event class
- CGenericFilter helper class and, The CGenericFilter helper class, The CGenericFilter helper class
- defining custom subscription properties, Custom subscription properties
- filtering criteria and, Implementing a publisher filter
- implementing, Implementing a publisher filter, Implementing a publisher filter
- parameters-based, Parameters-based publisher filtering
- PublisherProperties collection, Catalog Structure, Custom subscription properties
- publishers, COM+ Event Model
- asynchronous, Asynchronous Publishing
- controlling event order, Publishing Order
- event classes and, The Event Class
- in-process subscribers and, In-Process Subscribers
- serial vs. parallel publishing, Serial Versus Parallel Publishing
- subscribers on multiple other machines and, Solution 2: Machine-Specific Event Classes
- transactions, taking part in, COM+ Events and Transactions
Q
- QC.MessageMover, The MessageMover class
- QCAuthenticateMsgs property, Improved Queuing Support
- QCListenerMaxThreads property, Improved Queuing Support
- queue moniker, Invoking Queued Components on the Client Side
- asynchronous publishing and, Asynchronous Publishing
- QUEUEABLE interface attribute, Designing Queued Component Interfaces
- queued components, COM+ Component Services, Features of COMAdminCatalog, COM+ Queued Components, Summary
- (see also MSMQ)
- .NET serviced components and, COM+ Queued Components, The MessageMover class
- application startup and, Queued Component Application Startup
- architecture, Queued Components Architecture, The Listener
- asynchronous events and, Asynchronous Events
- authentication levels, setting, Queued Calls Authentication
- benefits of, Major Benefits of Queued Components, When Should You Use Queued Components?
- changing client workflow, Changes in Workflow
- changing transaction semantics, Synchronous Versus Asynchronous Components
- clients, limitations for, Queued Component Client
- COM+ vs. .NET mechanisms, COM+ Queued Components
- component availability with, Component Availability
- configuring
- applications to host, Application Configuration
- Component Services Explorer, Component Services Explorer Configuration
- interfaces, Queued Component Interface Configuration, Configuring Queued Interfaces
- designing interfaces, Designing Queued Component Interfaces, Designing Queued Component Interfaces
- disconnected work, Disconnected Work
- error handling for, Queued Component Error Handling, The MessageMover class, Queued Component Error Handling
- exception classes for, Queued Component Exception Classes, The MessageMover class, Queued component exception class
- IDispatch-derived interfaces and, IDispatch Considerations
- improvements in COM+ 1.5, Improved Queuing Support
- invoking on client side, Invoking Queued Components on the Client Side, Invoking Queued Components on the Client Side
- monikers and, Invoking Queued Components on the Client Side, A Queued Component’s Managed Client
- passing in as parameters, Receiving Output from a Queued Component
- pitfalls, Queued Components Pitfalls, Queued Component Application Startup
- poison message syndrome and, Handling Poison Calls
- receiving output from, Receiving Output from a Queued Component, Receiving Output from a Queued Component
- response objects and, Receiving Output from a Queued Component, Receiving Output from a Queued Component
- role-based security and, Queued Components and Role-Based Security
- security for, Queued Components Security, Queued Components Security Limitations
- synchronous vs. asynchronous, Synchronous Versus Asynchronous Components, Changes in Workflow
- transactions and, Queued Components and Transactions, Queued Components and Transactions
- when to use, When Should You Use Queued Components?
- writing .NET managed clients for, A Queued Component’s Managed Client
- QueueListenerEnabled property, COM+ Queued Components
- Queuing tab, Application Configuration, Improved Queuing Support
R
- Read Committed isolation level, Configurable Transaction Isolation Level
- Read Uncommitted isolation level, Configurable Transaction Isolation Level
- /reconfig switch, Manual Registration
- recorder objects, Queued Components Architecture
- RecycleActivationLimit property, Programmatic Recycling
- RecycleCallLimit property, Programmatic Recycling
- RecycleExpirationTimeout property, Programmatic Recycling
- RecycleLifetimeLimit property, Programmatic Recycling
- RecycleMemoryLimit property, Programmatic Recycling
- recycling applications (COM+ 1.5), Application Recycling
- REGCLS_SINGLEUSE flag, Application pooling
- registering assemblies with COM+, Registering Assemblies, The ProgId Attribute, Adding Roles to an Application, COM+ Loosely Coupled Events
- RegisterInterfaceInGlobal(), The Global Interface Table
- RegistrationHelper class, Programmatic Registration
- RegSvcs.exe utility, Manual Registration
- RelatedCollectionInfo collection, Catalog Structure
- Remove(), The ICatalogCollection Interface
- RemoveFilter(), Transient subscriber-side filtering
- Repeatable Read isolation level, Configurable Transaction Isolation Level
- replicating the COM+ Catalog, Features of COMAdminCatalog
- Required synchronization setting, Synchronization Required
- vs. Requires New setting, Required Versus Requires New
- Required transaction support, Transaction Required
- Required value, COM+ Transactions
- activity-based synchronization and, COM+ Synchronization
- web services and, Web services and transactions
- Requires New synchronization setting, Synchronization Requires New
- Requires New transaction support, Transaction Requires New
- RequiresNew value, COM+ Transactions
- activity-based synchronization and, COM+ Synchronization
- web services and, Web services and transactions
- resource managers, Resource Managers
- COM+ Catalog as, The COM+ Catalog and Transactions
- ITransaction interface and, Transactions and Context
- state-aware objects and, State-Aware Objects, State-Aware Objects
- transactions and pooled objects, Transactions and Object Pooling, Transactions and Object Pooling
- two-phase commit protocol and, The Two-Phase Commit Protocol
- resources
- acquiring, Acquiring Resources
- auto-enlisting, Resource Managers
- enlisting, Single Object/Single Resource Transaction, Multiple Objects/Multiple Resources Transaction
- manually enlisting, Transactions and Object Pooling, Transactions and Object Pooling
- response objects, Receiving Output from a Queued Component, Receiving Output from a Queued Component, Queued Components and Transactions
- ResumeProcess(), Pausing Applications
- retry queues, Handling Poison Calls, Queued Component Error Handling
- RevertToSelf(), Server-Side Impersonation
- RevokeInterfaceFromGlobal(), The Global Interface Table
- rich clients, Client Types
- JITA (Just-in-Time Activation), Just-in-Time Activation, JITA and IObjectControl
- scaling up with, Scaling Up with Rich Clients
- rich user interfaces, Scaling Up with Rich Clients
- role-based security, COM+ Security
- administering, Deploying and Administering Role-Based Security
- benefits of, Role-Based Security Benefits
- COM+ vs. .NET, COM+ Security
- configuring, Configuring Role-Based Security, Configuring Role-Based Security
- defining access control, Authorization
- deploying, Deploying and Administering Role-Based Security
- designing, Designing Role-Based Security
- disabling, Role-Based Security Without Global Authentication
- enabling authorization for
- library applications, Securing a Library Application
- server applications, Enabling Authorization
- event classes and, The Event Class and Role-Based Security
- imported legacy components and, Global Authentication Without Role-Based Security
- IsCallerInRole() and, IsCallerInRole( ) Returns TRUE When Security Is Not Enabled, IsCallerInRole( ) Returns TRUE When Security Is Not Enabled
- programmatic, Programmatic Role-Based Security
- queued components and, Queued Components and Role-Based Security
- securing a library application, Securing a Library Application
- Security Level properties group and, Setting the Security Level
- subscribers and, Subscribers and Role-Based Security
- roles
- adding to applications, Configuring Role-Based Security, Adding Roles to an Application
- allocating users to, Deploying and Administering Role-Based Security
- granting access to
- components/interfaces/methods, Configuring Role-Based Security, Assigning Roles to Component, Interface, and Method
- everyone via SetEveryoneAccess property, Adding Roles to an Application
- inherited, Configuring Role-Based Security
- Roles collection, Catalog Structure
- RolesForComponent collection, Catalog Structure
- RolesForInterface collection, Catalog Structure
- RolesForMethod collection, Catalog Structure
- root object of COM+ 1.5 Catalog, Legacy Components
- root object of COM+ Catalog, The Catalog Programming Model, The Catalog Root Object
- ICOMAdminCatalog interface, Features of COMAdminCatalog, Features of COMAdminCatalog
- shutting down/starting up COM+ applications, Features of COMAdminCatalog
- routing events to multiple machines, Solution 3: COM+ Routing, Solution 3: COM+ Routing
- RPC_E_CALL_COMPLETE error code, The Call Object
- Running Processes folder and pausing applications, Pausing Applications
S
- SaveChanges(), The ICatalogCollection Interface, Saving Changes
- scalability, COM+ Instance Management
- instance management and, Instance Management and Scaling
- Internet clients and, Scaling Up with Internet Clients
- rich clients and, Scaling Up with Rich Clients
- server-side impersonation and, Server-Side Impersonation
- vs. performance with JITA, Using JITA
- security, COM+ Component Services, COM+ Security
- .NET serviced components and, COM+ Security, Verifying Caller’s Role Membership
- basic terms and concepts, Basic Security Terms, Summary
- checked at application boundaries, Security Boundaries
- client-side, Programmatic Client-Side Security
- configuring, Configuring Role-Based Security
- at interface level, Configuring Role-Based Security
- for library applications, Configuring Application-Level Security Settings
- for server applications, Configuring Application-Level Security Settings
- events service and, COM+ Events and Security
- fine-tuning, Programmatic Role-Based Security
- lightweight proxies and, Lightweight Proxies
- limitations for queued components, Queued Components Security Limitations
- need for, The Need for Security
- pitfalls, COM+ Security Pitfalls
- queued components and, Queued Components Security, Queued Components Security Limitations
- role-based (see role-based security)
- server-side impersonation, Server-Side Impersonation, Server-Side Impersonation
- security blankets, Programmatic Client-Side Security
- security identity, Security Identity
- configuring for server applications, Configuring the Server Application Identity
- impersonation level and, Impersonation, Impersonation = Identify
- queued components security and, Queued Components Security
- Windows stations and, Configuring the Server Application Identity
- security level, setting for server applications, Setting the Security Level
- security settings
- checking after changing application activation mode, Changing Application Activation Mode
- configuring application-level, Configuring Application-Level Security Settings, Configuring Application-Level Security Settings
- disabling changes to, Disabling Changes to the Application Configuration
- Security tab
- for library applications, Securing a Library Application
- for server applications, Enabling Authorization
- SecurityCallContext class, Verifying Caller’s Role Membership
- SecurityRole attribute, Adding Roles to an Application, Assigning Roles to Component, Interface, and Method
- serial vs. parallel publishing, Serial Versus Parallel Publishing
- Serialized isolation level, Configurable Transaction Isolation Level
- server applications, Creating a COM+ Application
- activating, COM+ Application Types
- ApplicationAccessControl attribute, Configuring Application-Level Security Settings
- ApplicationActivation attribute and, Application Activation Type
- configuring
- as system service (COM+ 1.5), Service Activation Type
- security identity of, Configuring the Server Application Identity
- debugging, Debugging COM+ Applications
- deploying, Deploying COM+ Applications
- enabling authorization for, Enabling Authorization
- idle time management and, Idle Time Management
- pooling applications (COM+ 1.5), Application pooling
- proxy exports and, Proxy COM+ Applications
- recycling applications in COM+ 1.5, Application Recycling, Programmatic Recycling
- running as
- activator, Configuring the Server Application Identity
- designated user, Configuring the Server Application Identity, Configuring the Server Application Identity
- interactive user, Configuring the Server Application Identity, Impersonation = Delegate
- securing, Securing a Server Application
- setting
- authentication levels for, Setting the Authentication Level, Client authentication level compatibility
- impersonation levels for, Setting the Impersonation Level, Impersonation = Delegate
- security level for, Setting the Security Level, Setting the Security Level
- surrogate processes and, COM+ Surrogate Processes
- Server name property and persistent subscriptions, Solution 3: COM+ Routing
- server-side
- exception handling, Server-side exception handling
- impersonation, Server-Side Impersonation, Server-Side Impersonation
- service applications in COM+ 1.5, Service Activation Type
- service context switch, Lightweight Proxies
- serviced components (see .NET serviced components)
- ServicedComponent base class, Developing Serviced Components
- DisposeObject() and, COM+ Object Pooling, A Queued Component’s Managed Client
- IObjectConstruct interface and, COM+ Constructor String
- object pooling and, COM+ Object Pooling
- using IObjectControl, Using IObjectControl
- ServiceName property, Service Activation Type
- SetAbort(), The IObjectContext Interface
- SetBlanket(), Programmatic Client-Side Security
- SetComplete(), Using JITA, The IObjectContext Interface
- SetDeactivateOnReturn(), Using JITA, Transactions and JITA
- SetEveryoneAccess property (SecurityRole attribute), Adding Roles to an Application
- SetMultiInterfacePublisherFilter(), Dynamic association of a publisher filter with an event class
- SetMyTransactionVote(), Voting on a Transaction
- SetRecycleByActivations(), Programmatic Recycling
- ShouldFire(), The CGenericFilter helper class, The CGenericFilter helper class
- ShutdownApplication(), Features of COMAdminCatalog, Features of COMAdminCatalog
- signing assemblies, Registering Assemblies
- Simple Object Access Protocol (SOAP), Web services and transactions
- single-threaded apartment (STA) model, Pooled Object Design Requirements, Apartments: The Classic COM Solution
- NTA (neutral threaded apartment) and, The Neutral Threaded Apartment, COM+ and Threading Model
- object starvation and, Apartments: The Classic COM Solution
- when to use, COM+ and Threading Model
- singleton, configuring a COM+ component to be, Combining JITA with Object Pooling
- sink interfaces, COM+ Event Service
- adding persistent subscriptions, Adding a Persistent Subscription
- adding transient subscriptions, Adding a Transient Subscription
- in classic COM, Classic COM Events
- event class definitions and, Supplying the Event Class Definition, Supplying the Event Class Definition
- implementing, COM+ Loosely Coupled Events
- input parameters only for methods, Event Class Interface Design Guidelines
- managing in classic COM, Classic COM Events
- SOAP (Simple Object Access Protocol), Web services and transactions
- STA (single-threaded apartment) model, Pooled Object Design Requirements, Apartments: The Classic COM Solution
- NTA (neutral threaded apartment) and, The Neutral Threaded Apartment, COM+ and Threading Model
- object starvation and, Apartments: The Classic COM Solution
- when to use, COM+ and Threading Model
- standard vs. lightweight proxies, Lightweight Proxies
- StartApplication(), Features of COMAdminCatalog
- state-aware objects, State-Aware Objects, State-Aware Objects
- static association of publisher filters with event classes, Static association of a publisher filter with an event class
- statistics
- collecting, Tracking Instance Activity
- EventTrackingEnabled attribute and, COM+ Context Attributes
- transaction, Transaction Statistics
- subpooling and transactional-pooled objects, Transactions and Object Pooling
- subroot objects, avoid passing to clients, Passing Subroot Objects to Clients
- subscriber-side filtering, Subscriber-Side Filtering, Transient subscriber-side filtering
- SubscriberProperties collection, Catalog Structure
- subscribers, COM+ Event Model
- advantages/disadvantages of queued components, Asynchronous Subscribers
- asynchronous, Asynchronous Subscribers
- custom properties, defining, Custom subscription properties
- distributed events workaround and, Solution 1: One Machine for All the Subscribers and Event Classes
- event classes and, The Event Class
- GetSubscriptions() and, Implementing a publisher filter
- in-process, In-Process Subscribers
- per-user subscriptions, Per-User Subscriptions
- persistent (see persistent subscriptions)
- propagating publisher transactions, COM+ Events and Transactions
- residing on multiple other machines, Solution 2: Machine-Specific Event Classes
- role-based security and, Subscribers and Role-Based Security
- serial vs. parallel publishing, Serial Versus Parallel Publishing
- transient (see transient subscriptions)
- types of, Subscription Types, Adding a Transient Subscription
- SubscriptionData structure, The CGenericFilter helper class
- SubscriptionsForComponent collection, Catalog Structure
- Supported synchronization setting, Synchronization Supported
- Supported transaction support, Transaction Supported
- Supported value, COM+ Transactions
- activity-based synchronization and, COM+ Synchronization
- web services and, Web services and transactions
- surrogate processes for COM+, COM+ Surrogate Processes
- switches, command-line, Manual Registration
- synchronization, COM+ Component Services
- .NET serviced components and, COM+ Synchronization
- achieved by
- logical thread affinity (COM+), Activities: The COM+ Innovation
- object-to-thread affinity (COM), Apartments: The Classic COM Solution
- activity-based, COM+ Concurrency Model
- apartments and, Apartments: The Classic COM Solution
- causality-based, Causality-Based Lock
- configuring for COM+ components, COM+ Configuration Settings, Required Versus Requires New
- disabling support for, Synchronization Disabled
- encapsulation via marshaling, Encapsulation via Marshaling in COM
- lightweight proxies and, Lightweight Proxies
- logbook components and, How Does the Logbook Work?
- object-oriented programming and multiple threads, Object-Oriented Programming and Multiple Threads, Object-Oriented Programming and Multiple Threads
- Required vs. Required New settings, Required Versus Requires New
- required with transactional objects, Activities and Transactions
- Synchronization attribute, COM+ Synchronization
- SynchronizationOption enum parameter, COM+ Synchronization
- synchronous vs. asynchronous components, Synchronous Versus Asynchronous Components, Changes in Workflow
- System.EnterpriseServices namespace, Developing Serviced Components
- ApplicationActivation attribute and, Application Activation Type
- ApplicationID attribute and, The ApplicationID Attribute
- ApplicationName attribute and, Specifying Application Name
- Synchronization attribute and, COM+ Synchronization
- System.EnterpriseServices.Admin namespace, Programming the COM+ Catalog
- System.Object class, .NET components derive from, Simplified Component Development
- System.Runtime.InteropServices namespace, The Guid Attribute, A Queued Component’s Managed Client
- System.Runtime.Remoting.Context namespace, COM+ Synchronization
- System.Web.Services namespace, Web services and transactions
T
- test clients, writing, Writing a Test Client
- Thread Local Storage (TLS), COM+ and Threading Model
- threading models
- incompatibilities between, Encapsulation via Marshaling in COM, Assigning Objects to Contexts, Cross-Context Manual Marshaling
- logbook components and, How Does the Logbook Work?
- object pooling design issues, Pooled Object Design Requirements
- object-oriented programming and multiple threads, Object-Oriented Programming and Multiple Threads, Summary
- threads, logical, Activities: The COM+ Innovation
- timeouts
- component-level transaction, Transaction Execution Time
- global transaction, Transaction Execution Time
- setting idle, Idle Time Management
- TLBATTR_QUEUEABLE attribute, Designing Queued Component Interfaces
- TLBATTR_TRANS_REQUIRED attribute, Transaction Support IDL Extension
- TLS (Thread Local Storage), COM+ and Threading Model
- top-level collections, The Catalog Programming Model
- (see also catalog collections)
- accessing remote, Features of COMAdminCatalog
- accessing with GetCollection(), The Catalog Root Object
- TPM (Transaction Processing Monitor), Transaction Basics
- TraceComponents(), Using the Catalog Interfaces, Using the Catalog Interfaces
- tracing
- activities, Tracing Activities
- transactions, Tracing Transactions
- Transaction attribute, COM+ Transactions, Configurable Transaction Isolation Level
- transaction context components, Nontransactional Clients, Nontransactional Clients
- transaction layouts, Transactional Object Life Cycle
- Transaction Processing Monitor (TPM), Transaction Basics
- transaction root, Transaction Root
- transaction stream, Transactional Object Life Cycle
- transactional vs. nontransactional objects, Transaction Disabled
- TransactionContext class, The TransactionContext Object
- TransactionMode property, ASP.NET and transactions
- TransactionOption enum parameter, COM+ Transactions
- TransactionOption property (WebMethod attribute), Web services and transactions
- transactions, COM+ Component Services, COM+ Transactions, Accessing Objects Outside the Transaction
- .NET serviced components and, COM+ Transactions, The TransactionContext Object
- aborting, The Atomic Property, Voting on a Transaction, Voting on the Transaction, Voting on the Transaction
- accessing objects outside, Accessing Objects Outside the Transaction
- activities and, Activities and Transactions
- allocation decision matrix, Configuring Transactions
- architecture, COM+ Transactions Architecture, COM+ Transactions Architecture Benefits
- ASP.NET and, ASP.NET and transactions
- COM+ Catalog and, The COM+ Catalog and Transactions
- committing, The Atomic Property, Nontransactional Clients
- compensating, Compensating Transactions
- configuring, Configuring Transactions, Transaction Support IDL Extension
- contexts and, Transactions and Context, Transactions and Context
- deadlocks between, The Isolated Property
- design pitfalls, COM+ Transactions Pitfalls
- designing interfaces for, Designing Transactional Interfaces, Designing Transactional Interfaces
- events service and, COM+ Events and Transactions, Transient Subscribers and Transactions
- execution time of, Transaction Execution Time
- global timeouts and, Transaction Execution Time
- in-doubt, In-Doubt Transactions
- isolation levels, configuring in COM+ 1.5, Configurable Transaction Isolation Level
- JITA and, Transactions and JITA
- life cycle of objects, Transactional Object Life Cycle, Object Life Cycle Example
- MSMQ and, MSMQ Participates in Transactions
- multiple objects/multiple resources, Multiple Objects/Multiple Resources Transaction
- multiple objects/single resource, Multiple Objects/Single Resource Transaction
- nontransactional clients, Nontransactional Clients, Nontransactional Clients
- TransactionContext class and, The TransactionContext Object
- object pooling and, Transactions and Object Pooling
- properties of, Transaction Properties, The Durable Property
- queued components and, Queued Components and Transactions, Queued Components and Transactions
- scenarios of, Transaction Scenarios , Multiple Objects/Multiple Resources Transaction
- serialization in, The Isolated Property
- single object/single resource, Single Object/Single Resource Transaction
- statistics on, Transaction Statistics
- tracing, Tracing Transactions
- two-phase commit protocol, The Two-Phase Commit Protocol
- voting on (see voting on transactions)
- web services and, Web services and transactions, Web services and transactions
- TransactionVote, Voting on the Transaction
- TRANSACTION_NOT_SUPPORTED attribute, Transaction Support IDL Extension
- TRANSACTION_REQUIRED attribute, Transaction Support IDL Extension
- TRANSACTION_REQUIRES_NEW attribute, Transaction Support IDL Extension
- TRANSACTION_SUPPORTED attribute, Transaction Support IDL Extension
- transient subscriptions, The Event Class, Subscription Types
- adding, Adding a Transient Subscription, Adding a Transient Subscription
- custom properties and, Custom subscription properties
- loosely coupled events and, COM+ Loosely Coupled Events
- registering with COM+ Catalog, Adding a Transient Subscription, Adding a Transient Subscription
- removing, Adding a Transient Subscription
- subscriber-side filtering and, Transient subscriber-side filtering
- transactions and, Transient Subscribers and Transactions
- TransientSubscription collection, Catalog Structure, Adding a Transient Subscription
- two-phase commit protocol, The Two-Phase Commit Protocol
- two-tier vs. multitier architecture, COM+ Instance Management
- TxIsolationLevel property, Configurable Transaction Isolation Level
- type libraries, Supplying the Event Class Definition
- created by RegSvcs utility, Manual Registration
- generating, Supplying the Event Class Definition
- type library marshaling, COM+ Configured Components, Event Class Interface Design Guidelines
V
- versions of serviced components, understanding, Understanding Serviced Component Versions
- Visual Basic and CLR-compliance, .NET Programming Languages
- Visual Basic clients
- object initialization and, Visual Basic Persistable Objects
- queued components and, Invoking Queued Components on the Client Side
- voting on transactions, Transaction Basics, Voting on a Transaction, Voting on a Transaction
- .NET serviced components and, Voting on the Transaction, Voting on the Transaction
- AutoComplete attribute and, The AutoComplete Attribute
- collecting objectsÕ votes, Collecting Objects’ Votes
- COM+ context and, Transactions and Context, Transactions and Context
- Distributed Transaction Coordinator, The Distributed Transaction Coordinator
- from within web services, Web services and transactions
- two-phase commit protocol and, The Two-Phase Commit Protocol
- web forms and, ASP.NET and transactions
W
- web forms, transaction support for, ASP.NET and transactions
- web services
- support in COM+ 1.5, Web Services in COM+ 1.5
- transactions and, Web services and transactions, Web services and transactions
- WebMethod attribute, Web services and transactions
- WebService base class, Web services and transactions
- Windows stations and security identity, Configuring the Server Application Identity
- workload buffering and queued components, Workload Buffering
- wrapper class, GIT, The GIT Wrapper Class
- wrapper objects
- adding transient subscription filtering criteria, Transient subscriber-side filtering
- adding transient subscriptions, Adding a Transient Subscription, Adding a Transient Subscription
- IFilterInstaller interface and, Static association of a publisher filter with an event class
- registering transient subscriptions with COM+ Catalog, Adding a Transient Subscription, Adding a Transient Subscription
X
- Xact Dead Letter queue, Client-side exception handling
- XML logger components, Configuring the Logbook
- IObjectControl interface, implementing, How Does the Logbook Work?
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.