winrt::single_threaded_observable_vector Funktionsvorlage (C++/WinRT)
Eine Funktionsvorlage, die ein Objekt eines Typs erstellt und zurückgibt, der eine beobachtete 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.
Sie können optional eine vorhandene std::vectorrvalue in die Funktion übergeben– entweder ein temporäres Objekt übergeben oder std: :move on an 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 Auflistung initialisieren, wenn Sie eine übergeben, andernfalls die Standardzuordnung.
Parameter
values Ein optionaler Verweis auf einen Wert vom Typ std::vector , von dem die Elemente des Auflistungsobjekts initialisiert werden sollen.
Rückgabewert
Ein IObservableVector , der ein neues Auflistungsobjekt darstellt.
Anforderungen
Mindest unterstütztes SDK: Windows SDK Version 10.0.17763.0 (Windows 10, Version 1809)
Namespace: winrt
Header: %WindowsSdkDir%IncludeWindowsTargetPlatformVersion<>\cppwinrt\winrt\base.h (standardmäßig enthalten)
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 Vektorvorlage implementieren, um als nützliche, allgemeine Implementierung von IObservableVectorT<> 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 sich in einer Version des Windows SDK befinden, das sie 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 Funktion "Append" veranschaulicht, wie das IObservableVectorT<>::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 dessen Index (das letzte Element in diesem Fall). Mit diesen Argumenten kann ein XAML-Elementsteuerelement auf das Ereignis reagieren und sich auf optimale Weise aktualisieren.
So erstellen Sie eine Instanz des oben definierten Typs. Anstatt die winrt::single_threaded_observable_vector Factoryfunktionsvorlage zu aufrufen, erstellen Sie das Auflistungsobjekt 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>>();
Siehe auch
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für