C#与C++交互开发系列（五）：掌握P/Invoke的高级技巧

欢迎来到C#与C++交互开发系列的第五篇。在这篇博客中，我们将深入探讨一些高级的P/Invoke技巧。这些技巧能够帮助你处理更加复杂的互操作场景，包括结构体和回调函数的传递、多线程环境下的调用，以及错误处理。

5.1 结构体的传递

在P/Invoke中传递结构体时，需要确保C#和C++中结构体的定义一致，并使用StructLayout属性可以控制结构体在内存中的布局方式。这在与C++进行互操作时非常重要，因为需要确保C#中的结构体布局与C++中的结构体布局一致。

StructLayout属性有三种主要的布局形式，用于控制结构体在内存中的布局方式：使用StructLayout属性和相关的FieldOffset属性可以在C#中精确控制结构体的内存布局，从而确保在与C++等非托管代码进行互操作时，数据在两种环境中保持一致。

1. Sequential (顺序布局)
2. Explicit (显式布局)
3. Auto (自动布局)

1. Sequential (顺序布局)

这种布局方式按照字段在代码中定义的顺序来排列字段，并且会根据需要进行对齐。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
public struct SequentialStruct {
    public int a;
    public double b;
    public char c;
}

class Program {
    static void Main() {
        SequentialStruct s = new SequentialStruct { a = 1, b = 2.0, c = 'A' };
        Console.WriteLine($"Size of SequentialStruct: {Marshal.SizeOf(s)}");
    }
}

2. Explicit (显式布局)

这种布局方式允许你通过 FieldOffset 属性明确指定每个字段的内存偏移量，从而精确控制结构体的布局。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Explicit)]
public struct ExplicitStruct {
    [FieldOffset(0)]
    public int a;

    [FieldOffset(4)]
    public double b;

    [FieldOffset(12)]
    public char c;
}

class Program {
    static void Main() {
        ExplicitStruct s = new ExplicitStruct { a = 1, b = 2.0, c = 'A' };
        Console.WriteLine($"Size of ExplicitStruct: {Marshal.SizeOf(s)}");
    }
}

3. Auto (自动布局)

这种布局方式由CLR自动决定字段的排列顺序和内存对齐，不能与非托管代码交互。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Auto)]
public struct AutoStruct {
    public int a;
    public double b;
    public char c;
}

class Program {
    static void Main() {
        AutoStruct s = new AutoStruct { a = 1, b = 2.0, c = 'A' };
        Console.WriteLine($"Size of AutoStruct: {Marshal.SizeOf(s)}");
    }
}

4 使用说明

• Sequential：适用于需要与非托管代码交互的大多数情况。确保字段按声明顺序排列，通常与C++结构体匹配。
• Explicit：适用于需要精确控制内存布局的场合，比如定义联合体或与非托管代码交互时需要特殊的内存布局。
• Auto：仅用于托管代码，不用于非托管代码交互，因为CLR会自动调整字段顺序和内存对齐。

5 示例程序

Step 1: 编写C++代码

首先，假设我们有一个复杂的结构体：

// MyCppLibrary.cpp
extern "C" {
struct ComplexStruct {
    int a;
    double b;
    char c;
};
__declspec(dllexport) void ProcessStruct(ComplexStruct* cs);

Setp 2: C++ 导出函数定义：

// MyCppLibrary.cpp
#include "MyCppLibrary.h"

void ProcessStruct(ComplexStruct* cs) {
    cs->a += 1;
    cs->b += 1.0;
    cs->c = 'Z';
}

Step 3: 在C#中定义相应的结构体

在C#中，我们需要使用StructLayout属性来确保字段的内存布局与C++中的一致：

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct ComplexStruct {
    public int a;

    public double b;

    public byte c; // Char in C++ maps to byte in C#

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)]
    public byte[] padding; // Padding to align to 16 bytes for the next double field
}

Step 4: 使用P/Invoke调用C++函数

using System;
using System.Runtime.InteropServices;

class Program
{

    [DllImport("MyCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ProcessStruct(ref ComplexStruct cs);

    public static void Main() {
        ComplexStruct cs = new ComplexStruct { a = 1, b = 2.0, c = (byte)'A', padding = new byte[7] };
        ProcessStruct(ref cs);
        Console.WriteLine($"a: {cs.a}, b: {cs.b}, c: {cs.c}");
    }
}

在C++开发DLL并供C#使用时，确保数据类型的正确对齐是至关重要的。通过使用StructLayout和其他相关属性，可以确保C#中的结构体和C++中的结构体在内存布局上的一致性，从而实现正确的数据传递和函数调用。

5.2 回调函数的传递

在一些场景下，我们需要在C++代码中调用C#中定义的回调函数。可以通过委托和GCHandle来实现这一功能。

Step 1: 编写C++代码

定义一个接受回调函数的C++函数。

// MyCppLibrary.cpp
typedef void (*Callback)(int);

extern "C" {
    __declspec(dllexport) void RegisterCallback(Callback cb) {
        cb(42);
    }
}

Step 2: 在C#中定义相应的委托

using System;
using System.Runtime.InteropServices;

class Program
{
    // 定义回调函数的委托
    public delegate void Callback(int value);

    [DllImport("MyCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void RegisterCallback(Callback cb);

    static void Main()
    {
        // 定义回调函数
        Callback callback = new Callback(PrintValue);
        RegisterCallback(callback);
    }

    static void PrintValue(int value)
    {
        Console.WriteLine($"Callback value: {value}");
    }
}

运行程序，输出结果

5.3 多线程环境下的调用

在多线程环境中使用P/Invoke时，需要确保非托管代码是线程安全的。可以通过在C#中创建多线程，并在每个线程中调用非托管理函数来测试线程安全性。

Step 1: 编写C++代码

定义一个简单的线程安全函数。

// MyCppLibrary.cpp
#include <mutex>
#include <iostream>

std::mutex mtx;
static int index = 0;
extern "C" {
    __declspec(dllexport) void ThreadSafeFunction() {
        std::lock_guard<std::mutex> lock(mtx);
        index++;
        std::cout << "Critical section protected by std::lock_guard ==>" << index << "  \n";
        // 模拟长时间运行的操作
        Sleep(1000);
    }
}

Step 2: 在C#中创建多线程

using System;
using System.Runtime.InteropServices;
using System.Threading;

class Program
{
    [DllImport("MyCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ThreadSafeFunction();

    static void Main()
    {
        // 创建多个线程并调用ThreadSafeFunction
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++)
        {
            threads[i] = new Thread(ThreadSafeFunction);
            threads[i].Start();
        }

        // 等待所有线程完成
        foreach (var thread in threads)
        {
            thread.Join();
        }

        Console.WriteLine("All threads completed.");
    }
}

运行程序，输出结果。

5.4 错误处理

在使用P/Invoke时，处理来自非托管代码的错误非常重要。可以通过返回错误码或设置全局错误变量来实现错误处理。

Step 1: 编写C++代码

定义一个可能返回错误码的函数。

// MyCppLibrary.cpp
extern "C" {
    __declspec(dllexport) int Division(int a, int b, int* result) {
        if (b == 0) {
            return -1; // 错误码，表示除数为0
        }
        *result = a / b;
        return 0; // 成功
    }
}

Step 2: 在C#中处理错误

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("MyCppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int Division(int a, int b, out int result);

    static void Main()
    {
        int result;
        int errorCode = Division(10, 0, out result);
        if (errorCode != 0)
        {
            Console.WriteLine("Error: Division by zero.");
        }
        else
        {
            Console.WriteLine($"Result: {result}");
        }
    }
}

运行程序，输出结果。

5.5 总结

在这篇博客中，我们介绍了高级P/Invoke技巧，包括结构体和回调函数的传递、多线程环境下的调用，以及错误处理。通过这些技巧，你可以处理更加复杂的互操作场景，提高代码的健壮性和可维护性。在下一篇博客中，我们将探讨混合模式开发，结合C++/CLI和P/Invoke，实现更强大的跨语言互操作能力。