Microsoft delivered Windows 10 SDK Preview Build 17713 to be used in conjunction with at least Insider Build 17713. This package includes bug fixes moreover under development modifications to the API surface area.
You can get the current Preview SDK from the developer field on Windows Insider. Microsoft addresses developers to navigate to Windows Platform UserVoice and give feedback. Windows 10 SDK Preview Build 17713 performs on Visual Studio 2017. You can get this software development kit and further submit your applications to the target Windows 10 April 2018 update 1803 or earlier editions to the Store.
Windows 10 SDK Preview Build 17713 –
Windows 10 SDK Preview Build 17713 Details of changes and fixes
C++/WinRT Update for Windows 10 SDK Preview Build 17713
This update comes up with lots of changes and fixes for C++/WinRT. Most important, it starts the ability to build C++/WinRT without a dependency on SDK. Windows 10 SDK Preview Build 17713 does not carry Windows headers to make it interesting to the OS developer in addition to the OS repository. In this way, a developer will typically pull in a small number or no dependencies even inattentively. This also means a substantial decrease in the number of macros that a C++/WinRT developer must be cautious against. Lessening the dependency on the Windows headers indicates that C++/WinRT is additionally portable and standards compliant, and ahead their endeavor to make it a cross-compiler furthermore cross-platform library. So macros can never mangle the C++/WinRT headers. If you earlier were involved in C++/WinRT to include different Windows headers you will now need to do the same them manually.
Significant points of Windows 10 SDK Preview Build 17713
Support get_strong and get_weak to create delegates
Windows 10 SDK Preview Build 17713 permits developers to use either get_strong or get_weak replacing a raw this pointer at the time of creating a delegate pointing to a member function.
Include async cancellation callback:
The often requested feature for C++/WinRT coroutine support is the enhancement of a cancellation callback.
Simplify the use of APIs expecting IBuffer parameters
However, major APIs prefer group or arrays, adequate APIs rely on IBuffer that it should be simpler to use such APIs from C++. The current update gives straight access to the data behind an IBuffer implementation with the same data naming convention used by the C++ standard library containers. The feature also prevents colliding with metadata names that conventionally start with uppercase letters.
Enhanced support for Clang moreover Visual C++ stricter conformance modes.
Changed code gen
Various changes to decrease code size, improve inlining, along with optimizing factory caching.
Remove unnecessary recursion
When you run a command line it refers to a folder instead of a particular winmd, cppwinrt will not search recursively in future for winmd files. It creates performance issues in the build and can cause usage problems and detecting that is troublesome when developers unintentionally cause cppwinrt to consume more winmds than expected. The cppwinrt compiler also now controls duplicates with higher intelligence, amplifying resilient to user error and poorly-formed winmd files.
Declare both WINRT_CanUnloadNow moreover WINRT_GetActivationFactory in base.h: Callers don’t require declaration pronto. Their signatures have also modified, amounting to a breaking change. The declarations decrease most of the troubles of this change. Because C++/WinRT will not depend on the Windows headers the dependency has been removed from the Windows headers so this was a requirement.
Strengthen smart pointers
There was a problem as the event revokers even were unable to revoke when move-assigned a new value. So the SDK team has researched the smart pointer classes carefully noticed that they were not reliably handling self-assignment. Mostly other rely on com_ptr class template and here it is rooted. They corrected com_ptr and updated the event revokers to control move semantics properly to confirm that they revoke upon assignment. The team also indurated handle class template by the elimination of the implicit constructor that made incorrect code writing simple. This also caused bugs in the OS into compiler errors setlled down in this PR.
Support for non-WinRT interfaces is turned off by default. To enable, only use #include <unknwn.h> prior to a C++/WinRT headers.
in the current build, winrt::get_abi(winrt::hstring) returns void* replacing HSTRING. Code requiring the HSTRING ABI can only utilize a static_cast.
in addition, winrt::put_abi(winrt::hstring) returns void** as a substitute of HSTRING*. Code that requires the HSTRING ABI can use a reinterpret_cast.
HRESULT is onward projected as winrt::hresult. Code requiring an HRESULT can just static_cast when you want to type checking or support type traits, but it is differently convertible as long as <unknwn.h> is included first.
GUID is further projected as winrt::guid. Code implementing APIs with GUID parameters will run winrt::guid, but it is differently convertible while <unknwn.h> is included first.
The signatures of “WINRT_CanUnloadNow” and “WINRT_GetActivationFactory” has modified. Code will not declare these functions at any cost and but include winrt/base.h to include their declarations.
The winrt::handle constructor is onward explicit. Code assigning a raw handle value will call the attach method.
winrt::clock::from_FILETIME is now deprecated. Code should use winrt::clock::from_file_time alternatively.
Changes in Windows 10 SDK Preview Build 17713
From Windows 10 SDK Preview Build 17713, you are able to package your applications as MSIX. Later the applications can be installed and run on the system containing at least build 17682 build.
For this purpose, you need to use the MakeAppx tool. Simply click on the MSIX file and it will be got installed. To learn more about MSIX, have a look at this introductory video: link
MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.
In Windows 10 SDK Preview Build 17713, they have made certain significant modifications to the C/C++ ETW code generation of mc.exe –
“-mof” parameter is gone deprecated. This parameter give instructions to MC.exe (Message Compiler) to create ETW code that is supporting with Windows XP and former. The “-mof” parameter support will end in a coming edition of mc.exe.
While the “-mof” parameter does not run, the generated C/C++ header is onward compatible with kernel-mode as well as user-mode, This does not care whether “-km” or “-um” was specified on the command line. The header will utilize the _ETW_KM_ macro and itself determine whether it is being compiled for either kernel-mode or user-mode. This will call the appropriate ETW APIs for every mode.
“-km” and “-um” have one dissimilarity and this is EventWrite[EventName] macros generated with “-km” includes an Activity ID parameter and the other doesn’t.
The EventWrite[EventName] macros works as a default onward to calling EventWriteTransfer (user mode) or EtwWriteTransfer (kernel mode).
The generated header now supports multiple customization macros. As an instance, you can use the MCGEN_EVENTWRITETRANSFER macro if you require the generated macros to call anything different from EventWriteTransfer.
The manifest supports fresh attributes.
Event “name”: non-localized event name.
Event “attributes”: additional key-value metadata for an event, for instance, filename, line number, component name, function name.
Event “tags”: 28-bit value including user-defined semantics (per-event).
Field “tags”: 28-bit value plus user-defined semantics (per-field – can be put in an application for “data” or “struct” elements).
You are able to define onward “provider traits” in the manifest (e.g. provider group). If you utilize provider traits in the manifest, the EventRegister[ProviderName] macro will itself register them.
MC will onward report an error if a localized message file is missing a string.
The MC can now create “utf-8” and “utf-16” output using the “-cp utf-8” or “-cp utf-16” parameters.
Known Issues in Windows 10 SDK Preview Build 17713
One issue is SDK headers are generated using types in the ABI namespace. Microsoft has done this to stay away from conflicts with C++/CX and C++/WinRT clients that require to consuming types straight at the ABI layer. With the built-in setting, types emitted by MIDL are *not* put in the ABI namespace, although, this has the capability to produce conflicts from teams trying to consume ABI types from Windows WinRT MIDL and non-Windows WinRT MIDL generated headers. This is particularly difficult if the non-Windows header references Windows types.
To confirm that developers have a sequential view of the WinRT API surface, validation has been included in the generated headers to make sure that the ABI prefix is consistent between the Windows headers moreover user generated headers. If you find an error such as:
“5>c:\program files (x86)\windows kits\10\include\10.0.17687.0\winrt\windows.foundation.h(83)”:” error C2220:” warning treated as error – no ‘object’ file generated
“5>c:\program files (x86)\windows kits\10\include\10.0.17687.0\winrt\windows.foundation.h(83):” “warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition”
“5>g:\<PATH TO YOUR HEADER HERE>(41): note: see previous definition of CHECK_NS_PREFIX_STATE”
It indicates that certain your MIDL generated headers are inconsistent with the system generated headers.
2 methods exist to fix this –
Use this one as a preference – Compile your IDL file accompanied by the /ns_prefix MIDL command line switch. This will lead to all your types to be moved to the ABI namespace consistent with the Windows headers. This may need code modifications, although.
Otherwise – Add #define DISABLE_NS_PREFIX_CHECKS before adding the Windows headers. This will suppress the validation.
API Updates, Additions and Removals
If you are targeting new APIs, think about writing app to be adaptive for the purpose of running properly on the maximum number of Windows 10 devices.
Download Windows 10 SDK Preview Build 17713 from here
Source – Windows Developer blog