Interoperability with native code, also known as P/Invoke (Platform Invocation Services), allows .NET applications to call functions defined in native code libraries. This can be useful when you have existing native code that you want to reuse in your .NET application, or when you need to interact with operating system APIs or other native libraries.

To use P/Invoke in .NET, you need to define a static method with the `DllImport` attribute, which identifies the native library and the function to be called. The method signature should match the signature of the native function.

Here’s an example of how to use P/Invoke to call the `MessageBox` function from the user32.dll library:

using System;
using System.Runtime.InteropServices;

class Program
[DllImport(“user32.dll”, CharSet = CharSet.Unicode)]
public static extern int MessageBox(IntPtr hWnd, string text, string caption, int options);

static void Main()
MessageBox(IntPtr.Zero, “Hello, P/Invoke!”, “Message”, 0);

In this example, we define the `MessageBox` function from the `user32.dll` library using the `DllImport` attribute. We then call this function in the `Main` method, passing it the handle to the main window (`IntPtr.Zero`), the message text, the caption, and the options.

P/Invoke supports various types of interop, including marshaling of parameters and return values, handling of structures and arrays, and dealing with pointers and callbacks. You can specify additional attributes on the method parameters to control how the interop is performed.

Note that P/Invoke is primarily used for calling native code from managed code. If you need to call managed code from native code, you can use COM interop or write a mixed-mode assembly that combines managed and native code.