【C#】 DllExportでWindowスタイルなAPIをC#風に扱う

# TL;DR;
* **HRESULT**と**例外**の互換（DllImportに`PreserveSig=false`をつける）
* **出力引数**を**戻り値**に移動（`PreserveSig=false`）
* **refやout**を**ポインタ**と互換
* **文字列ポインタ**と**string**を互換（MarshalAs）

# 概要

C#とC/C++の相互運用といえば、C++/CLI、C++/CX、COM、IPCなどが考えられます。
その中でも、`System.Runtime.InteropServices.DllImport`（P/Invoke）という機能があります。
DllImportは基本的には、C++でExportした関数と同じ関数名で（互換性のある）引数、戻り値のメソッドをC#に宣言し、属性でマークすることで使用できます。
しかし、引数や戻り値に関しては**intなどの型互換だけでなく、参照<->ポインタ、HRESULT<->例外など**の互換も可能です。
また、C言語ではよく見かける出力引数を、一定条件下で戻り値として扱うこともできます。

# サンプル
次のようなC++のDLLがあるとします。
C言語（Windows）ではよく、戻り値を成否通知に使い、引数に二重ポインタを渡し、ポインタ先に返したいオブジェクトのポインタを書き込みます。

```c++
// 二重ポインタ（本体の確保は呼び出され側）
extern "C" __declspec(dllexport) HRESULT WINAPI GetBestCouple(TCHAR** ppAnswer)
{
    // *ppAnswer = TEXT("YukaMaki"); // NG
    // *ppAnswer = new TCHAR[32]; // NG

    // C#に返すメモリはCoTaskMemAllocで確保しないといけない
    *ppAnswer = (TCHAR*)CoTaskMemAlloc(32);
    lstrcpy(*ppAnswer, TEXT("YukaMaki"));
    return S_OK;
}
// 一重ポインタ（本体の確保は呼び出し側）
extern "C" __declspec(dllexport) HRESULT WINAPI GetBestCouple2(TCHAR* pAnswer)
{
    lstrcpy(pAnswer, TEXT("YukaMaki"));
    return S_OK;
}
```
ちなみに、これは以下のようなメモリ配置になっています。（`sizeof(void*)==4`の場合）
![](https://docs.google.com/drawings/d/e/2PACX-1vTIlkXC7G2c4eDH7R-sgy-GJphs7I5PTlD69DlqC5M0P15bHC7tT-Bs8SGw0BVGJiY8g2OtfotZnGB1/pub?w=754&amp;h=188&)

これを、色々な条件でDLLImportしてみましょう。

## Case 1
普通に二重ポインタ（`TCHAR**`）を渡し、実態へのポインタを格納しているメモリ領域を、C++側が確保した領域へのポインタに書き換えてもらいます。
C#側では二重ポインタ（`TCHAR**`）から`TCHAR*`を取り出して、マーシャラでデコード。

```cs
// HRESULT GetBestCouple(TCHAR** ppAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple")]
static extern int GetBestCouple_H_PP_(IntPtr ppAnswer);

// 本体A(TCHAR[])へのポインタB(TCHAR*)へ
// のポインタC(TCHAR**)のBの部分のメモリを確保してCにアドレスを記録
// TCHAR* pAnswer; // 確保
// TCHAR** ppAnswer = &pAnswer;
// の操作に相当
IntPtr ppAnswer = Marshal.AllocHGlobal(IntPtr.Size);
int hResult = GetBestCouple_H_PP_(ppAnswer);
// TCHAR* pAnswer = *ppAnswer;
// の操作に相当
IntPtr pAnswer = Marshal.ReadIntPtr(ppAnswer);
string answer = Marshal.PtrToStringAuto(pAnswer);
```

## Case 2
Case 1と同様の関数を呼び出しているが、C#側がout参照を渡しています。（これはref/in参照でもOK）
C#の参照もポインタと同じようなものなので、ポインタの参照、つまり二重ポインタと同様に働きます。
そのため、二重ポインタから本体の領域へのポインタを取り出す操作がなくなっています。

```cs
// HRESULT GetBestCouple(TCHAR** ppAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple")]
static extern int GetBestCouple_H_RP_(out IntPtr pAnswer);

IntPtr pAnswer;
int hResult = GetBestCouple_H_RP_(out pAnswer);
string answer = Marshal.PtrToStringAuto(pAnswer);
```

## Case 3
Case 2では戻り値を受け取っていましたが、捨てることも可能。

```cs
// HRESULT GetBestCouple(TCHAR** ppAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple")]
static extern void GetBestCouple_V_P_E(out IntPtr pAnswer);

IntPtr pAnswer;
GetBestCouple_V_P_E(out pAnswer);
string answer = Marshal.PtrToStringAuto(pAnswer);
```

## Case 4
`PreserveSig=false`を付けることで、HRESULTをC#の例外に変換してくれます。
戻り値はなくなりvoidになりますが、代わりに出力引数を戻り値にできます。
（Case 3のようにout参照にできるものを変えさせられます。）

```cs
// HRESULT GetBestCouple(TCHAR** ppAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple", PreserveSig = false)]
static extern IntPtr GetBestCouple_P__E();

IntPtr pAnswer = GetBestCouple_P__E();
string answer = Marshal.PtrToStringAuto(pAnswer);
```

## Case 5

ここまでは、文字列をポインタを受け取って、マニュアルでstringにデコードしていました。
`MarshalAs`を利用することで、直接**string（またはStringBuilder）で受け取る**ことができます。

C#の`char`はWide文字なので`WCHR`、`string`は`WCHAR*`と互換になります。
（アルファベットを含むほとんどの文字を2byteで表現します、つまり基本的にUTF-16）
~~そして、C++側のTCHARがWCHARであれば、変換の必要が無いためコピーを回避してポインタだけを受け取れます。（Case 4までより効率的）~~
→ [CoTaskMemAllocとGC](https://qiita.com/up-hashi/items/1c5717657c6e2aa38698#cotaskmemalloc%E3%81%A8gc)

> ```cs
> HRESULT PassStringRef4([in, out] LPWStr *s); // C++
> void PassStringRef4([MarshalAs(UnmanagedType.LPWStr)] ref string s); // C#
> ```
[文字列に対する既定のマーシャリング(MSDN)](https://docs.microsoft.com/ja-jp/dotnet/framework/interop/default-marshaling-for-strings)

上記のようにMSDNで紹介されているように、直接stringで受け取ってみます。
refで書いてありますが、outでも大丈夫です。outにする（＆`InAttribute`を消す）と、C++側にはnullになって渡ります。
ちなみに`LPWStr`は「Wide-String(=`WCHR*`)のlongポインタ」という意味で、TCHARはWCHARになります。（ここでは）
なので`TCHAR**`=`LPWStr*`です。

この後に`p0`と`p1`の指すメモリを見てみると、`p0`は元のアドレスで「GynGyn」がそのまま残っています。
一方で、`p1`はp0とは別のアドレスになっており、「YukaMaki」が書き込まれています。
このことからも、**`answer`が指し示す`TCHAR*`が変わった**ことがわかります。
（`GCHandle.Alloc`は、Managedオブジェクトのメモリ位置を固定してポインタを取得します。本当は、`GCHandle.Alloc`の後は`GCHandle.Free`する必要があります）

```cs
// HRESULT GetBestCouple(TCHAR** ppAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple")]
static extern int GetBestCouple_V_RS_([MarshalAs(UnmanagedType.LPTStr), In, Out] ref string answer);

string asnwer = "GyunGyun"; // stringの実体はTCHAR*
IntPtr p0 = GCHandle.Alloc(asnwer, GCHandleType.Pinned).AddrOfPinnedObject();
GetBestCouple_V_RS_(ref answer); // ref stringは実質TCHAR**
IntPtr p1 = GCHandle.Alloc(asnwer, GCHandleType.Pinned).AddrOfPinnedObject();
// p0: 0x10B4 "GyunGyun\0\0\0\0\0\0\0\0\0" （上書きされず残っている）
// p1: 0x2A40 "YukaMaki\0\0\0\0\0\0\0\0\0"
```

## Case 7
二重でないポインタ版。
一重ポインタを出力引数に取る場合、一般的には**呼び出し側が書き込み先の領域を確保する**ことが期待されます。

もちろん、`asnwerBuffer`が十分な大きさが無いと、Overflowします。
超巨大な文字列を扱う場合などはこちらの方がいいかもしれません。

```cs
// HRESULT GetBestCouple2(TCHAR* pAnswer)
[DllImport("D3DVisualization.dll", EntryPoint = "GetBestCouple2")]
static extern int GetBestCouple_V_S_([MarshalAs(UnmanagedType.LPWStr)] string asnwerBuffer);

string asnwerBuffer = new string('_', 16); // 16+1文字分を確保して'_'で埋める
// answerBuffer: "________________\0"
GetBestCouple_V_S_(asnwerBuffer); // answerBufferが確保した領域に上書きする
// answerBuffer: "YukaMaki\0______\0"
```

# `CoTaskMemAlloc`とGC

`CoTaskMemAlloc`で確保したメモリは、返却時にシステムによって解放されます。
わかりやすいように、C++側で512M文字（1GB）を確保します。
その後、C#側に制御が戻り、`GC.Collect`を読んで強制GCを走らせた後、使用メモリ量が急激に減少していることが確認できました。

また、グラフをよくみると、C++で確保した瞬間に1GB、C#に返るときに追加で1GB確保しています。コピーが発生しているように見えます。`UnmanagedType`を`LPSTR`や`LPWSTR`にしたり、`PreserveSig=true`にしても同じ結果になります。

```cpp
DLLEXPORT HRESULT WINAPI Get512MString(TCHAR*& dst)
{
    size_t size = 512 * 1024 * 1024; // 512 MB 確保
    dst = (TCHAR*)CoTaskMemAlloc(size * sizeof(TCHAR));
    for (size_t i = 0; i < size / 8; i++)
        memcpy(dst + i * 8, TEXT("YukaMaki"), 8 * sizeof(TCHAR));
    dst[size - 1] = TEXT('\0');
    return S_OK;
}
```
```cs
[DllImport("D3DVisualization.dll", PreserveSig = false)]
[return: MarshalAs(UnmanagedType.LPTStr)]
static extern string Get512MString();

int getCount() => Test().Length; // スコープが抜けるように別関数化
Console.WriteLine(getCount()); // 536870911
GC.Collect(); GC.Collect();
```

コピーは発生しているけど、最終的にどちらも解放されます。
![コメント 2020-03-13 030258.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/280975/50529b19-fa41-feff-bf29-2a6b36b06d9a.png)
`Test()`の戻り値をメンバにキープしてGCされないようにすると、C++で確保した分だけが解放されます。このことから、コピーされているのは間違いないですね。
![コメント 2020-03-13 034752.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/280975/379045d6-b71f-eba6-87c2-369a2d8bbc66.png)

ちなみに、`CoTaskMemAlloc`のメモリはC#にリターンした時に問答無用で解放されるので、C++側の静的な領域にポインタを確保しておいて、もう一度使おうとすると、アクセス違反でクラッシュします。


# まとめ

DllImportのために宣言するメソッドは意外と柔軟であることがわかりました。
そもそも、DLLのリンクは`extern C`なので、関数名しか見ていませんが…（故にオーバーロードとか無理）
型互換以外（ポインタも型ですが）についてまとめましたが、型も結構自由が利き、ユーザ定義のclass/structなんがが使えたりします。
[StructLayoutAttribute クラス(MSDN)](https://docs.microsoft.com/ja-jp/dotnet/api/system.runtime.interopservices.structlayoutattribute?view=netframework-4.8)

…とはいえ、DllImportしたメソッドはラップして利用することが推奨されていますし、ここまでの紹介は全てラッパーで解決できることだったりします。

一番ハマったのは、C++でメモリ確保をする部分でした。
**`CoTaskMemAlloc`を使わないと互換化できない**…ということでした。
MarshalAsのMSDNページに書いといてくださいよ…:rolling_eyes:
ただ、逆に開放はGCでやってくれます。


結論として、余分なコピーは発生しますが、**IntPtrで受け取って`Marshal.PtrToStringAuto`でデコードするのが一番安定**するような気がします。

# 参考

[WinAPIからの値の受け取り方について(C# と VB.NET の質問掲示板)](http://bbs.wankuma.com/index.cgi?mode=al2&namber=90644&KLOG=156)
[PreserveSigAttribute クラス(MSDN)](https://docs.microsoft.com/ja-jp/dotnet/api/system.runtime.interopservices.preservesigattribute?view=netframework-4.8)
[文字列に対する既定のマーシャリング(MSDN)](https://docs.microsoft.com/ja-jp/dotnet/framework/interop/default-marshaling-for-strings)
[【Windows/C#】なるべく丁寧にDllImportを使う(Qiita)](https://qiita.com/mitsu_at3/items/94807ee0b3bf34ffb6b2#%E6%96%87%E5%AD%97%E5%88%97%E3%82%92%E5%8F%97%E3%81%91%E5%8F%96%E3%82%8B)
[DLLから文字列を取得する方法(@IT)](https://www.atmarkit.co.jp/bbs/phpBB/viewtopic.php?topic=32071&forum=7&start=24)
[C#とCとのやり取りでCから配列変数を渡す例](https://www.valuestar.work/news/archives/72)
[ワイド文字(Wikipedia)](https://ja.wikipedia.org/wiki/%E3%83%AF%E3%82%A4%E3%83%89%E6%96%87%E5%AD%97)
[既定のマーシャリングの動作 -> アンマネージ シグネチャ（MSDN）](https://docs.microsoft.com/ja-jp/dotnet/framework/interop/default-marshaling-behavior#unmanaged-signature)
[P/Invoke時におけるマーシャラの動作（マーシャリング）(KrdLab's blog)](https://krdlab.hatenablog.com/entry/20061211/1165768253)
[【Unite 2017 Tokyo】パフォーマンス向上のためのスクリプトのベストプラクティス (slideshare)](https://www.slideshare.net/UnityTechnologiesJapan/unite-2017-tokyo-75841792)
[Standard ECMA-335 Common Language Infrastructure (CLI) (ECMA)](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf)