The Windows Runtime API design guidelines recommend that methods accept iterables rather than specific collections where possible. This allows clients to pass any iterable collection of their choosing, or possibly no collection at all (like a LINQ query).<\/p>\n
The generalization rules are:<\/p>\n
IIterable<T><\/code>.<\/li>\n- Maps from K to V are accepted as
IIterable<IKeyValuePair<K, V>><\/code>.<\/li>\n<\/ul>\nThis works out well in practice because iterable collections support IIterable<\/code>, so you can just pass the collection, and the language projection will pass the IIterable<\/code> to the method.<\/p>\nThings get a little weirder if you want to pass a collection of collections. For example, suppose you have a method which wants to accept an array of maps.<\/p>\n
void Something(IVector<IMap<String, String>> attributesArray);\r\n<\/pre>\nApplying the above guidance means that your method looks like this:<\/p>\n
void Something(IIterable<IIterable<IKeyValuePair<String, String>>> attributesArray);\r\n<\/pre>\nC# supports covariance, but C++ does not. This means that in C#, you can say<\/p>\n
var v = new[] {\r\n new Dictionary<string, string> { [\"foo\"] = fooValue },\r\n new Dictionary<string, string> { [\"bar\"] = barValue },\r\n };\r\n var result = Something(v);\r\n<\/pre>\nand the language lets you pass an IEnumerable<Dictionary<string, string>><\/code> instead of an IEnumerable<IEnumerable<IKeyValuePair<string, string>>><\/code>.<\/p>\nC++ does not support covariance. If you try the equivalent C++, it fails.<\/p>\n
\/\/ C++\/CX\r\n using AttributeMap = Map<String^, String^>;\r\n AttributeMap^ v[2] = {\r\n ref new AttributeMap{ { \"foo\", fooValue } },\r\n ref new AttributeMap( { \"bar\", barValue } },\r\n };\r\n auto result = Something(v); \/\/ does not compile\r\n\r\n\/\/ C++\/WinRT\r\n using AttributeMap = IMap<hstring, hstring>;\r\n AttributeMap v[2] = {\r\n single_threaded_map(std::map<hstring, hstring>{ { L\"foo\", fooValue } },\r\n single_threaded_map(std::map<hstring, hstring>{ { L\"bar\", barValue } },\r\n };\r\n auto result = Something(v); \/\/ does not compile\r\n<\/pre>\nYou have to misdeclare the inner maps as iterables.<\/p>\n
\/\/ C++\/CX\r\n using AttributeMap = Map<String^, String^>;\r\n using IAttributeIterable = Iiterable<IKeyValuePair<String^, String^>>;<\/span>\r\n auto d1 = ref new AttributeMap{ { \"foo\", fooValue } };\r\n auto d2 = ref new AttributeMap( { \"bar\", barValue } };\r\n auto v = ref new Vector<IAttributeIterable<\/span>>({ d1, d2 });\r\n auto result = Something(v);\r\n\r\n\/\/ C++\/WinRT\r\n using IAttributeIterable = IIterable<IKeyValuePair<hstring, hstring>>;<\/span>\r\n auto v = std::vector<IAttributeIterable<\/span>>({\r\n std::map<hstring, hstring>({ { L\"foo\", fooValue } }),\r\n std::map<hstring, hstring>({ { L\"bar\", barValue } }),\r\n });\r\n auto result = Something(v);\r\n<\/pre>\nFortunately, C++\/WinRT gives you a bit of help. The winrt::params<\/code> namespace lets you write<\/p>\n auto d1 = std::map<hstring, hstring>({ { L\"foo\", fooValue } });\r\n auto d2 = std::map<hstring, hstring>({ { L\"bar\", barValue } });\r\n auto result = Something({ d1, d2 });\r\n<\/pre>\nAnd the appropriate conversions will happen. So C++\/WinRT is roughly on par with C#. C++\/CX is kind of awkward though. Sorry, C++\/CX.<\/p>\n