C++/WinRT ile Koleksiyonlar

dahili olarak, bir Windows Çalışma Zamanı koleksiyonunda çok sayıda karmaşık hareketli parça vardır. Ancak bir koleksiyon nesnesini bir Windows Çalışma Zamanı işlevine geçirmek veya kendi koleksiyon özelliklerinizi ve koleksiyon türlerinizi uygulamak istediğinizde, C++/WinRT'de sizi destekleyecek işlevler ve temel sınıflar vardır. Bu özellikler karmaşıklığı sizin yerinize yönetir ve zaman ile çaba açısından size büyük ölçüde ek yükten tasarruf sağlar.

IVector, herhangi bir rastgele erişim öğe koleksiyonu tarafından uygulanan Windows Çalışma Zamanı arabirimidir. IVector'ı kendiniz uygulayacaksanız, IIterable, IVectorView ve IIterator'ı da uygulamanız gerekirdi. Özel bir koleksiyon türüne ihtiyacınız olsa bile, bu çok fazla çalışmadır. Ancak bir std::vector (veya std::map veya std::unordered_map) içinde verileriniz varsa ve bunu bir Windows Çalışma Zamanı API'sine geçirmek istiyorsanız, mümkünse bu iş düzeyini kullanmaktan kaçınmak istersiniz. C++/WinRT, koleksiyonları verimli bir şekilde ve çok az çabayla oluşturmanıza yardımcı olduğundan, bundan kaçınmak mümkündür .

Ayrıca bkz. XAML öğe denetimleri; bir C++/WinRT koleksiyonuna bağlama.

Koleksiyonlar için yardımcı işlevler

Genel amaçlı koleksiyon, boş

Bu bölüm, başlangıçta boş olan bir koleksiyon oluşturmak ve ardından bunu oluşturduktan sonra doldurmak istediğiniz senaryoyu ele alır.

Genel amaçlı koleksiyon uygulayan türde yeni bir nesne almak için winrt::single_threaded_vector işlev şablonunu çağırabilirsiniz. Nesnesi bir IVector olarak döndürülür ve döndürülen nesnenin işlevlerini ve özelliklerini çağırdığınız arabirimdir.

Aşağıdaki kod örneklerini doğrudan Windows Konsol Uygulaması (C++/WinRT) projesinin ana kaynak kod dosyasına kopyalayıp yapıştırmak istiyorsanız, önce Proje özelliklerinde Önceden Derlenmiş Üst Bilgileri Kullanma seçeneğini belirleyin.

// 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() };
}

Yukarıdaki kod örneğinde görebileceğiniz gibi, koleksiyonu oluşturduktan sonra öğeleri ekleyebilir, bunlar üzerinde yineleme yapabilir ve genellikle bir API'den almış olabileceğiniz herhangi bir Windows Çalışma Zamanı koleksiyon nesnesi gibi nesneye davranabilirsiniz. Koleksiyon üzerinde sabit bir görünüme ihtiyacınız varsa, gösterildiği gibi IVector::GetView'ı çağırabilirsiniz. Yukarıda gösterilen desen(koleksiyon oluşturma ve kullanma) bir API'ye veri geçirmek veya veri almak istediğiniz basit senaryolar için uygundur. IIterable'ın beklendiği her yerde IVector veya IVectorView aktarabilirsiniz.

Yukarıdaki kod örneğinde, winrt::init_apartment çağrısı iş parçacığını Windows Çalışma Zamanı içinde başlatır; varsayılan olarak çok iş parçacıklı bir apartment içinde. Çağrı ayrıca COM'u başlatır.

Genel amaçlı koleksiyon, verilerle hazırlanmış

Bu bölüm, bir koleksiyon oluşturup aynı anda doldurmak istediğiniz senaryoyu kapsar.

Önceki kod örneğinde Ekle'ye yapılan çağrıların ek yükünden kaçınabilirsiniz. Kaynak verilere zaten sahip olabilirsiniz veya Windows Çalışma Zamanı koleksiyonu nesnesini oluşturmadan önce kaynak verileri doldurmayı tercih edebilirsiniz. İşte bunu nasıl yapabilirsiniz.

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;
}

Yukarıdaki gibi, verilerinizi içeren geçici bir nesneyi coll1 geçirebilirsiniz. Veya bir std::vector dosyasını (bir daha erişmeyeceğiniz varsayılarak) işlevine taşıyabilirsiniz. Her iki durumda da işleve bir rvalue geçirirsiniz. Bu, derleyicinin verimli olmasını ve verileri kopyalamaktan kaçınmasını sağlar. rvalues hakkında daha fazla bilgi edinmek istiyorsanız bkz. Değer kategorileri ve bunlara başvurular.

Bir XAML öğeleri denetimini koleksiyonunuzla bağlamak istiyorsanız, bunu yapabilirsiniz. Ancak ItemsControl.ItemsSource özelliğini doğru ayarlamak için, bunu IInspectableIVector türünde bir değere (veya IBindableObservableVector gibi bir birlikte çalışabilirlik türüne) ayarlamanız gerektiğini unutmayın.

Bağlamaya uygun bir tür koleksiyonu oluşturan ve buna bir öğe ekleyen bir kod örneği aşağıda verilmiştir. Bu kod örneğinin bağlamını XAML öğeleri denetimlerinde bulabilirsiniz; C++/WinRT koleksiyonuna bağlama.

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

Verilerden bir Windows Çalışma Zamanı koleksiyonu oluşturabilir ve hiçbir şey kopyalamadan api'ye geçmeye hazır bir görünüm elde edebilirsiniz.

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

Yukarıdaki örneklerde oluşturduğumuz koleksiyon bir XAML öğeleri denetimine bağlanabilir; ancak koleksiyon gözlemlenebilir değildir.

Gözlemlenebilir koleksiyon

Gözlemlenebilir koleksiyon uygulayan türde yeni bir nesne almak için winrt::single_threaded_observable_vector işlev şablonunu herhangi bir öğe türüyle çağırın. Ancak, bir XAML öğeleri denetimine bağlama için uygun bir gözlemlenebilir koleksiyon yapmak için, öğe türü olarak IInspectable kullanın.

Nesnesi bir IObservableVector olarak döndürülür ve bu, döndürülen nesnenin işlevlerini ve özelliklerini çağırdığınız arabirimdir (veya ilişkili olduğu denetim).

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

Kullanıcı arabirimi (UI) denetimlerinizi gözlemlenebilir bir koleksiyona bağlama hakkında daha fazla ayrıntı ve kod örneği için bkz. XAML öğeleri denetimleri; C++/WinRT koleksiyonuna bağlama.

İlişkili koleksiyon (harita)

baktığımız iki işlevin ilişkilendirici koleksiyon sürümleri vardır.

İsteğe bağlı olarak, işleve rvalue türünde bir std::map veya std::unordered_map geçirerek bu koleksiyonları verilerle hazırlayabilirsiniz.

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)) };

Tek iş parçacıklı

Bu işlevlerin adlarındaki "single-threaded" ifadesi, herhangi bir eşzamanlılık desteği sunmadıklarını; başka bir deyişle, iş parçacığı açısından güvenli olmadıklarını gösterir. Bu işlevlerden döndürülen nesnelerin tümü çevik olduğundan, iş parçacıklarının söz konusu olması dairelerle ilgisizdir (bkz . C++/WinRT'de çevik nesneler). Yalnızca nesnelerin tek iş parçacıklı olmasıdır. Ve eğer yalnızca uygulama ikili arayüzü (ABI) üzerinden verileri iki yönde de aktarmak istiyorsanız, bu tamamen uygundur.

Koleksiyonlar için temel sınıflar

Tam esneklik için kendi özel koleksiyonunuzu uygulamak istiyorsanız bunu zor yoldan yapmaktan kaçınmanız gerekir. Örneğin, özel vektör görünümü C++/WinRT'nin temel sınıflarının yardımı olmadan böyle görünür.

...
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>() };

Bunun yerine, winrt::vector_view_base yapısı şablonundan özel vektör görünümünüzü türetmek ve yalnızca verilerinizi barındıran kapsayıcıyı kullanıma açmak için get_container işlevini uygulamak çok daha kolaydır.

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 };
};

get_container tarafından döndürülen kapsayıcı, winrt::vector_view_base tarafından beklenen başlangıç ve bitiş arabirimini sağlamalıdır. Yukarıdaki örnekte gösterildiği gibi , std::vector bunu sağlar. Ancak, kendi özel kapsayıcınız da dahil olmak üzere aynı sözleşmeyi yerine getiren herhangi bir kapsayıcıyı döndürebilirsiniz.

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 };
};

Bunlar, C++/WinRT'nin özel koleksiyonları uygulamanıza yardımcı olmak için sağladığı temel sınıflardır.

winrt::vector_view_base

Yukarıdaki kod örneklerine bakın.

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 }
    };
};

Önemli API'ler

  • Last updated on