|
 Trouver une ressource
Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !
 The COM and COM+ Programming Primer
The COM and COM+ Programming Primer
 Synopsis
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.
Commander ce livre au
prix de
60,95
€
57,9
€
Classé sous : Server, Using, Creating, Com, Class
Livres en rapport
|
Comparez les prix Nouvelle version
HTC G1
Entre 449€ et 449€
|