The COM and COM+ Programming Primer

Alan Gordon

796 pages, parution le 22/04/2000

Ajouter à une liste

Indisponible

Résumé

CONTENTS

What's in a Name? COM. Software Component. Programming-Language Independence. Location Transparency. COM as a Software Bus. DCOM. MTS. Fine-Grained Security. Scalability. Resource Management. Distributed Transactions. Windows DNA. COM+. ActiveX. OLE. Summary.
Classes, Objects, and Interfaces. What is Object-Orientation? Algorithmic Decomposition. Object-Oriented Decomposition. Classes. Objects. The Fragile Base Class Problem. Separating Interface and Implementation. Interfaces. COM Classes, Objects, and Interfaces. Summary.
Get on the Software Bus. Software Bus Problems. Naming. Life Cycle Management. Programming-Language Independence. Location Transparency. Extensibility. Versioning. Summary.
Building Your First COM Object. The Simple Spell Checker. A Summary of the Steps. Creating a New DLL Project Using Visual C++. Creating a Custom Interface Using IDL. Adding an IDL File to Your Project. Creating GUIDs for Your Component. Declaring a C++ Class That Implements the COM Interface. Implementing the SpellChecker Interface. Creating a Class Object. Understanding Class Objects. Creating a Class Object for the SpellChecker. Declaring a C++ Class that Implements the IClassFactory Interface. Implementing the IUnknown methods. Implementing the IClassFactory Methods. Creating the Required DLL Entry-Points. Instantiating the Class Object. Implementing DllGetClassObject for the SpellChecker. Unloading the Server. Implementing DllCanUnloadNow for the SpellChecker. Creating the Registration Functions. The Registry API. Implementing DllRegisterServer and DllUnregisterServer. Creating a Client. Creating a Dialog-Based Project Using the MFC AppWizard. Creating the User Interface. Adding the Code Needed to Initialize COM. Implementing the Client. Instantiating the SpellChecker COM Object and Setting the Interface Pointer. Summary.
Making It Simple with ATL and Visual C++ COM Native Support. A Quick Introduction to ATL. The Key ATL Classes. How It All Fits Together. The Writer's Component. The DocumentChecker COM Class. Highlighting the Steps. Creating an ATL Project Using the ATL/COM AppWizard. Adding the Document Checker COM Class Using the ATL Object Wizard. The ATL Object Wizard. Implementing ISpellChecker. Implementing IGrammarChecker. Adding an Empty Interface Definition to the IDL file. Compiling the IDL. Adding the New Interface to the Implementation Class. Adding the CheckGrammar Method to the IGrammarChecker Interface. Implementing the CheckGrammar Method. Creating a Client with Visual C++'s Native COM Support. Creating a Dialog-Based Project Using the MFC AppWizard. Creating the User Interface. Adding the Code Needed to Enable COM Support. Importing the Type Library for Your Server. Adding a Smart Pointer Instance to Your Dialog. Instantiating a COM Object. Implementing the User Interface. Test. Summary.
Creating an Out-of-Process Server. Marshaling. Using the MIDL-Generated Marshaler. Creating a Custom Marshaling DLL. How COM Finds a Marshaling DLL. Instancing. Class Object Registration. Registering an Out-of-Process Server. Building an Out-of-Process Server. A Summary of the Steps. Creating an ATL Executable Project Using the ATL AppWizard. Adding a Test Class to the Server. Implementing the ITestClass Interface. Creating an In-Process Version of Your Server. Creating a Client. Performance Testing. Single-Use Versus Multi-Use Revisited. Summary.
Automation. Defining Automation. IDispatch. GetIDsOfNames. Invoke. GetTypeInfo and GetTypeInfoCount. Using IDispatch. Defining IDispatch Interfaces. Dispinterfaces. Properties. Variants. Creating and Using Variants. BSTRs. Currency. Converting Variants from One Type to Another. Dual Interfaces. Early- and Late-Bound Clients. Building an Automation Server. A Summary of the Steps. Creating an ATL Project Using the ATL/COM AppWizard. Adding a COM Class with a Dual Interface. Adding a Second Interface to the COM Class. Adding Properties and Methods to the COM Class. Implementing the COM class. Creating a Late-Bound and Early-Bound Client. Summary.
COM Callbacks and Connectable Objects. Understand COM Callbacks/Events. Problems with Proprietary Outgoing Interfaces. Connectable Objects. IConnectionPointContainer. IConnectionPoint. IEnumConnections and IEnumConnectionPoints. IProvideClassInfo. Implementing Connection Points. The Connection Point Protocol. Your Multithreaded Stock Monitor Example. A Summary of the Steps. Create a New ATL Project Using the ATL/COM AppWizard. Make the Server Free-Threaded. Add a Free-Threaded, Connection Point-Enabled COM Class. Implement the Connection Point Interface. Add Methods to the Main Interface. Complete the Implementation of Your Server. Summary.
COM Threading. Definitions and Background. Processes. Threads. Multi-Threading. Thread-Safe. Object-Oriented Thread-Safety. Multi-Threading and COM. Determine if an Application Is Multi-Threaded. How an Object Indicates if It Is Thread-Safe. How the COM Runtime Serializes Method Calls. Use the Global Interface Table. Implement Objects That Will Run in Any STA. Implement Objects That Will Run in the Primary STA. Implement Objects That Will Run in the MTA. Implement Objects That Will Run in the TNA. Out-of-Process Servers and Apartments. Compare the Different Threading Models: An Apartment Study. Create an ATL Project Using the ATL/COM AppWizard. Add Five COM Classes Using the ATL Object Wizard. Remove Duplicate IThreadView Interfaces from the IDL. Implement the IThreadView Interface in All Five COM Classes. Create a Client. Testing. Summary.
Distributed COM. The Importance of DCOM. Location Transparency Revisited. AppID. Marshaling. Security. NT Security. Security Tokens. Security Support Providers. COM Security. Authentication. Access Control. Security Token Management. Miscellaneous Security Settings. Programmatic Security. Example: Configuring a Server via DCOM. A Summary of the Steps. Perform a Release Build. Ensure the Server Is Registered on the Client and Server. Ensure the Marshaling DLL is Installed and Registered on the Client and Server. Configure the Server to Run Remotely Using Dcomcnfg. Configure the Client. Test by Using Your Unmodified Client. Modify the Client So You Can Select a Server at Runtime. Testing. Summary.
An Introduction to the COM+ Architecture. Why Do You Need COM+? Enterprise-Class, Distributed Applications. Application Architecture. Software Architecture. Partition Business Applications. Other Application Architectures. DCOM Alone Is Not Enough. Fine-Grained Security. Scalability. Data Integrity. The COM+ Solution. How It Works: The COM+ Architecture. Attribute-Based Programming. The Importance of Context. Interception. Contexts and Apartments. Configure an Object to Use COM+. Preliminaries. COM+ Applications. MTS. Creating a COM+ Application. Summary.
An Introduction to the COM+ Services. Fine-Grained Security. Roles. Use COM+ Security Programmatically. Transactions. What is a Transaction? Distributed Transactions. 2-Phase Commit Protocol. Transactions and COM+. Scalability. JIT Activation. Object Pooling. IObjectControl. Database Connection Pooling. Synchronization. Activities. Queued Components. Design Restrictions on Queued Components. Queued Components and Transactions. Configuring a Queued Component. Using Queued Components. What Is a Moniker? The Queue Moniker. Poison Messages. Load Balancing. Compensating Resource Managers. Summary.
Building a 3-Tiered Application Using COM+ and Windows DNA 2000. What is the Windows DNA? Presentation Layer. Business Layer. Data Layer. MDAC. ODBC. OLEDB. ADO. The Windows DNA 2000. Windows 2000. Host Integration Server 2000. Application Center Server 2000. BizTalk Server 2000. Commerce Server 2000. Microsoft SQL Server 2000. Creating Your First COM+ Application. Configuring Visual C++ to Work With COM+. The Platform SDK. Configuring Visual C++ to Use the Platform SDK. The Publisher Example Program. Building the Publisher Example Application. Creating an ATL, DLL Server Project. Adding Book, Author, and Publisher Classes to the Project Using the ATL Object Wizard. Modifying the Project to Work with COM+ and ADO. Adding Methods to the Book Class. Adding the Author Class Methods. Adding the Publisher Class Method. Adding Support for the IObjectConstruct Interface. Implementing the Book Class Methods. Implementing the Author Methods. Implementing the Publisher Methods. Compiling Your Server. Configuring Your Components. Implementing the Visual Basic Client Application. Implementing the ASP, HTML Client. Object Pooling. Deploying COM+ Applications. Differences Between COM+ and MTS. Debugging with COM+. Setting the Executable for Debug Session in Visual C++. Specifying That a COM+ Application Should Start within a Debugger. Using the Task Manager to Open the Process in the Debugger. Summary.
Queued Components. What are Queued Components? Why Do You Need Queued Components? Microsoft Message Queue. What Is Message Queuing. The Advantages of Message Queuing. Integrate Disparate Systems. Installing and Using MSMQ. What You Will Need. Places to Go for Help. Using Queued Components in Your Example Program. Adding the BookPrinter Class to Your Project. Importing the MSXML Type Library. Adding the Methods for the BookPrinter Class. Adding The Registry Utility Function. Implementing the Methods in the BookPrinter class. Configuring the BookPrinter to be a Queued Component. Modifying Your Client. Summary.
COM+ Events. Why Do You Need COM+ Events? COM+ Events. Creating an Event Class. Creating Subscriptions. Using Queued Components with Events. Using Queued Components Between Publisher and Event Class. Using Queued Components Between the Event Class and the Subscribers. COM+ Events and Transactions. Filtering Events. Publisher Filtering. Parameter Filtering. Using COM+ Events in a Distributed Environment. Your COM+ Stock Monitoring Program. Creating the Event Class Project. Create an ATL, DLL Server Project. Add the Event Class to Your Project. Add the PriceChange and NewStockListed Methods to the Event Class. Configure the Event Class. Create Your Publisher Application. Create the Subscriber Project. Add the Subscriber Class to the Project Using the ATL Object Wizard. Import the Excel Type Library. Implement the Event Interface. Configure the Subscriber Component. Summary.

INDEX.

L'auteur - Alan Gordon

ALAN GORDON, Group Program Manager at FieldCentrix in Irvine, CA, is responsible for FX Service Center, an Internet-based service management and dispatch application built with ASP, COM+, and SQL Server. He is also responsible for E-Service, an ASP.NET-based product that allows field service companies to quickly enable their customers to make and track service calls on the Web.

Caractéristiques techniques

	PAPIER
Éditeur(s)	Prentice Hall
Auteur(s)	Alan Gordon
Parution	22/04/2000
Nb. de pages	796
Format	18 x 23,3
Couverture	Broché
Poids	1550g
Intérieur	Noir et Blanc
EAN13	9780130850324

Avantages Eyrolles.com

Livraison à partir de 0,01 € en France métropolitaine

Paiement en ligne SÉCURISÉ

Livraison dans le monde

Retour sous 15 jours

+ d'un million et demi de livres disponibles

Nouveautés "COM/DCOM, COM+, ATL, et Windows DNA"

La référence du programmeur atl/com

Consultez aussi

Informatique Développement d'applications Programmation Windows COM/DCOM, COM+, ATL, et Windows DNA