如何将一个结构数组从Rust返回到C#

Question

我正在学习Rust,因为我试图找到一个替代C/C++的互操作C#.

怎么可能像下面的C代码一样编写Rust代码？到目前为止,这是我的Rust代码,没有选择来编组它:

pub struct PackChar { id: u32, val_str: String, }

#[no_mangle]
pub extern fn get_packs_char(size: u32) -> Vec<PackChar> {

    let mut out_vec = Vec::new();

    for i in 0 .. size {
        let int_0 = '0' as u32;
        let last_char_val = int_0 + i % (126 - int_0);
        let last_char = char::from_u32(last_char_val).unwrap();
        let buffer = format!("abcdefgHi{}", last_char);

        let pack_char = PackChar {
            id: i,
            val_str: buffer,
        };

        out_vec.push(pack_char);
    }

    out_vec
}

上面的代码试图重现以下C代码,我能够按原样与之互操作.

void GetPacksChar(int size, PackChar** DpArrPnt)
{
    int TmpStrSize = 10;
    *DpArrPnt = (PackChar*)CoTaskMemAlloc( size * sizeof(PackChar));
    PackChar* CurPackPnt = *DpArrPnt;
    char dummyString[]= "abcdefgHij";
    for (int i = 0; i < size; i++,CurPackPnt++)
    {
        dummyString[TmpStrSize-1] = '0' + i % (126 - '0');
        CurPackPnt->IntVal = i;
        CurPackPnt->buffer = strdup(dummyString);
    }
}

可以通过C#中的DLL导入访问此C代码,如下所示:

[Dllimport("DllPath", CallingConvention = CallingConvention.Cdecl)]
public static extern void GetPacksChar(uint length, PackChar** ArrayStructs)

PackChar* MyPacksChar;
GetPacksChar(10, &MyPacksChar);
PackChar* CurrentPack = MyPacksChar;
var contLst = new List<PackChar>();
for (uint i = 0; i < ArrL; i++, CurrentPack++)
    contlist.Add(new PackChar() {
        IntVal = CurrentPack->IntVal, buffer = contLst->buffer
    });

Answer 1

让我们将其分解为Rust代码需要满足的各种要求：

1. DLL需要公开具有正确名称的函数GetPacksChar。这是因为您使用GetPacksCharC＃中的名称声明了该名称，并且名称必须匹配。
2. 在这种情况下，该函数需要正确的调用约定extern "C"。这是因为您CallingConvention = CallingConvention.Cdecl从C＃中声明了该函数，该函数与extern "C"Rust 中的调用约定匹配。
3. 该函数需要正确的签名，在这种情况下，采用与a uint和a 等效的Rust且不PackChar**返回任何内容。这与功能签名匹配fn (u32, *mut *mut PackChar)。
4. PackCharC＃和Rust之间需要匹配的声明。我将在下面进行介绍。
5. 该函数需要复制原始C函数的行为。我将在下面进行介绍。

最简单的部分是在Rust中声明功能：

#[no_mangle]
pub extern "C" fn GetPacksChar(length: u32, array_ptr: *mut *mut PackChar) {}

接下来，我们需要解决PackChar。根据在C＃代码中的用法，看起来应该声明它：

#[repr(C)]
pub struct PackChar {
    pub IntVal: i32,
    pub buffer: *mut u8,
}

打破下来，#[repr(C)]告诉锈编译器安排PackChar在内存中以同样的方式，C编译器会，这是很重要的，因为你告诉C＃，它的调用转换为C IntVal和buffer从C＃和原C版中都使用。在C版本中IntVal被声明为int，因此i32在Rust版本中使用，并且buffer在C中被视为字节数组，因此*mut u8在Rust中使用a 。

请注意，PackCharC＃中的定义应与C / Rust中的声明匹配，因此：

public struct PackChar {
    public int IntVal;
    public char* buffer;
}

现在剩下的就是重现Rust中C函数的原始行为：

#[no_mangle]
pub extern "C" fn GetPacksChar(len: u32, array_ptr: *const *mut PackChar) {
    static DUMMY_STR: &'static [u8] = b"abcdefgHij\0";

    // Allocate space for an array of `len` `PackChar` objects.
    let bytes_to_alloc = len * mem::size_of::<PackChar>();
    *array_ptr = CoTaskMemAlloc(bytes_to_alloc) as *mut PackChar;

    // Convert the raw array of `PackChar` objects into a Rust slice and
    // initialize each element of the array.
    let mut array = slice::from_raw_parts(len as usize, *array_ptr);
    for (index, pack_char) in array.iter_mut().enumerate() {
        pack_char.IntVal = index;
        pack_char.buffer = strdup(DUMMY_STR as ptr);
        pack_char.buffer[DUMMY_STR.len() - 1] = b'0' + index % (126 - b'0');
    }
}

上面的要点：

• 我们必须手动包含空终止符（\0），DUMMY_STR因为它是C字符串。
• 我们将CoTaskMemAlloc()和称为strdup()C函数。strdup()在libc板条箱中，您可能可以在ole32-sys板条箱中找到。
• 将该函数声明为，是unsafe因为我们必须做许多不安全的事情，例如调用C函数和do str::from_raw_parts()。

希望有帮助！