{"id":110116,"date":"2024-08-09T07:00:00","date_gmt":"2024-08-09T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=110116"},"modified":"2024-08-09T09:18:23","modified_gmt":"2024-08-09T16:18:23","slug":"20240809-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20240809-00\/?p=110116","title":{"rendered":"What does it even mean to Close a Windows Runtime asynchronous operation or action?"},"content":{"rendered":"

Windows Runtime asynchronous operations and actions support the Close<\/code> method. What does that even mean?<\/p>\n

There are at least five different implementations of Windows Runtime asynchronous operations and actions, and each one deals with the Close<\/code> operation differently. Let’s look at the different implementations and see if we can infer the principle that guides the Close<\/code> method.<\/p>\n

C++\/WinRT’s asynchronous operations and actions have a very simple implementation of Close<\/code>: It does nothing<\/a>! It doesn’t even check whether you called it before the asynchronous operation or action has completed.<\/p>\n

Okay, so we didn’t learn much from that.<\/p>\n

Next up is an internal implementation used by many Windows components, which builds on top of WRL’s AsyncBase<\/code><\/a>. The Close<\/code> method discards the result of IAsync\u00adOperation<\/code> if the result is a reference type or a string. If you Close<\/code> one of those guys, then the Get\u00adResults()<\/code> may return an empty result instead of the actual result.<\/p>\n

Okay, so one thing we learned is that once you call Close<\/code>, you can’t call Get\u00adResults()<\/code> and get reliable results.<\/p>\n

Furthermore, the implementation of AsyncBase<\/code> throws an “illegal state change” exception if you try to Close<\/code> the asynchronous operation or action before it has completed. And any method calls or property accesses after you Close<\/code> throw an “illegal method call” exception. So those are some other rules we can remember.<\/p>\n

Another implementation ships with Win2D<\/a>. This is also built on top of WRL’s AsyncBase<\/code>. The Win2D version supports only reference types, and the Close<\/code> method frees the completion result. So its behavior is a subset of the Windows internal implementation. We didn’t learn anything new here.<\/p>\n

A fourth implementation can be found in the Parallel Patterns Library (PPL)<\/a>. In this implementation, the Close<\/code> method throws an “illegal state change” exception if the asynchronous action or operation has not yet completed. Assuming that the operation has completed, the Close<\/code> method delegates to the virtual _OnClose<\/code> method, but the default implementation of _OnClose<\/code> does nothing. After the asynchronous operation or action has been closed, you cannot ask for its Id<\/code>, ErrorCode<\/code>, Status<\/code>, or Progress<\/code> handler, you cannot set the Completed<\/code> or Progress<\/code> handler, nor can you call GetResults()<\/code>. (Though it lets you read<\/i> the Completed<\/code> and Progress<\/code> properties.)<\/p>\n

The fifth implementation is in the Windows\u00adRuntime\u00adSystem\u00adExtensions<\/code> extension class<\/a>. I don’t have the source code, but I was able to reverse-engineer it with the help of ILSpy<\/a>. In this implementation, calling Close<\/code> before the asynchronous operation or action has completed throws an exception. If you call it after the completion, then the completion results are freed, as well as the completion handler, the progress handler (if applicable), and any supporting data structures for those things. And after you close the asynchronous operation or action, all future method calls or member accesses throw an exception.<\/p>\n

Okay, so combining all of these observations allows us to infer the rules for closing asynchronous operations and actions:<\/p>\n