{"id":111546,"date":"2025-09-03T07:00:00","date_gmt":"2025-09-03T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=111546"},"modified":"2025-09-03T08:02:09","modified_gmt":"2025-09-03T15:02:09","slug":"20250903-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20250903-00\/?p=111546","title":{"rendered":"How can I write a C++\/WinRT IAsyncOperation<T><\/CODE> where T<\/CODE> is not a Windows Runtime type?, part 1"},"content":{"rendered":"

I often get asked about how one could use C++\/WinRT’s IAsyncOperation<T><\/code> where T<\/code> is not a Windows Runtime type.<\/p>\n

The T<\/code> in IAsyncOperation<T><\/code> must be a Windows Runtime type because the algorithm for generating an interface ID for IAsyncOperation<T><\/code> works only on Windows Runtime types.<\/p>\n

But all hope is not lost. You just have to decide which rule you want to break.<\/p>\n

The best solution is to break the rule “I’m using IAsyncOperation<T><\/code>.” Instead, use some other coroutine library that supports arbitrary C++ types. Available options include cppcoro::task<T><\/code><\/a>, wil::task<T><\/code><\/a> (based on my simple_task<\/code><\/a>, but expanded to support COM via wil::com_task<T><\/code>), and concurrency::task<T><\/code><\/a>.<\/p>\n

Another option is not to use the T<\/code> to return the result, but rather pass the output parameter as an explicit input.<\/p>\n

winrt::IAsyncAction DoSomethingAsync(std::shared_ptr<std::optional<Widget>> result)\r\n{\r\n    \u27e6 calculations... \u27e7\r\n\r\n    \/\/ Store the result\r\n    result.get()->emplace(blah);\r\n\r\n    co_return;\r\n}\r\n<\/pre>\n
This is the most general case in which the Widget<\/code> is not inexpensively default-constructible. If the Widget<\/code> is cheap to construct, you can avoid the std::optional<\/code>:<\/p>\n
winrt::IAsyncAction DoSomethingAsync(std::shared_ptr<Widget> result)\r\n{\r\n    \u27e6 calculations... \u27e7\r\n\r\n    \/\/ Store the result\r\n    *result = blah;\r\n\r\n    co_return;\r\n}\r\n<\/pre>\n
It’s important that we use a shared_ptr<\/code> to ensure that the result lifetime extends to the point we store it. You might be tempted to do something like this:<\/p>\n
\/\/ Code in italics is wrong\r\nwinrt::IAsyncAction DoSomethingAsync(Widget& result<\/i>)\r\n{\r\n    \u27e6 calculations... \u27e7\r\n\r\n    \/\/ Store the result\r\n    result = blah;\r\n\r\n    co_return;\r\n}\r\n<\/pre>\n
The problem is that you have no guarantee that the caller will keep the result<\/code> value through to the completion of the coroutine. If the caller returns before Do\u00adSomething\u00adAsync<\/code> completes (say because it doesn’t await the result, or it encounters an exception before it can await the result), then the “Store the result” will be writing to an already-destroyed object and will corrupt memory.<\/p>\n
Another option is to use IAsyncOperation<T><\/code> but break the rule that T<\/code> is the thing you want to return. You can instead return an IInspectable<\/code> that is hiding another value inside it.<\/p>\n
template<typename T>\r\nstruct ValueAsInspectable :\r\n    winrt::implements<ValueAsInspectable<T>,\r\n    winrt::Windows::Foundation::IInspectable>\r\n{\r\n    T value;\r\n\r\n    template<template...Args>\r\n    ValueAsInspectable(Args&&... args) :\r\n        value{ std::forward<Args>(args)... } {}\r\n};\r\n<\/pre>\n
You can then use one of these “values disguised as an IInspectable<\/code>” as your operation’s result.<\/p>\n
winrt::IAsyncOperation<winrt::IInspectable> DoSomethingAsync()\r\n{\r\n    \u27e6 calculations... \u27e7\r\n\r\n    co_return winrt::make<ValueAsInspectable<Widget>>(blah, blah);\r\n}\r\n\r\nwinrt::fire_and_forget Sample()\r\n{\r\n    auto obj = co_await DoSomethingAsync();\r\n    auto& widget = winrt::get_self<ValueAsInspectable<Widget>>(obj)->value;\r\n    widget.Toggle();\r\n}\r\n<\/pre>\n
We make a ValueAsInspectable<Widget>><\/code> and put a Widget<\/code> inside it, constructed from the parameters blah, blah<\/code>. Upon receiving it, we use the fact that we know that this IInspectable<\/code> is really a Value\u00adAs\u00adInspectable<\u00adWidget><\/code>, and we use get_self<\/code> to access the backing C++ class and obtain a reference to the value<\/code> hiding inside.<\/p>\n
Note that this reference’s lifetime is controlled by the returned object, so you don’t want to do this:<\/p>\n
\/\/ Code in italics is wrong\r\n    auto& widget = winrt::get_self<ValueAsInspectable<Widget>>(\r\n            co_await DoSomethingAsync()<\/i>\r\n        )->value;\r\n<\/pre>\n
Because that saves a reference to an object inside an IInspectable<\/code> that is about to be destroyed.<\/p>\n
This wrapper technique has the downside of requiring you to trust that the IInspectable<\/code> returned by DoSomething<\/code> really is wrapping a Widget<\/code> in the same process. If it’s a remote object, or if it’s wrapping something else, or isn’t a wrapper at all, then you’re grabbing a reference to garbage.<\/p>\n
We’ll work on addressing these deficiencies next time, but if you have control over both the producer and consumer of the Value\u00adAs\u00adInspectable<\/code>, then this version may be sufficient.<\/p>\n
We can add some helpers to make it a bit more ergonomic.<\/p>\n
template<typename T, typename...Args>\r\nwinrt::Windows::Foundation::IInspectable\r\n    MakeValueAsInspectable(Args&&... args)\r\n{\r\n    return winrt::make<ValueAsInspectable<T>>(\r\n        std::forward<Args>(args)...);\r\n}\r\n\r\ntemplate<typename T>\r\nwinrt::Windows::Foundation::IInspectable\r\n    MakeValueAsInspectable(T&& arg) \r\n{\r\n    return winrt::make<ValueAsInspectable<\r\n        std::remove_reference_t<T>>(\r\n        std::forward<T>(arg));\r\n}\r\n<\/pre>\n
The first helper lets you write MakeValueAsInspectable(blah)<\/code>, and the type of the Value\u00adAs\u00adInspectable<\/code> will match the type you passed in (after removing references). This lets you write<\/p>\n
co_return MakeValueAsInspectable(42);\r\n<\/pre>\n
instead of<\/p>\n
co_return MakeValueAsInspectable<int>(42);\r\n<\/pre>\n
The second overload doesn’t add any value but at least creates consistency, so you can just use Make\u00adValue\u00adAs\u00adInspectable<\/code> everywhere.<\/p>\n
co_return MakeValueAsInspectable(42);\r\nco_return MakeValueAsInspectable<Widget>(blah, blah);\r\n<\/pre>\n
Okay, next time, we’ll look at those safety improvements.<\/p>\n","protected":false},"excerpt":{"rendered":"
It’s not representable in the Windows Runtime, but you can smuggle it.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-111546","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
It’s not representable in the Windows Runtime, but you can smuggle it.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111546","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=111546"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111546\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=111546"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=111546"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=111546"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}