Bug: In some situations, calling get_weak() may over-release the "outer" object

[JesseCol]

Version

2.0.240405.15

Summary

There seems to be an issue where get_weak() will over-release the "outer" object when:

• The object is aggregated/subclassed by a component in a different module or DLL.
• When get_weak() is called, the object is using the external control block for refcounting, rather than keeping the refcount internally. (the issue doesn't repro when l just call get_weak() in the class's ctor, for example).

In the debugger, for the repro case it appears get_weak()'s net effect on the refcounts is that the inner gets +1 ref count and the "this" gets -1 ref count.

Here's a repro project: GetWeakRefCount.zip

For best results, enable pageheap for the process before running (as admin: "gflags.exe -i ThermometerCoreApp.exe +hpa").

It is UWP because it's based on the "ThermometerWRC" sample project.

Reproducible example

No response

Expected behavior

I'd expect get_weak() not to effect the strong ref count of the inner or outer objects.

Actual behavior

In the repro case, when I call get_weak() I'm seeing the outer object lose a strong ref, and the inner object gain a strong ref.

Additional comments

No response

[kennykerr]

Spent a bit of time debugging this on my end. A few thoughts before I get back to work and forget all about this. 😉

• C++/WinRT support for weak references is limited to non-composable or at least non-open composable hierarchies. That's because it's implemented by swapping out the ref count on the object while open composable types delegate ref counting to the outer/derived object and thus there's really two ref counts at play and that's not supported by the C++/WinRT weak reference implementation.
• C++/WinRT support for open/binary composable hierarchies is limited to Xaml. Nothing else has ever been tested nor is it recommended.
• To the best of my knowledge, the base composable type in Xaml has always been implemented in something other than C++/WinRT. Its that base composable type(s) that must implement weak reference support. Derived types cannot do it - they simply delegate to the base.
• You may want to confirm that a derived type in the binary hierarchy isn't accidentally responding to queries for IWeakReferenceSource. That would be a big problem.
• You can instruct C++/WinRT not to implement weak reference support for a particular implementation by using the no_weak_ref marker type.

Here's a more minimal example of open composability in C++/WinRT for debugging purposes only:

https://gist.github.com/kennykerr/2a5dd202274f49031adbd50e02d8b4d0

[github-actions[bot]]

This issue is stale because it has been open 10 days with no activity. Remove stale label or comment or this will be closed in 5 days.

[acoates-ms]

To work around this issue, would it be possible to implement a base composable type in something other than C++/WinRT, then use C++/WinRT to compose types on top of that? Similar to what Xaml does?

[JesseCol]

Thanks Andrew, I do expect that would avoid the problem.

I forgot to mention, the workaround I'm using is to use make_weak() instead of get_weak(). This goes through the outer object (rather than the inner) and the refcounts appear to be updated correctly.

[github-actions[bot]]

This issue is stale because it has been open 10 days with no activity. Remove stale label or comment or this will be closed in 5 days.