ASP 3.0 The Complete Reference

Chapter 25

Creating Components (Outline)

Waited until this point so that all related web services could be introduced first.

Deciding When to Create Components

Guidelines for

Advantages of Components

Performance

Scalable

Isolation of business logic

Reuse

Debugging

Strong typing

Early binding

Operating system access

Compiled and protected

Disadvantages of Components

Longer development time

Debugging

Maintenance

Deployment

Designing Your Components

UML strategies

Modeling Tools

Prototyping

Establishing an Interface

Deciding on a Development Language

VB vs C++

Mention Java

Coding Considerations

Complexity of the Task

Supporting Context Within Components

Referencing of the context with which the components can run in. That they can be aware of the ASP environment and can have access to the resources of that environment.

ScriptingContext vs. ObjectContext

Comparison between the script context and object context. C++ is currently using the script context when components are created through the ATL Wizard. However, the script context has been declared obsolete by Microsoft, although it still runs within the system.

Threads

Threading Models

COM+ Services.

An extension to the Component Object Model, COM+ builds on COM's integrated services and features, making it easier for developers to create and use software components in any language, using any tool. Delivered on the Windows-based platform, COM+ is designed to preserve and extend developers' current investments in COM. Applications currently using COM technology will work in the COM+ environment.

Transaction Services.

Intended for line-of-business and electronic-commerce applications with Web-based interfaces, Transaction Services work with COM+ to make it easier to develop and deploy server-centric applications. Transaction Services offer comprehensive component functionality such as automatic transaction support for data-integrity protection; simple role-based security; and access to popular databases, message queuing products, and mainframe-based applications. This feature also includes performance-enhancing features such as connection-pooling.

Object Pooling.

Object pooling is an automatic service provided by COM+ that enables you to configure a component so that instances of it are kept active in a pool, ready to be used by any client that requests the component. You can administratively configure and monitor the pool maintained for a given component, specifying characteristics such as pool size and creation request timeout values. Once the application is running, COM+ manages the pool for you, handling the details of object activation and reuse according to the criteria you have specified. You can achieve significant performance and scalability benefits by reusing objects in this manner, particularly when they are written to take full advantage of reuse.

COM+ Events.

COM+ Events is a Loosely Coupled Events system that stores event information from different publishers in an event store in the COM+ catalog. Subscribers query this store and select the events that they want information about. Selecting event information from the event store creates a subscription. When an event occurs, the event system checks this database to find the interested subscribers, creates a new object of each interested class, and calls a method on that object. COM+ Events is designed to avoid the disadvantages of Tightly Coupled Events (TCE), such as polling, the need for both publisher and subscriber to be running at all times, divergent callback mechanisms, and the inability to filter or intercept an event.

Queued Components.

Queued Components is a key feature of COM+ that is based on Microsoft Message Queuing. It provides an easy way to invoke and execute components asynchronously. Processing can occur without regard to the availability or accessibility of either the sender or receiver. A home shopping network, for example, might benefit from asynchronous processing, where viewers phone in to several operators, orders are taken en masse, and then they are queued for later retrieval and processing by the server.

Shared Properties