{"id":96515,"date":"2017-07-03T07:00:00","date_gmt":"2017-07-03T21:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=96515"},"modified":"2019-03-13T01:13:43","modified_gmt":"2019-03-13T08:13:43","slug":"20170703-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20170703-00\/?p=96515","title":{"rendered":"Emulating the C# using<\/CODE> keyword in C++"},"content":{"rendered":"

C# has a very convenient using<\/code> statement which ensures that an object is Dispose()<\/code>d when control exits the block. C++ has a generalization of this concept with RAII types, but things get tricky when you have tasks, lambda capture, and the need to explicitly Close()<\/code> the hat pointer. <\/p>\n

Here we go. <\/p>\n

Here’s one attempt, for C++\/CX hat pointers: <\/p>\n

\ntemplate<typename T>\nclass unique_close\n{\npublic:\n  unique_close(T^ t) : m_t(t) { }\n  ~unique_close() { delete m_t; }\n\n  \/\/ Disallow copying\n  unique_close(const unique_close& other) = delete;\n  unique_close& operator=(const unique_close& other) = delete;\n\n  \/\/ Moving transfers the obligation to Close\n  unique_close(unique_close&& other)\n  {\n    *this = std::move(other);\n  }\n  unique_close& operator=(unique_close&& other)\n  {\n    using std::swap; \/\/ enable ADL on the swap\n    swap(m_t, other.m_t);\n    return *this;\n  }\n\nprivate:\n  T^ m_t;\n};\n\ntemplate<typename T>\nauto make_unique_close(T^ t)\n{\n  return unique_close<T>(t);\n}\n<\/pre>\n
With explicit task chaining, you need to remember to use std::<\/code>move<\/code> to move the unique_close<\/code> object into the final task in the chain if you didn’t construct it directly in the capture. If you forget to do this, then the destruction of the unique_close<\/code> objects in the main function will close the objects prematurely because they are still in control. <\/p>\n
\nvoid Scenario1_Render::ViewPage()\n{\n    ...\n\n    if (outfile)\n    {\n        auto page = pdfDocument->GetPage(pageIndex);\n\n        return create_task(outfile->OpenTransactedWriteAsync())\n            .then([this, page, usingPage{make_unique_close(page)}<\/font>]\n                  (StorageStreamTransaction^ transaction) mutable<\/font>\n        {\n            auto options = ref new PdfPageRenderOptions();\n            options->DestinationHeight = (unsigned)(page->Size.Height * 2);\n            options->DestinationWidth = (unsigned)(page->Size.Width * 2);\n            create_task(page->RenderToStreamAsync(transaction->Stream, options))\n                .then([this, usingPage{std::move(usingPage)},\n                       usingTransaction{make_unique_close(transaction)}<\/font>]() mutable<\/font>\n            {\n                \/\/ destruction of usingPage and usingTransaction\n                \/\/ will close the page and transaction.<\/font>\n            });\n        });\n    }\n    ...\n}\n<\/pre>\n
(Let us ignore the fact that this doesn’t work because task::<\/code>then<\/code> requires a copyable lambda, and ours is merely movable.) <\/p>\n
One way to address the added cognitive burden of having to remember to keep moving<\/a> the obligation to close is to share that obligation, so that only when the last shared reference is destructed does the object get closed. <\/p>\n
\ntemplate<typename T>\nclass ensure_close\n{\npublic:\n  ensure_close(T^ t) : m_t(t) { }\n  ~ensure_close() { delete m_t; }\n\n  \/\/ Disallow copying and moving\n  ensure_close(const ensure_close& other) = delete;\n  ensure_close& operator=(const ensure_close& other) = delete;\n  ensure_close(const ensure_close&& other) = delete;\n  ensure_close& operator=(const ensure_close&& other) = delete;\n\nprivate:\n  T^ m_t;\n};\n\ntemplate<typename T>\nusing shared_close = std::shared_ptr<ensure_close<T>>;\n\ntemplate<typename T>\nauto make_shared_close(T^ t)\n{\n  return std::make_shared<ensure_close<T>>(t);\n}\n<\/pre>\n
Now you can copy the shared_close<\/code> around, and only when the last copy is destructed does the wrapped hat pointer get closed.¹ <\/p>\n
\nvoid Scenario1_Render::ViewPage()\n{\n    ...\n\n    if (outfile)\n    {\n        auto page = pdfDocument->GetPage(pageIndex);\n        auto usingPage = make_shared_close(page);<\/font>\n\n        return create_task(outfile->OpenTransactedWriteAsync())\n            .then([this, page, usingPage<\/font>]\n                  (StorageStreamTransaction^ transaction)\n        {\n            auto usingTransaction = make_shared_close(transaction);<\/font>\n            auto options = ref new PdfPageRenderOptions();\n            options->DestinationHeight = (unsigned)(page->Size.Height * 2);\n            options->DestinationWidth = (unsigned)(page->Size.Width * 2);\n            return create_task(page->RenderToStreamAsync(transaction->Stream, options))\n                .then([this, usingPage, usingTransaction<\/font>]()\n            {\n                \/\/ destruction of the last shared usingPage\n                \/\/ and usingTransaction will close the page and transaction.<\/font>\n            });\n        });\n    }\n    ...\n}\n<\/pre>\n
Still, you have to remember to keep passing the usingPage<\/code> and usingTransaction<\/code> around. If you forget, then the object gets closed prematurely. (And if the shared_close<\/code> is created by one lambda and consumed by a sibling lambda, well you now have a shared_ptr<\/code> to a shared_close<\/code><\/a>, which is getting ridiculous.) <\/p>\n
But wait, you can stop the madness. <\/p>\n
Let’s go back to unique_close<\/code>: This class becomes much more convenient if you use the co_await<\/code> keyword, because the compiler will do the heavy lifting of cleaning up when the last task has completed.² <\/p>\n
\ntask<void> Scenario1_Render::ViewPageAsync()\n{\n    ...\n\n    if (outfile)\n    {\n        auto page = pdfDocument->GetPage(pageIndex);\n        auto usingPage = make_unique_close(page);<\/font>\n\n        auto transaction =\n            co_await outfile->OpenTransactedWriteAsync();\n        auto usingTransaction = make_unique_close(transaction);<\/font>\n        auto options = ref new PdfPageRenderOptions();\n        options->DestinationHeight = (unsigned)(page->Size.Height * 2);\n        options->DestinationWidth = (unsigned)(page->Size.Width * 2);\n        co_await page->RenderToStreamAsync(transaction->Stream, options);\n        \/\/ destruction of usingPage and usingTransaction\n        \/\/ will close the page and transaction.<\/font>\n    }\n    ...\n}\n<\/pre>\n
We have offloaded all the thinking to the compiler. The compiler will do the work of making sure that the unique_close<\/code> objects are destructed when control leaves the block. The unique_close<\/code> objects will remain alive during the co_await<\/code> statements, which is what we want. <\/p>\n
We could make our unique_close<\/code> a little fancier by making it a little more unique_ptr<\/code>y. <\/p>\n
\ntemplate<typename T>\nclass unique_close\n{\npublic:\n  unique_close(T^ t) : m_t(t) { }\n  ~unique_close() { delete m_t; }\n\n  T^ get() { return m_t; }\n  T^ operator*() { return m_t; }\n  T^ operator->() { return m_t; }<\/font>\n  ...\n};\n<\/pre>\n
This leaves us with <\/p>\n
\ntask<void> Scenario1_Render::ViewPageAsync()\n{\n    ...\n\n    if (outfile)\n    {\n        auto page = make_unique_close(<\/font>\n             pdfDocument->GetPage(pageIndex))<\/font>;\n        auto transaction = make_unique_close(<\/font>\n            co_await outfile->OpenTransactedWriteAsync())<\/font>;\n        auto options = ref new PdfPageRenderOptions();\n        options->DestinationHeight = (unsigned)(page->Size.Height * 2);\n        options->DestinationWidth = (unsigned)(page->Size.Width * 2);\n        co_await page->RenderToStreamAsync(transaction->Stream, options);\n        \/\/ destruction of page and transaction\n        \/\/ will close the page and transaction.<\/font>\n    }\n    ...\n}\n<\/pre>\n
That doesn’t seem so bad. Pretty close to C# but still in the spirit of C++.³ <\/p>\n
¹ You (and by “you” I mean “me”) would be sorely tempted to write this with a custom deleter instead. <\/p>\n
\nnamespace Details\n{\n  template<typename T>\n  struct close_deleter\n  {\n    void operator()(T^ t) { delete t; }\n  };\n}\n\ntemplate<typename T>\nauto make_shared_close(T^ t)\n{\n    return std::shared_ptr<T>(t, Details::close_deleter<T>());\n}\n<\/pre>\n
Except that this doesn’t work because std::shared_ptr<\/code> manages raw pointers, not hat pointers. <\/p>\n
² If you are a total crazy person, you might consider adding a boolean conversion operator to the unique_close<\/code>: <\/p>\n
\n...\n   operator bool() const { return true; }\n...\n<\/pre>\n
This appears to serve no purpose, but it lets you write this: <\/p>\n
\n\/\/ Oh my goodness what kind of craziness is about to happen?\n#define scope_using__(t, c) \\\n    if (auto _scope_using_##c##_ = make_unique_close(t))\n#define scope_using_(t, c) scope_using__(t, c) \n#define scope_using(t) scope_using(t, __COUNTER__)\n\ntask<void> Scenario1_Render::ViewPageAsync()\n{\n    ...\n\n    if (outfile)\n    {\n        auto page = pdfDocument->GetPage(pageIndex);\n        scope_using (page)\n        {<\/font>\n            auto transaction =\n                co_await outfile->OpenTransactedWriteAsync();\n            scope_using (transaction)\n            {<\/font>\n                auto options = ref new PdfPageRenderOptions();\n                options->DestinationHeight = (unsigned)(page->Size.Height * 2);\n                        options->DestinationWidth = (unsigned)(page->Size.Width * 2);\n                co_await page->RenderToStreamAsync(transaction->Stream, options);\n                \/\/ exiting the scope_using will close\n                \/\/ the corresponding objcts.<\/font>\n            }\n        }\n    }\n    ...\n}\n<\/pre>\n
This is a moral outrage. Let us never speak of this again<\/a>. <\/p>\n
³ If you wanted to be cute, you could rename make_unique_close<\/code> to Using<\/code>. <\/p>\n
\nauto page = Using<\/font>(pdfDocument->GetPage(pageIndex));\nauto transaction = Using<\/font>(co_await outfile->OpenTransactedWriteAsync());\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
The co_await enables new patterns.<\/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-96515","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
The co_await enables new patterns.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/96515","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=96515"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/96515\/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=96515"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=96515"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=96515"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}