{"id":108078,"date":"2023-04-21T07:00:00","date_gmt":"2023-04-21T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108078"},"modified":"2023-04-21T07:24:26","modified_gmt":"2023-04-21T14:24:26","slug":"20230421-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230421-00\/?p=108078","title":{"rendered":"Protecting a broker from a failing delegate"},"content":{"rendered":"

Last time, we saw how we can protect a broker from a failed event handler<\/a>. But what if the thing you need to protect against is a delegate?<\/p>\n

You can just replicate the event logic for detecting broken delegates, which we saw at the start of this mini-series<\/a>.<\/p>\n

\/\/ C++\/CX\r\npublic delegate String^ SomeClassConversionHandler(Object^ o);\r\n\r\npublic ref class SomeClass\r\n{\r\npublic:\r\n  SomeClass(SomeClassConversionHandler^ converter) :\r\n    m_converter(converter) {}\r\n\r\nprivate:\r\n  SomeClassConversionHandler^ m_converter;\r\n};\r\n\r\n\/\/ C++\/WinRT\r\n\/\/ .idl\r\nnamespace Contoso\r\n{\r\n  delegate String SomeClassConversionHandler(Object o);\r\n\r\n  runtimeclass SomeClass\r\n  {\r\n    SomeClass(SomeClassConversionHandler converter);\r\n  }\r\n}\r\n\r\n\/\/ .cpp\r\nstruct SomeClass : SomeClassT<SomeClass>\r\n{\r\n  SomeClass(Contoso::SomeClassConversionHandler const& converter)\r\n    : m_converter(converter) {}\r\n\r\n  Contoso::SomeClassConversionHandler m_converter;\r\n};\r\n<\/pre>\n
Suppose the Some\u00adClass<\/code> object does some work, but occasionally needs help converting an object to a string, and that assistance comes from a converter<\/code> provided at construction. Suppose the original code looks like this:<\/p>\n
void SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    auto converted = m_converter(o);\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
And we need to protect the call to m_converter<\/code> from a failed delegate.<\/p>\n
Well, first of all, we have to decide what we want to happen if the delegate fails.<\/p>\n
One possibility is that we want to treat any kind of failure to mean that the conversion to a string produces an empty string.<\/p>\n
\/\/ C++\/CX\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    String^ converted;\r\n    try {<\/span>\r\n      converted = m_converter(o);\r\n    } catch (...) {\r\n      \/\/ Treat all conversion failures as\r\n      \/\/ converting to empty string.\r\n      converted = L\"\";\r\n    }<\/span>\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\/\/ C++\/WinRT\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    winrt::hstring converted;\r\n    try {<\/span>\r\n      converted = m_converter(o);\r\n    } catch (...) {\r\n      \/\/ Treat all conversion failures as\r\n      \/\/ converting to empty string.\r\n      converted = L\"\";\r\n    }<\/span>\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
Now, this does mean that if the failure is due to a disconnected delegate, every conversion attempt will raise a new Disconnected\u00adException<\/code> that is caught and ignored. This is rather inefficient, because disconnection is a permanent state, and it clutters the error logs, so you may want to detect disconnected converters as a special case.<\/p>\n
bool IsDisconnectedHResult(int hr)\r\n{\r\n  return hr == HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) ||\r\n         hr == RPC_E_DISCONNECTED ||\r\n         hr == JSCRIPT_E_CANTEXECUTE;\r\n}\r\n\r\n\/\/ C++\/CX\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    String^ converted;\r\n    if (m_converted == nullptr) {\r\n      \/\/ If no converter, then just use empty string.\r\n      converted = L\"\";\r\n    } else {<\/span>\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (Exception^ ex) {\r\n        if (IsDisconnectedHResult(ex->HResult)) {\r\n          \/\/ Don't use this disconnected converter any more.\r\n          m_converter = nullptr;<\/span>\r\n        }\r\n        \/\/ Treat all conversion failures as\r\n        \/\/ converting to empty string.\r\n        converted = L\"\";\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\/\/ C++\/WinRT\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    winrt::hstring converted;\r\n    if (m_converted == nullptr) {\r\n      \/\/ If no converter, then just use empty string.\r\n      converted = L\"\";\r\n    } else {<\/span>\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (...) {\r\n        if (IsDisconnectedHResult(winrt::to_hresult())) {\r\n          \/\/ Don't use this disconnected converter any more.\r\n          m_converter = nullptr;<\/span>\r\n        }\r\n        \/\/ Treat all conversion failures as\r\n        \/\/ converting to empty string.\r\n        converted = L\"\";\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
Here, we overload nullptr<\/code> as a special converter value to mean “Don’t even try converting. Just go straight to an empty string.”<\/p>\n
If you already have assigned a special meaning to nullptr<\/code> (say, because that means “Perform a default conversion”), then you have some other options.<\/p>\n
You could add another member variable to remember whether the converter is any good.<\/p>\n
\/\/ C++\/CX\r\npublic ref class SomeClass\r\n{\r\npublic:\r\n  SomeClass(SomeClassConversionHandler^ converter) :\r\n    m_converter(converter) {}\r\n\r\nprivate:\r\n  SomeClassConversionHandler^ m_converter;\r\n  bool m_isConverterDisconnected = false;<\/span>\r\n};\r\n\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    String^ converted;\r\n    if (m_isConverterDisconnected) {\r\n      \/\/ Disconnected converter is treated as converting\r\n      \/\/ to empty string.\r\n      converted = L\"\";\r\n    } else<\/span> if (m_converter == nullptr) {\r\n      converted = DefaultConversion(o);\r\n    } else {\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (Exception^ ex) {\r\n        if (IsDisconnectedHResult(ex->HResult)) {\r\n          \/\/ Don't use this disconnected converter any more.\r\n          m_isConverterDisconnected = true;<\/span>\r\n        } else {\r\n          \/\/ Treat all conversion failures as\r\n          \/\/ converting to empty string.\r\n          converted = L\"\";\r\n        }\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\/\/ C++\/WinRT\r\nstruct SomeClass : SomeClassT<SomeClass>\r\n{\r\n  SomeClass(Contoso::SomeClassConversionHandler const& converter)\r\n    : m_converter(converter) {}\r\n\r\n  Contoso::SomeClassConversionHandler m_converter;\r\n  bool m_isConverterDisconnected = false;<\/span>\r\n};\r\n\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    winrt::hstring converted;\r\n    if (m_isConverterDisconnected) {\r\n      \/\/ Disconnected converter is treated as converting\r\n      \/\/ to empty string.\r\n      converted = L\"\";\r\n    } else<\/span> if (m_converter == nullptr) {\r\n      converted = DefaultConversion(o);\r\n    } else {\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (...) {\r\n        if (IsDisconnectedHResult(winrt::to_hresult())) {\r\n          \/\/ Don't use this disconnected converter any more.\r\n          m_isConverterDisconnected = true;<\/span>\r\n        } else {\r\n          \/\/ Treat all conversion failures as\r\n          \/\/ converting to empty string.\r\n          converted = L\"\";\r\n        }\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n<\/pre>\n
Or you could replace the disconnected delegate with a working one that performs the “What to do if the delegate is disconnected” action.<\/p>\n
\/\/ C++\/CX\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    String^ converted;\r\n    if (m_converter == nullptr) {\r\n      converted = DefaultConversion(o);\r\n    } else {\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (Exception^ ex) {\r\n        if (IsDisconnectedHResult(ex->HResult)) {\r\n          \/\/ Replace this disconnected delegate with a dummy one.\r\n          m_converter = ref new SomeClassConversionHandler(\r\n            [](Object^) -> String^ { return L\"\"; });<\/span>\r\n        }\r\n        \/\/ Treat all conversion failures as\r\n        \/\/ converting to empty string.\r\n        converted = L\"\";\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\/\/ C++\/WinRT\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    winrt::hstring converted;\r\n    if (m_converter == nullptr) {\r\n      converted = DefaultConversion(o);\r\n    } else {\r\n      try {\r\n        converted = m_converter(o);\r\n      } catch (...) {\r\n        if (IsDisconnectedHResult(winrt::to_hresult())) {\r\n          \/\/ Replace this disconnected delegate with a dummy one.\r\n          m_converter = [](auto&&) { return winrt::hstring(); };<\/span>\r\n        }\r\n        \/\/ Treat all conversion failures as\r\n        \/\/ converting to empty string.\r\n        converted = L\"\";\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
Now, maybe you want to deal with disconnected delegates differently from actively broken ones. For example, the delegate might throw an E_INVALIDARG<\/code> if the object is not convertible at all, and that’s different from “converts to nothing”.<\/p>\n
\/\/ C++\/CX\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    String^ converted;\r\n    try {\r\n      if (m_converter == nullptr) {\r\n        converted = DefaultConversion(o);\r\n      } else {\r\n        converted = m_converter(o);\r\n      }\r\n    } catch (Exception^ ex) {\r\n      if (IsDisconnectedHResult(ex->HResult)) {\r\n        \/\/ Don't use this disconnected converter any more.\r\n        \/\/ Use default conversions from now on.\r\n        m_converter = nullptr;\r\n        converted = DefaultConversion(o);\r\n      } else {\r\n        throw;<\/span>\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\/\/ C++\/WinRT\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    winrt::hstring converted;\r\n    try {\r\n      if (m_converter == nullptr) {\r\n        converted = DefaultConversion(o);\r\n      } else {\r\n        converted = m_converter(o);\r\n      }\r\n    } catch (...) {\r\n      if (IsDisconnectedHResult(winrt::to_hresult())) {\r\n        \/\/ Don't use this disconnected converter any more.\r\n        \/\/ Use default conversions from now on.\r\n        m_converter = nullptr;\r\n        converted = DefaultConversion(o);\r\n      } else {\r\n        throw;<\/span>\r\n      }\r\n    }\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
Here, we rethrow any exception from the converter that isn’t a disconnection. The exception then propagates back to the caller, to tell it that the conversion failed. The caller can then take whatever remedial action it deems appropriate.<\/p>\n
Dealing with a broken delegate is more work than dealing with a broken event handler because you have to reimplement the disconnection logic yourself. One way to sidestep this problem is to to leverage all the work that went into events: Just use an event!<\/p>\n
\/\/ C++\/CX\r\npublic ref class SomeClassConversionRequestedEventArgs\r\n{\r\n    property Object^ Value { Object^ get(); };\r\n    property String^ Converted\r\n    { String^ get(); void set(String^); };\r\n};\r\n\r\npublic ref class SomeClass\r\n{\r\npublic:\r\n  SomeClass() {}\r\n\r\n  event TypedEventHandler<SomeClass^, SomeClassConversionRequestedEventArgs^>;^\r\n    ConversionRequested;\r\n};\r\n\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    auto args = ref new SomeClassConversionRequestedEventArgs();\r\n    args->Value = o;\r\n    ConversionRequested(this, args);\r\n    auto converted = args->Converted;\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n\r\n\r\n\/\/ C++\/WinRT\r\n\/\/ .idl\r\nnamespace Contoso\r\n{\r\n  runtimeclass SomeClassConversionRequestedEventArgs\r\n  {\r\n    Object Value{ get };\r\n    String Converted;\r\n  }\r\n\r\n  runtimeclass SomeClass\r\n  {\r\n    SomeClass();\r\n    event TypedEventHandler<SomeClass, SomeClassConversionRequestedEventArgs>\r\n      ConversionRequested;\r\n  }\r\n}\r\n\r\n\/\/ .cpp\r\nstruct SomeClass : SomeClassT<SomeClass>\r\n{\r\n  SomeClass() {}\r\n\r\n  \/* save some typing *\/\r\n  using ConversionHandler = winrt::TypedEventHandler<\r\n      Contoso::SomeClass, Contoso::SomeClassConversionRequestedEventArgs>;\r\n\r\n  auto ConversionRequested(ConversionHandler const& handler) {\r\n    return m_conversionRequestedEvent.add(handler);\r\n  }\r\n  void ConversionRequested(winrt::event_token const& token) {\r\n    return m_conversionRequestedEvent.remove(token);\r\n  }\r\n\r\n  winrt::event<\r\n    winrt::TypedEventHandler<\r\n      Contoso::SomeClass, Contoso::SomeClassConversionRequestedEventArgs>>\r\n    m_conversionRequestedEvent;\r\n};\r\n\r\nvoid SomeClass::DoWork()\r\n{\r\n  if (need_conversion) {\r\n    Contoso::SomeClassConversionRequestedEventArgs args;\r\n    args.Value(o);\r\n    m_conversionRequestedEvent(*this, args);\r\n    auto converted = args.Converted();\r\n    \/* ... more code ... *\/\r\n  }\r\n}\r\n<\/pre>\n
The caller registers an event handler for the Conversion\u00adRequested<\/code> event, and now the event infrastructure now does the work of dealing with the disconnection exception. You can then apply the other techniques for  protecting a broker from a failed event handler if you want to customize how errors are handled.<\/p>\n","protected":false},"excerpt":{"rendered":"
Catching them in a different way.<\/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-108078","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Catching them in a different way.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108078","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=108078"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108078\/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=108078"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108078"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108078"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}