(NOTE:
Each chapter concludes with a Conclusion.)
Introduction. I. BACKGROUND.
1. Introduction to the .NET Framework. What Is .NET? Features of the .NET Framework. Concepts Important for This Book. Languages and Tools.
2. Bridging the Two Worlds-Managed and Unmanaged Code. Managed Code Versus Unmanaged Code. How Unmanaged Code Interacts with Managed Code. Unmanaged Code Isn't Always the Answer.
II. USING COMCOMPONENTS IN .NETAPPLICATIONS.
3. The Essentials for Using COM in Managed Code. Referencing a COM Component in Visual Studio .NET. Referencing a COM Component Using Only the .NET Framework SDK. Example: A Spoken Hello, World Using the Microsoft Speech API. The Type Library Importer. Using COM Objects in ASP.NET Pages. An Introduction to Interop Marshaling. Common Interactions with COM Objects. Using ActiveX Controls in .NET Applications. Deploying a .NET Application That Uses COM. Example: Using Microsoft Word to Check Spelling.
4. An In-Depth Look at Imported Assemblies. Converting the Library. Converting COM Data Types. Converting Methods and Properties. Converting Interfaces. Converting Classes. Converting Modules. Converting Structures. Converting Unions. Converting Enumerations. Converting Typedefs. Converting ActiveX Controls.
5. Responding to COM Events. Callbacks in .NET. Callbacks in COM. Handling COM Events in Managed Code. Handling ActiveX Control Events in Managed Code.
6. Advanced Topics for Using COM Components. Do-It-Yourself Marshaling. Threading and Apartments. Troubleshooting an InvalidCastException. Garbage Collection. Securing Unmanaged Calls. Using COM+ and DCOM Objects. Inheriting from COM Classes. Debugging into COM Components. Monitoring Performance.
7. Modifying Interop Assemblies. How to Change an Assembly's Contents. IL Assembler Syntax. Changing Data Types. Exposing Success HRESULTs. Arrays. Custom Attributes. Adding Methods to Modules.
III. USING .NETCOMPONENTS IN COMAPPLICATIONS.
8. The Essentials for Using .NET Components from COM. A Sample .NET Component. Using a .NET Component in Visual Basic 6. Using a .NET Component in Unmanaged Visual C++. Using a .NET Component in Unmanaged JScript. Assembly Registration. The Type Library Exporter. .NET Class Interfaces. Interacting with a .NET Object. Deploying a COM Application That Uses .NET. Hosting Windows Forms Controls in Internet Explorer.
9. An In-Depth Look at Exported Type Libraries. Converting the Assembly. Converting .NET Data Types. Converting Members. Converting Interfaces. Converting Classes. Converting Value Types. Converting Enumerations.
10. Advanced Topics for Using .NET Components. Avoiding Registration. Hosting Windows Forms Controls in Any ActiveX Container. Working Around COM-Invisibility. Using Reflection to Invoke Static Members. Handling .NET Events. Unexpected Casing in Type Libraries. Advanced Shutdown Topics.
IV. DESIGNING GREAT .NETCOMPONENTS FOR COMCLIENTS.
11. .NET Design Guidelines for Components Used by COM Clients. Naming Guidelines. Usage Guidelines. Reporting Errors. Exposing Enumerators to COM. Versioning. Deployment. Testing Your Component from COM.
12. Customizing COM's View of .NET Components. Customizing Data Types. Customizing Structure Layout. Exposing Class Interfaces. Using Visual Basic .NET's ComClassAttribute. Making APIs Invisible to COM. Customizing Registration. Providing Your Own GUIDs. Providing Your Own DISPIDs. Controlling Interface Derivation. Returning a Specific HRESULT. Disabling Type Library Marshaling of .NET Interfaces. Creating Multi-Cultured Methods. Using Optional Parameters in Any Language. Exposing .NET Objects As COM+ Objects.
13. Exposing .NETEvents to COM Clients. Exposing Events Without Using Extra CLR Support. Exposing Events Using Extra CLR Support. Example: Handling a .NET Windows Form's Events from COM.
14. Implementing COM Interfaces for Binary Compatibility. Getting Interface Definitions. Binary Compatibility with Visual Basic 6 Classes. Example: Implementing Office XP Smart Tag Interfaces. Interface Implementation Shortcuts in Visual Studio .NET. Common Problems When Implementing COM Interfaces. COM Interfaces with Default CCW Implementations. COM Interfaces Bridged to Different .NET Types.
V. DESIGNING GREAT COMCOMPONENTS FOR .NETCLIENTS.
15. Creating and Deploying Useful Primary Interop Assemblies. Primary Interop Assembly or Brand New Assembly? Creating a Primary Interop Assembly. Deploying and Registering a Primary Interop Assembly. Writing IDL That Produces Good Type Libraries. What About ActiveX Controls?
16. COM Design Guidelines for Components Used by .NET Clients. General Guidelines. Using Array Parameters. Issues with VARIANT Parameters. Reporting Errors. Adjusting Certain COM-Specific Idioms. Managing Limited Resources. Threading and Apartment Guidelines. Providing Self-Describing Type Information. Naming Guidelines. Performance Considerations.
17. Implementing .NET Interfaces for Type Compatibility. Class Interfaces. Interface Inheritance. Considerations for Visual C++ Programmers. Considerations for Visual Basic 6 Programmers.
VI. PLATFORM INVOCATION SERVICES (PINVOKE).
18. The Essentials of PInvoke. Using PInvoke in Visual Basic .NET. Using PInvoke in Other .NET Languages. Choosing the Right Parameter Types. Customizing Declare and DllImportAttribute.
19. Deeper Into PInvoke and Useful Examples. Callbacks. Passing Structures. Handling Variable-Length Structures and Signatures. Using C# Unsafe Code. Guarding Against Premature Garbage Collection. Choosing the DLL Location or Name Dynamically. Example: Responding Immediately to Console Input. Example: Clearing the Console Screen. Example: Using CoCreateInstanceEx to Activate Remote COM Objects.
VII. ADVANCED TOPICS.
20. Custom Marshaling. Transforming Types Without Custom Marshaling. Custom Marshaling Architecture. Marshalers, Marshalers, Marshalers! Limitations.
21. Manually Defining COM Types in Source Code. Using SDK Tools for Support. Manually Defining COM Interfaces. Manually Defining Coclass Interfaces and Event Types. Manually Defining COM Structures. Manually Defining COM Enums. Manually Defining COM Classes. Avoiding the Balloon Effect.
22. Using APIs Instead of SDK Tools. Generating an Assembly from a Type Library. Generating a Type Library from an Assembly. Registering and Unregistering Assemblies. Installing and Uninstalling Serviced Components. Example: Using the APIs in an Interactive Application.
VIII. COMPREHENSIVE EXAMPLES.
23. Writing a .NET Arcade Game Using DirectX. The User's Perspective. The Programmer's Perspective. DirectX Interaction. The Game Class. Sounds and Pictures. Layers. Screens. The Actors. Using the Game Class. E-mail Attack-The Advanced Version.
24. Writing .NET Visualizations For Windows Media Player. The COM Visualization API. Creating a .NET Visualization API. Using the .NET Visualization API.
IX. APPENDICES.
Appendix A. System.Runtime.InteropServices Reference. The System.Runtime.InteropServices Namespace. The System.Runtime.InteropServices.CustomMarshalers Namespace. The System.Runtime.InteropServices.Expando Namespace.
Appendix B. SDK Tools Reference. TLBIMP.EXE. TLBEXP.EXE. REGASM.EXE. AXIMP.EXE. REGSVCS.EXE.
Appendix C. HRESULT to .NET Exception Transformations. Appendix D. .NET Exception to HRESULT Transformations. Appendix E. PInvoke Definitions for Win32 Functions. GDI32.DLL. KERNEL32.DLL. OLE32.DLL. SHELL32.DLL. USER32.DLL.
Appendix F. Glossary. Index. 