book

COM Programming with Microsoft® .NET

by John Paul Mueller, Julian Templeman

February 2003

Intermediate to advanced

544 pages

14h 11m

English

Microsoft Press

Read now

Unlock full access

COM Programming with Microsoft® .NET
A Note Regarding Supplemental Files
Acknowledgments
Introduction
What’s in This BookWho Is the Audience for This Book?Companion ContentWhat You NeedEquipment UsedWorkstation SetupServer SetupReader AidsMicrosoft Press Support
I. The .NET View of COM and COM+
1. COM and .NET
Is COM Dead?How Does COM Work in the .NET World?Differences in the COM and .NET PhilosophiesLocating ComponentsComponent IdentificationObject LifetimesDetermining Object CapabilitiesConstructors and DestructorsNondeterministic FinalizationError HandlingType InformationVisibilityData HandlingUsing .NET Servers with COM ClientsUsing COM Servers with .NET ClientsInterop MarshalingMarshaling StructuresThe Marshal ClassEvent HandlingUsing the IDE to Access ComponentsLocating the Component You NeedLocating COM ComponentsLocating UI ComponentsSimple COM Access ExamplesUsing a COM ComponentUsing an ActiveX ControlSummary
2. COM+ and .NET
What Is the Place of COM+ in the .NET World?COM+ Problems and ImprovementsUsing the Component Services MMC Snap-InAn Overview of the InterfaceCreating COM+ Applications and Installing ComponentsCreating the COM+ ApplicationAdding Components to a COM+ ApplicationAdding Security to a COM+ ApplicationExporting COM+ ApplicationsUsing the .NET Framework Configuration MMC ConsoleManaging Components and ControlsRemoting Services ConfigurationDefining a Runtime Security PolicySummary
3. Using COM Components in .NET Code
COM Interop: Principles and MechanismsInterop AssembliesPrimary Interop AssembliesGenerating Runtime Callable WrappersUsing Visual Studio .NETUsing the TlbImp.exe ToolSimple Use of TlbImp.exeUsing TlbImp.exe OptionsNamespacesResolving ReferencesThe /transform:dispret OptionUsing the TypeLibConverter ClassAssemblies and the GACStrong NamesSigning AssembliesInstalling Assemblies into the GACDelayed SigningGenerating and Installing Primary Interop AssembliesHow COM Entities Are ConvertedDealing with AttributesImporting LibrariesImporting Data TypesHandling void* ArgumentsUsing IntPtr from Visual C#Converting ArraysImporting ClassesImplementing Multiple InterfacesImporting InterfacesImporting MethodsImporting PropertiesImporting Structures, Unions, and EnumerationsStructuresUnionsEnumerationsConstantsImporting TypedefsImporting ModulesHow to Design COM Components for Use with .NETResponding to COM EventsConnection PointsHandling Events from a COM SourceEvents ExampleUsing ActiveX Controls with .NETAdding an ActiveX Control to the ToolboxUsing the Command LineSummary
4. Using .NET Components in COM Applications
The COM Callable WrapperObject IdentityObject LifetimeStandard COM Interfaces on .NET ComponentsCustom Interfaces on .NET ComponentsThe Class InterfaceProblems with Using the Class InterfaceGenerating and Using COM Callable WrappersUsing COM-Related AttributesThe ClassInterface AttributeThe InterfaceType AttributeThe Guid and ProgId AttributesThe ComVisible AttributeThe AutomationProxy AttributeThe IDispatchImpl AttributeThe ComRegisterFunction and ComUnregisterFunction AttributesCreating a Type LibraryCommand-Line ToolsUsing TypeLibConverterSigning the AssemblyRegistering the ComponentUsing .NET Components from COM Client CodeThe Sample ComponentInstalling the Component for COM UseLooking at the Type LibraryUsing the Class in COM CodeExporting Metadata to Type LibrariesExporting AssembliesExporting NamespacesExporting ClassesExporting InterfacesChoosing Interface TypesInterfaces and InheritanceExporting MethodsExporting PropertiesExporting Data TypesExporting Value TypesExporting EnumerationsHow to Design .NET Components for Use with COMProvide a Default ConstructorAvoid Using Static and Overloaded MethodsBe Aware of Possible Naming ProblemsAssembly NamingMethod-Naming ConflictsAvoid Altering InterfacesDefine Event Source InterfacesUse of AttributesProvide HRESULTsUse Versioning CorrectlyHosting Windows Forms Controls in ActiveX Control ContainersRegistry EntriesIdentifying a ControlType Library EntriesMiscellaneous EntriesExample: Hosting a Windows Forms Control in Internet ExplorerExposing .NET Events in COMUsing Explicit Source InterfacesConsuming Events in Visual Basic 6Summary
5. An Overview of COM+ Coding for .NET
COM+ Begins with COMA Look at COM+ InteroperabilityCOM+ Design GoalsTransactions and COM+Messages and COM+COM+ ServicesUnderstanding the Role of DCOM in COM+How Does the Connection Work?Connection-Oriented Data Flow OptimizationCOM+-Specific IssuesApplication TypesServer ApplicationsLibrary ApplicationsProxy ApplicationsPreinstalled ApplicationsError HandlingSecuritySummary

II. Writing COM Code
6. Attributed Programming
What Are Attributes?How Do Attributes Work?Using Attributes in C++ CodeWalkthrough: Creating a Simple COM ComponentSeeing the Inserted CodeAdding COM ObjectsWhat About IDL?Adding Methods and PropertiesTesting the ComponentCreating the Server by HandCreating the Header FileCreating the ATL DLLAdding Interface and Coclass DefinitionsBasic Attributed ProgrammingCreating ModulesUsing the module AttributeThe custom AttributeCreating InterfacesDefining Interface MethodsDispatch InterfacesHandling ArraysCreating CoclassesDefault InterfacesStand-Alone AttributesThe emitidl AttributeHandling AggregationReview of COM Aggregation and DelegationThe aggregatable and aggregates AttributesHandling ErrorsEventsAdding Event SupportManually Writing COM Event CodeHandling EventsCompiler OptionsGenerating IDLSuppressing IDL GenerationSummary
7. ATL and ATL Server
Changes in ATL 7.0New Module ClassesData Handling and CollectionsClasses for Managing Lists, Arrays, and TreesThe CSimpleArray ClassThe CAtlArray ClassSupport for SAFEARRAYsSupport for Collections and EnumeratorsShared ClassesThe CSimpleStringT ClassMemory ManagementCSimpleStringT ExampleThe CStringT ClassPredefined Types for Use with CStringTCStringT ExampleString Conversion ClassesSecurity ClassesRegular Expression ClassesOther ChangesBreaking Changes Since Visual C++ 6.0Introduction to ATL ServerATL Server ArchitectureISAPI ExtensionsWeb Application DLLsServer Response FilesSRF SyntaxHandler and Subhandler TagsIncluding FilesDefining Replacement TagsWriting Web Applications Using ATL ServerUsing AttributesThe request_handler AttributeThe tag_name AttributeDefining Handler MethodsUsing Parsing FunctionsA Sample ATL Server ApplicationCreating the ProjectHandling Simple ArgumentsImplementing Custom ParsingWriting Web Services Using ATL ServerATL Server Web Service ArchitectureSOAP and Web ServicesImplementing Web ServicesExample: Creating a Web ServiceConsuming Web Services in C++Summary
III. Writing COM+ Code
8. A Simple COM+ Example
The Importance of Using GUIDsA Simple Component ExampleCreating the Simple ComponentRegistering the Component on the ServerUsing the GUI MethodUsing the RegSvcs UtilityExporting the ApplicationCreating the ClientTesting the ApplicationA Component Class ExampleDeriving from the Component ClassPerforming the Component Class SetupCreating the ClientA ServicedComponent Class ExampleDeriving from the ServicedComponent ClassPerforming the ServicedComponent Class SetupCreating the ClientSummary
9. Working with Disconnected Applications
Understanding the Role of MSMQ in this ApplicationCreating a Simple Recorder/PlayerDefining the Message QueueAccessing the Message QueueCreating the RecorderTesting the RecorderCreating the PlayerCreating a Simple COM+ Listener/PlayerCreating the Listener/Player ComponentDefining the MSMQ Rule and TriggerTesting the Listener/Player ApplicationCreating the MSMQ Client ApplicationDesigning the Data Encapsulation ComponentDesigning the Message Queue ComponentInstalling the Message Queue ComponentDesigning a Managed ClientTesting the ApplicationSummary
10. Creating Subscriptions
An Overview of the COM+ CatalogWhat Are Subscriptions?Understanding Transient SubscriptionsUnderstanding Permanent SubscriptionsUnderstanding the Need for Dynamic RegistrationCreating the Event ObjectDesigning the ComponentInstalling the Event ObjectCreating the PublisherCreating a Component SubscriberDesigning the Subscriber ComponentInstalling and Testing the Subscriber ComponentCreating a Dialog-Based SubscriberCreating a Permanent SubscriptionTesting the Permanent SubscriptionCreating a Transient SubscriptionTesting the Transient SubscriptionSummary
11. Web Application Scenarios
How Do Web-Based Applications Differ?COM+ 1.5 and SOAPCOM+ 1.5 and Application DumpsComponent InteractionsScripting Error HandlingHuman-Language SupportAccessibility ConcernsASP and Component CommunicationDefining the DatabaseCreating the Data Access ComponentUsing ASP to Access the DatabaseTesting the ApplicationSummary
IV. Interoperability
12. Interacting with Unmanaged Code
Managed and Unmanaged CodeManual and Automatic Memory ManagementInteroperating Between Managed and Unmanaged CodeGarbage Collection in .NETGenerationsThe Large Object HeapRootsFinalizationPlatform InvokeUsing Platform Invoke from Visual Basic .NETUsing the Declare StatementUsing DllImportSpecifying an Entry PointThe CharSet and ExactSpelling ParametersThe PreserveSig ParameterHandling ErrorsConverting Windows API Parameter TypesUsing Platform Invoke from Visual C#Using Platform Invoke from Managed C++Visual C# ConcernsThe unsafe KeywordThe fixed KeywordThe stackalloc KeywordVisual C++ ConcernsMarshaling Argument TypesPinningCalling Exported C++ Member FunctionsIJW (It Just Works)IJW vs. P/InvokeSummary
13. Advanced Interaction
The MarshalAs AttributeMarshaling StringsString and StringBuilderMarshaling StructsThe StructLayout AttributeExplicit LayoutHandling Nested StructuresMarshaling ArraysMarshaling Arrays in Platform InvokePassing Arrays by ValuePassing Arrays by ReferenceMarshaling Arrays in StructuresMarshaling Arrays of StructuresMarshaling Arrays in COM InteropPassing Arrays to COMPassing Managed Pointers to Unmanaged CodePinning in Managed C++Using gcroot in Managed C++Dynamically Loading Platform Invoke DLLsChoosing the Path to the DLL at Run TimeFully Dynamic DLL LoadingUsing CallbacksIntroduction to DelegatesUsing Delegates for CallbacksGarbage Collection ConsiderationsUsing the KeepAlive MethodUsing the HandleRef TypePerformance ConsiderationsSummary
14. Working with Predefined Interfaces
COM Requires Specific InterfacesUsing the OLE/COM Object ViewerA Quick Overview of InterfacesViewing the .NET CategoryViewing an Unmanaged ControlPerforming Interface AnalysisRe-creating COM Interfaces Using Managed CodeCreating a Component with Specialized Interfaces ExampleSummary
About the Author
Air Compressor
Index
About the Authors
Copyright

Overview

Providing both theoretical and practical approaches, this in-depth programming guide explains how to interoperate between COM/COM+ and Microsoft® .NET. Coverage includes writing COM and COM+ code, disconnected applications, and new technologies in .NET.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0735618755Catalog Page Errata

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills