C++/WinRT is designed to give C++ developers uncompromising performance as well as amazing productivity. Come and learn how to make effective use of C++ for the most demanding projects, whether it’s a system component, desktop or console app, or UWP app. In this session, we’ll also walk you through our early support for creating a XAML application in standard C++ and provide tips and guidance on how to move your C++/CX code to use standard C++ with C++/WinRT.

4. The Modern class-based, Object-oriented Windows API
Plus metadata about the classes/members
Plus language projections for natural and familiar use
• C++, C#, JavaScript, others

6. Use any Windows Runtime class as if it were a standard C++ class
Implement a Windows Runtime class using standard C++
Create XAML applications using standard C++ (Preview)

8. Uri "http://aka.ms/cppwinrt" // URI to fetch
HttpClient // Class that does the fetching
auto // Make async call & wait
// Display the page

9. // Uri uri(L"http://aka.ms/cppwinrt");
ComPtr IUriRuntimeClassFactory
THROW_IF_FAILED
ComPtr IUriRuntimeClass
THROW_IF_FAILED
"http://aka.ms/cppwinrt"
For this statement
You must write this code

10. #include
#include
using namespace
using namespace
int
Uri ref new "http://aka.ms/cppwinrt"
HttpClient ref new HttpClient
auto
79,360 bytes (x86 release)

11. #include
#include
#include
using namespace
using namespace
int
Uri "http://aka.ms/cppwinrt"
HttpClient
auto
23,522 bytes (x86 release)
70% smaller than CX

13. •
•
•

14. http://marketplace.visualstudio.com

16. m_ptr
winrt::Windows::Foundation::Uri

17. Without C++/WinRT
Visual Studio
Extension installed

18. With C++/WinRT
Visual Studio
Extension installed

21. Build
Add reference to
Microsoft.Graphics.Canvas.winmd
winrtMicrosoft.Graphics.Canvas.*.h

23. winmd reference

24. #include
using namespace
// Creates all the thumbnail previews for effect selection UI
void DetailPage
SepiaEffect
L"source"

26. Build
Class description Skeletal implementations
• Generated FilessourcesPhoto.h
• Generated FilessourcesPhoto.cpp
Complete base class Metadata file
• Photo.g.h Photo.winmd
Copy skeletons to project folder
Include in project
Photo.idl

27. namespace
delegate void Boolean // delegate type for event
runtimeclass Photo Windows.UI.Xaml.Data.INotifyPropertyChanged // Interface
// Constructors
Windows.Storage.StorageFile
String get // Read-only property
Single // Read-write property
Windows.Foundation.IAsyncAction // (Async) Method
event RecognitionHandler // event

28. namespace {
struct Photo PhotoT Photo
default
StorageFile const
hstring
float
void float
void
event_token PropertyChangedEventHandler const
void event_token const
Implementation namespace
Base implements WinRT
infrastructure (Photo.g.h)
Photo.h

29. m_ptr
winrt::PhotoEditor::Photo
winrt::PhotoEditor::implementation::Photo

30. Build
Photo.winmd
PhotoEditor.Photo
Video.winmd
PhotoEditor.Video
Effects.winmd
PhotoEditor.Effects
PhotoEditor.winmd
PhotoEditor.Photo
PhotoEditor.Video
PhotoEditor.Effects
Namespace metadata

32. Build
Class description
Skeletal implementations – code behind files
• Generated FilessourcesMainPage.h
• Generated FilessourcesMainPage.cpp
Complete base classes Metadata file
• MainPage.xaml.g.h MainPage.winmd
MainPage.g.h
MainPage.xaml
Copy skeletons to project folder
Include in project
MainPage.idl
XAML markup

33. "MainPage.g.h"
namespace
struct MainPage MainPageT MainPage
// Property changed notifications
event_token
PropertyChangedEventHandler const
void event_token const
Implementation namespace
Bases implements WinRT
infrastructure
MainPage.xaml.g.h
MainPage.g.h

36. 1. Type: x64
2. Press Enter or select

38. Where is the C++ compiler?
Where is the C++/WinRT compiler?

39. #include <stdio.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt;
int main()
{
init_apartment();
Windows::Foundation::Uri uri(L"https://microsoft.com/build");
printf("Welcome to %ls!n", uri.Path().c_str());
}

40. Brevity please
C++ exception handling
ISO C++17 standard
External references
Add /await for C++ coroutine support

41. #include <stdio.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt;
int main()
{
init_apartment();
Windows::Foundation::Uri uri(L"https://microsoft.com/build");
printf("Welcome to %ls!n", uri.Path().c_str());
}
Where does
this come from?

45. 1 of 15

46. Uri uri(L"http://kennykerr.ca/feed");
SyndicationClient client;
auto async = client.RetrieveFeedAsync(uri);
SyndicationFeed feed = async;
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
IAsyncOperationWithProgress<SyndicationFeed, RetrievalProgress>
error C2440: cannot convert from ...

47. Uri uri(L"http://kennykerr.ca/feed");
SyndicationClient client;
auto async = client.RetrieveFeedAsync(uri);
SyndicationFeed feed = async.get();
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
Blocks while
waiting for result

48. 2 of 15

49. Uri uri(L"http://kennykerr.ca/feed");
SyndicationClient client;
SyndicationFeed feed = client.RetrieveFeedAsync(uri).get();
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
What about UI
responsiveness?

50. Uri uri(L"http://kennykerr.ca/feed");
SyndicationClient client;
SyndicationFeed feed = co_await client.RetrieveFeedAsync(uri);
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
Remove trailing .get()
Prepend co_await

51. IAsyncAction PrintFeedAsync()
{
Uri uri(L"http://kennykerr.ca/feed");
SyndicationClient client;
SyndicationFeed feed = co_await client.RetrieveFeedAsync(uri);
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
}
Don’t forget the
coroutine return type

52. 3 of 15

53. IAsyncAction PrintFeedAsync(Uri const& uri)
{
SyndicationClient client;
auto feed = co_await client.RetrieveFeedAsync(uri);
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
}
DANGER!
Suspension point

54. IAsyncAction PrintFeedAsync(Uri uri)
{
SyndicationClient client;
auto feed = co_await client.RetrieveFeedAsync(uri);
for (auto&& item : feed.Items())
{
printf("%lsn", item.Title().Text().c_str());
}
}
Captured by value - great!

55. void PrintFeed(Uri const& uri)
{
SyndicationClient client;
auto feed = client.RetrieveFeedAsync(uri).get();
// ...
}
IAsyncAction PrintFeedAsync(Uri uri)
{
SyndicationClient client;
auto feed = co_await client.RetrieveFeedAsync(uri);
// ...
}
Function
• Synchronous
• Use const& params
Coroutine
• Asynchronous
• Use value params

56. 4 of 15

57. hstring ToUpper(hstring const& value);

58. hstring ToUpper(hstring const& value);
int main()
{
std::wstring std_wstring = L"Oranges";
hstring winrt_hstring = L"Apples";
printf("%lsn", ToUpper(winrt_hstring).c_str());
printf("%lsn", ToUpper(std_wstring).c_str());
printf("%lsn", ToUpper(L"Bananas").c_str());
}
Literals should just work

59. hstring ToUpper(hstring const& value);
int main()
{
std::wstring std_wstring = L"Oranges";
hstring winrt_hstring = L"Apples";
printf("%lsn", ToUpper(winrt_hstring).c_str());
printf("%lsn", ToUpper(hstring(std_wstring)).c_str());
printf("%lsn", ToUpper(L"Bananas").c_str());
}
Hidden copies…

60. // Generated code...
hstring ToUpper(param::hstring const& value);
// Your code...
int main()
{
std::wstring std_wstring = L"Oranges";
hstring winrt_hstring = L"Apples";
printf("%lsn", ToUpper(winrt_hstring).c_str());
printf("%lsn", ToUpper(std_wstring).c_str());
printf("%lsn", ToUpper(L"Bananas").c_str());
}
param::* types
optimize input
binding
This just works
and avoids copies

61. 5 of 15

62. int Sum(IVectorView<int> const& values);

63. int Sum(IVectorView<int> const& values);
int main()
{
std::vector<int> std_vector{ 2,3,4 };
IVectorView<int> winrt_vector = ...
assert(9 == Sum(winrt_vector));
assert(9 == Sum(std_vector));
assert(9 == Sum({ 2, 3, 4 }));
}
Initializer lists should just work

64. // Generated code...
int Sum(param::vector_view<int> const& values);
// Your code...
int main()
{
std::vector<int> std_vector{ 2,3,4 };
IVectorView<int> winrt_vector = ...
assert(9 == Sum(winrt_vector));
assert(9 == Sum(std_vector));
assert(9 == Sum({ 2, 3, 4 }));
}
Optimizes
input binding
This just works
and avoids copies

65. 6 of 15

66. // Generated code...
IAsyncOperation<int> SumAsync(param::async_vector_view<int> const& values);
// Your code...
int main()
{
std::vector<int> std_vector{ 2,3,4 };
IVectorView<int> winrt_vector = ...
assert(9 == SumAsync(winrt_vector).get());
assert(9 == SumAsync(std_vector).get());
assert(9 == SumAsync({ 2, 3, 4 }).get());
}
Constrained
for async input

67. IAsyncOperation<int> SumAsync(param::async_vector_view<int> const& values);
int main()
{
std::vector<int> std_vector{ 2,3,4 };
IVectorView<int> winrt_vector = ...
assert(9 == SumAsync(winrt_vector).get());
assert(9 == SumAsync(std::move(std_vector)).get());
assert(9 == SumAsync({ 2, 3, 4 }).get());
} Transfer ownership

68. 7 of 15

69. IAsyncOperation<uint32_t> ComputeAsync()
{
for (uint32_t y = 0; y < height; ++y)
for (uint32_t x = 0; x < width; ++x)
{
// Some compute-bound operation...
}
co_return 123;
} What’s the problem?

70. IAsyncOperation<uint32_t> ComputeAsync()
{
co_await resume_background();
for (uint32_t y = 0; y < height; ++y)
for (uint32_t x = 0; x < width; ++x)
{
// Some compute-bound operation...
}
co_return 123;
}
Returns control to caller
Immediately resumes
on thread pool

71. 8 of 15

72. IAsyncAction Async(TextBlock block)
{
co_await resume_background();
// Some compute-bound operation...
block.Text(L"Done!");
}
hresult_wrong_thread
Switch to thread pool

73. IAsyncAction Async(TextBlock block)
{
apartment_context ui_thread;
co_await resume_background();
// Some compute-bound operation...
co_await ui_thread;
block.Text(L"Done!");
}
Capture calling context
Switch to thread pool
Switch back to calling context
Update UI successfully!

74. 9 of 15

75. IAsyncAction Async(TextBlock block)
{
apartment_context ui_thread;
co_await resume_background();
// Some compute-bound operation...
co_await ui_thread;
block.Text(L"Done!");
}
Really?

76. IAsyncAction Async(TextBlock block)
{
co_await resume_background();
// Some compute-bound operation...
co_await resume_foreground(block.Dispatcher());
block.Text(L"Done!");
}
Switch to thread pool
Switch to dispatcher thread

77. 10 of 15

78. using namespace Windows::Foundation;
int main()
{
IStringable s = ...
printf("%lsn", s.ToString().c_str());
}
Windows::Foundation::IStringable
hstring ToString();

79. using namespace Windows::Foundation;
struct MyType : implements<MyType, >
{
};
int main()
{
IStringable s = ...
printf("%lsn", s.ToString().c_str());
}
Interfaces to implement
Implementation goes here

80. using namespace Windows::Foundation;
struct MyType : implements<MyType, IStringable>
{
hstring ToString() { return L"Hello world"; }
};
int main()
{
IStringable s = ...
printf("%lsn", s.ToString().c_str());
}

81. using namespace Windows::Foundation;
struct MyType : implements<MyType, IStringable>
{
hstring ToString() { return L"Hello world"; }
};
int main()
{
IStringable s = make<MyType>();
printf("%lsn", s.ToString().c_str());
}
Construct implementation
type on heap
Return projected type

82. using namespace Windows::Foundation;
struct MyType : implements<MyType, IStringable, IClosable>
{
hstring ToString() { return L"Hello world"; }
void Close() { /* Goodbye world */ }
};
int main()
{
IStringable s = make<MyType>();
printf("%lsn", s.ToString().c_str());
IClosable c = s.as<IClosable>();
c.Close();
}
Add interfaces
Add implementation
You’re done,
this works!

83. 11 of 15

84. using namespace Windows::Foundation::Collections;
template <typename T>
struct MyCollection : implements<MyCollection<T>, IVector<T>, IIterable<T>>
{
T GetAt(uint32_t const index);
uint32_t Size();
IVectorView<T> GetView();
void SetAt(uint32_t const index, T const& value);
void InsertAt(uint32_t const index, T const& value);
void RemoveAt(uint32_t const index);
void Append(T const& value);
void RemoveAtEnd();
void Clear();
uint32_t GetMany(uint32_t startIndex, array_view<T> values);
void ReplaceAll(array_view<T const> value);
IIterator<T> First();
};
Phew…

85. IVector<int> vector = single_threaded_vector<int>();
vector.Append(1);
vector.Append(2);
vector.Append(3);
for (auto&& value : vector)
{
printf("%d ", value);
}
IVectorView<int> view = vector.GetView();
Create general-purpose
implementation
Use IVector<T> interface
Get IVectorView<T> from IVector<T>

86. std::vector<int> values{ 1,2,3 };
auto vector = single_threaded_vector<int>(std::move(values));
for (auto&& value : vector)
{
printf("%d ", value);
}
“1 2 3”…

87. IVector<int> a =
single_threaded_vector<int>();
IMap<hstring, int> b =
single_threaded_map<hstring, int>();
IObservableVector<int> c =
single_threaded_observable_vector<int>();
IObservableMap<hstring, int> d =
single_threaded_observable_map<hstring, int>();

88. 12 of 15

89. using namespace Windows::Foundation;
EventHandler<int> handler;
handler = [](auto&& /*sender*/, int args)
{
printf("%dn", args);
};
if (handler)
{
IInspectable sender = ...;
handler(sender, 123);
}
Initially empty
Initialize or assign using:
• Lambda
• Free function
• Member function
Check validity
Invoke delegate

90. 13 of 15

91. IObservableVector<int> v = single_threaded_observable_vector<int>();
v.VectorChanged([](auto&& /*sender*/, auto&& /*args*/)
{
printf("Changedn");
});
v.Append(123);
VectorChanged(VectorChangedEventHandler<T> const&)
Invokes handler(s)

92. IObservableVector<int> v = ...
event_token token = v.VectorChanged([](auto&&, auto&&)
{
printf("Changedn");
});
v.Append(123);
v.VectorChanged(token);
v.Append(234);
64-bit token
Manually revoke handler
Invoke handler
Handler is not called

93. IObservableVector<int> v = ...
auto revoker = v.VectorChanged(auto_revoke, [](auto&&, auto&&)
{
printf("Changedn");
});
v.Append(123);
revoker.revoke();
Create auto-revoker
Includes weak reference to event source
Revoke handler if event source still exists
Destructor also calls revoke

94. 14 of 15

95. struct MyCollection : implements<MyCollection, IObservableVector<int>, ...>
{
event_token VectorChanged(VectorChangedEventHandler<int> const& handler)
{
return m_changed.add(handler);
}
void VectorChanged(event_token const token)
{
m_changed.remove(token);
}
event<VectorChangedEventHandler<int>> m_changed;
};
Just use event<T>
The delegate type
Adds handler to event array
Removes handler from array

96. 15 of 15

97. event<delegate<std::string, int, float>> changed;
changed.add([](std::string const& a, int b, float c)
{
printf("%s %d %.2fn", a.c_str(), b, c);
});
changed("Hello", 123, .456f);
changed("World", 456, .789f);
delegate<T…>
Non-WinRT types are fine
Doesn’t provide an ABI

98. Ask on stackoverflow using tag [c++-winrt]
https://aka.ms/cppwinrt/stackoverflow

99. https://www.visualstudio.com/downloads/
https://go.microsoft.com/fwlink/?linkid=870807
https://marketplace.visualstudio.com
https://aka.ms/PhotoEditorSample
https://aka.ms/cppwinrt
https://aka.ms/cppwinrt/api