c++、c++/CLI、c#のstructのマーシャリングについて

Question

下記サイトからフリーダウンロードできるライブラリをc#で使用したいと思っております。
その際に、下記ライブラリは*.libしか作成されないため、*.dllを作成する必要があります。
*.dllを作成するにあたり、提供されているライブラリがクラスになっているため、c++/CLIラッパを採用して作成しています。

Urg_driver.cppを直接ラッピングしたUrgDriver.cppを新規で作成しています。

https://sourceforge.net/projects/urgnetwork/files/urg_library/urg_library_ja-1.2.5.zip/download

#include "pch.h"

#include "ticks.h"
extern "C" {
#include "urg_sensor.h"
#include "urg_utils.h"
#include "urg_serial_utils.h"
#include "urg_errno.h"
#include "urg_debug.h"
}

#include "UrgDriver.h"
#include <string>
#include <vector>
#include <msclr\marshal.h>

using namespace msclr::interop;
using namespace qrk;

namespace QRK
{
    UrgDriver::UrgDriver(void)
    {
        urg_ = new urg_t;
        urg_t_initialize(urg_);
    }

    UrgDriver::~UrgDriver(void)
    {
        Close();
    }

bool UrgDriver::StartMeasurement(MeasurementType type,
        int scan_times, int skip_scan)
    {

        typedef struct { //struct部分にてマネージドクラスのメンバー関数ではローカルクラス定義は使用できません
            urg_measurement_type_t c_type;
            MeasurementType type;
        } type_table_t;
        

        type_table_t type_table[] = {
            { URG_DISTANCE, QRK::MeasurementType::Distance },
            { URG_DISTANCE_INTENSITY, QRK::MeasurementType::Distance_intensity },
            { URG_MULTIECHO, QRK::MeasurementType::Multiecho },
            { URG_MULTIECHO_INTENSITY, QRK::MeasurementType::Multiecho_intensity },
        };

        size_t n = sizeof(type_table) / sizeof(type_table[0]);
        for (size_t i = 0; i < n; ++i) {
            const type_table_t* p = &type_table[i];
            if (type == p->type) {
                int ret = urg_start_measurement(urg_,
                    p->c_type, scan_times, skip_scan);
                if (ret == URG_NO_ERROR) {
                    last_measure_type_ = type;
                }
                return (ret == URG_NO_ERROR) ? true : false;
            }
        }
        return false;
    }

bool UrgDriver::GetDistanceIntensity(System::Collections::Generic::IList<int>^ data, System::Collections::Generic::IList<unsigned short>^ intensity, int% time_stamp)
    {
        if (last_measure_type_ != QRK::MeasurementType::Distance_intensity) {
            urg_.last_errno = URG_MEASUREMENT_TYPE_MISMATCH;
            return false;
        }
        // 最大サイズを確保し、そこにデータを格納する
        size_t data_size = MaxDataSize();
        data.resize(data_size); //①resize部分にて、class "System::Collections::Generic::IList<int>"にメンバー"resize"がありません
        intensity.resize(data_size); //①と同じエラー
        int ret = urg_get_distance_intensity(urg_,
            &data[0], &intensity[0], (long*)time_stamp);//1. dataおよびintensity部分にて、式は左辺値または関数指定子である必要があります
        if (ret > 0) {
            data.resize(ret); //①と同じエラー
            intensity.resize(ret);//①と同じエラー
            adjust_time_stamp(time_stamp);
        }
        return (ret < 0) ? false : true;
    }

}

Answer 1

対象のNative C++ライブラリがCライブラリのラッパーなので、C++/CLIで直接ラッピングしたほうがいいのでは、とは思いますけどね。

urg_tについては、WrappingClassが持つにしても、Managed側に露出する必要がないと思いますよ。
ref classは実体を持てないので、ポインタ(urg_t*)にして、WrappingClassのコンストラクタでnewなりmallocなりすればいいです。

つまりはこういう感じのコードになるんですよね。

#pragma once
using OutAttribute = System::Runtime::InteropServices::OutAttribute;
namespace QRK
{
    public enum class ConnectionType {
        Serial,
        Ethernet,
    };
    public enum class MeasurementType {
        Distance,           
        Distance_intensity, 
        Multiecho,          
        Multiecho_intensity, 
    };
    public  ref class UrgDriver
    {
    public:

        static const int DefaultBaudrate = 115200;
        static const int DefaultPort = 10940;
        static const int InfinityTimes = -1;

        UrgDriver(void);
        ~UrgDriver(void);

        static array<System::String^>^ FindPorts(void);
        static array<System::String^>^ FindPorts([Out] array<bool>^% is_urg_ports);
        System::String^ What(void);

        bool Open(System::String^ device_name) { return Open(device_name, Default_baudrate, ConnectionType::Serial); }
        bool Open(System::String^ device_name, int baudrate) { return Open(device_name, baudrate, ConnectionType::Serial); }
        bool Open(System::String^ device_name, int baudrate, ConnectionType type);
        void Close(void);
...略...
    private:
        void adjust_time_stamp(int% time_stamp)
        {
            time_stamp += time_stamp_offset_;
        }
        urg_t* urg_;
        MeasurementType last_measure_type_;
        int time_stamp_offset_;

        System::String^ product_type_;
        System::String^ firmware_version_;
        System::String^ serial_id_;
    };

#include "ticks.h"
extern "C" {
#include "urg_sensor.h"
#include "urg_utils.h"
#include "urg_serial_utils.h"
#include "urg_errno.h"
#include "urg_debug.h"
}
#include "UrgDriver.h"
#include <string>
#include <vector>
#include <msclr\marshal.h>
using namespace msclr::interop;
using namespace qrk;
namespace QRK
{
    UrgDriver::UrgDriver(void)
    {
        urg_ = new urg_t;
        urg_t_initialize(urg_);
    }

    array<System::String^>^ UrgDriver::FindPorts(void)
    {
        array<bool>^ dummy_is_urg_port;
        return FindPorts(dummy_is_urg_port);
    }


    array<System::String^>^ UrgDriver::FindPorts(array<bool>^% is_urg_ports)
    {
        int n = urg_serial_find_port();
        array<System::String^>^ found_ports = gcnew array<System::String^>(n);
        is_urg_ports = gcnew array<bool>(n);

        for (int i = 0; i < n; ++i) {
            found_ports[i] = marshal_as<System::String^>(urg_serial_port_name(i));
            is_urg_ports[i] = urg_serial_is_urg_port(i) ? true : false;
        }
        return found_ports;
    }
...略...

Comments

[wave_vague]

回答ありがとうございます。
urg_tをManaged側に露出必要がないとのことなので、c#側で使用しなくてよいこと理解しました。

>ref classは実体を持てないので、ポインタ(urg_t*)にして、
>WrappingClassのコンストラクタでnewなりmallocなりすればいいです。

ここの部分なのですが、コンストラクタでnewしようとしており、WrapperClass.hにて下記のように記述したところ、class "qrk::UrgLib::pImpl"にアクセスできません。と表示されてしまいました。
UrgLib.cppで記述されている struct UrgLib::pImpl{}がprivateのためだと思われますが、、
namespace Wrapper
{
public ref class WrapperClass
{
private:
qrk::UrgLib::pImpl* _urg_t;

WrapperClass.cppのコンストラクタでは、_urg_t = new qrk::UrgLib::pImpl.();
と記述する予定でした。

urg_tをポインタにして、WrapperClassのコンストラクタでnewする方法をご教示いただけませんでしょうか

[matukeso]

そうではなくて、WrapperClassがqrk::UrgLib::pimpl相当を実装をする話です。
当該pimplはC->C++変換をするクラスですが、WrapperClassが同じようにC->C++/cli変換をするなら、WrapperClassがurg_t*を持つことをになるでしょう。
WrapperClassがこれまで通り、C++->C++/cli変換するなら、pimplは無視して、UrgLib*だけ持っていればいいでしょう。

[wave_vague]

回答ありがとうございます。
UrgLib.cppでincludeしていたcのヘッダーをWrapperClass.cppでもincludeし、
WrapperClassで struct UrgLib::pImpl相当を実装してみました(下記)。
その際に分からなかったことが数点ありました。

1.urg_t* urg_;
今の状態だと、識別子urg_tが定義されていません。
urg_tを定義する場合はどうすればよろしいでしょうか？

定義した後にWrapperClassのコンストラクタでnewする場合は、
urg_ = new urg_t;
であっていますでしょうか？

2.pImpl(void)の実装
今の状態だと既定のコンストラクタは値クラスでは参照できません　と表示されます。WrapperClassではどのように実装すればよろしいでしょうか？

3.urg_t_initialize(&urg_);　の引数のマーシャリング
1の質問に重複するのですが、urg_t_initialize()も今の状態だと、識別子が定義されていないためエラーが表示されます。

UrgLib.cppでインクルードしているcのヘッダファイルを、WrapperClass.cppでもインクルードした場合、urg_t* urg_;のエラー含めいくつかのエラーは消えますが、消えないエラーをコメントアウトしビルドした際に大量のエラーが表示されました。
※cのヘッダファイルだけWrapperClass.cppにインクルードした後ビルドしても同じエラーが出ます。

value class qrk::UrgLib::pImpl
{
urg_t* urg_;
measurement_type_t last_measure_type_;
long time_stamp_offset_;

System::String^ product_type_;
System::String^ firmware_version_;
System::String^ serial_id_;
System::String^ status_;
System::String^ state_;

pImpl(void)
:last_measure_type_(Distance), time_stamp_offset_(0)
{
urg_t_initialize(&urg_);
}

void adjust_time_stamp(int% time_stamp)
{
long tmptime_stamp = time_stamp;

if (tmptime_stamp) {
tmptime_stamp += time_stamp_offset_;
}
}
};

お手数をおかけしますがご教示いただけませんでしょうか

[matukeso]

なんでvalue classなの？ ref classでしょうよ。
urg_tとかurg_t_initializeが未定義云々はurg_sensor.hをincludeすればよべるでしよ。unmanaged ptrを渡すわけで、マーシャリングは要らない。

[wave_vague]

回答ありがとうございます。

WrapperClass.cppにて下記修正を行ったところ、ビルド時に、
C3816 'struct qrk::UrgLib::pImpl'は、異なるマネージ修飾子を伴って、前に宣言または定義されました
と表示されました。
このエラーはどのように修正すればよろしいか分かりますでしょうか？

・urg_sensor.hをインクルード
・value classをref classに修正
・urg_t_initialize()の引数を&urg_からurg_に修正

また、UrgLib.hで定義されていたprivate:の下にある2行はWrapperClassでも実装(考慮)する必要がありますでしょうか？

namespace qrk
{
class URGLIB_API UrgLib : public Lidar
{
private:
struct pImpl;
std::auto_ptr<pImpl> pimpl;
};
}

[matukeso]

それは単に、urg_driver.hのqrk::UrgLib::pImplと名前がかぶっているという話です。
WrapperClassがCのラッパーになるなら、urg_driver.hはincludeしないべきでしょうし、名前はC++のラッパーと紛らわしくなるのでちがうものにすべきでしょう。
implはC++特有の話なので、Managedでは不要と思います。直接implの中身を持てばいいです。
Lidarはインタフェイスなので、JavaっぽくInterfaceとImplementationを分けたり、DIで挿入したいなら入れてください。直接使うだけなら不要です。

[wave_vague]

回答ありがとうございます。

ご教示いただいた内容を元にWrapperClassを間に挟むのをやめ、UrgDriverを直接ラッピングする方法を採用しました。

その際に分からないことが数点あったため、ご教示いただけませんでしょうか
※修正に当たり、質問本文も大幅に修正したためご確認お願い致します。

1.UrgDriver.cppでのbool UrgDriver::StartMeasurement()について
typedef struct {
urg_measurement_type_t c_type;
MeasurementType type;
} type_table_t;
はどのように使用すればよろしいでしょうか

2.UrgDriver.cppでのbool UrgDriver::GetDistanceIntensity()について
c++で使用できるresize()をSystem::Collections::Generic::IList<int>で使用する場合はどうすればよろしいでしょうか

現状、dataおよびintensity部分にて 式は左辺値または関数指定子である必要があります と表示されるのですが、
urg_get_distance_intensity()の引数はどのように指定すればよろしいでしょうか
time_stampは単に(long*)でキャストしているだけですが、これでよいでしょうか

3.C#側からの呼び出しについて
以前は、using Wrapper;、WrapperClass wr = new WrapperClass();を宣言し、c++のメソッドを呼び出していましたが、
UrgDriverを直接ラッピングしているため、呼び出し方は下記方法になりますでしょうか

using System.Runtime.InteropServices;

//例Open()を呼ぶ場合
[DllImport("UrgDriver.dll")]
static extern Open(string device_name, int baudrate, ConnectionType type);

//実際に呼び出す場合
Open("対象IPアドレス"、10940、typeはどのように指定すればよいか)

この場合、第3引数はc#側でどのように指定すればよろしいでしょうか

[matukeso]

1.swicth 文で書ける筈です
2.ローカル変数としてvector<long>を定義して
ert>0の条件式で引数のIList^へ積み替えます
3.C++/CliのdllができればC#側は参照追加でnew UrgDriverを書けます。

[wave_vague]

回答ありがとうございます。

1.switch文で書いてみました。下記のような感じで合ってますでしょうか？
bool UrgDriver::StartMeasurement(MeasurementType type,
int scan_times, int skip_scan)
{
switch (type)
{
case QRK::MeasurementType::Distance_intensity:
{int ret = urg_start_measurement(urg_,
URG_DISTANCE_INTENSITY, scan_times, skip_scan);
if (ret == URG_NO_ERROR) {
last_measure_type_ = type;
}
return (ret == URG_NO_ERROR) ? true : false;
}
break;

case QRK::MeasurementType::Multiecho:
{int ret = urg_start_measurement(urg_,
URG_MULTIECHO, scan_times, skip_scan);
if (ret == URG_NO_ERROR) {
last_measure_type_ = type;
}
return (ret == URG_NO_ERROR) ? true : false;
}
break;

case QRK::MeasurementType::Multiecho_intensity:
{int ret = urg_start_measurement(urg_,
URG_MULTIECHO_INTENSITY, scan_times, skip_scan);
if (ret == URG_NO_ERROR) {
last_measure_type_ = type;
}
return (ret == URG_NO_ERROR) ? true : false;
}
break;

default:
{int ret = urg_start_measurement(urg_,
URG_DISTANCE, scan_times, skip_scan);
if (ret == URG_NO_ERROR) {
last_measure_type_ = type;
}
return (ret == URG_NO_ERROR) ? true : false;
}
break;
}
return false;
}

2.ローカルでstd::vector<long> (std::vector<unsigned short>もついでに定義)を定義し、処理(下記)を書いてみたのですが、ret>0の条件で引数のIList^へ積み替える部分が分からなかったためご教示いただけますでしょうか。
※time_stampもローカルでlongと定義しました。

bool UrgDriver::GetDistanceIntensity(System::Collections::Generic::IList<int>^ data, System::Collections::Generic::IList<unsigned short>^ intensity, int% time_stamp)
{
if (last_measure_type_ != QRK::MeasurementType::Distance_intensity) {
urg_->last_errno = URG_MEASUREMENT_TYPE_MISMATCH;
return false;
}

std::vector<long> tmpdata(data->Count);
std::vector<unsigned short> tmpintensity(intensity->Count);

for (int i = 0; i < (int)tmpdata.size(); i++)
{
tmpdata[i] = data[i];
}

for (int i = 0; i < (int)tmpintensity.size(); i++)
{
tmpintensity[i] = tmpintensity[i];
}

long tmptime_stamp = time_stamp;

// 最大サイズを確保し、そこにデータを格納する
size_t data_size = MaxDataSize();
tmpdata.resize(data_size);
tmpintensity.resize(data_size);

int ret = urg_get_distance_intensity(urg_,
&tmpdata[0], &tmpintensity[0], &tmptime_stamp);

time_stamp = tmptime_stamp;

data->Clear();
for (int i = 0; i < (int)tmpdata.size(); i++)
{
data->Add(tmpdata[i]);
}

intensity->Clear();
for (int i = 0; i < (int)tmpintensity.size(); i++)
{
intensity->Add(tmpintensity[i]);
}

if (ret > 0) {

data.resize(ret);
intensity.resize(ret);
adjust_time_stamp(time_stamp);
}
return (ret < 0) ? false : true;
}

3.対象dllを呼び出したいc#のプロジェクト参照にて右クリック→参照の追加で対象のdllにチェックを付けてOK
using UrgDriver;

UrgDriver urgdriver = new UrgDriver();

で使用しようと思います。

[matukeso]

switchはurg_measurement_type_tを埋めるだけでいいのでは。urg_start…以下の分は共通なのでswitchの外に移せます。
tmpdataは用意したsize()個のうち、ret個だけが有効なので、そのぶんだけIList::Addします。

[wave_vague]

回答ありがとうございます。
switchの箇所は今の状態でも問題はないが、urg_start…以下の分はswitchの外に移せるということなのでそちらで実装しようと思います。

>tmpdataは用意したsize()個のうち、ret個だけが有効なので、そのぶんだけIList::Addします。
下記のような感じでしょうか？
※if(ret > 0)の上で記述していた内容を中に移行しました

if (ret > 0) {
//data.resize(ret);
//intensity.resize(ret);
data->Clear();
for (int i = 0; i < (int)tmpdata.size(); i++)
{
data->Add(tmpdata[i]);
}

intensity->Clear();
for (int i = 0; i < (int)tmpintensity.size(); i++)
{
intensity->Add(tmpintensity[i]);
}
adjust_time_stamp(time_stamp);
}

[matukeso]

そのforループの条件はi<retだ、と言ったつもりですしたが。

[wave_vague]

回答ありがとうございます。
下記のように修正しました。
intensityは型はdataと異なりますが、処理はdataと同様になると考えるためintensityのforループ条件もi < retとして考えてよろしいでしょうか？

if (ret > 0)
{
//data.resize(ret);
//intensity.resize(ret);
data->Clear();
for (int i = 0; i < ret; i++)
{
data->Add(tmpdata[i]);
}

intensity->Clear();
for (int i = 0; i < ret; i++)
{
intensity->Add(tmpintensity[i]);
}
adjust_time_stamp(time_stamp);
}

[wave_vague]

この処理で大丈夫でした。