Получение строки в кодировке UTF-8 из библиотеки Rust в C # - PullRequest
Новая
       42

Получение строки в кодировке UTF-8 из библиотеки Rust в C #

0 голосов
/ 15 февраля 2019

Я нашел много информации о строках US-ANSI для реализации Rust DLL в C #, но это не решает никаких проблем для строк в кодировке UTF-8.

Например, "Brötchen", один развызывается в C #, приводит к "Brötchen".

Rust 

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

#[no_mangle]
pub extern fn string_test() -> *mut c_char {
    let c_to_print = CString::new("Brötchen")
        .expect("CString::new failed!");
    let r = c_to_print;
    r.into_raw()  
}

C # 

[DllImport(@"C:\Users\User\source\repos\testlib\target\debug\testlib.dll")]
private static extern IntPtr string_test();

public static void run()
{
    var s = string_test();
    var res = Marshal.PtrToStringAnsi(s);
    // var res = Marshal.PtrToStringUni(s);
    // var res = Marshal.PtrToStringAuto(s);
    // Are resulting in: ????n
    Console.WriteLine(res); // prints "Brötchen", expected "Brötchen"
}

Как получить желаемый результат?

Я не думаю, что это дубликат Как я могу преобразовать строку в UTF-8 в C #? , потому что его ответы приводят так же, как Marshal.PtrToStringAuto(s) и Marshal.PtrToStringUni(s).

1 Ответ

0 голосов
/ 18 февраля 2019

Благодаря @ комментарию E_net4 , рекомендовавшему прочитать Rust FFI Omnibus , я пришел к ответу, который довольно сложен, но работает.

Я подумал, что ядолжны переписать классы, которые я использую.Кроме того, я использую библиотеку libc и CString.

Cargo.toml 

[package]
name = "testlib"
version = "0.1.0"
authors = ["John Doe <jdoe@doe.com>"]
edition = "2018"

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

[dependencies]
libc = "0.2.48"

src / lib.rs 

extern crate libc;

use libc::{c_char, uint32_t};
use std::ffi::{CStr, CString};
use std::str;

// Takes foreign C# string as input, converts it to Rust String
fn mkstr(s: *const c_char) -> String {
    let c_str = unsafe {
        assert!(!s.is_null());

        CStr::from_ptr(s)
    };

    let r_str = c_str.to_str()
        .expect("Could not successfully convert string form foreign code!");

    String::from(r_str)
}


// frees string from ram, takes string pointer as input
#[no_mangle]
pub extern fn free_string(s: *mut c_char) {
    unsafe {
        if s.is_null() { return }
        CString::from_raw(s)
    };
}

// method, that takes the foreign C# string as input, 
// converts it to a rust string, and returns it as a raw CString.
#[no_mangle]
pub extern fn result(istr: *const c_char) -> *mut c_char {
    let s = mkstr(istr);
    let cex = CString::new(s)
        .expect("Failed to create CString!");

    cex.into_raw()
}

C # Class 

using System;
using System.Text;
using System.Runtime.InteropServices;


namespace Testclass
{
    internal class Native
    {
        [DllImport("testlib.dll")]
        internal static extern void free_string(IntPtr str);

        [DllImport("testlib.dll")]
        internal static extern StringHandle result(string inputstr);
    }

    internal class StringHandle : SafeHandle
    {
        public StringHandle() : base(IntPtr.Zero, true) { }

        public override bool IsInvalid
        {
            get { return false; }
        }

        public string AsString()
        {
            int len = 0;
            while (Marshal.ReadByte(handle,len) != 0) { ++len; }
            byte[] buffer = new byte[len];
            Marshal.Copy(handle, buffer, 0, buffer.Length);
            return Encoding.UTF8.GetString(buffer);
        }

        protected override bool ReleaseHandle()
        {
            Native.free_string(handle);
            return true;
        }
    }

    internal class StringTesting: IDisposable
    {
        private StringHandle str;
        private string resString;
        public StringTesting(string word)
        {
            str = Native.result(word);
        }
        public override string ToString()
        {
            if (resString == null)
            {
                resString = str.AsString();
            }
            return resString;
        }
        public void Dispose()
        {
            str.Dispose();
        }
    }

    class Testclass
    {
        public static string Testclass(string inputstr)
        {
            return new StringTesting(inputstr).ToString();
        }

        public static Main()
        {
            Console.WriteLine(new Testclass("Brötchen")); // output: Brötchen 
        }
    }
}

Хотя это архивирует желаемый результат, я все еще не уверен, что вызывает неправильное декодирование в коде, предоставленном вопросом.

...