book

Learning DCOM

by Thuan L. Thai

April 1999

Intermediate to advanced

502 pages

15h 5m

English

O'Reilly Media, Inc.

Read now

Unlock full access

FTPFTPMAIL
Specifications and ReferencesThe ClassicsKnowledge Base ArticlesTechnical ArticlesOther Related Documentation

The Object-Oriented ModelEncapsulationInheritancePolymorphismThe Client/Server Model
Location TransparencyDynamic and Remote Object ActivationSecurityInterfacesLifetime Support and Dynamic DiscoveryBinary InteroperabilityConnection ManagementConcurrency ManagementReuseInterface RepositoryImplementation RepositoryStatic InvocationDynamic InvocationEvents
IUnknownMicrosoft Interface Definition LanguageMIDL basicsDefining a custom interface using MIDLExamining the attributes of IUnknownArrays and strings as interface method parametersCustom types as interface method parametersAdding more custom interfacesDefining a type libraryPublished interfaces must never changeReturn ValuesHRESULTCustom HRESULTsData TypesBase data typesAutomation compatible typesInterface Marshalers: Proxy and StubThe Binary LayoutDispatch and Dual InterfacesAn Interface Recap
Implementing InterfacesIUnknown RulesIdentity rulesExistence rulesImplementing COM ObjectsCOM object definition using the nested classes techniqueCOM object definition using the multiple inheritance techniqueImplementing IUnknown methodsImplementing other interface methods
Standard FactoriesCustom Factories
Server TypesOut-of-process serversIn-process serversInitialization and TerminationOut-of-process serversIn-process serversDynamic Activation SupportOut-of-process serversIn-process serversComponent LifetimeOut-of-process serversIn-process serversImplementation RegistrationOut-of-process serversIn-process serversRegistering interface marshalers
Initialization and TerminationCreating an ObjectCoCreateInstanceCoCreateInstanceExCoGetClassObjectClass monikersInitializing an ObjectUsing an ObjectDeleting an ObjectIn- and Out-of-Process Issues
EncapsulationPolymorphismReuseContainmentAggregationUsing objects that support aggregationDeveloping objects that support aggregation
Simple Data Types and Top-Level PointersSecondary and Embedded PointersCOM API functions for distributed memory managementManaging embedded pointersCharacter PointersAutomation Data TypesMemory management for a BSTRMemory management for a SAFEARRAY
Structure of a Marshaled Interface ReferenceActivationStandard MarshalingMore on activationRemote invocationCustom MarshalingThe object’s responsibilityThe custom proxy’s responsibilityHandler MarshalingAutomation MarshalingRemote Connection Management
Single-Threaded ApartmentBasic requirementsSynchronizationOther issuesSharing Interface Pointers Among ApartmentsMultithreaded ApartmentBasic requirementsSynchronizationOther issuesOut-of-Process Server ConsiderationsIn-Process Server ConsiderationsThreadingModel=“” (default)ThreadingModel=“Apartment”ThreadingModel=“Free”ThreadingModel=“Both”Free-Threaded MarshalerPerformance
Configurable SecurityMachine-wide securityApplication-wide securityApplication identityProgrammable SecurityGeneral application-wide security on both the client and server sideAccess security on the server sideActivation security on the client sideCall-level security on the client sideUsing the security context on the server side
Generated InterfaceGenerated Implementation
Implementing Interface MethodsAdding a Custom InterfaceAdding Another Dual Interface
Initializing and Uninitializing COMCreating the User Interface
Creating an Interface Wrapper ClassThe COleDispatchDriver ClassUsing COM Interfaces with Generated Wrappers
The #import StatementUsing COM Interfaces with Smart PointersNative C++ Compiler FeaturesMore on smart pointersException handling
Remote Activation API FunctionsUsing COM Interfaces Manually
The RemotePtr ClassUsing the RemotePtr Class
Creating the ProjectAdding an ActiveX ControlMerging the Proxy/Stub CodeAdding PropertiesAdding MethodsStep 1: Merging the proxy/stub code for external (remote) interfacesStep 2: Reusing the RemotePtr classStep 3: Coding the OcrImage method
Control ButtonsServer Name and Image LocationWang Image Edit ActiveX ControlOCR ResultsATLCyberOcr ActiveX ControlComplete HTML and VBScript Source CodeProblems with COM over the InternetProblems with securityProblems with firewalls or proxy servers
Creating an MFC ActiveX Control ProjectUnderstanding the generated codeCreating the user interfaceUsing an ActiveX control within an ActiveX controlImplementing the ActiveX Control: CMFCCyberServerCtrlCMFCCyberServerCtrl::OnCreateCMFCCyberServerCtrl::OnDrawImplementing CImagingWindowCImagingWindow::OnCreateCImagingWindow::OnSizeHandling command messages
Creating the ProjectAdding a Composite ControlCreating the User InterfacePutting common controls onto the compositePutting ActiveX controls onto the compositeTesting the user interfaceImplementationImporting the embedded ActiveX controlAdding command handlers in ATLTesting the final product
Playing with Property PagesStep 1: Creating the applicationStep 2: Adding the two viewsStep 3: Adding a splitter windowStep 4: Putting the two ActiveX controls on their appropriate viewsStep 5: Showing the property pagesAdding a Property to CMFCCyberServerCtrl
Creating the Project and a COM ObjectImplementing the SecureOcrImage MethodValidating the Invocation
Constructor and DestructorGetting the Access TokenGetting User InformationGetting Group Information
Creating Message FilesCreating a message file for your componentCompiling a message fileUpdating the Registry with Event Source InformationLogging Messages
Administrative Alert SetupGenerating an Administrative Alert
Setting the Authentication IdentitySetting the Process-Wide SecurityMerging Proxy/Stub Code into a Client EXE ComponentUsing Activation SecurityUsing Call SecurityHandling ErrorsTesting and Understanding COM SecurityTest Scenario I—Observing call-level security and logged eventsTest Scenario II—Observing administrative alertsTest Scenario III—Observing activation security
Creating the ChatBroker ComponentAdding a Broker COM ObjectThe IRegisterChatServer interfaceThe IDiscussions interfaceCaching a List of DiscussionsCChatDiscussionList::AddDiscussionCChatDiscussionList::RemoveDiscussionCChatDiscussionList::GetDiscussionListCChatDiscussionList::GetChatServerCChatDiscussionList::GetSizeChatBroker’s special condition for component lifetime managementImplementing the Interface MethodsMerging Proxy/Stub Code into a Server EXE Component
Creating an Event Source ObjectAdding a Connection PointStep 1: Define a callback interface using MIDLStep 2: Implement a connection point objectStep 3: Add a connection point to the event source objectReceiving and Disseminating a Chat MessageThe Responsibility of the ChatServer ApplicationHandling of command-line optionsRegistering interface marshalersOpening and closing the discussionRunning the ChatServer
Creating the ChatClient ProjectCreating the user interface and adding command handlersMerging proxy/stub code into a project without an IDL FileConnecting to and Disconnecting from a ChatBrokerJoining and Leaving a Chat DiscussionSending a Chat MessageReceiving Chat Messages
Runtime that Simplifies Component Development and UsageHide nonbusiness logic complexitiesSimplify component development and usageServices that Support Large-Scale Enterprise Needs
The main( ) routineThe Class FactoryThe COM Object

Content preview from Learning DCOM

Chapter 3. Objects

In this chapter:

Having gone through a general overview of COM in the last chapter, you now will get intimate with it. First, let’s get one thing straight. COM is nothing new because it builds purely on top of proven successful software technologies, including object-oriented and distributed computing technologies. These technologies thoroughly separate interface from implementation. Everyone who has any exposure to encapsulation and software layering can more or less relate to COM.

Tip

The interface definitions and C++ code that you see in this chapter can be automated by Visual C++ and the ATL wizards with a few mouse clicks. Even so, it’s important for you to see what’s going on in the code and not just rely on clicking a few buttons. You can’t understand what choices to make from the wizards until you know how to create a COM object from scratch. Moreover, performance is heavily affected by the choices that you make. Consider the information in this chapter (and in Chapter 4 and Chapter 5), the internals of the wizard-generated code that is presented in Chapter 6, and onwards. In short, you’ll be empowered with the knowledge gained from Chapter 3 through Chapter 6.

Similar to other programming disciplines, the basics of COM include three things: COM interfaces, COM objects, and COM class factories.^[16] For brevity, we usually leave off the word COM and simply say interfaces, objects, and class factories. In COM programming, an interface ...