ライブラリの基礎 - C++DLL

概要

C# EXEからC++ DLLへ様々なデータ型の変数を渡したい場合がある。

しかし、C#の変数とC++の変数はメモリへの配置が基本型以外異なるため、直接、C#からC++に渡すことができない。

例えば、文字列を扱う場合、C#のstring型とC++のstd::string型は同一ではないため、マーシャリングの処理が必要となる。
マーシャリングとは、異なる2つのシステム間において、データを交換できるようにデータを操作する処理を指す。

DllImport属性

DLLImport属性は、DLLエントリポイントを定義する関数を記述することで、DLLファイルに定義された関数を呼び出すことができる。

 [ DllImport( "DLL名" ) ]

また、DLLファイルに定義された関数を、関数名または序数で指定するには、DllImport属性のEntryPointフィールドを使用する。
メソッド定義内の関数の名前がDLLエントリポイントと同じである場合は、その関数をEntryPointフィールドで明示的に識別する必要はない。
同じではない場合は、次のいずれかの記述で名前または序数を指定する。

以下の例では、EntryPointフィールドを使用して、MessageBoxAをMsgBoxAに置き換える方法を示している。

 using System;
 using System.Runtime.InteropServices;
 
 internal static class NativeMethods
 {
    [DllImport("user32.dll", EntryPoint = "MessageBoxA")]
    internal static extern int MsgBoxA(IntPtr hWnd, string lpText, string lpCaption, uint uType);
 }

また、以下の例では、DLLファイルに定義された関数を序数で指定している。

 [DllImport("DllName", EntryPoint = "Functionname")]
 [DllImport("DllName", EntryPoint = "#123")]  // 序数を使用するには、序数値の前にシャープ記号#を付ける必要がある

DllImport属性には、DLLファイル名を指定する以外にも、下表のような引数を与えることができる。

名称	説明	既定値
EntryPoint	呼び出すDLLエントリポイントの名前または序数を指定する。 DLLの関数名とC#上で使用する関数名を異なる名前にする時に指定する。
CharSet	文字列パラメータをメソッドにマーシャリングして、名前マングルを制御する方法を指定する。 文字コードの相互変換する時に指定する。 指定なしの場合は、CharSet.Autoとなる。	CharSet.Auto
SetLastError	Win32エラー情報を維持するかどうか指定する。 指定なしの場合は、falseとなる。	FALSE
ExactSpelling	エントリポイントの関数名を厳密に一致させるかどうか指定する。 指定なしの場合は、falseとなる。	FALSE
PreserveSig	定義通りのメソッドのシグネチャを維持するかどうか指定する。
CallingConvention	アンマネージドコードを呼び出すためのエントリポイントの呼び出し規約を、明示的に指定できる。 指定なしの場合は、__stdcall(StdCall)となる。 詳細は、下表を参照すること。	StdCall

詳細は、以下のMSDNのWebサイトを参照すること。
DllImportAttribute クラス (System.Runtime.InteropServices) | MSDN

• 呼び出し規約(Calling Convention)

  CallingConvention列挙型で、アンマネージドコードを呼び出すための呼び出し規約を指定する。
  

  下表に、CallingConvention列挙型を示す。
  

  
  

  また、実行時に指定のDLLを読み込めない場合、モジュールが見つからないとして、FileNotFoundExceptionやDllNotFoundException等の例外が投げられる。
  

System.IO.FileNotFoundException はハンドルされませんでした。
Message: 型 'System.IO.FileNotFoundException' のハンドルされていない例外が mscorlib.dll で発生しました
追加情報:ファイルまたはアセンブリ '**.dll'、またはその依存関係の 1 つが読み込めませんでした。
指定されたモジュールが見つかりません。
これは参照しているDLLがない、またはそのDLLが依存しているDLLが適切に配置されていない場合に発生します。
これは問題のDLLをdumpbinで調べ、それを配置することで解決できます。

列挙子	説明
Cdecl	呼び出し元がスタックを消去する。 これを使用すると、varargsで関数を呼び出すことができる。 これは、printf関数等の可変長引数のメソッドの呼び出しで使用する。
StdCall	呼び出し先がスタックを消去する。 アンマネージド関数を呼び出す既定値内のテキスト。
ThisCall	最初の引数がthisポインタで、その他の引数はスタックにプッシュされる。 アンマネージドDLLからエクスポートしたクラスのメソッドを呼び出すために使用する。
Winapi	プラットフォームに応じた既定の呼び出し規約を使用する。 例えば、WindowsではStdCall、Windows CE.NETではCdecl、LinuxではCdeclである。 (正確には、この設定は呼び出し規約ではない)
FastCall	この呼び出し規約はサポートされていない。

以下の例では、呼び出し規約を適用する方法をCdeclとしている。
これは、呼び出し元がスタックをクリーンアップするために使用する必要がある。

 using System;
 using System.Runtime.InteropServices;
 
 internal static class NativeMethods
 {
    // C#は可変長引数をサポートしていないため、全ての引数を明示的に定義する必要がある。
    // スタックは呼び出し元によってクリーンアップされるため、CallingConvention.Cdeclを使用する必要がある。
 
    // int printf( const char *format [, argument]... )
 
    [DllImport("msvcrt.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
    internal static extern int printf(String format, int i, double d);
 
    [DllImport("msvcrt.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
    internal static extern int printf(String format, int i, String s);
 }
 
 public class App
 {
    public static void Main()
    {
       NativeMethods.printf("\nPrint params: %i %f", 99, 99.99);
       NativeMethods.printf("\nPrint params: %i %s", 99, "abcd");
    }
 }

詳細は、以下のMSDNのWebサイトを参照すること。
CallingConvention 列挙型 (System.Runtime.InteropServices) | MSDN

StructLayout属性

StructLayout属性とは、クラスまたは構造体のデータメンバを、メモリ内でどのように配置するかを表す。

 [ StructLayout( LayoutKind列挙 ) ]

下表に、LayoutKind列挙子を示す。

LayoutKind列挙子	説明
Sequential	宣言される順番に従って並べる。
Explicit	FieldOffsetAttributeで独自のオフセットを指定して並べる。
Auto	適切なレイアウトで並べる。 (これを指定すると、マネージドコード外からアクセスできない)

下表に、StructLayout属性のパラメータを示す。

StructLayout属性のパラメータ	説明	既定値
Pack	パックサイズを指定するint値である。 指定可能な値は、1、2、4、8、16のいずれかである。	8
CharSet	文字列のマーシャリング方法を示すCharSet列挙である。	CharSet.Auto
Size	構造体またはクラスのサイズを指定する。

 [StructLayout( LayoutKind.Sequential )]
 public struct Position
 {
    public double x;
    public double y;
    public double z;
 }

詳細は、以下のMSDNのWebサイトを参照すること。
StructLayoutAttribute クラス (System.Runtime.InteropServices) | MSDN

CLSCompliant属性

CLSCompliant属性は、CLSへの準拠を検証するかどうかをコンパイラに指示する。

外部から参照できない型やメンバに対しては、この属性を指定する必要は無い。
指定する場合、このアセンブリの外から認識できないため、CLS準拠の確認は '型' で実行されませんと警告が表示される。

以下の例では、UInt32型はCLSに準拠しないため、CLSCompliant(false)と指定する必要がある。

 [CLSCompliant( false )]
 public int SetValue( UInt32 value );

以下の例では、CLSCompliantAttribute属性をアセンブリ全体に適用する。

 using System;
 [assembly: CLSCompliant(true)]

詳細は、以下のMSDNのWebサイトを参照すること。
CLSCompliantAttribute クラス (System) | MSDN

SuppressUnmanagedCodeSecurity属性

SuppressUnmanagedCodeSecurity属性は、アンマネージドコードの呼び出し時に実行されたスタックウォークを、実行時に省いて効率を大幅に向上させる。

詳細は、以下のMSDNのWebサイトを参照すること。
SuppressUnmanagedCodeSecurityAttribute クラス | MSDN

MarshalAs属性

MarshalAs属性は、マネージドコードとアンマネージドコードの間で、データをマーシャリングする方法を指定する。

詳細は、以下のMSDNのWebサイトを参照すること。
MarshalAsAttribute クラス (System.Runtime.InteropServices) | MSDN

 // パラメータへの適用
 public void M1([MarshalAs(UnmanagedType.LPWStr)]string msg)
 {
 
 }
 
 // クラスのフィールドへの適用
 class MsgText
 {
    [MarshalAs(UnmanagedType.LPWStr)]
    public string msg = "Hello World";
 }
 
 // 戻り値への適用
 [return: MarshalAs(UnmanagedType.LPWStr)]
 public string GetMessage()
 {
    return "Hello World";
 }

In属性 / Out属性

In属性 / Out属性は、データの渡し方を指示する。

	説明
In属性	呼び出し側にデータをマーシャリングして渡すことを示す。
Out属性	呼び出し元にデータをマーシャリングして戻すことを示す。

 void Method([in] int[] array);

C#のデータ型とC++のデータ型

Windows APIのデータ型 (括弧内は対応するC言語の型)	対応するC#のデータ型 (括弧内は.NET Frameworkでの型名)	備考
HANDLE (void *) HMODULE HINSTANCE HWND HWM HGDIOBJ HDC	System.IntPtr System.UIntPtr	x86は4バイト x64は8バイト
char 配列名 [配列サイズ］	MarshalAs(UnmanagedType.ByValTStr, SizeConst = 配列のサイズ)] public string 配列名
char **	文字を渡すとき string (System.String) 文字を受け取るとき System.Text.StringBuilder
BYTE (unsigned char) UCHAR	byte (System.Byte)	UCHAR型は、C#のstring型およびIntPtr型でも可能。
BYTE[] (unsigned char *) PBYTE (byte *)	System.Byte[] [MarshalAs(UnmanagedType.LPArray)] byte[] [MarshalAs(UnmanagedType.LPArray)] Intptr
unsigned char &	ref byte
SHORT (short)	short (System.Int16)
WORD (unsigned short)	ushort (System.UInt16)
INT (int) LONG (long) DWORDLONG HPARAM LPARAM WPARAM	int (System.Int32)	System.Int16でも取得できる可能性がある。
UINT (unsigned int) DWORD (unsigned long) ULONG (unsigned long)	uint (System.UInt32)
DECIMAL	decimal (System.Decimal)
bool	bool (System.Boolean)
BOOL (long)	bool (System.Boolean)
CHAR (char)	文字を渡すとき char (System.Char) 文字を受け取るとき StringBuilder
WCHAR (wchar_t)	文字を渡すとき char (System.Char) 文字を受け取るとき StringBuilder
PCAHR (char *) LPSTR (char *, char[]) LPWSTR (wchar_t *, wchar_t[])	文字を渡すとき string (System.String) 文字を受け取るとき System.Text.StringBuilder
LPCSTR (const char *, const char[]) LPCWSTR (const wchar_t *, const wchar_t[])	文字を渡すとき string (System.String) 文字を受け取るとき System.Text.StringBuilder
LPTSTR (char * または wchar_t *)	文字を渡すとき [MarshalAs(UnmanagedType.LPTStr)] string 文字を受け取るとき System.Text.StringBuilder
LPCTSTR (const char * または const wchar_t *)	文字を渡すとき string (System.String) 文字を受け取るとき System.Text.StringBuilder
BSTR	文字を渡すとき string (System.String) 文字を受け取るとき System.Text.StringBuilder
FLOAT (float)	float (System.Single)
float <配列名>[] float <配列名> [配列サイズ]	float[] ref float[]
DOUBLE (double)	double (System.Double)
double <配列名>[] double <配列名> [配列サイズ]	double[] ref double[]
VARIANT	System.Object
COLORREF	uint
GUID	Guid
struct <構造体名> <変数名>	ref <構造体名> <変数名>
struct <構造体名>	public struct <構造体名>	out <構造体名>であらかじめ構造体をインスタンス化して、変数名を宣言する。

整数型および浮動小数点型のマーシャリング

Linux

下記に、Linux向けC++ライブラリを記述する。

 // SampleLib.cpp
 
 #include <cstdio>
 #include <cstring>
 
 extern "C" int __attribute__((visibility("default"))) SampleFunc01(int a)
 {
    printf(--<SampleDll:SampleFunc01>--\r\n");
    printf("a = %d\r\n", a);
    printf("---------------------------\r\n");
 
    return 10;
 }
 
 extern "C" double __attribute__((visibility("default"))) SampleFunc02(double a)
 {
    printf("--<SampleDll:SampleFunc02>--\r\n");
    printf("a = %f\r\n", a);
    printf("---------------------------\r\n");
 
    return 3.14;
 }

Windows

Windows向けC++ DLLの作成方法はライブラリの基礎 - DLLの作成(C/C++/MFC)を参照する。

下記に、C++ DLLを記述する。

 // SampleDLL.h
 
 int __stdcall SampleFunc01(int a);
 double  __stdcall SampleFunc02(double a);

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 int __stdcall SampleFunc01(int a)
 {
    printf(--<SampleDll:SampleFunc01>--\r\n");
    printf("a = %d\r\n", a);
    printf("---------------------------\r\n");
 
    return 10;
 }
 
 double __stdcall SampleFunc02(double a)
 {
    printf("--<SampleDll:SampleFunc02>--\r\n");
    printf("a = %f\r\n", a);
    printf("---------------------------\r\n");
 
    return 3.14;
 }

 // SampleDll.def  // モジュール定義ファイル
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          SampleFunc01   @1
          SampleFunc02   @2

Linux / Windows

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

 using System;
 using System.Text;
 using System.Runtime.InteropServices;
 
 namespace SampleEXE
 {
    class Program
    {
       [DllImport("SampleDLL.dll")]  // Windows
       [DllImport("SampleLib.so")]   // Linux
       private static extern int SampleFunc01(int a);
 
       [DllImport("SampleDLL.dll")]  // Windows
       [DllImport("SampleLib.so")]   // Linux
       private static extern double SampleFunc02(double a);
 
       static void Main(string[] args)
       {
          var iRet= SampleFunc01(1);
          Console.WriteLine(iRet);
          Console.WriteLine();
 
          var dRet= SampleFunc01(0.01);
          Console.WriteLine(dRet);
          Console.WriteLine();
 
          Console.ReadKey();
       }
    }
 }

ポインタのマーシャリング

例えば、C++ DLLから次のような関数がエクスポートされているとする。

 void WINAPI ConvertToString(char *pstrRet);
 void WINAPI ConvertToShort(short *psRet);
 void WINAPI ConvertToDouble(double *pdRet);

上記の関数において、C# EXEから使用する時、ConvertToString関数の引数のchar*型は文字列なので、string型またはStringBuilder型を渡す。
ConvertToShort関数の引数のshort*型は、IntPtr型を渡す。
(IntPtr型は汎用ポインタを表す型であり、void*型とほぼ同義)
ConvertToDouble関数の引数のdouble*型は、IntPtr型を渡す。

ただし、C#は厳しい型付け言語のため、曖昧さを解決するために、変換メソッドを経由する必要がある。

具体的には、IntPtr型の変数にMarshal.AllocHGlobalメソッドで必要なサイズのメモリを確保して、それをC++ DLLの関数へ受け渡しを行う。
Marshal.ReadInt16メソッド(型により異なる)等で変換した後、確保したメモリをMarshal.FreeHGlobal関数で解放するというプロセスを経る必要がある。

以下の例では、C++ DLLを呼ぶC# EXEのソースコードを記述している。

 using System.Runtime.InteropServices;  // DllImportを使用するために必要
 
 // 呼び出し元の関数名を変更する
 
 // C++ DLL側の文字コードがUnicodeの場合は"CharSet = CharSet.Unicode"と明示的に指定する
 [DllImport("Sample.dll", EntryPoint = "ConvertToString", CharSet = CharSet.Unicode)]
 extern static void _ConvertToString(StringBuilder pstrRet);
 
 [DllImport("Sample.dll", EntryPoint = "ConvertToShort")]
 extern static void _ConvertToShort(IntPtr psRet);
 
 [DllImport("Sample.dll", EntryPoint = "ConvertToDouble")]
 extern static void _ConvertToDouble(IntPtr pdRet);
 
 public static string ConvertToString()
 {
    // 値を受け渡しを行う場合、StringBuilderクラスを使用する
    var strRet = = new System.Text.StringBuilder(256);
 
    // 値を渡すだけの場合、string型を使用する
    //string strRet = "";
  
    // C++ DLLの関数を呼ぶ
    _ConvertToString(strRet);
 
    return strRet;
 }
  
 public static short ConvertToShort()
 {
    // 2バイトのメモリ確保
    IntPtr buffer = new IntPtr();
    buffer = Marshal.AllocHGlobal(2);
 
    // C++ DLLの関数を呼ぶ
    _ConvertToShort(buffer);
 
    // 2バイトのメモリをshort型に変換
    short sRet = Marshal.ReadInt16(buffer);
 
    // メモリの開放
    Marshal.FreeHGlobal(buffer);
 
    return sRet;
 }
 
 public static double ConvertToDouble()
 {
    // 8バイトのメモリ確保
    IntPtr buffer = new IntPtr();
    buffer = Marshal.AllocHGlobal(8);
 
    // C++ DLLの関数を呼ぶ
    _ConvertToDouble(buffer);
 
    // IntPtr型からdouble型の数値を取得する
    // Int64型へ変換後、BitConverter.Int64BitsToDoubleメソッドでdouble型に変換する
    var i64Ret = Marshal.ReadInt64(buffer);
    var dRet   = BitConverter.Int64BitsToDouble(i64Ret);
 
    // 必ずメモリを解放する
    Marshal.FreeHGlobal(buffer);
 
    return dRet;
 }

IntPtr型の変数は様々なものが入る。
構造体を取得することもできるが、C# EXEで構造体を定義しなければならない。
ネイティブコードと.NET Frameworkでは型の管理方法が違うため、実際には型の相互変換(マーシャリング)が行われる。

なお、Windows APIではBOOL型の実体はLONG型なので、.NET Frameworkではboolの代わりにintを指定することも可能である。

配列のマーシャリング

このセクションでは、C# EXEからC++ DLLへ配列を渡す方法を記載する。

まず、以下にC++ DLLを記述する。

 // SampleDLL.h
 
 #pragma once

 void __stdcall SampleArray01(int array[], int length);
 int* __stdcall SampleArray02(int length);
 void __stdcall SampleArray03(int array[], int length);

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 void __stdcall SampleArray01(int array[], int length)
 {
    for (int i = 0; i < length; i++)
    {
       std::cout << array[i] << std::endl;
    }
 }
 
 int* __stdcall SampleArray02(int length)
 {
    int* iary = new int[length];
 
    for (int i = 0; i < length; i++)
    {
        iary[i] = i;
    }
 
    return iary;
 }
 
 void __stdcall SampleArray03(int array[], int length)
 {
    for (int i = 0; i < length; i++)
    {
       arr[i] = i;
    }
 }

 // モジュール定義ファイル
 // SampleDll.def
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          SampleArray01   @1
          SampleArray02   @2
          SampleArray03   @3

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

手順としては、以下の処理の流れとなる。

1. C# EXEでマネージド配列(C# EXEの配列)を定義する。
2. C# EXEにおいて、アンマネージド配列(C++ DLLの配列)のメモリを確保する。
3. マネージド配列の内容を、上記で確保したアンマネージド配列のメモリにコピーする。
4. C++ DLLの関数を実行する時、ポインタを渡す。
5. 使用したアンマネージド配列のメモリを解放する。

 namespace SampleEXE
 {
    [DllImport("SampleDll.dll", EntryPoint = "SampleArray01", CallingConvention = CallingConvention.Cdecl)]
    static extern void _SampleArray01(IntPtr array, int length);
 
    [DllImport("SampleDll.dll", EntryPoint = "SampleArray02", CallingConvention = CallingConvention.Cdecl)]
    static extern IntPtr _SampleArray02(int length);
 
    [DllImport("SampleDll.dll", EntryPoint = "SampleArray03", CallingConvention = CallingConvention.Cdecl)]
    static extern IntPtr _SampleArray03(IntPtr array, int length);
 
    static void Main()
    {
       SampleArray01();
       SampleArray02();
       SampleArray03();
    }
 
    // SampleArray01
    // 配列を渡す場合
    private static void SampleArray01()
    {
       // 配列の定義
       var array = new int[] { 0, 1, 2, 3, 4 };
 
       // アンマネージド配列のメモリの確保
       IntPtr ptrRet = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(int)) * array.Length);
 
       // マネージド配列をアンマネージドにコピーする
       Marshal.Copy(array, 0, ptrRet, array.Length);
 
       // C++ DLLに配列を渡す(ポインタを渡す)
       _SampleArray01(ptrRet, array.Length);
 
       // アンマネージドメモリの解放
       Marshal.FreeCoTaskMem(ptrRet);  
    }
 
    // SampleArray02
    // 配列を受ける場合 (戻り値がint型ポインタ)
    private static void SampleArray02()
    {
       // 空の配列の定義
       int[] array = new int[5];
 
       // 戻り値のポインタをIntPtrで受け取る
       IntPtr ptrRet = _SampleArray02(array.Length);
 
       // アンマネージド配列からマネージド配列へコピー
       Marshal.Copy(ptrRet, array, 0, array.Length);
 
       foreach(int n in array)
       {
          Console.WriteLine(n + " ");
       }
    }
 
    // SampleArray03
    // 配列を受ける場合 (引数がint型の配列)
    private static void SampleArray03()
    {
       // 空の配列の定義
       int[] array = new int[5];
 
       // アンマネージド配列のメモリを確保
       IntPtr ptrRet = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(int)) * array.Length);
 
       // 引数でポインタを渡す
       _SampleArray03(ptrRet, array.Length);
 
       // アンマネージド配列からマネージド配列へコピー
       Marshal.Copy(ptrRet, array, 0, array.Length);
 
       // アンマネージド配列のメモリを解放
       Marshal.FreeCoTaskMem(ptrRet);
 
       foreach(int n in array)
       {
          Console.WriteLine(n + " ");
       }
    }
 }

文字列のマーシャリング (1)

C++ DLLの作成方法はライブラリの基礎 - DLLの作成(C/C++/MFC)を参照する。

下記にもC++ DLLを記述する。

 // SampleDLL.h
 
 int            __stdcall Mul(int x, int y)
 void           __stdcall MulUsePointer(int *x, int *y, int *result)
 void           __stdcall SetNameStr(const char *t)
 const char*    __stdcall GetNameStr()
 void           __stdcall SetNameWStr(const wchar_t *t)
 const wchar_t* __stdcall GetNameWStr()

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 static std::string _str   = "";
 static std::wstring _wstr = L"";
 
 int __stdcall Mul(int x, int y)
 {
    return x * y;
 }
 
 void __stdcall MulUsePointer(int *x, int *y, int *result)
 {
    *result = (*x) * (*y);
 }
 
 void __stdcall SetNameStr(const char *t)
 {
    _str = std::string(t);
 }
 
 const char* __stdcall GetNameStr()
 {
    return _str.c_str();
 }
 
 void __stdcall SetNameWStr(const wchar_t *t)
 {
    _wstr = std::wstring(t);
 }
 
 const wchar_t * __stdcall GetNameWStr()
 {
    return _wstr.c_str();
 }

 // SampleDll.def  // モジュール定義ファイル
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          Mul             @1
          MulUsePointer   @2
          SetNameStr      @3
          GetNameStr      @4
          SetNameWStr     @5
          GetNameWStr     @6

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

DllImpoort文は、DLLファイル名を指定する。
この時、C#の実行ファイルと同一階層にDLLファイルがある場合、DLLファイル名のみを指定するだけでよい。
異なる階層にDLLファイルがある場合、フルパスで指定する必要がある。

C++ DLLの関数を実行する時、"エントリーポイントが見つかりません。"とエラーが出力される場合、DllImport文に誤りがある可能性が高い。

 using System;
 using System.Runtime.InteropServices;
 
 namespace SampleCSharp
 {
    class Program
    {
       [DllImport("SampleDLL", EntryPoint = "Mul")]
       static extern int _Mul(int x, int y);
 
       [DllImport("SampleDLL", EntryPoint = "MulUsePointer")]
       static extern void _MulUsePointer(ref int x, ref int y, out int result);
 
       [DllImport("SampleDLL", EntryPoint = "SetNameStr", CharSet = CharSet.Ansi)]
       static extern void _SetNameStr(string t);
 
       [DllImport("SampleDLL", EntryPoint = "GetNameStr", CharSet = CharSet.Ansi)]
       static extern IntPtr _GetNameStr();
 
       [DllImport("SampleDLL", EntryPoint = "SetNameWStr", CharSet = CharSet.Unicode)]
       static extern void _SetNameWStr(string t);
 
       [DllImport("SampleDLL", EntryPoint = "GetNameWStr", CharSet = CharSet.Unicode)]
       static extern IntPtr _GetNameWStr();
 
       static void Main(string[] args)
       {
          int x = 10;
          int y = 20;
 
          int resultMul = _Mul(x, y);
          Console.WriteLine("Mul = " + resultMul);
 
          _MulUsePointer(ref x, ref y, out int resultMulUsePointer);
          Console.WriteLine("MulUsePointer = " + resultMulUsePointer);
 
          string testString = "東京都新宿 1-1";
          _SetNameStr(testString);
          Console.WriteLine("GetNameStr = " + Marshal.PtrToStringAnsi(_GetNameStr()));
 
          _SetNameWStr(testString);
          Console.WriteLine("GetNameWStr = " + Marshal.PtrToStringUni(_GetNameWStr()));
       }
    }
 }

文字列のマーシャリング (2)

Linux

Linux向けC++ライブラリを記述する。

 // SampleLib.cpp
 
 #include <cstdio>
 
 extern "C" double __attribute__((visibility("default"))) SampleFunc01(int a)
 {
    printf("--<SampleDll:SampleFunc01>--\r\n");
    printf("a = %d\r\n", a);
    printf("---------------------------\r\n");
 
    return 3.14;
 }
 
 extern "C" void __attribute__((visibility("default"))) SampleFunc02(int a, char *pstr)
 {
    printf("--<SampleDll:SampleFunc02>--\r\n");
    printf("[%d] %s\r\n", a, pstr);
    printf("-----------------------------\r\n");
 }
 
 extern "C" void __attribute__((visibility("default"))) SampleFunc03(int a, char *pstr)
 {
    printf("--<SampleDll:SampleFunc03>--\r\n");
    printf("[%d] %s\r\n", a, pstr);

    sprintf(pstr, u8"C++ DLL側から文字列を返す場合は、StringBuilderクラスを使用する");
    printf("------------------------\r\n");
 }

Windows

Windows向けC++ DLLの作成方法はライブラリの基礎 - DLLの作成(C/C++/MFC)を参照する。

下記に、C++ DLLを記述する。

 // SampleDLL.h
 
 double __stdcall SampleFunc01(int a);
 void   __stdcall SampleFunc02(int a, char *pstr)
 void   __stdcall SampleFunc03(int a, char *pstr)

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 double __stdcall SampleFunc01(int a)
 {
    printf(--<SampleDll:SampleFunc01>--\r\n");
    printf("a = %d\r\n", a);
    printf("---------------------------\r\n");
 
    return 3.14;
 }
 
 void __stdcall SampleFunc02(int a, char *pstr)
 {
    printf("--<SampleDll:SampleFunc02>--\r\n");
    printf("[%d] %s\r\n", a, str);
    printf("-----------------------------\r\n");
 }
 
 void __stdcall SampleFunc03(int a, char *pstr)
 {
    printf("--<SampleDll:SampleFunc03>--\r\n");
    printf("[%d] %s\r\n", a, str);
    sprintf_s(str, 256, "C++ DLL側から文字列を返す場合は、StringBuilderクラスを使用する");
    printf("------------------------\r\n");
 }

 // SampleDll.def  // モジュール定義ファイル
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          SampleFunc01   @1
          SampleFunc02   @2
          SampleFunc03   @3

Linux / Windows

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

文字列をC++ DLL側に渡す場合は、string型を使用する。
文字列をC++ DLL側から返す場合は、StringBuilderクラスを使用する。
StringBuilderクラスは受け渡しの両方が可能なので、文字列は全てStringBuilderクラスを使用すべきである。

 using System;
 using System.Text;
 using System.Runtime.InteropServices;
 
 namespace SampleEXE
 {
    class Program
    {
       /// <summary>
       /// 最も基本的な関数のインポート例
       /// </summary>
       /// <param name="a">4 バイト符号付き整数を指定します。</param>
       /// <returns>倍精度浮動小数を返します。</returns>
       [DllImport("SampleDLL.dll")]  // Windows
       [DllImport("SampleLib.so")]   // Linux
       private static extern double SampleFunc01(int a);
 
       [DllImport("SampleDLL.dll", CharSet = CharSet.Unicode)]  // Windows
       [DllImport("SampleLib.so", CharSet = CharSet.Auto)]      // Linux
       // C++ DLL側の文字コードがUnicodeの場合は"CharSet = CharSet.Unicode"と明示的に指定する
       private static extern void SampleFunc02(int a, string str);
 
       [DllImport("SampleDLL.dll", CharSet = CharSet.Unicode)]  // Windows
       [DllImport("SampleLib.so", CharSet = CharSet.Auto)]      // Linux
       // C++ DLL側の文字コードがUnicodeの場合は"CharSet = CharSet.Unicode"と明示的に指定する
       private static extern void SampleFunc03(int a, StringBuilder str);
 
       static void Main(string[] args)
       {
          var dRet= SampleFunc01(1);
          Console.WriteLine(dRet);
          Console.WriteLine();
 
          var str = "string型で文字列を渡すことができます。";
          SampleFunc02(2, str);
 
          var strb = new System.Text.StringBuilder(256);
          strb.Append("文字列のバッファを渡す場合は StringBuilder クラスで受け渡します。");
          SampleFunc03(3, strb);
          Console.WriteLine(strb);
 
          Console.ReadKey();
       }
    }
 }

構造体のマーシャリング

C++ DLLの作成方法はライブラリの基礎 - DLLの作成(C/C++/MFC)を参照する。

下記にもC++ DLLを記述する。

 // SampleDLL.h
 
 void   __stdcall DisplayFunc(SampleStruct1 Structure)
 void   __stdcall GetFunc(SampleStruct1 Structure)
 void   __stdcall SetFunc(SampleStruct2 *pStructure)

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 typedef struct tagSampleStruct
 {
    int  index;
    char name[128];
    int  data[50];
 } SampleStruct1, *pSampleStruct;
 
 typedef struct tagSampleStruct2
 {
    int    length;
    double *data;
 } SampleStruct2, *pSampleStruct2;
 
 void __stdcall DisplayFunc(SampleStruct1 st)
 {
    printf("--<SampleDll:DisplayFunc>--\r\n");
    printf("index = %d\r\n", st.index);
    printf("name = %s\r\n", st.name);
    printf("data[0] = %d, data[1] = %d, data[2] = %d, data[3] = %d\r\n", st.data[0], st.data[1], st.data[2], st.data[3]);
    printf("------------------------\r\n");
 }
 
 void __stdcall GetFunc(SampleStruct1 *pst)
 {
    printf("--<SampleDll:GetFunc>--\r\n");
    pst->index = 10;
    memcpy_s(pst->name, sizeof(pst->name), "Tarou Yamada", sizeof("Tarou Yamada"));
    memset(pst->data, 20, sizeof(pst->data));
    printf("------------------------\r\n");
 }
 
 void __stdcall SetFunc(SampleStruct2 *pStructure)
 {
    printf("--<SampleDll:SetFunc>--\r\n");
 
    memset(pStructure, 0, sizeof(SampleStruct2));
 
    // double dAryData[256] = {0.0f};
    pStructure->length                  = 10;
    double dAryData[pStructure->length] = {0.0f};
    pStructure->data                    = dAryData;
 
    for(int i = 0; i < pStructure->length; i++)
    {
       dAryData[i] = (i + 1) / 10.0f;
    }
 
    printf("------------------------\r\n");
 }

 // SampleDll.def  // モジュール定義ファイル
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          DisplayFunc   @1
          GetFunc       @2
          SetFunc       @3

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

C++では構造体のサイズはコンパイル時に決定されるが、C#では実行時に決定される。
したがって、C#側で構造体のサイズを予め指定する必要がある。
この時、構造体は固定長サイズとなるため、配列等を定義する場合は異なるサイズの配列を後からインスタンス化することができなくなる。

構造体をC++ DLL側から返す場合、IntPtr型からdouble型の配列を取得する時は、Int64型へ変換した後、BitConverter.Int64BitsToDoubleメソッドでdouble型に変換する。

 using System;
 using System.Text;
 using System.Runtime.InteropServices;
 
 namespace SampleEXE
 {
    class Program
    {
       /// <summary>
       /// 構造体を引数に持つ関数のインポート例
       /// </summary>
       /// <param name="st">DLL 側に渡す構造体を指定します</param>
       [DllImport("SampleDLL.dll", EntryPoint = "DisplayFunc", CallingConvention = CallingConvention.Cdecl)]
       private static extern void _DisplayFunc(SampleStruct1 st);
 
       /// <summary>
       /// DLL側からメンバにポインタを含む構造体を受け取る関数のインポート例
       /// </summary>
       /// <param name="pst">受け渡す構造体の先頭アドレスを示すポインタを指定する</param>
       [DllImport("SampleDLL.dll", EntryPoint = "GetFunc", CallingConvention = CallingConvention.Cdecl)]
       private static extern void _GetFunc(IntPtr pst);
 
       /// <summary>
       /// DLL側からメンバにポインタを含む構造体を受け取る関数のインポート例
       /// </summary>
       /// <param name="pst">受け渡す構造体の先頭アドレスを示すポインタを指定する</param>
       [DllImport("SampleDLL.dll", EntryPoint = "SetFunc", CallingConvention = CallingConvention.Cdecl)]
       private static extern void _SetFunc(IntPtr pst);
 
       /// <summary>
       /// DLLとの取り合いのために定義する構造体
       /// LayoutKind.Sequentialを指定することで、C/C++同様、変数の宣言順通りにメモリに配置されるようになる
       /// </summary>
       [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
       private struct SampleStruct1
       {
          /// <summary>
          /// 4バイト符号付整数
          /// </summary>
          [MarshalAs(UnmanagedType.I4)]
          public int index;
 
          /// <summary>
          /// 固定長文字配列(SizeConstは配列のサイズを示す)
          /// </summary>
          [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
          public string name;
 
          /// <summary>
          /// 固定長配列(SizeConstは配列の要素数を示す)
          /// </summary>
          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
          public int[] data;
       }
 
       /// <summary>
       /// DLLとの取り合いのために定義する構造体
       /// LayoutKind.Sequentialを指定することで、C/C++同様、変数の宣言順通りにメモリに配置されるようにする
       /// </summary>
       [StructLayout(LayoutKind.Sequential)]
       private struct SampleStruct2
       {
          public int length;
          public IntPtr data;
       }
　
       static void Main(string[] args)
       {
          SampleFunc01();
          SampleFunc02();
          SampleFunc03();
 
          Console.ReadKey();
       }
 
       private static void SampleFunc01()
       {
          var structure = new SampleStruct1()
          {
             index = 4,
             name = "構造体サンプル",
             data = new int[50],
          };
 
          structure.data[0] = 11;
          structure.data[1] = 22;
          structure.data[2] = 33;
 
          _SampleFunc01(structure);
       }
 
       private static void SampleFunc02()
       {
          var structure = new SampleStruct1()
          {
             index = 0,
             name = "",
             data = new int[50],
          };
 
          // COMタスクメモリアロケータから、C#の構造体のサイズ分のメモリブロックを割り当てる
          IntPtr structurePtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(structure));
 
          _GetFunc(structurePtr);
 
          // Marshal.PtrToStructureメソッドを使用して、IntPtr変数が示すメモリに格納された情報をC#の構造体にコピーする
          structure = (SampleStruct1)Marshal.PtrToStructure(structurePtr, structure.GetType());
 
          Marshal.FreeCoTaskMem(structurePtr);
 
          Console.WriteLine($"index : {structure.index}");
          Console.WriteLine($"name : {structure.name}");
          Console.WriteLine($"data : {structure.data}");
       }
 
       private static void SampleFunc03()
       {
          // SampleStruct2構造体のサイズを取得する
          // 指定サイズ分だけメモリ領域を確保して、その先頭アドレスをstructure1に格納する
          var structure1 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SampleStruct2)));
          try
          {
             // C++ DLLのSampleFunc02関数の実行
             SetFunc(structure1);
 
             // 受け取ったstructure1からSampleStruct2構造体の情報に構築し直す
             var structure2 = (SampleStruct2)Marshal.PtrToStructure(structure1, typeof(SampleStruct2));
             for (int i = 0; i < structure2.length; i++)
             {
                // IntPtr型からdouble型の数値を取得するときは、一度Int64型に変換して、これをBitConverter.Int64BitsToDoubleメソッドでdouble型に変換する
                var v = Marshal.ReadInt64(structure2.data, i * sizeof(double));
                Console.WriteLine("data[{0}] = {1}", i, BitConverter.Int64BitsToDouble(v));
             }
          }
          catch (Exception ex)
          {
             System.Diagnostics.Debug.WriteLine(ex);
          }
          finally
          {
             // 必ずメモリを解放する
             Marshal.FreeHGlobal(structure1);
          }
       }
    }
 }

関数ポインタのマーシャリング

C# EXEからC++ DLLへコールバック関数を渡す。

ただし、Func型、Action型、構造体内にあるchar型の配列のようなNon-Bittable型(非Blittable型)が含まれている場合、以下の例外が発生する。
このような型の場合は、属性を用いたマーシャルの変換は不可能である。

Non-blittable generic types cannot be marshaled.

Linux

Linux向けのC++ライブラリを記述する。

 // SampleLib.cpp
 
 #include <cstdio>
 #include <cstring>
 
 using UnManagedCallback = bool (*)(int);
 
 int __stdcall SampleCallback(UnManagedCallback CallbackFunc, int lPalam)
 {
    int iRet = 0;
  
    bool bRet = CallbackFunc(lPalam);
    if(bRet)
    {
       iRet = 1;
    }
    else
    {
       iRet = -1;
    }
 
    return iRet;
 }

Windows

Windows向けのC++ DLLを記述する。

 // SampleDLL.h
 
 #pragma once

 int __stdcall SampleCallback(int handle, int lPalam);

 // SampleDll.cpp
 
 #include <stdio.h>
 #include <string.h>
 #include "SampleDll.h"
 
 using UnManagedCallback = bool (*)(int);
 
 int __stdcall SampleCallback(UnManagedCallback CallbackFunc, int lPalam)
 {
    int iRet = 0;
  
    bool bRet = CallbackFunc(lPalam);
    if(bRet)
    {
       iRet = 1;
    }
    else
    {
       iRet = -1;
    }
 
    return iRet;
 }

 // モジュール定義ファイル
 // SampleDll.def
 
 LIBRARY SampleDll
 
 EXPORTS
          ; 公開する関数名をリストアップ
          SampleCallback   @1

Linux / Windows

次に、C# EXEからC++ DLLを呼び出す方法を記述する。

マネージドコールバック関数を定義する。
以下の例では、ManagedCallBackというデリゲートを宣言している。
C++ DLLのSampleCallBack関数にデリゲートを引数として渡すことで、既知のコールバック形式に自動的に変換される。

 using System;
 using System.Runtime.InteropServices;
 
 namespace ConsoleSample01
 {
    delegate bool ManagedCallBack(int x);
 
    class Program
    {
        [DllImport("SampleDLL.dll")]  // Windows
        [DllImport("SampleLib.so")]   // Linux
        private static extern int SampleCallback(ManagedCallBack CallBack, int lPalam);

        static void Main(string[] args)
        {
            var CallBack = new ManagedCallBack(CallBackFunction);

            var iRet = SampleCallback(CallBack, 0);

            Console.WriteLine($"{iRet}");

            Console.ReadKey();
        }

        public static bool CallBackFunction(int x)
        {
            Console.WriteLine($"{x}");
            return true;
        }
    }
 }

トラブル対処

可能な限り、デバッグビルドしたDLLとそのPDBファイルを用意する。

デバッグ

C++DLLがデバッグできない場合、以下の手順で、混合モードデバッグを有効にする。

1. [ソリューションエクスプローラー]からC#プロジェクトを右クリックして、[プロパティ]を選択する。
   
2. [プロパティページ]画面が表示されるので、[デバッグ]タブ - [アンマネージ コード デバッグを有効にする]([ネイティブコードのデバッグを有効にする])を選択する。
   
3. [プロパティページ]画面を閉じる。

[デバッガーを有効にする] - [デバッグ] ページ (プロジェクト デザイナー) | MSDN ネイティブ コードのデバッグ | MSDN

この設定をしていない場合、C++DLLからのエラーにより、アプリケーションが終了することがある。

※注意
Visual Studio 2017以降、プロジェクトのプロパティの代わりにlaunchSettings.jsonファイルを使用して、
.NET Coreアプリでネイティブコードの混合モードデバッグを有効にする必要がある。

詳細については、マネージドコードとネイティブコードのデバッグに関するページを参照すること。