Platform Invoke Cheat Sheet
Base Class Libraries Introduction
We recognize that using
P\Invoke can sometimes be harder than you might feel is necessary. There are
many nuances to how you define your signatures and structures, and how to marshal
types. There are many resources available on MSDN and in the SDK, but they
are often hard to find and not especially well cross-referenced. To help ease
the burden on .Net developers we have compiled a list of resources that
should provide assistance to any developer, beginner or advanced, having
problems with a wide range of P\Invoke problems.
P\Invoke Signature and Structure Samples
View the ReadMe describing the platform invoke samples demonstrating how to
call functions exported from an unmanaged library: how to declare different
types, how to use available attributes to modify default behavior, how to use
methods of the Marshal class when needed, and which aspects of garbage
collection and threading could affect results.
Zip File containing samples described above
Signature and Structure Library for Win32
When a Win32 API is not exposed by the .NET framework you must manually write
an interop wrapper to access that API. Writing these wrappers is difficult
and error prone. This post includes C# definitions of many common Win32APIs
and their related data structures. It does not include all Win32 APIs and it
is missing all #define constants. It was created by a rather complex
semi-automatic process. These definitions are all unsafe
C# and you should understand the implications of this before using the
definitions. It should also be noted that these methods are defined with the
least common type that is guaranteed to work and you may not be able to tell
exactly which data-type the api requires where just by looking at the
signatures, be sure to reference the Win32 API for specifications on these
MSDN Articles and Tutorials
This tutorial shows you what
you need to do to be able to call unmanaged DLL functions from C#. The
attributes discussed in the tutorial allow you to call these functions and
have data types be marshaled correctly
Win32 to Microsoft .NET Framework API Map
This article identifies the Microsoft
.NET Framework version 1.0 or 1.1 APIs that provide similar
functionality to Microsoft Win32 functions. One or more relevant
.NET Framework APIs are shown for each Win32 function listed. The
intended audience for this article is experienced Win32 developers who are
creating applications or libraries based on the Microsoft .NET Framework,
but anyone looking for a managed counterpart for a Win32 function could find
this document useful.
Marshaling for Value Types
Most value types, such as integers and floating-point
numbers, are blittable
and do not require marshaling. Other non-blittable
types have dissimilar representations in managed and unmanaged memory and do
require marshaling. Still other types require explicit formatting across the
This topic provides the follow information on formatted
Many unmanaged functions expect you to pass, as a
parameter to the function, members of structures (user-defined types in
Visual Basic) or members of classes that are defined in managed code. When
passing structures or classes to unmanaged code using platform invoke, you
must provide additional information to preserve the original layout and
alignment. This topic introduces the StructLayoutAttribute
attribute, which you use to define formatted types. For managed structures
and classes, you can select from several predictable layout behaviors
supplied by the LayoutKind enumeration.
Data With Platform Invoke
This section provides samples that demonstrate how to create
managed function prototypes for passing arguments to and receiving return
values from functions exported by unmanaged libraries. The samples also
demonstrate when to use the MarshalAsAttribute
attribute and the Marshal
class to explicitly marshal data.
Win32 API”s from C#
This column focuses on the practical use and
application of P\Invoke for calling Windows API functions.
P\Invoke to Develop a .NET Base Class Library for Serial Device
Out-of-the-box, the only way of coding RS232
serial communications applications in the .NET environment is to import the
outdated and somewhat limited MSComm ActiveX control. This article describes
the development of a lean, multithreaded, and modern RS232 base class library
in C# managed code. The library uses Platform Invocation Services to interact
with the Win32 API directly. Application programmers can use the library from
any .NET language through inheritance; the article explores examples written
in C# and Visual Basic .NET.
Introduction to P\Invoke and Marshaling on the Microsoft .NET Compact
Learn how to use the Platform Invoke (P\Invoke) feature of
the .NET Compact Framework.
P\Invoke on the Microsoft .NET Compact Framework
Explore advanced interoperability on the .NET Compact
Types During Platform Invoke on the Microsoft .NET Compact Framework
Learn how to marshal data between managed and unmanaged
code using the .NET Compact Framework.
a P\Invoke Library
The intent of this sample is to provide a collection of
P\Invokes, as well test procedures that demonstrate their application. This
sample provides several of the most commonly requested P\Invoke functions as
well as a class that handles the enumeration and invoking of the various test
procedures. This class is used by a Form to allow the user to select and run
the tests from a selection list.
Serial APIS in Compact Framework
This paper considers specific challenges the .NET
Compact Framework presents when controlling serial communications from
managed code. Design principles, portable code, and implementation of
P\Invoking are discussed.
callbacks from native Win32 code
In the .NET Compact Framework newsgroup several people have
asked questions about passing delegates to native Win32 DLL's to be used as
asynchronous callbacks to P\Invoke back into managed code after an unmanaged
function wants to report back to its caller. Unfortunately, passing delegates
to unmanaged code is not supported by the .NET Compact Framework. As an
alternative, the .NET Compact Framework contains the MessageWindow class.
This class can be used to pass Windows messages from unmanaged code to
managed code. The functionality of MessageWindow is great if you need to pass
Windows messages to a managed control. In certain solutions however, using
the MessageWindow class is somewhat artificial and not a true replacement for
delegates. With a little extra coding effort it is possible to setup an event
handler mechanism that exposes itself to the managed application developer as
if true delegates exist to call back from unmanaged code into managed code.
In this article we provide you with the details of this mechanism.
[Printer friendly version]
© Copyright 2007 Microsoft Corporation. All Rights Reserved.
Code of Conduct
About the team