Getting Started with PInvoke in Font

Maker PDF-417 2d barcode in Font Getting Started with PInvoke

This section starts with a simple example of a DLL developed using C++ to which you will add code during your experiments using PInvoke. The CInteropDLL.h header file declares a macro defining the decorations associated with each exported function: #define CINTEROPDLL_API __declspec(dllexport) extern "C" { void CINTEROPDLL_API HelloWorld(); } The __declspec directive is specific to the Microsoft Visual C++ compiler, and other compilers may provide different ways to indicate the functions that must be exported when compiling a DLL.

The first function is the HelloWorld function; its definition is as expected: void CINTEROPDLL_API HelloWorld() { printf("Hello C world invoked by F#!\n"); } Say you now want to invoke the HelloWorld function from an F# program. You simply have to define the prototype of the function and inform the runtime how to access the DLL and the other information needed to perform the invocation. The program performing the invocation is the following: open System.Runtime.InteropServices module CInterop = [<DllImport("CInteropDLL", CallingConvention=CallingConvention.Cdecl)>] extern void HelloWorld() CInterop.HelloWorld() The extern keyword informs the compiler that the function definition is external to the program and must be accessed through the PInvoke interface. A C-style prototype definition follows the keyword, and the whole declaration is annotated with a custom attribute defined in the System.Runtime.InteropServices namespace. The F# compiler adopts C-style syntax for extern prototypes, including argument types (as you ll see later), because C headers and prototypes are widely used, and this choice helps in the PInvoke definition. The DllImport custom attribute provides the information needed to perform the invocation. The first argument is the name of the DLL containing the function; the remaining option specifies the calling convention chosen to make the call. Since not specified otherwise, the runtime assumes that the name of the F# function is the same as the name of the entry point in the DLL. It is possible to override this behavior using the EntryPoint parameter in the DllImport attribute. It is important to note the declarative approach of the PInvoke interface. There is no code involved in accessing external functions. The runtime interprets metadata in order to automatically interoperate with native code contained in a DLL. This is a different approach from the one adopted by different virtual machines such as, for example, the Java virtual machine. The Java Native Interface (JNI) requires that the programmer defines a layer of code using types of the virtual machine and invokes the native code. Platform Invoke requires high privileges in order to execute native code, because the activation record of the native function is allocated on the same stack containing the activation records of managed functions and methods. Moreover, as we will discuss shortly, it is also possible to have the native code invoking a delegate marshalled as a function pointer, allowing stacks with native and managed activation records to be interleaved. The HelloWorld function is a simple case since the function does not have input arguments and does not return any value. Consider this function with input arguments and a return value: int CINTEROPDLL_API Sum(int i, int j) { return i + j; }

Invoking the Sum function requires integer values to be marshalled to the native code and the value returned to managed code. Simple types such as integers are easy to marshal since they usually are passed by value and use types of the underlying architecture. The F# program using the Sum function is as follows: module CInterop = [<DllImport("CInteropDLL", CallingConvention=CallingConvention.Cdecl)>] extern int Sum(int i, int j) printf "Sum(1, 1) = %d\n" (CInterop.Sum(1, 1)); Parameter passing assumes the same semantics of the CLR, and parameters are passed by value for value types and by the value of the reference for reference types. Again, you use the custom attribute to specify the calling convention for the invocation.