{"id":111787,"date":"2025-11-13T07:00:00","date_gmt":"2025-11-13T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=111787"},"modified":"2025-12-28T15:04:27","modified_gmt":"2025-12-28T23:04:27","slug":"20251113-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20251113-00\/?p=111787","title":{"rendered":"Could we use CTAD to simplify the use of WRL’s Callback function?"},"content":{"rendered":"

Commenter Bwmat asked, “Can CTAD avoid the need for the lengthy type name in the last example<\/a>?” This was in response to the rather lengthy type in the explicit specialization<\/p>\n

void MyClass::RegisterCompletion(ABI::IAsyncAction* action)\r\n{\r\n    m_showingToken = inputPane->put_Showing(\r\n        Microsoft::WRL::Callback<\/span><ABI::ITypedEventHandler<<\/span>\r\n            ABI::InputPane*,                             <\/span>\r\n            ABI::InputPaneVisibilityEventArgs*>><\/span>(        <\/span>\r\n            this, &MyClass::OnInputPaneShowing).Get());\r\n}\r\n<\/pre>\n
Now, you cannot literally use CTAD (Class Template Argument Deduction) here because Callback<\/code> is not a class.<\/p>\n
Class template argument deduction exists to cover for the lack of type deduction in class naming. But functions do<\/i> have type deduction! So let’s use it.<\/p>\n
We’re starting with this:<\/p>\n
template<\r\n   typename TDelegateInterface,\r\n   typename TCallbackObject,\r\n   typename... TArgs\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n<\/pre>\n
We want to deduce the TDelegateInterface<\/code> to be TypedEventHandler<TArgs...><\/code>:<\/p>\n
template<\r\n   typename TDelegateInterface\r\n        = TypedEventHandler<TArgs...>,<\/span>\r\n   typename TCallbackObject,\r\n   typename... TArgs\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n<\/pre>\n
Unfortunately, this doesn’t work because template default parameters cannot refer to future template parameters.<\/p>\n
We could try reordering the parameters.<\/p>\n
template<\r\n   typename TCallbackObject,         <\/span>\r\n   typename... TArgs,                <\/span>\r\n   typename TDelegateInterface       <\/span>\r\n        = TypedEventHandler<TArgs...><\/span>\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n<\/pre>\n
However, this doesn’t work because template parameter packs must come at the end of the template parameter list.<\/p>\n
We can finesse the problem by splitting the template into one that specifically has exactly two TArgs<\/code> and one for the other cases.<\/p>\n
template<\r\n   typename TDelegateInterface,\r\n   typename TCallbackObject,\r\n   typename... TArgs,\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n\r\ntemplate<\r\n    typename TCallbackObject,\r\n    typename TArg1, typename TArg2,\r\n    typename TDelegateInterface =\r\n        TypedEventHandler<TArg1, TArg2>\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs1, TArg2)\r\n);\r\n<\/pre>\n
Unfortunately, this fails due to the ambiguous call. We have to remove the first one from consideration when the number of parameters to the callback is exactly two.<\/p>\n
template<\r\n   typename TDelegateInterface,\r\n   typename TCallbackObject,\r\n   typename... TArgs,\r\n>\r\nstd::enable_if_t<sizeof...(TArgs) != 2,\r\n    ComPtr<TDelegateInterface>>\r\nCallback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n\r\ntemplate<\r\n    typename TCallbackObject,\r\n    typename TArg1, typename TArg2,\r\n    typename TDelegateInterface =\r\n        TypedEventHandler<TArg1, TArg2>\r\n>\r\nComPtr<TDelegateInterface> Callback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArg1, TArg2)\r\n);\r\n<\/pre>\n
But even with this version, the two-argument callback has poor ergonomics: If you want to specify a custom delegate interface (like, say, Suspending\u00adEvent\u00adHandler<\/code>), you have to slog through the first three parameters so you can finally specify the last one.<\/p>\n
Callback<MyObject, IInspectable*, SuspendingEventArgs*,<\/span> SuspendingEventHandler>(\r\n    this, &MyObject::OnSuspending);\r\n<\/pre>\n
Instead, we can use  type deduction from the future<\/a>.<\/p>\n
template<\r\n   typename TDelegateInterface = void<\/span>,\r\n   typename TCallbackObject,\r\n   typename... TArgs\r\n>\r\nComPtr<std::conditional_t<\r\n    std::is_same_v<TDelegateInterface, void>,\r\n    TypedEventHandler<TArgs...>,\r\n    TDelegateInterface>>\r\nCallback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n<\/pre>\n
But wait, the Typed\u00adEvent\u00adHandler<\/code> takes only two template arguments, so if we invoke Callback<\/code> with a pointer to member function that takes only one argument, we get a compiler error because it cannot form TypedEventHandler<TArg><\/code>.<\/p>\n
struct MyObject\r\n{\r\n    HRESULT OnUIInvoked(IUICommand* command);\r\n};\r\n\r\nCallback<UICommandInvokedHandler<(this, &MyObject::OnUIInvoked);\r\n\/\/ ^^^ error: template argument deduction\/substitution failed\r\n\/\/            wrong number of template arguments to TypedEventHandler\r\n<\/pre>\n
We have to delay the mention of TypedEventHandler<TArgs...><\/code> until we are committed to using it.<\/p>\n
template<typename... TArgs>                  <\/span>\r\nstruct TypedEventHandlerHolder               <\/span>\r\n{                                            <\/span>\r\n    using type = TypedEventHandler<TArgs...>;<\/span>\r\n};                                           <\/span>\r\n\r\ntemplate<\r\n   typename TDelegateInterface = void,\r\n   typename TCallbackObject,\r\n   typename... TArgs\r\n>\r\nComPtr<typename<\/span> std::conditional_t<\r\n    std::is_same_v<TDelegateInterface, void>,\r\n    TypedEventHandlerHolder<TArgs...>,     <\/span>\r\n    std::type_identity<TDelegateInterface>><\/span>\r\n        ::type                             <\/span>\r\n>\r\nCallback(\r\n   _In_ TCallbackObject *object,\r\n   _In_ HRESULT (TCallbackObject::* method)(TArgs...)\r\n);\r\n<\/pre>\n
Now, back at the top, I mentioned that CTAD doesn’t apply because CTAD is for class templates, but Callback<\/code> is a function template.<\/p>\n
But what if we made Callback<\/code> a class template?<\/p>\n
template<\r\n    typename TDelegateInterface,\r\n    typename TCallbackObject,\r\n    typename... TArgs\r\n>\r\nstruct Callback : ComPtr<TDelegateInterface>\r\n{\r\n    Callback(TCallbackObject *object,\r\n             HRESULT (TCallbackObject::* method)(TArgs...));\r\n};\r\n<\/pre>\n
Now, CTAD will infer the TCallbackObject<\/code> and TArgs<\/code>, and we can use a deduction guide to infer the TDelegateInterface<\/code>.<\/p>\n
template<\r\n    typename TCallbackObject,\r\n    typename TArg1, TArg2\r\n>\r\nCallback(TCallbackObject*,\r\n         HRESULT (TCallbackObject::*)(TArg1, TArg2))\r\n    -> Callback<TypedEventHandler<TArg1, TArg2>, TCallbackObject, TArg1, TArg2>;\r\n<\/pre>\n
Unfortunately, CTAD doesn’t work with partial specialization, so you can’t write<\/p>\n
Callback<SuspendingEventHandler>(this, &MyObject::OnSuspending);\r\n<\/pre>\n
So I guess we’re stuck with the function overload with type deduction from the future.<\/p>\n
But really, I think  the winning move is not to play<\/a>.<\/p>\n
Instead of trying to make Callback<\/code> fancy, create a separate function TypedEventHandlerCallback<\/code>.<\/p>\n
template<\r\n   typename TCallbackObject,\r\n   typename TArg1, typename TArg2>\r\nComPtr<TypedEventHandler<TArg1, TArg2>>\r\nTypedEventHandlerCallback(\r\n    TCallbackObject* object,\r\n    HRESULT (TCallbackObject::*method)(TArg1, TArg2));\r\n<\/pre>\n
Then the original code would be<\/p>\n
void MyClass::RegisterCompletion(ABI::IAsyncAction* action)\r\n{\r\n    m_showingToken = inputPane->put_Showing(\r\n        TypedEventCallback(this, &MyClass::OnInputPaneShowing).Get());\r\n}\r\n<\/pre>\n
While we’re there, we can also make an EventHandlerCallback<\/code> function.<\/p>\n
template<\r\n   typename TCallbackObject,\r\n   typename TArg>\r\nComPtr<EventHandler<TArg>>\r\nEventHandlerCallback(\r\n    TCallbackObject* object,\r\n    HRESULT (TCallbackObject::*method)(IInspectable*, TArg));\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Not directly, but maybe indirectly.<\/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-111787","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Not directly, but maybe indirectly.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111787","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=111787"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111787\/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=111787"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=111787"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=111787"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}