跨语言互操作基础

将 Rust 引入 C# 技术栈能够兼顾开发效率与运行性能，但两种语言在内存模型、类型系统和运行时行为上存在本质差异。Rust 编译为 C 兼容库后，C# 通过 P/Invoke 进行调用，这一过程中隐藏诸多易错点。

最小可运行示例

Rust 侧导出函数：

// src/lib.rs
#[no_mangle]
pub extern "C" fn compute_sum(lhs: i32, rhs: i32) -> i32 {
    lhs + rhs
}

Cargo 配置：

[lib]
name = "mathcore"
crate-type = ["cdylib"]

C# 侧声明与调用：

[DllImport("mathcore", CallingConvention = CallingConvention.Cdecl)]
public static extern int compute_sum(int lhs, int rhs);

var total = compute_sum(10, 32); // 42

陷阱一：类型宽度与符号性错配

跨语言调用时，开发者常假设同名类型具有相同位宽，但 C# 的 long 为 64 位有符号整数，而 C 的 long 在 Windows x64 上仅为 32 位。Rust 的 c_long 跟随目标平台定义，更易引发隐蔽错误。

推荐映射方案

// 错误：C# 默认 bool 为 4 字节，Rust bool 为 1 字节
[DllImport("lib")]
public static extern bool validate_flag(); // 风险！

// 正确：显式指定封送行为
[DllImport("lib")]
[return: MarshalAs(UnmanagedType.U1)]
public static extern bool validate_flag();

陷阱二：字符串编码与所有权纠纷

字符串是跨语言交互的高危区域。C# 的 string 为 UTF-16 编码的托管对象，Rust 的 String 为 UTF-8 的堆分配类型，二者无法直接互操作。

安全传递模式

Rust 侧接收指针并转换为 Rust 字符串：

use std::ffi::CStr;
use std::os::raw::c_char;

#[no_mangle]
pub extern "C" fn greet_user(name_ptr: *const c_char) -> *mut c_char {
    if name_ptr.is_null() {
        return std::ptr::null_mut();
    }
    
    let c_str = unsafe { CStr::from_ptr(name_ptr) };
    let name = match c_str.to_str() {
        Ok(s) => s,
        Err(_) => return std::ptr::null_mut(),
    };
    
    let greeting = format!("Hello, {}!", name);
    CString::new(greeting).unwrap().into_raw()
}

C# 侧负责释放返回的内存：

[DllImport("lib", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr greet_user([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

[DllImport("lib", CallingConvention = CallingConvention.Cdecl)]
public static extern void free_string(IntPtr ptr);

public string SafeGreet(string userName)
{
    var nativePtr = greet_user(userName);
    try
    {
        return Marshal.PtrToStringUTF8(nativePtr) ?? string.Empty;
    }
    finally
    {
        free_string(nativePtr); // 必须释放 Rust 分配的内存
    }
}

关键原则：谁分配谁释放。若 Rust 使用 Box::into_raw 或 CString::into_raw 分配，必须提供对应的释放函数供 C# 调用。

陷阱三：结构体布局与对齐假设

编译器可能插入填充字节优化访问速度，导致跨语言结构体布局不一致。必须显式控制布局行为。

// Rust: 强制 C 兼容布局
#[repr(C)]
pub struct MetricSample {
    pub timestamp_sec: u64,
    pub value: f64,
    pub tag_count: u32,
}

// C#: 显式顺序布局
[StructLayout(LayoutKind.Sequential, Pack = 8)]
public struct MetricSample
{
    public ulong TimestampSec;
    public double Value;
    public uint TagCount;
}

注意 Pack = 8 与 Rust 默认对齐策略的匹配。对于嵌套结构体或包含数组字段的场景，建议使用 LayoutKind.Explicit 精确控制每个字段的偏移量：

[StructLayout(LayoutKind.Explicit, Size = 24)]
public struct AlignedPacket
{
    [FieldOffset(0)] public ulong SequenceId;
    [FieldOffset(8)] public double Payload;
    [FieldOffset(16)] public uint Checksum;
}

陷阱四：回调函数与线程上下文

将 C# 委托作为回调传递给 Rust 时，GC 可能移动委托目标，导致非托管代码访问失效内存。需固定委托引用并管理生命周期。

// C# 侧：保持委托实例存活
public class CallbackBridge : IDisposable
{
    private readonly NativeCallback _callback;
    private readonly GCHandle _handle;
    
    private delegate void NativeCallback(int status, IntPtr data);
    
    public CallbackBridge(Action<int> handler)
    {
        _callback = (status, _) => handler(status);
        _handle = GCHandle.Alloc(_callback, GCHandleType.Normal);
    }
    
    public IntPtr FunctionPointer => Marshal.GetFunctionPointerForDelegate(_callback);
    
    public void Dispose()
    {
        if (_handle.IsAllocated)
            _handle.Free();
    }
}

Rust 侧存储并调用：

type ProgressNotifier = extern "C" fn(i32, *mut c_void);

static mut NOTIFIER: Option<ProgressNotifier> = None;

#[no_mangle]
pub extern "C" fn register_notifier(cb: ProgressNotifier) {
    unsafe {
        NOTIFIER = Some(cb);
    }
}

pub fn notify_progress(percent: i32) {
    unsafe {
        if let Some(cb) = NOTIFIER {
            cb(percent, std::ptr::null_mut());
        }
    }
}

陷阱五：异常边界与资源泄漏

Rust 的 panic 无法跨越 FFI 边界传播，会导致进程终止。C# 的异常同样不能穿透至 Rust。必须在边界处建立防护层。

Rust 侧使用 catch_unwind 隔离恐慌：

use std::panic;

#[no_mangle]
pub extern "C" fn process_batch(input: *const u8, len: usize) -> i32 {
    let result = panic::catch_unwind(|| {
        // 实际业务逻辑
        unsafe { perform_computation(input, len) }
    });
    
    match result {
        Ok(Ok(val)) => val,
        Ok(Err(_)) => -1,      // 业务错误
        Err(_) => -2,          // 恐慌被捕获
    }
}

C# 侧配合 SafeHandle 管理非托管资源：

public sealed class NativeBuffer : SafeHandleZeroOrMinusOneIsInvalid
{
    private NativeBuffer() : base(true) { }
    
    public static NativeBuffer Allocate(int size)
    {
        var ptr = NativeMethods.rust_alloc(size);
        if (ptr == IntPtr.Zero)
            throw new OutOfMemoryException();
            
        return new NativeBuffer { handle = ptr };
    }
    
    protected override bool ReleaseHandle()
    {
        NativeMethods.rust_free(handle);
        return true;
    }
}

性能优化建议

• 批量操作：减少 FFI 往返次数，将多次单值调用合并为数组批量处理
• 零拷贝视图：使用 Span<T> 或 ReadOnlyMemory<T> 直接映射 Rust 返回的连续内存
• 对象池：对频繁创建的结构体使用 ArrayPool 复用缓冲区

调试诊断技巧

启用原生代码调试：

<Project>
  <PropertyGroup>
    <EnableNativeCodeDebugging>true</EnableNativeCodeDebugging>
  </PropertyGroup>
</Project>

使用 lldb 或 WinDbg 附加混合模式堆栈，结合 rustc 的 -C debuginfo=2 参数保留符号信息。