convertible_observable_vector::IndexOf slows debugging because it uses exceptions in a non-exceptional case

[mcooley]

We have a scenario where some code in XAML repeatedly calls IObservableVector::IndexOf, where value is a different type than the container items. That causes hresult_no_interface to be thrown and caught internally within cppwinrt many times in this code.

All of these exceptions cause ~1s pauses in the debugger and make it difficult for the developer to be productive if they have first-chance exceptions turned on.

It appears that since #695 was merged, IInspectable.try_as is equivalent (?) to unbox_value and could be used in the implementation of IndexOf to avoid this. (Is that true, or did I miss some nuance there?)

[kennykerr]

@oldnewthing

[kennykerr]

Something like this should avoid the exception:

bool IndexOf(Windows::Foundation::IInspectable const& value, uint32_t& index) const
{
    if (auto box = value.try_as<T>())
    {
        return IndexOf(box.value(), index);
    }
    else
    {
        return false;
    }
}

[mcooley]

I played around with this a bit more and ran into two nuances:

1. The auto-returning version of try_as<T> can return std::optional<T> or a reference type for T. One has .value(), the other doesn't. The only uniform way to get a T out in both cases is to use the bool-returning version of try_as<T>.
2. value can be null, and that's a case where try_as returns false but we need to search the collection anyway.

So the result ends up a little uglier, maybe something like this...

if constexpr(std::is_convertible_v<std::nullptr_t, T>)
{
    if (!value)
    {
        return IndexOf(T{nullptr}, index);
    }
}

T unboxedValue;
if (value.try_as(unboxedValue))
{
    return IndexOf(unboxedValue, index);
}
else
{
    index = 0;
    return false;
}

Edit: and now I see that T unboxedValue; won't work; we don't want to be calling T's default constructor.

[kennykerr]

Of course, the following should cover both cases:

bool IndexOf(Windows::Foundation::IInspectable const& value, uint32_t& index) const
{
    if constexpr (is_com_interface_v<T>)
    {
        return IndexOf(value.try_as<T>(), index);
    }
    else if (auto box = value.try_as<T>())
    {
        return IndexOf(box.value(), index);
    }
    else
    {
        return false;
    }
}

[kennykerr]

It's a little more complicated but here's a fix with some tests to cover the different scenarios: #1017

[kennykerr]

Version 2.0.210913.7 has now been published with this fix.