{"id":104346,"date":"2020-10-08T07:00:00","date_gmt":"2020-10-08T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=104346"},"modified":"2020-10-08T06:26:26","modified_gmt":"2020-10-08T13:26:26","slug":"20201008-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20201008-00\/?p=104346","title":{"rendered":"An iterable of iterables: C# collections support covariance, but C++ collections do not"},"content":{"rendered":"

Collections in the C# language support covariance. Collections in the C++ language do not<\/a>.<\/p>\n

This means, for example, that if a function wants a collection of T<\/code>, C# lets you pass a collection of things that derive from T<\/code>, but C++ requires you to pass a collection of exactly T<\/code>.<\/p>\n

This can be confusing for methods that accept collections of collections. C++ will allow the outer collection to decay, but the objects inside the collection cannot. The Windows Runtime by convention accepts collections of T<\/code> in the form of an IIterable<T><\/code> (which projects into C# as of an IEnumerable<T><\/code>), so that you can pass anything that can produce a sequence of T<\/code> objects. It could be a std::vector<T><\/code> or a std::array<T><\/code> or even a SQL or LINQ query that produces a sequence of T<\/code> objects.<\/p>\n

But things get a little weird if you have a collection of collections, because C++ collections don’t support covariance.<\/p>\n

Before we look at covariance, let’s look at simple conversion. Suppose you have to pass an IIterable<Point><\/code> to a method like Ink\u00adManager.<\/code>Select\u00adWith\u00adPoly\u00adLine<\/code> which takes a parameter of type IIterable<Point><\/code>.<\/p>\n

\/\/ C#\r\nvar points = new List<Point> {\r\n        UpperLeftCorner, UpperRightCorner, LowerRightCorner, LowerLeftCorner\r\n    };\r\ninkManager.SelectWithPolyline(points);\r\n\r\n\/\/ C++\/CX\r\nauto points = ref new Vector<Point>({\r\n      UpperLeftCorner, UpperRightCorner, LowerRightCorner, LowerLeftCorner,\r\n});\r\ninkManager->SelectWithPolyline(points);\r\n\r\n\/\/ C++\/WinRT\r\nauto points = single_threaded_vector<Point>({\r\n      UpperLeftCorner, UpperRightCorner, LowerRightCorner, LowerLeftCorner,\r\n  });\r\ninkManager.SelectWithPolyline(points);\r\n<\/pre>\n
This works because List<T><\/code> is convertible to IEnumerable<T><\/code>, and Vector<T><\/code> is convertible to IIterable<T><\/code>. The conversion works one level deep.<\/p>\n
Now suppose you are implementing the UIElement.<\/code>Find\u00adSub\u00adElements\u00adFor\u00adTouch\u00adTargeting<\/code>:<\/p>\n
\/\/ C#\r\nvirtual override IEnumerable<IEnumerable<Point>> FindSubElementsForTouchTargeting();\r\n\r\n\/\/ C++\/CX\r\nvirtual IIterable<IIterable<Point>^>^ FindSubElementsForTouchTargeting() override;\r\n\r\n\/\/ C++\/WinRT\r\nIIterable<IIterable<Point>> FindSubElementsForTouchTargeting();\r\n<\/pre>\n
In C#, this is straightforward. You can have a list of lists:<\/p>\n
virtual override IEnumerable<IEnumerable<Point>> FindSubElementsForTouchTargeting()\r\n{\r\n  var polygon1 = new List<Point> {\r\n        UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n    };\r\n  var polygon2 = new List<Point> {\r\n        UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n    };\r\n  var results = new List<List<Point>> { polygon1, polygon2 };\r\n  return results;\r\n}\r\n<\/pre>\n
Thanks to covariance, a List<List<Point>><\/code> is compatible with IEnumerable<IEnumerable<Point>><\/code> because List<T><\/code> is compatible with IEnumeraable<T><\/code>, and IEnumeraable<T><\/code> is covariant in T<\/code>.<\/p>\n
C++ is not as lucky. The analogous code in C++\/CX would be something like this:<\/p>\n
virtual override IEnumerable<IEnumerable<Point>> FindSubElementsForTouchTargeting()\r\n{\r\n  auto polygon1 = ref new Vector<Point>({\r\n        UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n    });\r\n  auto polygon2 = ref new Vector<Point>({\r\n        UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n    });\r\n  auto results = ref new Vector<Vector<Point>>({ polygon1, polygon2 });\r\n  return results;\r\n}\r\n<\/pre>\n
And in C++\/WinRT:<\/p>\n
IIterable<IIterable<Point>> FindSubElementsForTouchTargeting()\r\n{\r\n  auto polygon1 = single_threaded_vector<Point>({\r\n        UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n    });\r\n  auto polygon2 = single_threaded_vector<Point>({\r\n        UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n    });\r\n  auto results = single_threaded_vector<IVector<Point>>({ polygon1, polygon2 });\r\n  return results;\r\n}\r\n<\/pre>\n
This code doesn’t work because there is no conversion from Vector<Vector<Point>^>^<\/code> to IIterable<IIterable<Point>^>^<\/code> (C++\/CX) or from IVector<IVector<Point>><\/code> to IIterable<IIterable<Point>><\/code> (C++\/WinRT). The automatic conversion gets you part way there, but it can’t convert the inner portion due to the lack of covariance.<\/p>\n\n\n\n\n\n\n\n\n
C++\/CX<\/th>\nC++\/WinRT<\/th>\n<\/tr>\n
Vector<\/span><<\/tt><\/td>\nVector<<\/tt><\/td>\nPoint>^>^<\/tt><\/td>\nIVector<\/span><<\/tt><\/td>\nIVector<\/tt><\/td>\n<Point>><\/tt><\/td>\n<\/tr>\n
\u2193<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u2193<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
IIterable<\/span><<\/tt><\/td>\nVector<\/span><<\/tt><\/td>\nPoint>^>^<\/tt><\/td>\nIIterable<\/span><<\/tt><\/td>\nIVector<\/span><\/tt><\/td>\n<Point>><\/tt><\/td>\n<\/tr>\n
\u00a0<\/td>\n\n
\u274c<\/div>\n
\u2193<\/div>\n<\/td>\n
\u00a0<\/td>\n\u00a0<\/td>\n\n
\u274c<\/div>\n
\u2193<\/div>\n<\/td>\n
\u00a0<\/td>\n<\/tr>\n
IIterable<\/span><<\/tt><\/td>\nIIterable<\/span><<\/tt><\/td>\nPoint>^>^<\/tt><\/td>\nIIterable<\/span><<\/tt><\/td>\nIIterable<\/span><<\/tt><\/td>\n<Point>><\/tt><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
You have to declare the inner portion exactly correctly the first time. The language isn’t going to help you.<\/p>\n
\/\/ C++\/CX\r\nvirtual override IEnumerable<IEnumerable<Point>> FindSubElementsForTouchTargeting()\r\n{\r\n  auto polygon1 = ref new Vector<Point>({\r\n        UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n    });\r\n  auto polygon2 = ref new Vector<Point>({\r\n        UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n    });\r\n  auto results = ref new Vector<IEnumerable<\/span><Point>>({ polygon1, polygon2 });\r\n  return results;\r\n}\r\n<\/pre>\n
And in C++\/WinRT:<\/p>\n
IIterable<IIterable<Point>> FindSubElementsForTouchTargeting()\r\n{\r\n  auto polygon1 = single_threaded_vector<Point>({\r\n        UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n    });\r\n  auto polygon2 = single_threaded_vector<Point>({\r\n        UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n    });\r\n  auto results = single_threaded_vector<IIterable<\/span><Point>>({ polygon1, polygon2 });\r\n  return results;\r\n}\r\n<\/pre>\n
You do lose the ability to index the results<\/code> and access the original vectors, since by the time you put them into the results<\/code>, they have been turned into IIterable<\/code>s.<\/p>\n
C++\/WinRT gives you a little help here. If the iterable of iterables is a parameter to a function, then you can let C++\/WinRT auto-generate the outer iterable, at which point the automatic conversions will kick in for the inner objects because the type is being explicitly specified by the parameter.<\/p>\n
extern void SomeMethod(winrt::param::iterable<\r\n    IIterable<Point>> const& elementOutlines);\r\n\r\nauto polygon1 = single_threaded_vector<Point>({\r\n      UpperLeftCorner1, UpperRightCorner1, LowerRightCorner1, LowerLeftCorner1,\r\n  });\r\nauto polygon2 = single_threaded_vector<Point>({\r\n      UpperLeftCorner2, UpperRightCorner2, LowerRightCorner2, LowerLeftCorner2,\r\n  });\r\nSomeMethod({ polygon1, polygon2 });\r\n<\/pre>\n
That wasn’t too messy.<\/p>\n","protected":false},"excerpt":{"rendered":"
You have to say exactly what you want, which may not be exactly what you have.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-104346","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
You have to say exactly what you want, which may not be exactly what you have.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/104346","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=104346"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/104346\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=104346"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=104346"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=104346"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}