Moonmile Solutions Blog

内部コードを std::string/char * にするか std::wstring/wchar_t * にするかで、SWIG の挙動が変わるような感じなので、その前段階のテスト

戻り値をstring型にする SWIG の技

C#側からみればC++のDLLから文字列を取得したい場合、GetName( const char *, int ) としてバッファを渡すよりも、string GetName() な形で、string 型を返して欲しいわけです。そうなると、dllimport の部分も

 [DllImport("hellodll", EntryPoint = "GetNameStr")]
 static extern string GetNameStr();

な形にしておきたいところですよね。しかし、これはできません。戻り値は string に自動変換してくれないんですね。

不思議なことに、SWIG の場合は戻り値に string を使えて、まあこんな風に string 型を渡したり受け取ったりできます。

    var hello = new Hello();

    hello.SetName("Tomoaki Masuda");
    var name = hello.GetName();
    Console.WriteLine($"name: {name}");

当然のことながら、これは Hello クラス内でラップしている訳で、

  public string GetName() {
    string ret = helloswigPINVOKE.Hello_GetName(swigCPtr);
    return ret;
  }

となっていますが、dllimport を見ると、下記のようになっていて、string 型を返しています。

  [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="CSharp_Hello_GetName")]
  public static extern string Hello_GetName(global::System.Runtime.InteropServices.HandleRef jarg1);

dllimport で string 型を返しているので、どういうトリックになっているのかとコードを追ってみると、

  protected class SWIGStringHelper {

    public delegate string SWIGStringDelegate(string message);
    static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString);

    [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="SWIGRegisterStringCallback_helloswig")]
    public static extern void SWIGRegisterStringCallback_helloswig(SWIGStringDelegate stringDelegate);

    static string CreateString(string cString) {
      return cString;
    }

    static SWIGStringHelper() {
      SWIGRegisterStringCallback_helloswig(stringDelegate);
    }
  }

文字列専用のヘルパークラスがあって、string 型を戻すときは

1. C++ 側でここで設定されているデリゲート関数を呼び出す。
2. C# 側であらかじめ string なデータを作る。
3. C++ 側から、string なデータのポインタを返す。
4. これを C# 側で string 型で受けて string として利用する。

というなかなか興味深いことをやっています。Python とか Java のコードは追っていないのですが、これは冗長ではあるけど、C#（.NETの世界）のマネージなメモリ空間でデータを扱えるようにする良い手段ですよね。

って、ことまでは分かったのですが、じゃあここの「冗長」な部分は、本来の C# ならばどうするのか？ってのが次です。

C#側でMarshal.PtrToStringAnsiを使う

サンプルコードは、

moonmile/hellodll: C++ の DLL から const char *, wchar_t * を読み込むテスト
https://github.com/moonmile/hellodll

にあります。
C++ の内部的には、std::string あるいは std::wstring を使っている状態で、C# へのインターフェースに、char * あるいは wchar_t * を使うという想定ですね。

– hellodll : C++ の共有ライブラリ
– hello : C# から hellodll を呼び出し
– helloCore: .NET Core から hellodll の呼び出し
– helloStd, helloStdCore : .NET Standard で hellodll を呼び出し、それを .NET Core で利用するパターン

C++ 側ではこんな（乱暴な）感じで、インターフェースを作っておきます。単純な文字列の受け渡しなので、_str や _wstr の中身は C# 側では弄らず、C++ 側でのみ弄るという想定です。C# で弄ったときは、あらためて SetNameStr(char *) のように文字列を渡して貰えばいいのです。

#include <string>
static std::string _str = "";
static std::wstring _wstr = L"";
extern "C" {
	__declspec(dllexport) int __stdcall Add(int x, int y) {
		return x + y;
	}

	__declspec(dllexport) void __stdcall SetNameStr(char *t) {
		_str = std::string(t);
	}
	__declspec(dllexport) char * __stdcall GetNameStr() {
		return (char*)_str.c_str();
	}
	__declspec(dllexport) void __stdcall SetNameWStr(const wchar_t *t) {
		_wstr = std::wstring(t);
	}
	__declspec(dllexport) const wchar_t * __stdcall GetNameWStr() {
		return _wstr.c_str();
	}
}

これを C# 側で受けると、こんな感じになります。C# から渡すときは string が使えるけど、C++ から貰うときは IntPtr で受けます。

 [DllImport("hellodll", EntryPoint = "SetNameStr")]
 static extern void SetNameStr(string t);
 [DllImport("hellodll", EntryPoint = "GetNameStr")]
 static extern IntPtr GetNameStr();
 [DllImport("hellodll", EntryPoint = "SetNameWStr", CharSet = CharSet.Unicode)]
 static extern void SetNameWStr(string t);
 [DllImport("hellodll", EntryPoint = "GetNameWStr", CharSet = CharSet.Unicode)]
 static extern IntPtr GetNameWStr();

IntPtr で受けた値を、Marshal.PtrToStringAnsi あるいは、Marshal.PtrToStringUni で変換します。char * と wchar_t * に対応するわけです。

  string s = "こんにちは C++ の世界";
  SetNameStr(s);
  var s1 = Marshal.PtrToStringAnsi(GetNameStr());

でもって、いちいち文字列を貰うたびに Marshal.PtrToStringAnsi を使うのは面倒なおで、次のようにヘルパークラスを作っておいて、

public class HelloDll
{
    public static void SetNameStr(string s) { _SetNameStr(s); }
    public static string GetNameStr() { return Marshal.PtrToStringAnsi(_GetNameStr()); }
    public static void SetNameWStr(string s) { _SetNameWStr(s); }
    public static string GetNameWStr() { return Marshal.PtrToStringUni(_GetNameWStr()); }


    [DllImport("hellodll", EntryPoint = "SetNameStr")]
    static extern void _SetNameStr(string t);
    [DllImport("hellodll", EntryPoint = "GetNameStr")]
    static extern IntPtr _GetNameStr();
    [DllImport("hellodll", EntryPoint = "SetNameWStr", CharSet = CharSet.Unicode)]
    static extern void _SetNameWStr(string t);
    [DllImport("hellodll", EntryPoint = "GetNameWStr", CharSet = CharSet.Unicode)]
    static extern IntPtr _GetNameWStr();
}

対応する static メソッドを呼び出せばよいのです。

string s = "こんにちは C++ の世界";
HelloDll.SetNameStr(s);
var s1 = Marshal.PtrToStringAnsi(GetNameStr());
Console.WriteLine(s1);

一見、ヘルパークラスは冗長な感じがしますが、インテリセンスが効くことと、名前空間などで区切ることができる、C++の短い名前をC#の長い名前に直すことができる、というメリットがあります。
少し高速さには掛けますが、所詮 C++/C# 変換しているところで遅くなっているので、そこは気にしないことにします。

C++と.NET Standard/Core の関係

試しに、.NET Standard を経由してみたのが、helloStd, helloStdCore のプロジェクトです。

一度、.NET Standard のクラスライブラリを作成しておいて、

public class HelloDll
{
    public static void SetNameStr(string s) { _SetNameStr(s); }
    public static string GetNameStr() { return Marshal.PtrToStringAnsi(_GetNameStr()); }
    public static void SetNameWStr(string s) { _SetNameWStr(s); }
    public static string GetNameWStr() { return Marshal.PtrToStringUni(_GetNameWStr()); }


    [DllImport("hellodll", EntryPoint = "SetNameStr")]
    static extern void _SetNameStr(string t);
    [DllImport("hellodll", EntryPoint = "GetNameStr")]
    static extern IntPtr _GetNameStr();
    [DllImport("hellodll", EntryPoint = "SetNameWStr", CharSet = CharSet.Unicode)]
    static extern void _SetNameWStr(string t);
    [DllImport("hellodll", EntryPoint = "GetNameWStr", CharSet = CharSet.Unicode)]
    static extern IntPtr _GetNameWStr();
}

.NET Core から .NET Standard のクラスライブラリを参照設定させて実行というスタイルです。

static void Main(string[] args)
{
    Console.WriteLine("Test helloCoreStd");
    string s = "こんにちは C++ の世界";

    HelloDll.SetNameStr(s);
    var s1 = HelloDll.GetNameStr();
    Console.WriteLine(s1);

    HelloDll.SetNameWStr(s + " in Unicode");
    var s2 = HelloDll.GetNameWStr();
    Console.WriteLine(s2);
    Console.WriteLine("end");
}

先の、.NET Core から C++ 直接呼出しと何が違うのかというと、いったん .NET Standard で包むことによって、.NET Core 以外の環境で動作ができるという話です。C++ のライブラリは環境ごとにビルドして配布（Windows/Ubuntu/Raspberry Piのように）する必要はありますが、.NET Standard のクラスライブラリはそのまま各種の .NET 開発環境で利用できるという訳ですね。所謂、インターフェースクラスの代わりになります。
そうなると、このクラス（アセンブリ）を利用して、Xamarin.Android/iOS で利用することも可能という話です。そうすると、自前の小さな C++ ライブラリをいちいち C# に書き替えることなく（あるいは Marshal.* や unsafe を駆使することなく）スマートフォン環境に組み込めるのではないかな、と思ったり。このあたりは、もう少し見ていかないといけませんが。

FFFTP2 のライブラリ化の前調査として、C++ のクラスに書き替えたときに、.NETから呼び出すことができるだろうか？というのを調べていました。基本 C# から C/C++ を呼び出すときは dllimport を使う訳ですが、これは「Cインターフェース」を使っているので、C++のクラスを直接呼び出すことはしていません。なので、C++の場合は、一度Cのインターフェースに直して呼び出さないといけないですよね。OpenCvSharp の場合も、OpenCV を呼び出すときに、dllimport を使っていますが、ひとつひとつ C インターフェスに直して組み替えています。ここの手間がなんとも言えないのと、将来的に C++ の構造が変わったときにはこの部分を手作業で直さないといけませんよね（実際 OpenCV2 から OpenCV3 の変換のときに発生している問題で）。となれば、Xamarin.Android のバインド機能よろしく、*.jar ファイルから適当な C# のクラスを吐き出すような仕組みが欲しいところです。

本式にやるならば？ CppSharp っぽいのですが https://github.com/mono/CppSharp どうやら「棘の道」だそうなので、ちょっと避けて、SWIG http://swig.org/ を試しています。
以前、Python から Cライブラリを呼び出すのに SWIG を使う話をちらっと聞いた後に、それ以降調べていなかったのですが、どうやら C++ にも対応しています。

SWIGのwindows版をダウンロード

Visual Studio 2017 で作業をするので、windows 版を落とします。https://sourceforge.net/projects/swig/files/ にある swigwin のほうをダウンロードして展開すると、swig.exe と変換インターフェースがある Lib/*.i 等がでてきます。

ここでは C/C++ を C# に変換するので、Lib/charp/*.i が使われますね。

サンプル

サンプルは http://github.com/moonmile/helloswig にあります。

– helloswig : Visual Studio で作った C++ の DLL プロジェクト
– hello : DLL を利用する C# プロジェクト

hello プロジェクトは可搬性を確認するために、.NET Core プロジェクトで作ってあります。Windows 上のみで動かす場合や Linux 上で mono を使う場合は .NET Framework のプロジェクトでも可能です。Windows 上のみで動作を考えるならば、DLL は MFC DLL でも動作します。

helloswig プロジェクト

helloswig.cpp に実体を定義します。これは DLL 内で動くコードですね。

#include "stdafx.h"
#include "helloswig.h"

Hello::Hello() : _name("") {}

void Hello::SetName(const char *name ) {
	_name = std::string(name);
}

const char * Hello::GetName() {
	return _name.c_str();
}

int Hello::Add(int x, int y) { return x + y; }
int Hello::Mul(int x, int y) { return x * y; }

helloswig.h は外部インターフェースです。

#pragma once
#include <string>
class Hello
{
private:
	std::string _name;
public:
	Hello();
	void SetName(const char *name);
	const char *GetName();
	int Add(int x, int y);
	int Mul(int x, int y);
};

SWIG の場合、デフォルトでヘッダファイルの全てのクラス＆全てのメソッドが公開対象になるので、この部分はエクスポート用のものを作ったほうがよいかもしれません。後、異なる環境でビルドすることを考えると windows.h などの読み込みはできないので、結構「綺麗なヘッダファイル」が必要かもしれません。

#pragma once
#include <string>
class Hello
{
private:
	std::string _name;
public:
	Hello();
	void SetName(const char *name);
	const char *GetName();
	int Add(int x, int y);
	int Mul(int x, int y);
};

helloswig.i は、SWIG で取り込むための設定ファイルです。%module の部分が DLL の名前（C#側の dllimport で指定されます）。%include が公開するための C++ インターフェスです。

/* File : helloswig.i */
%module helloswig

%{
#include "helloswig.h"
%}

/* Let's just grab the original header file here */
%include "helloswig.h"

*.i ファイルはそのままではビルドできないので、swig.exe を呼び出すようにします。
ファイルのプロパティで、「カスタムビルドツール」を指定して、

コマンドラインと出力ファイルを指定します。

swig.exe のパスは環境によって合わせてください。swig.exe のあるフォルダの Lib フォルダーから設定済みの *.i ファイルを読み込むようです。

echo Invoking SWIG...
echo on
..\swig.exe -c++ -csharp "%(FullPath)"
%40echo off

一度、ビルドを通すと helloswig_wrap.cxx のようなラップをしたクラスが作成されます。中身を見ると解るのですが、一度 C インターフェースに直してしています。

...
#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void * SWIGSTDCALL CSharp_new_Hello() {
  void * jresult ;
  Hello *result = 0 ;
  
  result = (Hello *)new Hello();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Hello_SetName(void * jarg1, char * jarg2) {
  Hello *arg1 = (Hello *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (Hello *)jarg1; 
  arg2 = (char *)jarg2; 
  (arg1)->SetName((char const *)arg2);
}
...

これと同時に、helloswigPINVOKE.cs のような C# 側でインポートするクラスが作られます。

...
  [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="CSharp_new_Hello")]
  public static extern global::System.IntPtr new_Hello();

  [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="CSharp_Hello_SetName")]
  public static extern void Hello_SetName(global::System.Runtime.InteropServices.HandleRef jarg1, string jarg2);

  [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="CSharp_Hello_GetName")]
  public static extern string Hello_GetName(global::System.Runtime.InteropServices.HandleRef jarg1);
...

hello プロジェクト

C# 側は、もともと何もないクラスですが、C++ プロジェクト（helloswigプロジェクト）
で作成した *.cs ファイル（Hello.cs, helloswig.cs, helloswigPINVOKE.cs）を追加します。

Program.cs

using System;

namespace hello
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello swig world.");

            var hello = new Hello();
            hello.SetName("Tomoaki Masuda");
            var name = hello.GetName();
            Console.WriteLine($"name: {name}");

            hello.SetName("Jhon doe");
            name = hello.GetName();
            Console.WriteLine($"name: {name}");

            int x = 10;
            int y = 20;
            Console.WriteLine($"{x} + {y} = {hello.Add(x, y)}");
            Console.WriteLine($"{x} * {y} = {hello.Mul(x, y)}");

            Console.WriteLine("end");
        }
    }
}

C# 側の main コードは、通常に C# のコードになります。
SWIG で出力した C# コードをいちいち追加しないといけないのですが、まあそのあたりはバッチ処理をするとかリンクで解決するとかできるでしょう。

ビルドして実行する

.NET Core でインポートできる DLL は x64 のみなので、そのあたりを注意しながら実行ファイルを作ります。

1. C++プロジェクト（helloswig）を x64/Debug あるいは x64/Release でビルド.
2. C#プロジェクト（hello）をビルド。.NET Core なのでコマンドラインから dotnet build でも ok です。
3. 作成した dll を .NET Core の実行ファイルの場所にコピー（bin/Debug/netcoreapp2.0/ にコピー）
4. dotnet run する。

Ubuntu環境でビルド実行する

さて、Windows 環境で動作が確認できたので、Ubuntuに持って行って動かしてみましょう。コードをごっそりと Ubuntu に持って行って、共有ファイルを作成するための Makefile を作ります。

all: libhelloswig.so

libhelloswig.so: helloswig.o
	g++ -sharad helloswig.o helloswig_wrap.o -o libhelloswig.so
helloswig.o: helloswig.cpp
	g++ -c helloswig.cpp
helloswig_wrap.o: helloswig_wrap.cpp
	g++ -c helloswig_wrap.cpp

あまりに久々だったので、ベタな makefile ですが、まあこれで libhelloswig.so がビルドできます。
本来ならば、ubuntu 上で swig を動かしてラップする C# コードを吐き出すところですが、既に Windows 上で作成しているので再利用します。ちなみに、ubuntu 上では「sudo apt-get install swig」で SWIG がインストール可能です。

libhelloswig.so ファイルを指定するために LD_LIBRARY_PATH を設定して dotnet run します。

export LD_LIBRARY_PATH=~/swig/helloswig

ここで、ちょっと面白いのは .NET Core で DllImport を使うと、Windows の場合は「helloswig.dll」を参照し、Ubuntu 上では「libhelloswig.so」を参照するところですね。こんため、Windows の SWIG で出力した C# ラッパーがそのまま Ubuntu でも使えます。

  [global::System.Runtime.InteropServices.DllImport("helloswig", EntryPoint="CSharp_new_Hello")]
  public static extern global::System.IntPtr new_Hello();

共有ファイルに lib を付けておくと便利です。

Raspberry Pi上で実行する

では、ラズパイ上で動かしてみましょう。Raspberry Piでは、.NET Core がビルドできないのであらかじめ Windows 側で C# コードをビルドしておきます。

dotnet publish -r linux-arm

C++ のプロジェクトはRaspberry Pi上で make します。

これで、

– Windows
– Ubuntu
– Raspberry Pi

の3つの環境で、.NET Core + SWIG + C++ライブラリが同じソースで動作ができました。

SWIGの難点

SWIG自体は、C# へのコンバートだけでなく、JavaやPythonなどへのコンバートがサポートされているので、色々な言語で活用ができます。まあ、小さな自前の C/C++ ライブラリを Python などで使う分にはこれでいけそうな気がするのですが、Windows上の複雑なライブラリをコンバートしようとすると難しそうな点がいくつかあります。

– Windows.h などの Unix 系にないインクルードファイルは読み込めない
– LPCTSTR などの定義が読み込めない（別途定義が必要）
– 文字列系のインターフェースは const char * か wchar_t に限られる？

最後のひとつは、std_string.i や std_wstring.i のインターフェースはあるのですが、SWIGTYPE_p_std__string.cs や SWIGTYPE_p_wchar_t.cs のような独自なクラスが作られるのでちょっと違う感じなんですよね。ただし、const char * は string に変換されるので、dllimport の仕組みのままのようです。ただし、このあたりは独自に *.i ファイルを作ればよいので、ピンポイントで std::string から string に変換するとか、std::wstring からコード変換するとかはできそうな感じなのですが。このあたりは別途調査。