Asynchronous C++/CX并发性：：使用DataReader LoadAsync函数创建任务原因：'；操作标识符无效。'；

我正在使用本机C++/CX为Hololens第一代开发TCP客户端模块

我创建了一个包含1 x（uint32_t）+7 x（float）的数据包类 服务器是以同步方式实现的，每一帧都将数据包流式传输到客户端（Hololens）

接收机.h

namespace HoloNet {
    public ref class holoATCFrameReceiver sealed
    {
    public:
        holoATCFrameReceiver(
            _In_ Windows::Networking::Sockets::StreamSocket^ streamSocket);

        Windows::Foundation::IAsyncOperation<TrackerFrame^>^ ReceiveAsync();


    private:
        Concurrency::task<TrackerFrame^> ReceiveTrackerFrameAsync();


    private:
        Windows::Networking::Sockets::StreamSocket^ _streamSocket;


        Windows::Storage::Streams::DataReader^      _reader;
        bool                                        _readInProgress;

    };
}

名称空间全息网{
公共参考类全息ATC框架接收器密封
{
公众：
全息接收机(
_在uWindows:：Networking:：Socket:：StreamSocket^StreamSocket）中；
Windows:：Foundation:：IAsyncOperation^ReceiveAsync（）；
私人：
并发：：task ReceiveTrackerFrameAsync（）；
私人：
Windows:：Networking:：Socket:：StreamSocket^\u StreamSocket；
Windows:：Storage:：Streams:：DataReader^\u reader；
bool_readInProgress；
};
}

和Receiver.cpp

namespace HoloNet {
    holoATCFrameReceiver::holoATCFrameReceiver(
        Windows::Networking::Sockets::StreamSocket ^ streamSocket)
        : _streamSocket(streamSocket)
    {
        _readInProgress = false;

        // reader
        _reader = ref new Windows::Storage::Streams::DataReader(
            _streamSocket->InputStream);

        _reader->UnicodeEncoding =
            Windows::Storage::Streams::UnicodeEncoding::Utf8;

        _reader->ByteOrder =
            Windows::Storage::Streams::ByteOrder::LittleEndian;
    }

    Windows::Foundation::IAsyncOperation<TrackerFrame^>^ holoATCFrameReceiver::ReceiveAsync()
    {
        return concurrency::create_async(
            [this]()
            {
                return ReceiveTrackerFrameAsync();
            });
    }

    Concurrency::task<TrackerFrame^> 
        holoATCFrameReceiver::ReceiveTrackerFrameAsync()
    {
        return concurrency::create_task(
            _reader->LoadAsync(TrackerFrame::TrackerFrameLength)
        ).then([this](Concurrency::task<unsigned int> headerBytesLoadedTaskResult)
        {
            headerBytesLoadedTaskResult.wait();
            const size_t frameBytesLoaded = headerBytesLoadedTaskResult.get();

            if (TrackerFrame::TrackerFrameLength != frameBytesLoaded)
            {
                throw ref new Platform::FailureException();
            }


            _readInProgress = true;

            TrackerFrame^ header;

            TrackerFrame::Read(
                _reader,
                &header);

            dbg::trace(
                L"SensorFrameReceiver::ReceiveAsync: sensor %i: t( %f, %f %f ), q( %f, %f, %f, %f)",
                header->sensorID,
                header->x,
                header->y,
                header->z,
                header->qw,
                header->qx,
                header->qy,
                header->qz);

            _readInProgress = false;

            return header;
        });
    }

}

名称空间全息网{
holoATCFrameReceiver:：holoATCFrameReceiver(
Windows:：Networking:：Socket:：StreamSocket^StreamSocket）
：_streamSocket（streamSocket）
{
_readInProgress=false；
//读取器
_reader=ref新窗口：：存储：：流：：数据读取器(
_streamSocket->InputStream）；
_读卡器->联合编码=
Windows:：Storage:：Streams:：Unicode编码：：Utf8；
_读卡器->字节顺序=
Windows:：Storage:：Streams:：ByteOrder:：LittleEndian；
}
Windows:：Foundation:：IAsyncOperation^holoATCFrameReceiver:：ReceiveAsync（）
{
返回并发：：创建异步(
[这]（）
{
返回ReceiveTrackerFrameAsync（）；
});
}
并发：：任务
holoATCFrameReceiver:：ReceiveTrackerFrameAsync（）
{
返回并发：：创建任务(
_reader->LoadAsync（TrackerFrame:：TrackerFrameLength）
).then（[this]（并发：：任务头字节加载的taskresult）
{
headerBytes加载的taskresult.wait（）；
const size_t framebytesloadded=headerBytes加载为kresult.get（）；
if（TrackerFrame:：TrackerFrameLength！=frameBytesLoaded）
{
throw ref new Platform:：FailureException（）；
}
_readInProgress=true；
跟踪器帧^头；
TrackerFrame:：Read(
_读者，
&标题）；
跟踪(
L“SensorFrameReceiver:：ReceiveAsync:传感器%i:t（%f，%f%f），q（%f，%f，%f）”，
标题->传感器ID，
标题->x，
标题->y，
标题->z，
标题->qw，
标题->qx，
标题->qy，
标题->qz）；
_readInProgress=false；
返回头；
});
}
}

该错误在*\u reader->LoadAsync（TrackerFrame:：TrackerFrameLength）*

在客户端类中调用接收方，如下所示：

    void holoTcpATCClient::OnReceiveATCframe(TrackerFrame^& header) {
        std::lock_guard<std::mutex> guard(_socketMutex);
        // check read in process
        if (_readInProcess)
        {
            return;
        }

        _readInProcess = true;
        concurrency::create_task(
            _receiver->ReceiveAsync()).then(
                [&](concurrency::task<TrackerFrame^> sensorFrameTask)
        {
            sensorFrameTask.wait();
            TrackerFrame^ sensorFrame = sensorFrameTask.get()
            header =  sensorFrame;
        });
        _readInProcess = false;
    }

void HolotPatcClient:：OnReceiveATCframe（TrackerFrame^&header）{
std：：锁定保护装置（_socketMutex）；
//签入过程
如果（_readInProcess）
{
返回；
}
_readInProcess=true；
并发：：创建任务(
_receiver->ReceiveAsync（）），然后(
[&]（并发：：任务sensorFrameTask）
{
sensorFrameTask.wait（）；
TrackerFrame^sensorFrame=sensorFrameTask.get（）
标题=传感器帧；
});
_readInProcess=false；
}

\u receiver->ReceiveAsync（）是错误的开始

我想知道是否有办法通过在concurrency:：create_任务下对DataReader for StreamSocket的LoadAsync（）进行一些修改来假装发生了这种情况？

---

非常感谢您事先的帮助

套接字连接是否正确？传递给_reader->LoadAsync（）方法的TrackerFrame:：TrackerFrameLength参数是否正确？还有一个相关的，你可以参考它来检查你的代码。非常感谢@Faywang MSFT，我正在仔细检查这部分，发现参数是正确的。以下是我计算TrackerFrame:：TrackerFrameLength的方法：`静态属性uint32_t TrackerFrameLength{uint32_t get（）{return（sizeof（uint32_t）+sizeof（float）*7）；}}`是否接收器读取速度过快导致此错误，这可能会在_reader->LoadAsync（）之前添加一些检测？当我使用Official样本时，它运行良好。那么，你能提供一个简单的样品，可以复制给我们测试吗？