.NET 2.0 Interoperability Recipes

Transcription

1 .NET 2.0 Interoperability Recipes A Problem-Solution Approach Bruce Bukovics

2 .NET 2.0 Interoperability Recipes: A Problem-Solution Approach Copyright 2006 by Bruce Bukovics All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. ISBN-13: ISBN-10: Printed and bound in the United States of America Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. Lead Editor: Ewan Buckingham Development Editor: Ralph Davis Technical Reviewers: Christophe Nasarre, Nicholas Paldino Editorial Board: Steve Anglin, Dan Appleman, Ewan Buckingham, Gary Cornell, Jason Gilmore, Jonathan Hassell, James Huddleston, Chris Mills, Matthew Moodie, Dominic Shakeshaft, Jim Sumser, Matt Wade Project Manager: Sofia Marchant Copy Edit Manager: Nicole LeClerc Assistant Production Director: Kari Brooks-Copony Production Editor: Ellie Fountain Compositor: Kinetic Publishing Services, LLC Proofreader: Elizabeth Berry Indexer: John Collin Cover Designer: Kurt Krames Manufacturing Director: Tom Debolski Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor, New York, NY Phone SPRINGER, fax , orders-ny@springer-sbm.com, or visit For information on translations, please contact Apress directly at 2560 Ninth Street, Suite 219, Berkeley, CA Phone , fax , info@apress.com, or visit The information in this book is distributed on an as is basis, without warranty. Although every precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work. The source code for this book is available to readers at in the Source Code section.

3 For my son, Brennen

4 Contents at a Glance About the Author xi About the Technical Reviewers xiii Acknowledgments xv Introduction xvii CHAPTER 1 Using C-Style APIs CHAPTER 2 C-Style APIs: Structures, Classes, and Arrays CHAPTER 3 Win32 API CHAPTER 4 Using C++ Interop CHAPTER 5 Using COM CHAPTER 6 Exposing Managed Code to COM CHAPTER 7 Marshaling to COM Clients CHAPTER 8 COM+ Enterprise Services CHAPTER 9 COM+ Enterprise Services Transactions INDEX v

5 Contents About the Author xi About the Technical Reviewers xiii Acknowledgments xv Introduction xvii CHAPTER 1 Using C-Style APIs Identifying the Unmanaged Function Using the Function from Managed Code Simplifying Reuse of Unmanaged Functions Changing the Calling Convention Renaming a Function Changing the Character Set Used for Strings Using Data Types That Improve Performance Handling Errors from Unmanaged Functions Using C++ Interop As a Managed Wrapper Catching Unmanaged Exceptions with C++ Interop Freeing Unmanaged Memory Requesting Permission to Access Unmanaged Code Securing Access to Unmanaged Code Calling Functions Dynamically CHAPTER 2 C-Style APIs: Structures, Classes, and Arrays Passing Structures Returning a Structure from Unmanaged Code Specifying the Exact Layout of a Structure Controlling Field-Level Marshaling Within Structures Allocating Memory Within Structures Passing Classes to Unmanaged Code Passing Simple Arrays Handling String Arrays Passing Arrays of Structures vii

6 viii CONTENTS CHAPTER 3 Win32 API Accessing ANSI or Wide Functions Retrieving the Win32 Error Code Handling Callbacks Using Windows Constants Handling Handles Passing Managed Objects Marshaling Win32 Types Replacing Win32 Calls with.net CHAPTER 4 Using C++ Interop Using C++ Classes Mixing Managed and Unmanaged Code Detecting Compile-Time Traits Using Managed Objects from Unmanaged Code Marshaling Strings Marshaling Structures and Embedded Pointers Handling Callbacks with C++ Interop Using C++ As a Custom COM Wrapper CHAPTER 5 Using COM Using COM Components from.net Importing a Type Library Handling COM Events Marshaling COM Data Types Marshaling COM Variants Marshaling COM Arrays Extending COM Classes Changing the Apartment Model Refactoring for Performance Creating a Late-Bound COM Object Sharing an Interop Assembly Deploying Your Application Converting HRESULTs to Exceptions Refactoring HRESULTs Retrieving the HRESULT Providing Additional Error Information

7 CONTENTS ix CHAPTER 6 Exposing Managed Code to COM Exposing.NET Classes Using Late Binding Exposing.NET Classes Using Early Binding Exposing.NET Classes with Interfaces Managing COM Identity Controlling COM Visibility Preparing Assemblies for COM Interop Exposing Managed Events to COM Providing HRESULTs for Exceptions Preserving Success HRESULTs CHAPTER 7 Marshaling to COM Clients Controlling Parameter Direction Marshaling Strings Marshaling Arrays Marshaling Variants Marshaling Currency Marshaling Null Variant Strings Marshaling Classes and Structures Passing Optional Parameters CHAPTER 8 COM+ Enterprise Services Exposing Managed Code to COM Implementing a Server Application Installing a Serviced Component Registering Components Dynamically Activating Components Just-in-Time Using Object Pooling Implementing Private Components Using Role-Based Security Performing Manual Security Checks Writing Managed Queued Components

8 x CONTENTS CHAPTER 9 COM+ Enterprise Services Transactions Monitoring Transaction Status Enabling Automatic Transactions Placing an Automatic Vote Placing a Manual Vote Defining a Unit of Work Controlling the Transaction Isolation Level Implementing Transactional Code Blocks Building Your Own Resource Manager Using Services Without Components INDEX

9 About the Author BRUCE BUKOVICS has been a working developer for over 25 years. Over the last quarter-century he has designed and developed applications in such widely varying areas as banking, corporate finance, credit card processing, payroll processing, and retail automation. He has firsthand developer experience with C, C++, Delphi, Visual Basic, C#, and Java, and rode the waves of technology as they drifted from mainframe to client/server to n-tier, from COM to COM+, and from web services to.net Remoting and beyond. He considers himself a pragmatic programmer. He doesn t stand on formality and doesn t do things a certain way just because they have always been done that way. He s willing to look at alternate or unorthodox solutions to a problem if that s what it takes. Bruce is currently employed at Radiant Systems, Inc., in Alpharetta, Georgia, as a senior developer and architect in the central technology group. xi

10 About the Technical Reviewers CHRISTOPHE NASARRE is a software architect for Business Objects, a company that develops desktop and web-based business intelligence solutions. During his spare time, Christophe writes articles for MSDN Magazine, MSDN/Longhorn, and ASP Today, and since 1996 he has reviewed books on Win32, COM, MFC, and.net. NICHOLAS PALDINO is a developer in the New York City area for Exis Consulting, Inc., a boutique software provider that offers software solutions in the fixed income space. Nicholas has also been awarded the Microsoft MVP award for the past four years for his frequent contributions in the microsoft.public.dotnet.languages.csharp newsgroup, where he submits anywhere between 100 and 500 posts a month. He also provides technical review services for a number of publishers. xiii

11 Acknowledgments First of all, I d like to thank the entire team at Apress. You all worked very hard to make this book a reality. Thank you for an exceptional job and for making the process a smooth one. Special thanks go to Ewan Buckingham, who was my editor at Apress, and to Sofia Marchant, who kept things organized and on track. Thanks also go to Nicole LeClerc and Ellie Fountain for a great job copy editing and production editing, respectively, and for being so easy to work with. I would especially like to thank Ralph Davis, who took on the role of development editor for the book. Ralph did a fantastic job handling this first-time author. Not only was he there to correct my mistakes, but also he questioned things that weren t clear and encouraged me to improve things that were. Ralph was my sounding board and voice of reason. I would also like to thank my technical reviewers, Christophe Nasarre and Nicholas Paldino, who both did an amazing job. Their comments and suggestions helped to improve the accuracy and clarity of all of the recipes. Their efforts and attention to detail made this a much better book. Thanks also go to John Osborn for believing in the initial idea for this book and championing it. Finally, I d like to thank my loving wife, Teresa, and son, Brennen, for being patient with me when I was working late, for understanding when I said I was busy, and for encouraging me when things didn t always go as planned. I love both of you very much. Brennen, I have time to play that game of chess now. xv

12 Introduction It is difficult or impossible to immediately throw out all existing code and start over when a new technology arrives. That s the situation with Microsoft.NET. It represents a new and improved way of developing software for the Windows platform. And, given the chance, you would likely love to rewrite all of your existing code in the newer managed code environment that.net provides. However, you have that little problem known as legacy code. You may have C libraries, C++ class libraries, Visual Basic 6.0 COM components, or ATL COM components that you rely upon to run your applications. You may be using third-party libraries and COM components that represent a significant investment. You can t simply throw all of that away. Instead, you need to find a way to move forward with new.net development while reusing existing pieces of tested, working code. You need a way to interoperate with the existing code until you have a chance to finally rewrite all of it in.net (if ever). Fortunately, Microsoft.NET provides a rich set of tools that allow you to do just that. These tools simplify the transition to an all-.net environment, allowing you to replace a component here and a component there. The problem is that sometimes those tools are difficult to understand and use. And in many cases, Microsoft has provided more than one way to accomplish a particular interop task. Finding the appropriate tool for the task at hand can sometimes be a frustrating experience. I wrote this book as a resource for other Windows developers who are transitioning from native Windows code to.net managed code. My aim is to guide you past the infrequently used interop options and focus on those that you will use most often. Intended Audience This book is appropriate for any.net developer who needs to interoperate between.net code and non-.net Windows code. You may be an experienced.net developer who has never had the need to interoperate with native code before. Or you may be completely new to.net and are just learning the languages and class libraries associated with.net. In either case, this book is for you. Most of the examples in this book are presented in both C# and Visual Basic.NET (VB.NET). You will be able to understand the examples as long as you know one of these languages. But this book isn t designed to teach you a language. Likewise, you should already be familiar with the basics of the.net Framework Class Library (FCL). You don t have to be a guru, but you should at least know the basics. Since the book is all about interop with existing code, the examples also typically use one or more native Windows languages. For example, the chapters covering the use of C-style functions use examples written in native C++ code. The chapter that focuses on the use of COM xvii

13 xviii INTRODUCTION components presents Visual Basic 6.0 (VB6) and C++ ATL example components that are used by.net client code. These same native languages are later used as client code when managed classes are exposed to COM. While unmanaged code is used extensively in the examples, it is not the primary focus of this book. So if you know VB6 but don t know C++, that s OK you ll still benefit from the examples. Most of the.net code works the same way regardless of the unmanaged language used. If there are differences, they are noted in the examples. Likewise, the chapters covering COM and COM+ assume that you are already familiar with these technologies. This is not a book about learning COM and COM+, but it will show you how to use COM and COM+ from.net. How This Book Is Organized This book is organized into nine chapters, with each one focusing on a different aspect of Windows interoperability. The following sections provide a brief summary of the contents of each chapter. Chapter 1: Using C-Style APIs This chapter discusses the use of Platform Invocation Services (PInvoke) to access C-style functions from managed.net code. It includes recipes that demonstrate how to declare and use unmanaged functions, change the calling convention and character set, handle errors and exceptions, and manage memory. Chapter 2: C-Style APIs: Structures, Classes, and Arrays This chapter is a logical continuation of Chapter 1 and covers topics that relate to user-defined types such as structures and classes. Recipes in this chapter cover passing structures, classes, and arrays between managed and unmanaged code; controlling the field alignment within a structure; and implementing field-level marshaling within a structure. Chapter 3: Win32 API This chapter covers the topics associated with using Win32 functions from managed.net code. Recipes include accessing the ANSI or Unicode version of a function, retrieving Win32 error codes, handling callbacks, and passing handles and objects between managed and unmanaged code. The chapter also provides a recipe that illustrates how to replace a set of Win32 functions entirely with managed code. Chapter 4: Using C++ Interop The focus of this chapter is on using C++ to solve various interop problems. Recipes in this chapter include how to mix managed and unmanaged code in a project and within a single source file, how to use managed objects from unmanaged code, and how to marshal strings and structures with embedded pointers and callbacks. There is also a recipe that demonstrates the use of C++ as a custom COM wrapper.

14 INTRODUCTION xix Chapter 5: Using COM All of the recipes in this chapter demonstrate some aspect of using COM components from managed.net code. Recipes include importing and using a COM object, handling COM events, marshaling common COM data types, handling HRESULT codes, and providing error information. Chapter 6: Exposing Managed Code to COM The recipes in this chapter are the reciprocal of Chapter 5. They show you how to expose managed.net code as COM components, suitable for use by any COM client. Recipes include exposing managed components to COM by defining your own interface, controlling COM identity and visibility, exposing managed events to COM, and handling HRESULT codes and managed exceptions. Chapter 7: Marshaling to COM Clients This chapter continues where Chapter 6 left off, focusing on a set of specific COM marshaling problems. Recipes include how to control parameter direction; how to marshal strings, arrays, Variants, and currency; and how to marshal classes and structures to COM clients. Chapter 8: COM+ Enterprise Services This chapter shows you how to make use of COM+ services from managed code. Recipes include developing a COM+ component in managed code, installing and registering the component, using just-in-time (JIT) activation, using object pooling, implementing role-based COM+ security, and writing Queued Components. Chapter 9: COM+ Enterprise Services Transactions The recipes in this chapter all focus on the use of COM+ transactions. The recipes demonstrate how to enable transactions, how to place a vote for a transaction, how to use the new.net Framework 2.0 transactional code blocks, how to build your own resource manager, and how to use services without components. Software Requirements To run the examples in this book, you need some way to build and run C# or VB.NET code. The bare minimum for this is the.net Framework SDK and a source code editor. While this minimal setup allows you to run the example code, many of the recipes show you how to use features of Visual Studio.NET 2005 to simplify the job of interop. Therefore, use of Visual Studio.NET 2005 is highly recommended. All of the code in this book was originally developed using beta 2 and release candidate 1 of Visual Studio.NET It was subsequently checked using the final release to manufacturing (RTM) version. All of the C++ unmanaged code used in the examples can be built with Visual Studio.NET You don t need the older 6.0 version of Visual C++ for this purpose. However, many of the COM examples use VB6. Since VB6 is a drastically different language than VB.NET, you ll need VB6 to build and run those examples.