Gyűjtemények C++/WinRT használatával

Belső felépítését tekintve egy Windows-futtatókörnyezet-gyűjtemény számos bonyolult összetevőből áll. Ha azonban gyűjteményobjektumot szeretne átadni egy Windows-futtatókörnyezet függvénynek, vagy saját gyűjteménytulajdonságokat és gyűjteménytípusokat szeretne implementálni, a C++/WinRT függvények és alaposztályok támogatják Önt. Ezek a funkciók leveszik a válláról a bonyolultság terhét, és rengeteg idő- és munkaráfordítást takarítanak meg.

A IVector az elemek bármely véletlen hozzáférésű gyűjteménye által megvalósított Windows-futtatókörnyezet-felület. Ha saját maga szeretné implementálni az IVectort , akkor az IIterable, az IVectorView és az IIterator implementálására is szükség lenne. Még ha egyéni gyűjteménytípusra is szüksége van , az sok munkát igényel. Ha azonban az adatai egy std::vectorban (vagy egy std::mapben, illetve egy std::unordered_mapben) vannak, és csak át szeretné adni őket egy Windows-futtatókörnyezet API-nak, akkor célszerű elkerülni ezt a pluszmunkát, ha lehetséges. És ennek elkerülése lehetséges, mert a C++/WinRT segít a gyűjtemények hatékony és kis erőfeszítéssel történő létrehozásában.

Lásd még : XAML-elemek vezérlői; kötés egy C++/WinRT-gyűjteményhez.

Segédfüggvények gyűjteményekhez

Általános célú gyűjtemény, üres

Ez a szakasz azt az esetet tárgyalja, amikor egy kezdetben üres gyűjteményt szeretne létrehozni, majd azt a létrehozást követően feltölteni.

Ha egy általános célú gyűjteményt megvalósító új objektumot szeretne lekérni, meghívhatja a winrt::single_threaded_vector függvénysablont. Az objektum IVectorként lesz visszaadva, és ez az a felület, amelyen keresztül meghívja a visszaadott objektum függvényeit és tulajdonságait.

Ha a következő kódpéldákat közvetlenül egy Windows Konzolalkalmazás (C++/WinRT) projekt fő forráskódfájljába szeretné beilleszteni, először állítsa be a Nem előre összeállított fejléceket a projekttulajdonságokban.

// main.cpp
#include <winrt/Windows.Foundation.Collections.h>
#include <iostream>
using namespace winrt;

int main()
{
    winrt::init_apartment();

    Windows::Foundation::Collections::IVector<int> coll{ winrt::single_threaded_vector<int>() };
    coll.Append(1);
    coll.Append(2);
    coll.Append(3);

    for (auto const& el : coll)
    {
        std::cout << el << std::endl;
    }

    Windows::Foundation::Collections::IVectorView<int> view{ coll.GetView() };
}

Ahogy a fenti kód példában látható, a gyűjtemény létrehozása után hozzáfűzhet elemeket, átfuttathatja őket, és általában úgy kezelheti az objektumot, mint bármely olyan Windows-futtatókörnyezet gyűjteményobjektumot, amelyet egy API-tól kapott. Ha nem módosítható nézetre van szüksége a gyűjteményen keresztül, az ábrán látható módon meghívhatja az IVector::GetView parancsot. A fent látható minta – egy gyűjtemény létrehozása és felhasználása – olyan egyszerű forgatókönyvekhez megfelelő, ahol adatokat szeretne továbbítani egy API-ba, vagy adatokat szeretne kinyerni belőle. Átadhat egy IVector vagy egy IVectorView objektumot mindenhol, ahol IIterable objektumot várnak.

A fenti kódpéldában a winrt::init_apartment hívás inicializálja a szálat a Windows-futtatókörnyezet környezetben; alapértelmezés szerint egy többszálú apartmanban. A hívás a COM-t is inicializálja.

Általános célú adatgyűjtés, adatokból kiindulva

Ez a szakasz azt a forgatókönyvet ismerteti, amikor gyűjteményt szeretne létrehozni és egyidejűleg feltölteni.

Az előző kód példájában elkerülheti a Hozzáfűzésre irányuló hívások többletterhelését. Előfordulhat, hogy már rendelkezik a forrásadatokkal, vagy inkább a forrásadatokat szeretné feltölteni a Windows-futtatókörnyezet gyűjteményobjektum létrehozása előtt. Ezt a következőképpen teheti meg.

auto coll1{ winrt::single_threaded_vector<int>({ 1,2,3 }) };

std::vector<int> values{ 1,2,3 };
auto coll2{ winrt::single_threaded_vector<int>(std::move(values)) };

for (auto const& el : coll2)
{
    std::cout << el << std::endl;
}

Átadhat egy, az adatait tartalmazó ideiglenes objektumot a winrt::single_threaded_vector számára, ahogyan fent, a coll1 esetében is. Vagy áthelyezhet egy std::vektort (feltéve, hogy nem fér hozzá újra) a függvénybe. Mindkét esetben egy rvalue-t ad át a függvénynek. Ez lehetővé teszi a fordító hatékony működését és az adatok másolásának elkerülését. Ha többet szeretne megtudni a revalutákról, tekintse meg az Értékkategóriákat és az ezekre mutató hivatkozásokat.

Ha egy XAML-elemvezérlőt szeretne a gyűjteményhez kötni, akkor megteheti. De vegye figyelembe, hogy az ItemsControl.ItemsSource tulajdonság helyes beállításához olyan értékre kell állítani, amelynek típusa IVector, IInspectable elemekkel (vagy egy interoperabilitási típusra, például IBindableObservableVector).

Íme egy példa kódra, amely egy kötésre alkalmas típusú gyűjteményt hoz létre, és hozzáfűz egy elemet. Ennek a kódpéldának a környezetét az XAML-elemek vezérlőiben találhatja meg; kötés egy C++/WinRT-gyűjteményhez.

auto bookSkus{ winrt::single_threaded_vector<Windows::Foundation::IInspectable>() };
bookSkus.Append(winrt::make<Bookstore::implementation::BookSku>(L"Moby Dick"));

Létrehozhat egy Windows-futtatókörnyezet gyűjteményt az adatokból, és az API-nak való továbbításra kész nézetet kaphat, mindezt anélkül, hogy bármit másolna.

std::vector<float> values{ 0.1f, 0.2f, 0.3f };
Windows::Foundation::Collections::IVectorView<float> view{ winrt::single_threaded_vector(std::move(values)).GetView() };

A fenti példákban a létrehozott gyűjtemény egy XAML-elemvezérlőhöz köthető; de a gyűjtemény nem figyelhető meg.

Megfigyelhető gyűjtemény

Egy megfigyelhető gyűjteményt megvalósító új objektum lekéréséhez hívja meg a winrt::single_threaded_observable_vector függvénysablont bármilyen elemtípussal. Ahhoz azonban, hogy egy megfigyelhető gyűjtemény alkalmas legyen az XAML-elemek vezérlőelemhez való kötésre, használja az IInspectablet elemtípusként.

Az objektum IObservableVectorként lesz visszaadva, és ez az a felület, amelyen keresztül Ön (vagy a vezérlőelem, amelyhez kötődik) meghívja a visszaadott objektum függvényeit és tulajdonságait.

auto bookSkus{ winrt::single_threaded_observable_vector<Windows::Foundation::IInspectable>() };

A felhasználói felület vezérlőinek megfigyelhető gyűjteményhez való kötésével kapcsolatos további részletekért és kódpéldákért lásd az XAML-elemek vezérlőit; a C++/WinRT-gyűjteményhez való kötést.

Asszociatív gyűjtemény (térkép)

A két függvénynek vannak asszociatív gyűjteményverziói, amelyeket megvizsgáltunk.

Ezeket a gyűjteményeket igény szerint adatokkal is előzetesen feltöltheti, ha a függvénynek egy rvalue értéket ad át, amelynek típusa std::map vagy std::unordered_map.

auto coll1{
    winrt::single_threaded_map<winrt::hstring, int>(std::map<winrt::hstring, int>{
        { L"AliceBlue", 0xfff0f8ff }, { L"AntiqueWhite", 0xfffaebd7 }
    })
};

std::map<winrt::hstring, int> values{
    { L"AliceBlue", 0xfff0f8ff }, { L"AntiqueWhite", 0xfffaebd7 }
};
auto coll2{ winrt::single_threaded_map<winrt::hstring, int>(std::move(values)) };

Egyszálas

A függvények neveiben az "egyszálas" azt jelzi, hogy nem biztosítanak egyidejűséget – vagyis nem szálbiztosak. A szálak említése nem kapcsolódik a lakásokhoz, mert az ezekből a függvényekből visszaadott objektumok mind agilisak (lásd a C++/WinRT agilis objektumait). Csak az objektumok egyszálasak. És ez teljesen helyénvaló, ha csak az egyik vagy a másik irányba akarja továbbítani az adatokat az alkalmazás bináris interfészén (ABI) keresztül.

Gyűjtemények alaposztályai

Ha a teljes rugalmasság érdekében saját egyéni kollekciót szeretne megvalósítani, érdemes elkerülnie, hogy ezt a nehezebb úton tegye meg. Így nézne ki például egy egyéni vektornézet a C++/WinRT alaposztályainak segítsége nélkül.

...
using namespace winrt;
using namespace Windows::Foundation::Collections;
...
struct MyVectorView :
    implements<MyVectorView, IVectorView<float>, IIterable<float>>
{
    // IVectorView
    float GetAt(uint32_t const) { ... };
    uint32_t GetMany(uint32_t, winrt::array_view<float>) const { ... };
    bool IndexOf(float, uint32_t&) { ... };
    uint32_t Size() { ... };

    // IIterable
    IIterator<float> First() const { ... };
};
...
IVectorView<float> view{ winrt::make<MyVectorView>() };

Ehelyett sokkal egyszerűbb az egyéni vektornézetet kinyerni a winrt::vector_view_base struct sablonból, és csak implementálni a get_container függvényt, hogy elérhetővé tegye az adatokat tárolót.

struct MyVectorView2 :
    implements<MyVectorView2, IVectorView<float>, IIterable<float>>,
    winrt::vector_view_base<MyVectorView2, float>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

private:
    std::vector<float> m_values{ 0.1f, 0.2f, 0.3f };
};

A get_container által visszaadott tárolónak meg kell adnia a winrt::vector_view_base által várt kezdő és záró felületet. Ahogy a fenti példában látható, az std::vector ezt biztosítja. De bármely olyan tárolót visszaküldhet, amely megfelel ugyanannak a szerződésnek, beleértve a saját egyéni tárolóját is.

struct MyVectorView3 :
    implements<MyVectorView3, IVectorView<float>, IIterable<float>>,
    winrt::vector_view_base<MyVectorView3, float>
{
    auto get_container() const noexcept
    {
        struct container
        {
            float const* const first;
            float const* const last;

            auto begin() const noexcept
            {
                return first;
            }

            auto end() const noexcept
            {
                return last;
            }
        };

        return container{ m_values.data(), m_values.data() + m_values.size() };
    }

private:
    std::array<float, 3> m_values{ 0.2f, 0.3f, 0.4f };
};

Ezek azok az alaposztályok, amelyeket a C++/WinRT biztosít az egyéni gyűjtemények implementálásához.

winrt::vector_view_base

Lásd a fenti kód példákat.

winrt::vector_base

struct MyVector :
    implements<MyVector, IVector<float>, IVectorView<float>, IIterable<float>>,
    winrt::vector_base<MyVector, float>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

    auto& get_container() noexcept
    {
        return m_values;
    }

private:
    std::vector<float> m_values{ 0.1f, 0.2f, 0.3f };
};

winrt::observable_vector_base

struct MyObservableVector :
    implements<MyObservableVector, IObservableVector<float>, IVector<float>, IVectorView<float>, IIterable<float>>,
    winrt::observable_vector_base<MyObservableVector, float>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

    auto& get_container() noexcept
    {
        return m_values;
    }

private:
    std::vector<float> m_values{ 0.1f, 0.2f, 0.3f };
};

winrt::map_view_base

struct MyMapView :
    implements<MyMapView, IMapView<winrt::hstring, int>, IIterable<IKeyValuePair<winrt::hstring, int>>>,
    winrt::map_view_base<MyMapView, winrt::hstring, int>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

private:
    std::map<winrt::hstring, int> m_values{
        { L"AliceBlue", 0xfff0f8ff }, { L"AntiqueWhite", 0xfffaebd7 }
    };
};

winrt::map_base

struct MyMap :
    implements<MyMap, IMap<winrt::hstring, int>, IMapView<winrt::hstring, int>, IIterable<IKeyValuePair<winrt::hstring, int>>>,
    winrt::map_base<MyMap, winrt::hstring, int>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

    auto& get_container() noexcept
    {
        return m_values;
    }

private:
    std::map<winrt::hstring, int> m_values{
        { L"AliceBlue", 0xfff0f8ff }, { L"AntiqueWhite", 0xfffaebd7 }
    };
};

winrt::observable_map_base

struct MyObservableMap :
    implements<MyObservableMap, IObservableMap<winrt::hstring, int>, IMap<winrt::hstring, int>, IMapView<winrt::hstring, int>, IIterable<IKeyValuePair<winrt::hstring, int>>>,
    winrt::observable_map_base<MyObservableMap, winrt::hstring, int>
{
    auto& get_container() const noexcept
    {
        return m_values;
    }

    auto& get_container() noexcept
    {
        return m_values;
    }

private:
    std::map<winrt::hstring, int> m_values{
        { L"AliceBlue", 0xfff0f8ff }, { L"AntiqueWhite", 0xfffaebd7 }
    };
};

Fontos API-k

  • Last updated on