Вызов неуправляемого кода из .NET (P/Invoke)

Platform Invocation Services, commonly referred to as P/Invoke, is a feature of Common Language Infrastructure implementations, like Microsoft's Common Language Runtime, that enables managed code to call native code. Managed code, such as C# or VB. NET, provides native access to classes, methods, and types defined within the libraries that make up the NET Framework. While the NET Framework provides an extensive set of functionality, it may lack access to many lower level operating system libraries normally written in unmanaged code or third party libraries also written in unmanaged code. P/Invoke is the technique a programmer can use to access functions in these libraries. Calls to functions within these libraries occur by declaring the signature of the unmanaged function within managed code, which serves as the actual function that can be called like any other managed method. The declaration references the library's file path and defines the function parameters and return in managed types that are most likely to be implicitly marshaled to and from the unmanaged types by the common language run time (CLR). When the unmanaged data types become too complex for a simple implicit conversion from and to managed types, the framework allows the user to define attributes on the function, return, and/or the parameters to explicitly refine how the data should be marshaled so as not to lead to exceptions in trying to do so implicitly. There are many abstractions of lower level programming concepts available to managed code programmers as compared to programming in unmanaged languages. As a result, a programmer with only managed code experience will need to brush up on programming concepts such as pointers, structures, and passing by reference to overcome some of the obstacles in using P/Invoke.

By using C++/CLI, an application may simultaneously use the managed heap (by way of tracking pointers) and any native memory region, without the explicit declaration. (Implicit)
A primary benefit in this case being, if underlying native data structures change, so long as the naming is compatible, a breaking change is avoided. i. e. Adding/removing/re ordering structures in a native header will be transparently supported so long as the structure member names did not also change.

When using P/Invoke, the CLR handles DLL loading and conversion of the unmanaged previous types to CTS types (also referred to as parameter marshalling). To perform this, the CLR:
Locates the DLL containing the function. Loads the DLL into memory. Locates the address of the function in memory and pushes its arguments onto the stack, marshaling data as required. P/Invoke is useful for using standard (unmanaged) C or C++ DLLs. It can be used when a programmer needs to have access to the extensive Windows API, as many functions provided by the Windows libraries lack available wrappers. When a Win32 API is not exposed by the NET Framework the wrapper to this API must be written manually.

PInvoke. net is a wiki containing P/Invoke signatures for a large number of standard Windows APIs. It is owned by Redgate Software and has around 50000 hits per month. The signatures are manually produced by users of the wiki. They can be searched using a free addin to Microsoft Visual Studio.

PInvoker is an application which imports native DLLs and C++ h files and exports fully formed and compiled P/Invoke interop DLLs. It overcomes the ambiguity problem by wrapping native pointer function parameters in PInvoker specific NET interface classes. Instead of using standard NET parameter types in P/Invoke method definitions (, , etc.) it uses these interface classes in the P/Invoke function calls. For instance, if we consider the above example code, PInvoker would produce a NET P/Invoke function accepting a NET interface class wrapping the native pointer. The construction of this class could be from a or from a array. The actual native memory structure for both is the same, but the respective interface class constructors for each type will populate the memory in different ways. The responsibility for deciding what NET type needs to be passed into the function is therefore passed to the developer.

The P/Invoke Wizard uses a similar method to the Microsoft Interop Assistant in that it accepts native C++ h file code and produces C# (or VB. NET) code for you to paste into your NET application code. It also has options for which framework you wish to target: NET Framework for the desktop or NET Compact Framework for Windows Mobile smart devices (and Windows CE).

xInterop C++ NET Bridge is a windows application to created C# wrapper for native C++ DLLs and C++ bridge to access NET assemblies, it comes with a C#/. NET library which wraps the standard C++ classes, such as string, iostream, etc., C++ classes and objects can be accessed from NET. This tool generates C# wrapper DLLs with source code from existing native C++ DLLs and the associated header files which are required by the tool to build a C# wrapper DLL. The P/Invoke signatures and data marshaling are generated by the application. The resulting C# wrapper has the similar interface of the C++ counterpart with the parameter type converted to the NET code. This tool recognizes template classes which is not exported from the C++ DLL and instantiates the template class and export it in a supplement DLL and the corresponding C++ interface can be used in NET.