Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Eine Funktionsvorlage, die ein Objekt eines Typs erstellt und zurückgibt, der eine observable Auflistung implementiert. Das Objekt wird als IObservableVector zurückgegeben, und das ist die Schnittstelle, über die Sie die Funktionen und Eigenschaften des zurückgegebenen Objekts aufrufen.
Optional können Sie einen vorhandenen std::vector-Wert an die Funktion übergeben – entweder ein temporäres Objekt übergeben oder std::move für einen lvalue aufrufen.
Weitere Informationen und Codebeispiele finden Sie unter Sammlungen mit C++/WinRT.
Syntax
template <typename T, typename Allocator = std::allocator<T>>
winrt::Windows::Foundation::Collections::IObservableVector<T> single_threaded_observable_vector(std::vector<T, Allocator>&& values = {})
Vorlagenparameter
typename T Der Typ der Elemente der Auflistung.
typename Allocator Der Typ des Allocators des Vektors, aus dem Sie die Sammlung initialisieren, wenn Sie einen übergeben, andernfalls der Standardzuordnungsverkn.
Parameter
values Optionaler Verweis auf einen Wert vom Typ "std::vector ", aus dem die Elemente des Auflistungsobjekts initialisiert werden sollen.
Rückgabewert
Ein IObservableVector , der ein neues Auflistungsobjekt darstellt.
Anforderungen
Mindestens unterstütztes SDK: Windows SDK Version 10.0.17763.0 (Windows 10, Version 1809)
Namensraum: winrt
Header: %WindowsSdkDir%Include<WindowsTargetPlatformVersion>\cppwinrt\winrt\Windows.Foundation.Collections.h
Wenn Sie über eine ältere Version des Windows SDK verfügen
Wenn Sie nicht über die Windows SDK-Version 10.0.17763.0 (Windows 10, Version 1809) oder höher verfügen, müssen Sie Ihre eigene observable Vektorvorlage implementieren, um als nützliche, allgemeine Implementierung von IObservableVector<T> zu dienen. Nachfolgend finden Sie eine Auflistung einer Klasse namens single_threaded_observable_vector<T>. Es ist einfach, von dem folgenden Typ zu winrt::single_threaded_observable_vector zu wechseln, wenn Sie eine Version des Windows SDK verwenden, das es enthält.
// single_threaded_observable_vector.h
#pragma once
namespace winrt::Bookstore::implementation
{
using namespace Windows::Foundation::Collections;
template <typename T>
struct single_threaded_observable_vector : implements<single_threaded_observable_vector<T>,
IObservableVector<T>,
IVector<T>,
IVectorView<T>,
IIterable<T>>
{
event_token VectorChanged(VectorChangedEventHandler<T> const& handler)
{
return m_changed.add(handler);
}
void VectorChanged(event_token const cookie)
{
m_changed.remove(cookie);
}
T GetAt(uint32_t const index) const
{
if (index >= m_values.size())
{
throw hresult_out_of_bounds();
}
return m_values[index];
}
uint32_t Size() const noexcept
{
return static_cast<uint32_t>(m_values.size());
}
IVectorView<T> GetView()
{
return *this;
}
bool IndexOf(T const& value, uint32_t& index) const noexcept
{
index = static_cast<uint32_t>(std::find(m_values.begin(), m_values.end(), value) - m_values.begin());
return index < m_values.size();
}
void SetAt(uint32_t const index, T const& value)
{
if (index >= m_values.size())
{
throw hresult_out_of_bounds();
}
++m_version;
m_values[index] = value;
m_changed(*this, make<args>(CollectionChange::ItemChanged, index));
}
void InsertAt(uint32_t const index, T const& value)
{
if (index > m_values.size())
{
throw hresult_out_of_bounds();
}
++m_version;
m_values.insert(m_values.begin() + index, value);
m_changed(*this, make<args>(CollectionChange::ItemInserted, index));
}
void RemoveAt(uint32_t const index)
{
if (index >= m_values.size())
{
throw hresult_out_of_bounds();
}
++m_version;
m_values.erase(m_values.begin() + index);
m_changed(*this, make<args>(CollectionChange::ItemRemoved, index));
}
void Append(T const& value)
{
++m_version;
m_values.push_back(value);
m_changed(*this, make<args>(CollectionChange::ItemInserted, Size() - 1));
}
void RemoveAtEnd()
{
if (m_values.empty())
{
throw hresult_out_of_bounds();
}
++m_version;
m_values.pop_back();
m_changed(*this, make<args>(CollectionChange::ItemRemoved, Size()));
}
void Clear() noexcept
{
++m_version;
m_values.clear();
m_changed(*this, make<args>(CollectionChange::Reset, 0));
}
uint32_t GetMany(uint32_t const startIndex, array_view<T> values) const
{
if (startIndex >= m_values.size())
{
return 0;
}
uint32_t actual = static_cast<uint32_t>(m_values.size() - startIndex);
if (actual > values.size())
{
actual = values.size();
}
std::copy_n(m_values.begin() + startIndex, actual, values.begin());
return actual;
}
void ReplaceAll(array_view<T const> value)
{
++m_version;
m_values.assign(value.begin(), value.end());
m_changed(*this, make<args>(CollectionChange::Reset, 0));
}
IIterator<T> First()
{
return make<iterator>(this);
}
private:
std::vector<T> m_values;
event<VectorChangedEventHandler<T>> m_changed;
uint32_t m_version{};
struct args : implements<args, IVectorChangedEventArgs>
{
args(CollectionChange const change, uint32_t const index) :
m_change(change),
m_index(index)
{
}
CollectionChange CollectionChange() const
{
return m_change;
}
uint32_t Index() const
{
return m_index;
}
private:
Windows::Foundation::Collections::CollectionChange const m_change{};
uint32_t const m_index{};
};
struct iterator : implements<iterator, IIterator<T>>
{
explicit iterator(single_threaded_observable_vector<T>* owner) noexcept :
m_version(owner->m_version),
m_current(owner->m_values.begin()),
m_end(owner->m_values.end())
{
m_owner.copy_from(owner);
}
void abi_enter() const
{
if (m_version != m_owner->m_version)
{
throw hresult_changed_state();
}
}
T Current() const
{
if (m_current == m_end)
{
throw hresult_out_of_bounds();
}
return*m_current;
}
bool HasCurrent() const noexcept
{
return m_current != m_end;
}
bool MoveNext() noexcept
{
if (m_current != m_end)
{
++m_current;
}
return HasCurrent();
}
uint32_t GetMany(array_view<T> values)
{
uint32_t actual = static_cast<uint32_t>(std::distance(m_current, m_end));
if (actual > values.size())
{
actual = values.size();
}
std::copy_n(m_current, actual, values.begin());
std::advance(m_current, actual);
return actual;
}
private:
com_ptr<single_threaded_observable_vector<T>> m_owner;
uint32_t const m_version;
typename std::vector<T>::const_iterator m_current;
typename std::vector<T>::const_iterator const m_end;
};
};
}
Die Append-Funktion veranschaulicht, wie das IObservableVector<T>::VectorChanged-Ereignis ausgelöst wird.
m_changed(*this, make<args>(CollectionChange::ItemInserted, Size() - 1));
Die Ereignisargumente geben sowohl an, dass ein Element eingefügt wurde als auch, was sein Index ist (in diesem Fall das letzte Element). Diese Argumente ermöglichen es einem XAML-Elementsteuerelement, auf das Ereignis zu reagieren und sich optimal zu aktualisieren.
So erstellen Sie eine Instanz des oben definierten Typs. Anstatt die Vorlage " winrt::single_threaded_observable_vector Factoryfunktion" aufzurufen, erstellen Sie das Sammlungsobjekt durch Aufrufen von "winrt::make".
#include "single_threaded_observable_vector.h"
...
winrt::Windows::Foundation::Collections::IVector<winrt::Windows::Foundation::IInspectable> m_bookSkus;
...
m_bookSkus = winrt::make<winrt::Bookstore::implementation::single_threaded_observable_vector<winrt::Windows::Foundation::IInspectable>>();