COM and .NET Interoperability provides a complete overview of the process of building .NET applications that interact (interoperate) with existing COM code. Before digging into that critical topic, author Andrew Troelsen offers a concise overview of the COM architecture and provides examples using various COM frameworks (C++, ATL, and VB 6.0) as well as the core .NET managed languages (C# and VB .NET).

After covering the preliminaries, the book explores numerous issues that arise in interoperability, including interacting with the Win32 API, dynamically generating source code via System.CodeDOM, creating serviced (COM+) components using managed code, manually editing (and recompiling) .NET metadata, and the process of constructing custom COM/.NET conversion utilities. Both intermediate and advanced developers will welcome the practical information they need to quickly work with COM and COM+ in .NET applications, and learn how to create .NET components that are COM compatible.

The in-depth technical detail of the inner workings of both COM and .NET sets it apart. It says a lot about this title that it is only after 300 pages of introductory material on the inner workings of COM and .NET that the text turns to interoperability between the two. First comes a traditional tour of COM components, including all the gnarly details of Iunknown, GUIDs, type libraries, late binding (and Idispatch), and deployment through the registry. A short section looks at using the Active Template Library (ATL) and its wizards to simplify "traditional" COM components.

The author also examines how to build and deploy equivalent components in .NET, along with some more advanced material on reflection, generating on-the-fly code, and assembly information. Material on emulating late-binding in .NET is also a standout here, as this technique is not obvious under the new Windows.

At the heart of this book are six chapters showing how to get .NET to call COM code and vice versa, organized into beginning, intermediate, and advanced techniques for each. Core material here shows how to invoke COM objects within .NET, as well as ActiveX controls, a worthy addition, as this is likely to be a workable strategy for .NET developers for years to come. Advanced techniques range further afield. When it comes to calling .NET code from older COM code, apart from the basics of invoking .NET from within "traditional" C++ and Visual Basic, the author also shows how to "consume" new .NET classes like collections within COM.

Final sections turn toward other COM+ services, with a full tour of transactions and just-in-time activation (JITA) for building more scalable Windows components. (Here, besides "classic" COM+ components in C++, the author shows how to do it in .NET.) The book rounds out with examples of "fully serviced" Windows components in .NET, including a solid example using a Web service.

While COM is destined to wither away, for the next few years there will be ample opportunity for advanced programmers to leverage an in-depth knowledge of COM and .NET. This book's authoritative treatment of most every conceivable permutation of COM and .NET code interaction makes it the definitive resource on the subject. Armed with this title, any advanced C++/C# developer will be able to mix in old code and new code effectively. --Richard Dragan

Topics covered: Introduction to Platform Invocation (PInvoke) services; calling a traditional DLL from C and C++; using PInvoke to call a traditional DLL with .NET; callback functions in .NET for DLLs; tutorial for COM servers (conventions and built-in interfaces, GUIDs, class factories, deployment); C++ COM clients; IDispatch and scriptable objects; Active Template Library (ATL) basics (including wizard support); COM servers in VB 6; COM IDL files in detail (type libraries and programming reading type info); using C# to view COM type libraries; .NET servers (including assemblies and deployment options); advanced techniques for on-the-fly code generation with the System.CodeDOM APIs; .NET types explained; using .NET reflection APIs (viewing type info in C#); late binding in .NET; basic .NET to COM interoperability (converting COM IDL to .NET types); deploying Interop assemblies; intermediate techniques (including using COM Variants, Param arrays, structures and collections between platforms, events and delegates, error handling); advanced techniques (COM classes implementing .NET interfaces); consuming ActiveX controls in .NET code; modifying Interop assemblies; basic COM to .NET code-sharing techniques (including the COM Callable Wrapper, CCW, the tlbexp.exe utility, COM-aware .NET types); consuming .NET components in VB 6, C++, and VBScript; intermediate COM to .NET techniques (using .NET enumerated types, structures, delegates, and collections within COM); advanced techniques for using .NET in COM (changing type marshaling, custom COM interfaces, defining COM interfaces using managed code, manually defining COM atoms in C#, custom hosts for the .NET runtime); overview of COM+ (including the transactions, pooling, and the COM+ Catalog); classic COM+ components versus .NET equivalentsp; lazy automatic registration; object construction strings; just-in-time activation (JITA); transactional programming in .NET; and sample serviced components (including a Web service example).

COM and .NET Interoperability provides a complete overview on the process of building .NET applications which interact (interoperate) with existing COM code. Before digging into that critical topic, Andrew offers a concise overview of the COM architecture, and provides examples using various COM frameworks (C++, ATL, and VB 6.0). Next, the reader will learn the core aspects of the .NET platform and come to understand the use of both C# and VB .NET during the process. With these primers aside, the remainder of the book covers numerous interoperability issues including interacting with the Windows API, event programming and the process of building custom code conversion utilities.

• Educates readers on the building blocks of the COM and .NET architectures
• Covers the internal aspects of COM /.NET interoperability with minimal focus on integrated Wizard tools
• Readers learn to build custom COM /.NET conversion tools
• Covers accessing COM components, Win32 API, and C DLLs from .NET applications
• Covers COM components accessing .NET types