14

在 Windows 应用商店应用程序中，C++（虽然 C# 类似），执行类似的操作

IAsyncAction^ Action = CurrentAppSimulator::ReloadSimulatorAsync(proxyFile);
create_task( Action ).then([this]()
{
}.wait();

导致未处理的异常。通常是

Microsoft C++ exception: Concurrency::invalid_operation at memory location 0x0531eb58

在尝试使用之前，我需要完成该操作以获取我的应用内购买信息。这里奇怪的是，除了 IAsyncAction 之外的其他任何东西都可以正常等待。IAsyncOperation 和 IAsyncOperationWithProgress 工作得很好，但是这个？异常然后崩溃。

老实说，我不知道 IAsyncOperation 和 IAsyncAction 之间有什么区别，它们看起来和我很相似。

更新：

通过分析此页面http://msdn.microsoft.com/en-us/library/vstudio/hh750082.aspx，您可以发现 IAsyncAction 只是一个没有返回类型的 IAsyncOperation。但是，您可以看到大多数 IAsyncAction-s 是可等待的。但真正的问题是某些 Windows 函数只想在特定线程上执行（出于某种原因）。ReloadSimulatorAsync 就是这样一个很好的例子。

使用这样的代码：

void WaitForAsync( IAsyncAction ^A )
{   
    while(A->Status == AsyncStatus::Started)
    {
        std::chrono::milliseconds milis( 1 );
        std::this_thread::sleep_for( milis );
    }   
    AsyncStatus S = A->Status;  
}

导致无限循环。如果调用其他功能，它实际上可以工作。这里的问题是，如果一切都是 Async ，为什么需要在特定线程上执行任务？而不是 Async 它应该是 RunOn(Main/UI)Thread 或类似的。

已解决，见答案；

4

4 回答 4

6

wait在创建它之后调用concurrency::task它完全违背了首先拥有任务的意义。

您必须意识到，在 Windows 运行时，有许多异步操作不能（或不应该）在 UI 线程上运行（或等待）；你找到了其中一个，现在你正试图等待它。你得到的不是潜在的死锁，而是一个异常。

为了解决这个问题，您需要使用continuation。你大部分都在那儿；你已经定义了一个延续函数：

IAsyncAction^ Action = CurrentAppSimulator::ReloadSimulatorAsync(proxyFile);
create_task( Action ).then([this]()
{
}).wait();

// do important things once the simulator has reloaded
important_things();

...但你没有使用它。您传入的函数的目的是在任务完成后从 UI 线程then中调用。因此，您应该这样做：

IAsyncAction^ Action = CurrentAppSimulator::ReloadSimulatorAsync(proxyFile);
create_task( Action ).then([this]()
{
    // do important things once the simulator has reloaded
    important_things();
});

在任务完成之前，您重要的重新加载后代码不会运行，它将在后台线程上运行，因此不会阻塞或死锁 UI。

于 2013-11-11T23:28:55.693 回答
6

这是完成工作的神奇修复：

void WaitForAsync( IAsyncAction ^A )
{   
    while(A->Status == Windows::Foundation::AsyncStatus::Started)
    {   
        CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);                     
    }

    Windows::Foundation::AsyncStatus S = A->Status; 
}
于 2013-11-17T16:48:12.343 回答
2

一般来说，您应该使用延续（.then（...）），就像亚当的回答所说的那样，而不是阻止。但是假设您出于某种原因想要等待（为了测试一些代码？），您可以从最后一个延续中触发一个事件（使用 C# 用语）：

    TEST_METHOD(AsyncOnThreadPoolUsingEvent)
    {

        std::shared_ptr<Concurrency::event> _completed = std::make_shared<Concurrency::event>();


        int i;

        auto workItem = ref new WorkItemHandler(
            [_completed, &i](Windows::Foundation::IAsyncAction^ workItem)
        {

            Windows::Storage::StorageFolder^ _picturesLibrary = Windows::Storage::KnownFolders::PicturesLibrary;

            Concurrency::task<Windows::Storage::StorageFile^> _getFileObjectTask(_picturesLibrary->GetFileAsync(L"art.bmp"));

            auto _task2 = _getFileObjectTask.then([_completed, &i](Windows::Storage::StorageFile^ file)
            {

                i = 90210;

                _completed->set();

            });

        });

        auto asyncAction = ThreadPool::RunAsync(workItem);

        _completed->wait();


        int j = i;

    }

顺便说一句，由于某种原因，此方法在 Visual Studio 测试结束后会导致异常。不过，我也已经在应用程序中对其进行了测试，并且没有问题。我不太确定测试有什么问题。

如果有人想要 C++/Wrl 示例，那么我也有。

2017 年 7 月 8日更新：这里要求的是一个 C++/Wrl 示例。我刚刚在 Visual Studio 2017 的通用 Windows (10) 测试项目中运行了它。这里的关键是奇怪的部分Callback<Implements< RuntimeClassFlags<ClassicCom >, IWorkItemHandler , FtmBase >>，而不是Callback<IWorkItemHandler>. 当我有后者时，程序卡住了，除了它在 .exe 项目中。我在这里找到了这个解决方案：https ://social.msdn.microsoft.com/Forums/windowsapps/en-US/ef6f84f6-ad4d-44f0-a107-3922d56662e6/thread-pool-task-blocking-ui-thread 。有关详细信息，请参阅“敏捷对象”。

#include "pch.h"
#include "CppUnitTest.h"
#include <Windows.Foundation.h>
#include <wrl\wrappers\corewrappers.h>
#include <wrl\client.h>
#include <wrl/event.h>
#include <memory>
#include "concrt.h"
#include <Windows.System.Threading.h>


using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace Windows::System::Threading;

using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::System::Threading;



namespace TestWinRtAsync10
{
    TEST_CLASS(UnitTest1)
    {
    public:

        TEST_METHOD(AsyncOnThreadPoolUsingEvent10Wrl)
        {
            HRESULT hr = BasicThreadpoolTestWithAgileCallback();

            Assert::AreEqual(hr, S_OK);
        }

        HRESULT BasicThreadpoolTestWithAgileCallback()
        {

            std::shared_ptr<Concurrency::event> _completed = std::make_shared<Concurrency::event>();

            ComPtr<ABI::Windows::System::Threading::IThreadPoolStatics> _threadPool;
            HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPool).Get(), &_threadPool);

            ComPtr<IAsyncAction> asyncAction;
            hr = _threadPool->RunAsync(Callback<Implements<RuntimeClassFlags<ClassicCom>, IWorkItemHandler, FtmBase>>([&_completed](IAsyncAction* asyncAction) -> HRESULT
            {

                // Prints a message in debug run of this test
                std::ostringstream ss;
                ss << "Threadpool work item running.\n";
                std::string _string = ss.str();
                std::wstring stemp = std::wstring(_string.begin(), _string.end());
                OutputDebugString(stemp.c_str());
                // 
                _completed->set();

                return S_OK;

            }).Get(), &asyncAction);

            _completed->wait();

            return S_OK;
        }

    };
}

2017 年 8 月 8 日更新：更多示例，根据评论。

#include "pch.h"
#include "CppUnitTest.h"

#include <wrl\wrappers\corewrappers.h>
#include <wrl\client.h>
#include <wrl/event.h>
#include <memory>
#include "concrt.h"
#include <Windows.System.Threading.h>


#include <Windows.ApplicationModel.Core.h>

using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;

namespace TestWinRtAsync10
{
    TEST_CLASS(TestWinRtAsync_WrlAsyncTesting)
    {

    public:

        TEST_METHOD(PackageClassTest)
        {
            ComPtr<ABI::Windows::ApplicationModel::IPackageStatics> _pPackageStatics;

            HRESULT hr = GetActivationFactory(Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_ApplicationModel_Package).Get(), &_pPackageStatics);

            ComPtr<ABI::Windows::ApplicationModel::IPackage> _pIPackage;

            hr = _pPackageStatics->get_Current(&_pIPackage);

            ComPtr<ABI::Windows::ApplicationModel::IPackage3> _pIPackage3;

            hr = _pIPackage->QueryInterface(__uuidof(ABI::Windows::ApplicationModel::IPackage3), &_pIPackage3);

            ComPtr<__FIAsyncOperation_1___FIVectorView_1_Windows__CApplicationModel__CCore__CAppListEntry> _pAsyncOperation;

            hr = _pIPackage3->GetAppListEntriesAsync(&_pAsyncOperation);

            std::shared_ptr<Concurrency::event> _completed = std::make_shared<Concurrency::event>();

            _pAsyncOperation->put_Completed(Microsoft::WRL::Callback<Implements<RuntimeClassFlags<ClassicCom>, ABI::Windows::Foundation::IAsyncOperationCompletedHandler <__FIVectorView_1_Windows__CApplicationModel__CCore__CAppListEntry*>, FtmBase >>
                ([&_completed](ABI::Windows::Foundation::IAsyncOperation<__FIVectorView_1_Windows__CApplicationModel__CCore__CAppListEntry*>* pHandler, AsyncStatus status)
            {
                __FIVectorView_1_Windows__CApplicationModel__CCore__CAppListEntry* _pResults = nullptr;

                HRESULT hr = pHandler->GetResults(&_pResults);

                ComPtr<ABI::Windows::ApplicationModel::Core::IAppListEntry> _pIAppListEntry;

                unsigned int _actual;

                hr = _pResults->GetMany(0, 1, &_pIAppListEntry, &_actual);

                ComPtr<ABI::Windows::ApplicationModel::IAppDisplayInfo> _pDisplayInfo;

                hr = _pIAppListEntry->get_DisplayInfo(&_pDisplayInfo);

                Microsoft::WRL::Wrappers::HString _HStrDisplayName;

                hr =  _pDisplayInfo->get_DisplayName(_HStrDisplayName.GetAddressOf());


                const wchar_t * _pWchar_displayName = _HStrDisplayName.GetRawBuffer(&_actual);


                OutputDebugString(_pWchar_displayName);


                _completed->set();

                return hr;



            }).Get());

            _completed->wait();

        };

    };
}

这输出：

测试WinRtAsync10

于 2015-06-10T17:23:56.957 回答
1

以防万一有人需要这里是 C++/WinRT 中的解决方案。假设您有ProcessFeedAsync()返回的函数IAsyncAction，只需要以下简单代码：

winrt::init_apartment();

auto processOp{ ProcessFeedAsync() };
// do other work while the feed is being printed.
processOp.get(); // no more work to do; call get() so that we see the printout before the application exits.

来源

于 2019-01-23T08:41:38.393 回答