Tài liệu COM and .NET Component Services

l Chapter 1 introduces the Component Services Explorer and basic COM+ terminology. This chapter deliberately holds
your hand as you develop your first Hello World COM+ component. Subsequent chapters do much less handholding
and assume you are familiar with the COM+ environment. If you already have experience with basic COM+
development, feel free to skip this chapter.
l Chapter 2 demystifies the COM+ context by presenting it as the key mechanism for providing component services
using call interception. Generally, you need not be concerned with contexts at all. However, the COM+ context
underlies the way COM+ services are implemented.
l Chapter 3 describes two scalability-enabling mechanisms that COM+ provides for a modern enterprise application:
object pooling and Just-in-Time Activation (JITA). The discussion of instance management, and especially JITA, is
independent of transactions. Early COM+ documentation and books tended to couple instance management and
transactions. However, I found that not only can you use instance management independently of transactions, but it is
easier to explain it that way. Besides explaining how to best use object pooling and JITA, Chapter 3 describes other
activation and instance management COM+ services such as the constructor string.
l Chapter 4 explains the difficult, yet common, problems that transactions address, and provides you with a distilled
overview of transaction processing and the transaction programming model. The difficult part of writing this chapter
was finding a way to convey the right amount of transaction processing theory. I want to help you understand and
accept the resulting programming model, but not bury you in the details of theory and COM+ plumbing. This chapter
focuses on COM+ transaction architecture and the resulting design considerations you have to be aware of.
l Chapter 5 first explains the need in the component world for a concurrency model and the limitations of the classic
COM solution. It then describes how the COM+ solution, activities, improves deficiencies of apartments.
l Chapter 6 shows how to access component and application configuration information programmatically using the
COM+ Catalog interfaces and objects. Programmatic access is required when using some advanced COM+ services
and to automate setup and development tasks. This chapter provides you with comprehensive catalog structure
diagrams, plenty of sample code, and a handy utility.
l Chapter 7 explains how to secure a modern application using the rich and powerful (yet easy to use) security
infrastructure provided by COM+. This chapter defines basic security concepts and shows you how to design security
into your application from the ground up. You can design this security by using COM+ declarative security via the
Component Services Explorer and by using advanced programmatic security.
l Chapter 8 explains what COM+ queued components are and how to use them to develop asynchronous, potentially
disconnected applications and components. In addition to showing you how to configure queued components, this
chapter addresses required changes to the programming model. If you have ever had to develop an asynchronous

method invocation option for your components, you will love COM+ queued components.
l Chapter 9 covers COM+ loosely coupled events, why there is a need for such a service, and how the service ties into
other COM+ services described in earlier chapters (such as transactions, security, and queued components). Many
people consider COM+ events their favorite service. If you have had to confront COM connection points, you will
appreciate COM+ Events.
l Chapter 10 shows how .NET components can take advantage of the component services described in the previous
chapters. If you are not familiar with .NET, I suggest you read Appendix C first—it contains an introduction to .NET
and C#. Chapter 10 repeats in C# many of the C++ or VB 6.0 code samples found in earlier chapters, showing you
how to implement them in .NET.