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

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

#[no_mangle]
pub extern "C" 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 代码可以通过 C# 中的 DLL 导入访问，如下所示:

[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
    });

最佳答案

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

1. DLL 需要公开一个具有正确名称 GetPacksChar 的函数。这是因为您使用 C# 中的名称 GetPacksChar 声明它并且名称必须匹配。
2. 函数需要正确的调用约定，在本例中为 extern "C"。这是因为您将函数声明为 C# 中的 CallingConvention = CallingConvention.Cdecl，这与 Rust 中的 extern "C" 调用约定相匹配。
3. 该函数需要正确的签名，在本例中采用 Rust 等效的 uint 和 PackChar** 并且不返回任何内容。这与函数签名 fn (u32, *mut *mut PackChar) 相匹配。
4. PackChar 的声明需要在 C# 和 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)] 告诉 Rust 编译器以与 C 编译器相同的方式在内存中排列 PackChar，这很重要，因为您告诉 C# 它正在调用 C。IntVal 和 buffer 都在 C# 和原始 C 版本中使用。 IntVal 在 C 版本中声明为 int，因此我们在 Rust 版本中使用 i32，而 buffer在 C 中被视为字节数组，因此我们在 Rust 中使用 *mut u8。

注意PackChar在C#中的定义要和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');
    }
}

以上要点:

• 我们必须在 DUMMY_STR 中手动包含空终止字符 (\0)，因为它本来就是一个 C 字符串。
• 我们调用CoTaskMemAlloc() 和strdup()，它们都是C 函数。 strdup() 在 libc crate 中, 你可能可以在 the ole32-sys crate 中找到.
• 该函数被声明为不安全，因为我们必须做一些不安全的事情，比如调用 C 函数和执行 str::from_raw_parts()。

希望对您有所帮助!

关于c# - 如何将结构向量从 Rust 返回到 C#？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33581363/