{"id":107565,"date":"2022-12-08T07:00:00","date_gmt":"2022-12-08T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=107565"},"modified":"2022-12-08T07:36:46","modified_gmt":"2022-12-08T15:36:46","slug":"20221208-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20221208-00\/?p=107565","title":{"rendered":"If you’re going to wrap a Windows Runtime event, you may as well let the wrapped event source manage the token"},"content":{"rendered":"

Suppose that you have a Windows Runtime object with an event that is just a proxy for an event on some other object. For example, maybe we have this:<\/p>\n

runtimeclass Widget\r\n{\r\n    event Windows.Foundation.TypedEventHandler<Widget, Object> Changed;\r\n\r\n    \/* ... other members ... *\/\r\n}\r\n\r\nruntimeclass Dashboard\r\n{\r\n    event Windows.Foundation.TypedEventHandler<Dashboard, Object> Changed;\r\n\r\n    \/* ... other members ... *\/\r\n}\r\n<\/pre>\n
Secretly, a Dashboard<\/code> uses a Widget<\/code> to do the real work, and the Changed<\/code> event on the Dashboard<\/code> is just a wrapper around the Widget<\/code>‘s Changed<\/code> event. The Dashboard<\/code> registers for the Widget<\/code>‘s Changed<\/code> event, and the event handler turns around and raises the Dashboard<\/code>‘s Changed<\/code> event.<\/p>\n
namespace winrt::Namespace::implementation\r\n{\r\n    struct Dashboard : DashboardT<Dashboard>\r\n    {\r\n        Namespace::Widget const m_widget;\r\n        event<TypedEventHandler<Namespace::Dashboard, IInspectable> m_changed;\r\n\r\n        Dashboard()\r\n        {\r\n            m_widget.Changed({ get_weak(), &Dashboard::OnChanged });\r\n        }\r\n\r\n        auto Changed(TypedEventHandler<Namespace::Dashboard, IInspectable> const& handler)\r\n        {\r\n            return m_changed.add(handler);\r\n        }\r\n\r\n        void Changed(event_token token)\r\n        {\r\n            return m_changed.remove(token);\r\n        }\r\n\r\n        void OnChanged(Namespace::Widget const&, IInspectable const&)\r\n        {\r\n            m_event(*this, nullptr);\r\n        }\r\n    };\r\n}\r\n<\/pre>\n
The idea here is that the Dashboard<\/code> listens on the Changed<\/code> event of its private Widget<\/code>, and when the Widget<\/code> changes, it turns around and raises its own Changed<\/code> event to anybody who is listening.<\/p>\n
One problem with this approach is that it registers a Changed<\/code> event on the Widget<\/code> even if there is nobody listening to the Dashboard<\/code>‘s Changed<\/code> event. This can be a problem if the Widget<\/code>‘s Changed<\/code> event is expensive to subscribe to. For example, detecting changes to a Widget<\/code> may require the creation of a “watcher” object which monitors some system state. If nobody has subscribed to the Dashboard<\/code>‘s Changed<\/code> event, then there’s no need to run the Widget<\/code> change watcher.<\/p>\n
Some people solve this problem by registering on the Widget<\/code>‘s Changed<\/code> event only when somebody registers for the Dashboard<\/code>‘s Changed<\/code> event.<\/p>\n
namespace winrt::Namespace::implementation\r\n{\r\n    struct Dashboard : DashboardT<Dashboard>\r\n    {\r\n        Namespace::Widget const m_widget;\r\n        event<TypedEventHandler<Namespace::Dashboard, IInspectable> m_changed;\r\n        std::once_flag m_subscribe_once;<\/span>\r\n\r\n        Dashboard()\r\n        {\r\n            \/\/ m_widget.Changed({ get_weak(), &Dashboard::OnChanged });<\/span><\/span>\r\n        }\r\n\r\n        auto Changed(TypedEventHandler<Namespace::Dashboard, IInspectable> const& handler)\r\n        {\r\n            std::call_once(m_subscribe_once, [&]() {\r\n                m_widget.Changed({ get_weak(), &Dashboard::OnChanged });\r\n            });<\/span>\r\n            return m_changed.add(handler);\r\n        }\r\n\r\n        void Changed(event_token token)\r\n        {\r\n            return m_changed.remove(token);\r\n        }\r\n\r\n        void OnChanged(Namespace::Widget const&, IInspectable const&)\r\n        {\r\n            m_event(*this, nullptr);\r\n        }\r\n    };\r\n}\r\n<\/pre>\n
This at least delays the registration until needed, but it doesn’t remove the registration when no longer needed. For that, we would have to add some more synchronization:<\/p>\n
namespace winrt::Namespace::implementation\r\n{\r\n    struct Dashboard : DashboardT<Dashboard>\r\n    {\r\n        Namespace::Widget const m_widget;\r\n        event<TypedEventHandler<Namespace::Dashboard, IInspectable> m_changed;\r\n        std::mutex m_lock;\r\n        winrt::event_token m_token{};<\/span>\r\n\r\n        Dashboard()\r\n        {\r\n        }\r\n\r\n        auto Changed(TypedEventHandler<Namespace::Dashboard, IInspectable> const& handler)\r\n        {\r\n            std::lock_guard guard(m_lock);\r\n            if (!m_changed) {\r\n                m_token = m_widget.Changed({ get_weak(), &Dashboard::OnChanged });\r\n            }<\/span>\r\n            return m_changed.add(handler);\r\n        }\r\n\r\n        void Changed(event_token token)\r\n        {\r\n            std::lock_guard guard(m_lock);<\/span>\r\n            m_changed.remove(token);\r\n            if (!m_changed) {\r\n                m_widget.Changed(std::exchange(m_token, {}));\r\n            }<\/span>\r\n        }\r\n\r\n        void OnChanged(Namespace::Widget const&, IInspectable const&)\r\n        {\r\n            m_event(*this, nullptr);\r\n        }\r\n    };\r\n}\r\n<\/pre>\n
But there’s an easier way.<\/p>\n
Just get out of the event business entirely, and let the registrations go all the way to the Widget<\/code>. Let the event registration token be the one from the Widget<\/code>‘s Changed<\/code> event. All you have to do is convert the event parameters when the Widget<\/code>‘s Changed<\/code> event is raised.<\/p>\n
namespace winrt::Namespace::implementation\r\n{\r\n    struct Dashboard : DashboardT<Dashboard>\r\n    {\r\n        Namespace::Widget const m_widget;\r\n        \/\/ event<TypedEventHandler<Namespace::Dashboard, IInspectable> m_changed;<\/span><\/span>\r\n\r\n        Dashboard()\r\n        {\r\n        }\r\n\r\n        auto Changed(TypedEventHandler<Namespace::Dashboard, IInspectable> const& handler)\r\n        {\r\n            return m_changed.add([weak = get_weak(), handler](auto&&, auto&&)\r\n            {\r\n                if (auto strong = weak.get()) handler(*strong.get(), nullptr);\r\n            });<\/span>\r\n        }\r\n\r\n        void Changed(event_token token)\r\n        {\r\n            m_widget.Changed(token);<\/span>\r\n        }\r\n\r\n        \/\/ void OnChanged(Namespace::Widget const&, IInspectable const&)<\/span><\/span>\r\n        \/\/ {<\/span><\/span>\r\n        \/\/     m_event(*this, nullptr);<\/span><\/span>\r\n        \/\/ }<\/span><\/span>\r\n    };\r\n}\r\n<\/pre>\n
When a client wants to register a Dashboard<\/code> Changed<\/code> event handler, we wrap it inside a Widget<\/code> Changed<\/code> event handler and let the Widget<\/code> deal with it. The wrapper captures a weak reference to the Dashboard<\/code> to avoid a circular reference. When the wrapper is called, it recovers the original Dashboard<\/code> from the weak reference so it can use it as the sender<\/code> when calling the client’s original handler.<\/p>\n
This approach gives the Widget<\/code> full insight into the clients, so it can perform whatever optimizations it likes. And it’s less work for you, too, since you’ve delegated all the event bookkeeping to the Widget<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"
It keeps the original object in control.<\/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-107565","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
It keeps the original object in control.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107565","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=107565"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107565\/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=107565"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=107565"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=107565"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}