Category Archives: PC

Auto Added by WPeMatico

Mixed Reality @ Microsoft – June 2018 Update – Windows Experience Blog

Recent Microsoft-Harvard Business Review survey shows 87 percent of respondents are currently exploring, piloting, or deploying mixed reality in their company.
Hey everyone — I hope this month’s blog post finds you well!
Today, we are welcoming the solstice in the U.S., and I am very much looking forward to summer in Seattle. In addition to some planned vacation time, I will also be working with our team and partners on some exciting product development efforts for mixed-reality business applications. I can’t wait to share more about that in the coming months!
But before we look too far ahead, June has already been filled with some cool mixed-reality moments.
Earlier this month my colleagues Dio Gonzalez and Katie Kelly presented at the sixth annual Augmented World Expo (AWE) in Santa Clara, California. I was encouraged but not at all surprised to hear from them about the tremendous growth of the conference, with many more incredible and varied AR solutions than ever before. This mirrors the signals we’ve long observed at Microsoft and aligns with the level of activity we continue to see in this space: Mixed-reality technology is increasingly providing demonstrable value across a wide range of workplace scenarios, which is fueling further interest from developers and businesses alike. AWE is a great conference, and I hope to be able to join again next year.
Supporting this observation, Microsoft recently partnered with Harvard Business Review Analytic Services to conduct a survey investigating the unique role and importance of mixed reality within the context of the modern workplace. This research surveyed 394 executives of companies with more than 250 employees each and spanning several industries, from manufacturing, engineering, and construction to retail, defense, and education.
The results—which you can read here—were released today, and the findings are fascinating: Among a great many observations, we learned that 87 percent of respondents are currently exploring, piloting, or deploying mixed reality in their company work flows. Similarly, 68 percent of respondents believe that mixed reality will play an important role in helping to achieve their companies’ strategic goals over the next 18 months.
The survey results identified several exciting areas of opportunity in the growing mixed-reality space.
One of the key opportunities is with Firstline Workers, who make up 80 percent of the workforce but often have limited access to relevant, contextual information due to the on-the-field nature of their jobs. These are the workers who are typically on the frontlines of any business workflow: behind the counters, in the clinics, traveling between customers for field service, or on the factory floors. Several of Microsoft’s commercial customers, for instance, are already empowering their Firstline Workers today with mixed-reality solutions that enable remote assistance, spatial planning, environmentally contextual data, and much more. Mixed reality allows these Firstline Workers to conduct their usual, day-to-day activities with the added benefit of heads-up, hands-free access to incredibly valuable, contextual information.
Lastly, a couple of days ago Alex Kipman spoke about mixed reality in the modern workplace at LiveWorx in Boston. LiveWorx brings together BDMs, engineers, and developers to learn about the tools available to help drive digital transformation in the workplace – such as IoT, mixed reality, and robotics.
Given our mission to help empower people and companies to achieve more, the conference was a great fit for our team. Alex hit on Microsoft’s strategy for mixed reality, in particular how it will serve to accelerate our ambition for an Intelligent Cloud and an Intelligent Edge. For those who have been with us on our mixed-reality journey, and for those who are just joining us, his fireside chat with Jon Fortt is a must-watch.
I am already looking forward to next month’s blog. In the meantime, as always, I’m available on Twitter (@lorrainebardeen) and eager to hear about what you’re doing with mixed reality.
Talk soon!
Lorraine

Introducing WinAppDriver UI Recorder – Windows Developer Blog

A new open-sourced tool is now available for the Windows Application Driver (WinAppDriver) community: the WinAppDriver UI Recorder tool. This tool will enable users to easily create automated UI tests.For those of you not familiar with WinAppDriver, it is a UI automation service for Windows 10 that users can use to test their applications. We recently released our v1.1 preview that you can read more about here.
What is UI Recorder
For many in the WinAppDriver community, Inspect has been the most common tool for users to select UI elements and view their attribute data. Though Inspect serves its intended purpose of viewing accessibility data, it falls behind when it comes to supporting scenarios specifically for UI automation, such as being able to generate XPath queries.
For situations such as these, the WinAppDriver UI Recorder tool hopes to fill in the gaps from Inspect and serve as its alternative.
As for its initial release, the UI Recorder tool will enable the following two key scenarios:
1) Inspecting UI elements and retrieving their XPath expressions
2) Generating C# code for certain actions (mouse click) when “Record” is active
Generated Code can be pasted into the UI Recorder Template folder for WinAppDriver playback
We’re hoping that with this tool, users will have a simpler and more intuitive approach in writing automation scripts for WinAppDriver.
Getting Started
The code for the UI Recorder is open-sourced and available on WinAppDriver’s GitHub repo here. It’s recommended to use Visual Studio 2017 to start building and compiling it. Once compiled, you can immediately start using UI Recorder.
In addition to access to the source, a zipped executable can be found here on our GitHub Releases section.
Using UI Recorder
The UI Recorder tool aims to provide an intuitive, and simplistic, user interface that is divided into two panels, as seen below:

UI Recorder tracks both keyboard and mouse interactions against an application interface—representing a UI action. When Recording is active, both the top and bottom panels are dynamically updated with varying UI element information every time a new UI action takes place. The Top Panel shows the generated XPath query of the currently selected UI element, and the Bottom Panel shows the raw XML information for the same element. You can navigate to the C# Code tab on the bottom panel to view generated C# code of the recorded action which you can use on a WinAppDriver test.
The following animation provides an example of the recording process:

The code recorded can be coped over to the clipboard and pasted onto the WinAppDriver UI Recorder template project to be replayed.
Providing Feedback
With the UI Recorder tool being open-source, we highly encourage the community to submit any PRs with changes or enhancements, and to post suggestions on how they would like to see the UI Recorder grow.
Please use the GitHub Issues Board to provide any feedback on the UI Recorder tool – we look forward to hearing about any suggestions, feature requests, or bug reports!
Staying Informed
To stay up to date with WinAppDriver news follow @mrhassanuz.
Summary
A new tool for WinAppDriver is available now: UI Recorder. Now users have an intuitive way automate UI with WinAppDriver by not only being able to generate XPath expressions on the fly, but also C# code from by recording UI action events through mouse clicks.
Updated June 20, 2018 4:55 pm

Meet Microsoft News: A new way to stay informed across the Web, Windows 10, iOS and Android – Windows Experience Blog

Our mission for more than two decades has been to keep you informed in an easily accessible, comprehensive and trustworthy way. Today, we share the next step in our evolution.
Microsoft has been in the news business for more than 23 years. When we launched MSN in 1995, the news industry was just beginning to provide content online. The period that followed was one of dramatic change and reinvention, forcing news organizations to re-think their programming and business strategies. We changed, too, from a feature of Windows 95 to a network of web and app experiences that now reaches nearly half a billion people in more than 140 countries and 28 languages. As we’ve evolved, our central mission has remained the same: to keep our audience informed in an easily accessible, comprehensive and trustworthy way.
Today, we’re excited to share the next step in our evolution – Microsoft News.
Microsoft News Editors at Mexico City Editorial Hub
What is Microsoft News? 
Microsoft News is the new name for our news engine that powers familiar sites like MSN.com, and our newly redesigned Microsoft News app for iOS and Android. Microsoft News also powers news on Microsoft Edge, the News app in Windows 10, Skype, Xbox and Outlook.com.
Microsoft News represents the ways we keep people informed across the web, phone and PC, using our long-tested approach of curating news via publishing partnerships, human editors, and AI. We work with more than a thousand premium publishers and more than 3,000 brands in all major global markets – like USA Today, The New York Times, FOX News, The Washington Post, The Guardian, Le Monde, Die Welt, El País, BBC News, Kyodo News, and many more – to aggregate the best news, videos, photos and other content and deliver it, for free, to people all over the world.
MSN, powered by Microsoft News
Microsoft News makes it easy for you to personalize your news experience, including prioritizing your favorite topics on MSN.com or selecting interests to follow in your news feed on the Microsoft Edge Start page and our apps on Windows 10, iOS and Android, so you can quickly get to the information you want most when and where you want it. We also enable our many publishing partners to connect with new audiences and earn money for their content at a time when that is crucial to the survival of the industry – so they can continue to invest in high-quality, credible journalism.
Microsoft News for iOS and Android
You can experience the best of what Microsoft News has to offer in our newly redesigned Microsoft News app for iOS and Android, available today. The app makes it easy to get news wherever you are, focused on the topics you care about most – like having your own portable newsroom.
Microsoft News app for Android – dark theme
The app has been completely redesigned into a modern and beautiful experience tailored to iOS and Android devices. Here are some of our favorite new features:
New personalization upgrades, including the ability to tailor interests to follow in your news feed – such as World News, Personal Finance, Fitness and many more – and to roam interests across devices and local news options for top cities
Easy to configure breaking news alerts
A new dark theme, enabling better night reading
Simplified access through seamless integration with iOS and Android widgets
Continuous reading, for a smooth content experience
Get the app now.
Supporting the publishing ecosystem and quality journalism
We know we can’t do it alone. We may have decades of news experience under our belt but there are many institutions that have been at it much, much longer. These institutions have defined what we think of as quality journalism through years of essential reporting.
We believe that a free, well-funded press is a critical part of our social fabric and are proud to partner with the world’s best news brands, offering a business model that gives people access, at no-cost, to trustworthy news and provides a sustainable source of revenue for publishers. In just the past four years we’ve delivered more than $600 million back to our publishers, enabling them to focus on what they do best: quality journalism.
“Microsoft has been a great partner over the last several years, working closely with our newsroom and collaborating as they consider new features and services. We appreciate partners like Microsoft who value trusted reporting and seek ways to elevate and share premium journalism to millions of readers who are looking for information from a reliable source.”— Maribel Wadsworth, publisher of USA TODAY and president, USA TODAY NETWORK
“Microsoft is a great partner for us because it offers both impressive reach and a well-earned reputation as a trusted source of news.” — Rich Kennedy, SVP of Business Development, Business Insider
“We are very happy that Microsoft is investing further in highlighting valuable and trusted sources of news. The launch of Microsoft News is another positive proof point of publisher-platform relationships strengthening and we look forward to seeing what’s to come.” — Matt Dornic, VP for Communications and Digital Partnerships, CNN
“Microsoft has been a valued partner in delivering CBSN’s live, 24/7 news coverage and analysis to an expansive audience that’s hungry for quality news and information. We look forward to continuing our strong relationship.” — Christy Tanner, Executive Vice President and General Manager, CBS News Digital
“MSN delivers premium content at scale and high ad viewability that truly performs for our advertisers.” — Jeff Lucas, Head of Americas Sales and Global Teams, Oath
“As part of our strategic partnership with Microsoft, Taboola powers content recommendations across Microsoft’s consumer properties in 55 markets and localized for 22 languages. We work together to create highly personalized experiences for consumers, drive engagement, monetization, increase awareness for Microsoft’s internal promotions and enable audience growth. We have seen in our three years of partnership that Microsoft audiences are incredibly valuable. When looking at Microsoft News users discovering content, as opposed to people coming from social or search, they engage 2-3x more, and in many ways are ‘super users’.”— Adam Singolda, Founder and CEO, Taboola
Curated news by editors
Every day, our publishing partners send us more than 100,000 unique pieces of content.  Our AI scans the content as it arrives, processes it to understand dimensions like freshness, category, topic type, opinion content and potential popularity and then presents it for our editors. Our algorithms suggest appropriate photos to pair with content to help bring stories to life. Editors then curate the top stories throughout the day, across a variety of topics, so our readers get the latest news from the best sources.
This curation process is global, using editors with local expertise. Today, there are more than 800 editors working from 50 locations around the world – including editorial newsrooms serving multiple regions in India, Germany, France, Mexico, Canada and Spain. Many of our editors have extensive backgrounds in media and journalism and have worked at a variety of news organizations including The Washington Post, The Chicago Tribune, Globe and Mail, Newsday, NBCSports.com, Seattle Times, Asahi Shimbun and Associated Press.
Microsoft News Editors at Delhi Media Center
Diversity, in our newsroom and in the publishers we partner with, is a key ingredient of the Microsoft News experience. We carefully compose our pages every day to present multiple sides of a story and consciously curate a wide variety of opinion pieces so that our readers can explore issues via new and different perspectives. We believe thoughtful opinion pieces—which we clearly mark as such—help readers better understand the news. With that goal in mind, we’re always assessing our network of partners to ensure that we provide the most diverse, credible and well-rounded content available.
At Microsoft News, we’re constantly refining and improving our experiences to continue to serve the needs of people and partners around the globe. We hope you will visit MSN.com, the Microsoft Edge Start page and give the new app a try!
Updated June 20, 2018 6:25 am

Windows 10 SDK Preview Build 17692 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17692 or greater). The Preview SDK Build 17692 contains bug fixes and under development changes to the API surface area.The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.
Things to note:
This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1803 or earlier to the Store.
The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download Visual Studio 2017 here.
This build of the Windows SDK will only install on Windows 10 Insider Preview.
What’s New:
MSIX Support
It’s finally here! You can now package your applications as MSIX! These applications can be installed and run on any device with 17682 build or later.
To package your application with MSIX, use the MakeAppx tool. To install the application – just click on the MSIX file. To understand more about MSIX, watch this introductory video: link
Feedback and comments are welcome on our MSIX community: http://aka.ms/MSIXCommunity
MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.
MC.EXE
We’ve made some important changes to the C/C++ ETW code generation of mc.exe (Message Compiler):
The “-mof” parameter is deprecated. This parameter instructs MC.exe to generate ETW code that is compatible with Windows XP and earlier. Support for the “-mof” parameter will be removed in a future version of mc.exe.
As long as the “-mof” parameter is not used, the generated C/C++ header is now compatible with both kernel-mode and user-mode, regardless of whether “-km” or “-um” was specified on the command line. The header will use the _ETW_KM_ macro to automatically determine whether it is being compiled for kernel-mode or user-mode and will call the appropriate ETW APIs for each mode.
The only remaining difference between “-km” and “-um” is that the EventWrite[EventName] macros generated with “-km” have an Activity ID parameter while the EventWrite[EventName] macros generated with “-um” do not have an Activity ID parameter.
The EventWrite[EventName] macros now default to calling EventWriteTransfer (user mode) or EtwWriteTransfer (kernel mode). Previously, the EventWrite[EventName] macros defaulted to calling EventWrite (user mode) or EtwWrite (kernel mode).
The generated header now supports several customization macros. For example, you can set the MCGEN_EVENTWRITETRANSFER macro if you need the generated macros to call something other than EventWriteTransfer.
The manifest supports new attributes.
Event “name”: non-localized event name.
Event “attributes”: additional key-value metadata for an event such as filename, line number, component name, function name.
Event “tags”: 28-bit value with user-defined semantics (per-event).
Field “tags”: 28-bit value with user-defined semantics (per-field – can be applied to “data” or “struct” elements).

You can now define “provider traits” in the manifest (e.g. provider group). If provider traits are used in the manifest, the EventRegister[ProviderName] macro will automatically register them.
MC will now report an error if a localized message file is missing a string. (Previously MC would silently generate a corrupt message resource.)
MC can now generate Unicode (utf-8 or utf-16) output with the “-cp utf-8” or “-cp utf-16” parameters.
Known Issues:
The SDK headers are generated with types in the “ABI” namespace. This is done to avoid conflicts with C++/CX and C++/WinRT clients that need to consume types directly at the ABI layer[1]. By default, types emitted by MIDL are *not* put in the ABI namespace, however this has the potential to introduce conflicts from teams attempting to consume ABI types from Windows WinRT MIDL generated headers and non-Windows WinRT MIDL generated headers (this is especially challenging if the non-Windows header references Windows types).
To ensure that developers have a consistent view of the WinRT API surface, validation has been added to the generated headers to ensure that the ABI prefix is consistent between the Windows headers and user generated headers. If you encounter an error like:
5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): error C2220: warning treated as error – no ‘object’ file generated5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition5>g:(41): note: see previous definition of ‘CHECK_NS_PREFIX_STATE’
It means that some of your MIDL generated headers are inconsistent with the system generated headers.
There are two ways to fix this:
Preferred: Compile your IDL file with the /ns_prefix MIDL command line switch. This will cause all your types to be moved to the ABI namespace consistent with the Windows headers. This may require code changes in your code however.
Alternate: Add #define DISABLE_NS_PREFIX_CHECKS before including the Windows headers. This will suppress the validation.
API Spot Light:
Check out LauncherOptions.GroupingPreference.

namespace Windows.System {
public sealed class FolderLauncherOptions : ILauncherViewOptions {
ViewGrouping GroupingPreference { get; set; }
}
public sealed class LauncherOptions : ILauncherViewOptions {
ViewGrouping GroupingPreference { get; set; }
}

This release contains the new LauncherOptions.GroupingPreference property to assist your app in tailoring its behavior for Sets. Watch the presentation here: https://channel9.msdn.com/events/Build/2018/BRK2412

API Updates, Additions and Removals
When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.
The following APIs have been added to the platform since the release of 17134. The APIs listed below have been removed.
Additions:

namespace Windows.AI.MachineLearning {
public interface ILearningModelFeatureDescriptor
public interface ILearningModelFeatureValue
public sealed class ImageFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class ImageFeatureValue : ILearningModelFeatureValue
public interface ITensor : ILearningModelFeatureValue
public sealed class LearningModel : IClosable
public sealed class LearningModelBinding : IIterable, IMapView
public sealed class LearningModelDevice
public enum LearningModelDeviceKind
public sealed class LearningModelEvaluationResult
public enum LearningModelFeatureKind
public sealed class LearningModelSession : IClosable
public struct MachineLearningContract
public sealed class MapFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class SequenceFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class TensorBoolean : ILearningModelFeatureValue, ITensor
public sealed class TensorDouble : ILearningModelFeatureValue, ITensor
public sealed class TensorFeatureDescriptor : ILearningModelFeatureDescriptor
public sealed class TensorFloat : ILearningModelFeatureValue, ITensor
public sealed class TensorFloat16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt32Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt64Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorInt8Bit : ILearningModelFeatureValue, ITensor
public enum TensorKind
public sealed class TensorString : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt16Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt32Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt64Bit : ILearningModelFeatureValue, ITensor
public sealed class TensorUInt8Bit : ILearningModelFeatureValue, ITensor
}
namespace Windows.ApplicationModel {
public sealed class AppInstallerInfo
public sealed class LimitedAccessFeatureRequestResult
public static class LimitedAccessFeatures
public enum LimitedAccessFeatureStatus
public sealed class Package {
IAsyncOperation CheckUpdateAvailabilityAsync();
AppInstallerInfo GetAppInstallerInfo();
}
public enum PackageUpdateAvailability
public sealed class PackageUpdateAvailabilityResult
}
namespace Windows.ApplicationModel.Calls {
public sealed class VoipCallCoordinator {
IAsyncOperation ReserveCallResourcesAsync();
}
}
namespace Windows.ApplicationModel.Chat {
public static class ChatCapabilitiesManager {
public static IAsyncOperation GetCachedCapabilitiesAsync(string address, string transportId);
public static IAsyncOperation GetCapabilitiesFromNetworkAsync(string address, string transportId);
}
public static class RcsManager {
public static event EventHandler TransportListChanged;
}
}
namespace Windows.ApplicationModel.ComponentUI {
public sealed class ComponentAddedEventArgs
public enum ComponentLaunchError
public sealed class ComponentLaunchOptions
public sealed class ComponentLaunchResults
public sealed class ComponentManager
public sealed class ComponentRemovedEventArgs
public sealed class ComponentReparentResults
public sealed class ComponentSite
public enum ComponentState
public sealed class ComponentStateEventArgs
public sealed class InputSitePrototype
}
namespace Windows.ApplicationModel.DataTransfer {
public static class Clipboard {
public static event EventHandler HistoryChanged;
public static event EventHandler HistoryEnabledChanged;
public static event EventHandler RoamingEnabledChanged;
public static bool ClearHistory();
public static bool DeleteItemFromHistory(ClipboardHistoryItem item);
public static IAsyncOperation GetHistoryItemsAsync();
public static bool IsHistoryEnabled();
public static bool IsRoamingEnabled();
public static void SetContentForUser(DataPackage content, User user);
public static void SetContentWithOptionsForUser(DataPackage content, User user, ClipboardContentOptions clipboardOptions);
public static SetHistoryItemAsContentStatus SetHistoryItemAsContent(ClipboardHistoryItem item);
}
public sealed class ClipboardContentOptions
public sealed class ClipboardHistoryChangedEventArgs
public sealed class ClipboardHistoryItem
public sealed class ClipboardHistoryItemsResult
public enum ClipboardHistoryItemsResultStatus
public sealed class DataPackagePropertySet : IIterable, IMap {
bool CanIncludeInClipboardHistory { get; set; }
bool CanUploadToCloudClipboard { get; set; }
IVector DataFormatsForClipboardHistory { get; }
IVector DataFormatsForCloudClipboard { get; }
}
public enum SetHistoryItemAsContentStatus
}
namespace Windows.ApplicationModel.Store.Preview {
public enum DeliveryOptimizationDownloadMode
public enum DeliveryOptimizationDownloadModeSource
public sealed class DeliveryOptimizationSettings
public static class StoreConfiguration {
public static bool IsPinToDesktopSupported();
public static bool IsPinToStartSupported();
public static bool IsPinToTaskbarSupported();
public static void PinToDesktop(string appPackageFamilyName);
public static void PinToDesktopForUser(User user, string appPackageFamilyName);
}
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public enum AppInstallationToastNotificationMode
public sealed class AppInstallItem {
AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
bool PinToDesktopAfterInstall { get; set; }
bool PinToStartAfterInstall { get; set; }
bool PinToTaskbarAfterInstall { get; set; }
}
public sealed class AppInstallManager {
bool CanInstallForAllUsers { get; }
}
public sealed class AppInstallOptions {
AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
bool InstallForAllUsers { get; set; }
AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
bool PinToDesktopAfterInstall { get; set; }
bool PinToStartAfterInstall { get; set; }
bool PinToTaskbarAfterInstall { get; set; }
bool StageButDoNotInstall { get; set; }
}
public sealed class AppUpdateOptions {
bool AutomaticallyDownloadAndInstallUpdateIfFound { get; set; }
}
}
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivity {
bool IsRoamable { get; set; }
}
}
namespace Windows.Data.Text {
public sealed class TextPredictionGenerator {
CoreTextInputScope InputScope { get; set; }
IAsyncOperation GetCandidatesAsync(string input, uint maxCandidates, TextPredictionOptions predictionOptions, IIterable previousStrings);
IAsyncOperation GetNextWordCandidatesAsync(uint maxCandidates, IIterable previousStrings);
}
public enum TextPredictionOptions : uint
}
namespace Windows.Devices.Enumeration {
public sealed class DeviceInformation {
string ContainerDeviceId { get; }
DevicePhysicalInfo PhysicalInfo { get; }
}
public enum DeviceInformationKind {
DevicePanel = 8,
}
public sealed class DeviceInformationPairing {
public static bool TryRegisterForAllInboundPairingRequestsWithProtectionLevel(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel);
}
public sealed class DevicePhysicalInfo
public enum PanelDeviceShape
}
namespace Windows.Devices.Enumeration.Pnp {
public enum PnpObjectType {
DevicePanel = 8,
}
}
namespace Windows.Devices.Lights {
public sealed class LampArray
public enum LampArrayKind
public sealed class LampInfo
public enum LampPurposes : uint
}
namespace Windows.Devices.Lights.Effects {
public interface ILampArrayEffect
public sealed class LampArrayBitmapEffect : ILampArrayEffect
public sealed class LampArrayBitmapRequestedEventArgs
public sealed class LampArrayBlinkEffect : ILampArrayEffect
public sealed class LampArrayColorRampEffect : ILampArrayEffect
public sealed class LampArrayCustomEffect : ILampArrayEffect
public enum LampArrayEffectCompletionBehavior
public sealed class LampArrayEffectPlaylist : IIterable, IVectorView
public enum LampArrayEffectStartMode
public enum LampArrayRepetitionMode
public sealed class LampArraySolidEffect : ILampArrayEffect
public sealed class LampArrayUpdateRequestedEventArgs
}
namespace Windows.Devices.PointOfService {
public sealed class BarcodeScannerCapabilities {
bool IsVideoPreviewSupported { get; }
}
public sealed class ClaimedBarcodeScanner : IClosable {
event TypedEventHandler Closed;
}
public sealed class ClaimedBarcodeScannerClosedEventArgs
public sealed class ClaimedCashDrawer : IClosable {
event TypedEventHandler Closed;
}
public sealed class ClaimedCashDrawerClosedEventArgs
public sealed class ClaimedLineDisplay : IClosable {
event TypedEventHandler Closed;
}
public sealed class ClaimedLineDisplayClosedEventArgs
public sealed class ClaimedMagneticStripeReader : IClosable {
event TypedEventHandler Closed;
}
public sealed class ClaimedMagneticStripeReaderClosedEventArgs
public sealed class ClaimedPosPrinter : IClosable {
event TypedEventHandler Closed;
}
public sealed class ClaimedPosPrinterClosedEventArgs
}
namespace Windows.Devices.PointOfService.Provider {
public sealed class BarcodeScannerDisableScannerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerEnableScannerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerFrameReader : IClosable
public sealed class BarcodeScannerFrameReaderFrameArrivedEventArgs
public sealed class BarcodeScannerGetSymbologyAttributesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerHideVideoPreviewRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerProviderConnection : IClosable {
IAsyncOperation CreateFrameReaderAsync();
IAsyncOperation CreateFrameReaderAsync(BitmapPixelFormat preferredFormat);
IAsyncOperation CreateFrameReaderAsync(BitmapPixelFormat preferredFormat, BitmapSize preferredSize);
}
public sealed class BarcodeScannerSetActiveSymbologiesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerSetSymbologyAttributesRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerStartSoftwareTriggerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerStopSoftwareTriggerRequest {
IAsyncAction ReportFailedAsync(int reason);
IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
}
public sealed class BarcodeScannerVideoFrame : IClosable
}
namespace Windows.Devices.Sensors {
public sealed class SimpleOrientationSensor {
public static IAsyncOperation FromIdAsync(string deviceId);
public static string GetDeviceSelector();
}
}
namespace Windows.Devices.SmartCards {
public static class KnownSmartCardAppletIds
public sealed class SmartCardAppletIdGroup {
string Description { get; set; }
IRandomAccessStreamReference Logo { get; set; }
ValueSet Properties { get; }
bool SecureUserAuthenticationRequired { get; set; }
}
public sealed class SmartCardAppletIdGroupRegistration {
string SmartCardReaderId { get; }
IAsyncAction SetPropertiesAsync(ValueSet props);
}
}
namespace Windows.Devices.WiFi {
public enum WiFiPhyKind {
HE = 10,
}
}
namespace Windows.Globalization {
public static class CurrencyIdentifiers {
public static string MRU { get; }
public static string SSP { get; }
public static string STN { get; }
public static string VES { get; }
}
}
namespace Windows.Graphics.Capture {
public sealed class Direct3D11CaptureFramePool : IClosable {
public static Direct3D11CaptureFramePool CreateFreeThreaded(IDirect3DDevice device, DirectXPixelFormat pixelFormat, int numberOfBuffers, SizeInt32 size);
}
public sealed class GraphicsCaptureItem {
public static GraphicsCaptureItem CreateFromVisual(Visual visual);
}
}
namespace Windows.Graphics.Imaging {
public sealed class BitmapDecoder : IBitmapFrame, IBitmapFrameWithSoftwareBitmap {
public static Guid HeifDecoderId { get; }
public static Guid WebpDecoderId { get; }
}
public sealed class BitmapEncoder {
public static Guid HeifEncoderId { get; }
}
}
namespace Windows.Management.Deployment {
public enum DeploymentOptions : uint {
ForceUpdateFromAnyVersion = (uint)262144,
}
public sealed class PackageManager {
IAsyncOperationWithProgress DeprovisionPackageForAllUsersAsync(string packageFamilyName);
}
public enum RemovalOptions : uint {
RemoveForAllUsers = (uint)524288,
}
}
namespace Windows.Management.Policies {
public static class NamedPolicy {
public static IAsyncAction ClearAllPoliciesAsync(string accountId);
public static IAsyncAction ClearAllPoliciesForAllAccountsAsync();
public static void SetBinaryPolicyAtPath(string accountId, string area, string name, IBuffer policyValue);
public static void SetBinaryPolicyAtPathForUser(User user, string accountId, string area, string name, IBuffer policyValue);
public static void SetBooleanPolicyAtPath(string accountId, string area, string name, bool policyValue);
public static void SetBooleanPolicyAtPathForUser(User user, string accountId, string area, string name, bool policyValue);
public static void SetInt32PolicyAtPath(string accountId, string area, string name, int policyValue);
public static void SetInt32PolicyAtPathForUser(User user, string accountId, string area, string name, int policyValue);
public static void SetInt64PolicyAtPath(string accountId, string area, string name, long policyValue);
public static void SetInt64PolicyAtPathForUser(User user, string accountId, string area, string name, long policyValue);
public static void SetStringPolicyAtPath(string accountId, string area, string name, string policyValue);
public static void SetStringPolicyAtPathForUser(User user, string accountId, string area, string name, string policyValue);
}
}
namespace Windows.Media.Audio {
public sealed class CreateAudioDeviceInputNodeResult {
HResult ExtendedError { get; }
}
public sealed class CreateAudioDeviceOutputNodeResult {
HResult ExtendedError { get; }
}
public sealed class CreateAudioFileInputNodeResult {
HResult ExtendedError { get; }
}
public sealed class CreateAudioFileOutputNodeResult {
HResult ExtendedError { get; }
}
public sealed class CreateAudioGraphResult {
HResult ExtendedError { get; }
}
public sealed class CreateMediaSourceAudioInputNodeResult {
HResult ExtendedError { get; }
}
public enum MixedRealitySpatialAudioFormatPolicy
public sealed class SetDefaultSpatialAudioFormatResult
public enum SetDefaultSpatialAudioFormatStatus
public sealed class SpatialAudioDeviceConfiguration
public sealed class SpatialAudioFormatConfiguration
public static class SpatialAudioFormatSubtype
}
namespace Windows.Media.Control {
public sealed class CurrentSessionChangedEventArgs
public sealed class GlobalSystemMediaTransportControlsSession
public sealed class GlobalSystemMediaTransportControlsSessionManager
public sealed class GlobalSystemMediaTransportControlsSessionMediaProperties
public sealed class GlobalSystemMediaTransportControlsSessionPlaybackControls
public sealed class GlobalSystemMediaTransportControlsSessionPlaybackInfo
public enum GlobalSystemMediaTransportControlsSessionPlaybackStatus
public sealed class GlobalSystemMediaTransportControlsSessionTimelineProperties
public sealed class MediaPropertiesChangedEventArgs
public sealed class PlaybackInfoChangedEventArgs
public sealed class SessionsChangedEventArgs
public sealed class TimelinePropertiesChangedEventArgs
}
namespace Windows.Media.Core {
public sealed class MediaStreamSample {
IDirect3DSurface Direct3D11Surface { get; }
public static MediaStreamSample CreateFromDirect3D11Surface(IDirect3DSurface surface, TimeSpan timestamp);
}
}
namespace Windows.Media.Devices {
public enum AudioRoutingPolicy
public static class SystemAudioDeviceRoutingManager
public sealed class SystemAudioDeviceRoutingSession : IClosable
}
namespace Windows.Media.Devices.Core {
public sealed class CameraIntrinsics {
public CameraIntrinsics(Vector2 focalLength, Vector2 principalPoint, Vector3 radialDistortion, Vector2 tangentialDistortion, uint imageWidth, uint imageHeight);
}
}
namespace Windows.Media.Import {
public enum PhotoImportContentTypeFilter {
OnlyImagesAndVideosFromCameraRoll = 3,
}
public sealed class PhotoImportItem {
string Path { get; }
}
}
namespace Windows.Media.MediaProperties {
public sealed class ImageEncodingProperties : IMediaEncodingProperties {
public static ImageEncodingProperties CreateHeif();
}
public static class MediaEncodingSubtypes {
public static string Heif { get; }
}
}
namespace Windows.Media.Protection.PlayReady {
public static class PlayReadyStatics {
public static IReference HardwareDRMDisabledAtTime { get; }
public static IReference HardwareDRMDisabledUntilTime { get; }
public static void ResetHardwareDRMDisabled();
}
}
namespace Windows.Media.Streaming.Adaptive {
public enum AdaptiveMediaSourceResourceType {
MediaSegmentIndex = 5,
}
}
namespace Windows.Networking.Connectivity {
public sealed class ConnectionProfile {
bool CanDelete { get; }
IAsyncOperation TryDeleteAsync();
}
public enum ConnectionProfileDeleteStatus
}
namespace Windows.Networking.NetworkOperators {
public enum ESimOperationStatus {
CardGeneralFailure = 13,
ConfirmationCodeMissing = 14,
EidMismatch = 18,
InvalidMatchingId = 15,
NoCorrespondingRequest = 23,
NoEligibleProfileForThisDevice = 16,
OperationAborted = 17,
OperationProhibitedByProfileClass = 21,
ProfileNotAvailableForNewBinding = 19,
ProfileNotPresent = 22,
ProfileNotReleasedByOperator = 20,
}
}
namespace Windows.Perception {
public sealed class PerceptionTimestamp {
TimeSpan SystemRelativeTargetTime { get; }
}
public static class PerceptionTimestampHelper {
public static PerceptionTimestamp FromSystemRelativeTargetTime(TimeSpan targetTime);
}
}
namespace Windows.Perception.Spatial {
public sealed class SpatialAnchorExporter
public enum SpatialAnchorExportPurpose
public sealed class SpatialAnchorExportSufficiency
public sealed class SpatialLocation {
Vector3 AbsoluteAngularAccelerationAxisAngle { get; }
Vector3 AbsoluteAngularVelocityAxisAngle { get; }
}
}
namespace Windows.Perception.Spatial.Preview {
public static class SpatialGraphInteropPreview
}
namespace Windows.Security.DataProtection {
public enum UserDataAvailability
public sealed class UserDataAvailabilityStateChangedEventArgs
public sealed class UserDataBufferUnprotectResult
public enum UserDataBufferUnprotectStatus
public sealed class UserDataProtectionManager
public sealed class UserDataStorageItemProtectionInfo
public enum UserDataStorageItemProtectionStatus
}
namespace Windows.Security.Integrity {
public static class WindowsIntegrityPolicy
}
namespace Windows.Services.Cortana {
public sealed class CortanaActionableInsights
public sealed class CortanaActionableInsightsOptions
}
namespace Windows.Services.Store {
public sealed class StoreAppLicense {
bool IsDiscLicense { get; }
}
public sealed class StoreContext {
IAsyncOperation RequestRateAndReviewAppAsync();
IAsyncOperation SetInstallOrderForAssociatedStoreQueueItemsAsync(IIterable items);
}
public sealed class StoreQueueItem {
IAsyncAction CancelInstallAsync();
IAsyncAction PauseInstallAsync();
IAsyncAction ResumeInstallAsync();
}
public sealed class StoreRateAndReviewResult
public enum StoreRateAndReviewStatus
}
namespace Windows.Storage.Provider {
public enum StorageProviderHydrationPolicyModifier : uint {
AutoDehydrationAllowed = (uint)4,
}
}
namespace Windows.System {
public sealed class FolderLauncherOptions : ILauncherViewOptions {
ViewGrouping GroupingPreference { get; set; }
}
public static class Launcher {
public static IAsyncOperation LaunchFolderPathAsync(string path);
public static IAsyncOperation LaunchFolderPathAsync(string path, FolderLauncherOptions options);
public static IAsyncOperation LaunchFolderPathForUserAsync(User user, string path);
public static IAsyncOperation LaunchFolderPathForUserAsync(User user, string path, FolderLauncherOptions options);
}
public sealed class LauncherOptions : ILauncherViewOptions {
ViewGrouping GroupingPreference { get; set; }
}
}
namespace Windows.System.Profile {
public static class OutOfBoxExperienceInfo
public enum OutOfBoxExperienceStatus
}
namespace Windows.System.Profile.SystemManufacturers {
public sealed class SystemSupportDeviceInfo
public static class SystemSupportInfo {
public static SystemSupportDeviceInfo LocalDeviceInfo { get; }
}
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
IVectorView Apps { get; }
}
public sealed class RemoteSystemApp
public sealed class RemoteSystemAppRegistration
public enum RemoteSystemAppResourceAccessType
public sealed class RemoteSystemAppResourceInfo
public sealed class RemoteSystemConnectionRequest {
RemoteSystemApp RemoteSystemApp { get; }
public static RemoteSystemConnectionRequest CreateWithRemoteSystemApp(RemoteSystemApp remoteSystemApp);
}
}
namespace Windows.System.Update {
public enum SystemUpdateAttentionRequiredReason
public sealed class SystemUpdateItem
public enum SystemUpdateItemState
public sealed class SystemUpdateLastErrorInfo
public static class SystemUpdateManager
public enum SystemUpdateManagerState
public enum SystemUpdateStartInstallAction
}
namespace Windows.System.UserProfile {
public sealed class AssignedAccessSettings
}
namespace Windows.UI.Accessibility {
public sealed class ScreenReaderPositionChangedEventArgs
public sealed class ScreenReaderService
}
namespace Windows.UI.Composition {
public enum AnimationPropertyAccessMode
public sealed class AnimationPropertyInfo : CompositionObject
public sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
void SetAnimatableReferenceParameter(string parameterName, IAnimationObject source);
}
public enum CompositionBatchTypes : uint {
AllAnimations = (uint)5,
InfiniteAnimation = (uint)4,
}
public sealed class CompositionGeometricClip : CompositionClip
public class CompositionGradientBrush : CompositionBrush {
CompositionMappingMode MappingMode { get; set; }
}
public enum CompositionMappingMode
public class CompositionObject : IAnimationObject, IClosable {
void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
public static void StartAnimationGroupWithIAnimationObject(IAnimationObject target, ICompositionAnimationBase animation);
public static void StartAnimationWithIAnimationObject(IAnimationObject target, string propertyName, CompositionAnimation animation);
}
public sealed class Compositor : IClosable {
BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation();
CompositionGeometricClip CreateGeometricClip();
CompositionGeometricClip CreateGeometricClip(CompositionGeometry geometry);
RedirectVisual CreateRedirectVisual();
RedirectVisual CreateRedirectVisualWithSourceVisual(Visual source);
}
public interface IAnimationObject
public sealed class RedirectVisual : ContainerVisual
}
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionSourceConfiguration : CompositionObject
public enum InteractionSourceRedirectionMode
public sealed class InteractionTracker : CompositionObject {
bool IsInertiaFromImpulse { get; }
int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option);
int TryUpdatePositionBy(Vector3 amount, InteractionTrackerClampingOption option);
}
public enum InteractionTrackerClampingOption
public sealed class InteractionTrackerInertiaStateEnteredArgs {
bool IsInertiaFromImpulse { get; }
}
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
InteractionSourceConfiguration PointerWheelConfig { get; }
}
}
namespace Windows.UI.Input.Inking.Preview {
public sealed class PalmRejectionDelayZonePreview : IClosable
}
namespace Windows.UI.Notifications {
public sealed class ScheduledToastNotificationShowingEventArgs
public sealed class ToastNotifier {
event TypedEventHandler ScheduledToastNotificationShowing;
}
}
namespace Windows.UI.Shell {
public sealed class TaskbarManager {
IAsyncOperation IsSecondaryTilePinnedAsync(string tileId);
IAsyncOperation RequestPinSecondaryTileAsync(SecondaryTile secondaryTile);
IAsyncOperation TryUnpinSecondaryTileAsync(string tileId);
}
}
namespace Windows.UI.StartScreen {
public sealed class StartScreenManager {
IAsyncOperation ContainsSecondaryTileAsync(string tileId);
IAsyncOperation TryRemoveSecondaryTileAsync(string tileId);
}
}
namespace Windows.UI.Text {
public sealed class RichEditTextDocument : ITextDocument {
void ClearUndoRedoHistory();
}
}
namespace Windows.UI.Text.Core {
public sealed class CoreTextLayoutRequest {
CoreTextLayoutBounds LayoutBoundsVisualPixels { get; }
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
bool IsTabGroupingSupported { get; }
}
public sealed class ApplicationViewTitleBar {
void SetActiveIconStreamAsync(RandomAccessStreamReference activeIcon);
}
public enum ApplicationViewWindowingMode {
CompactOverlay = 3,
Maximized = 4,
}
public interface ISystemTray
public interface ISystemTrayStatics
public sealed class SystemTray : ISystemTray
public enum ViewGrouping
public sealed class ViewModePreferences {
ViewGrouping GroupingPreference { get; set; }
}
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
bool TryHide();
bool TryShow();
bool TryShow(CoreInputViewKind type);
}
public enum CoreInputViewKind
}
namespace Windows.UI.WebUI {
public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
public delegate void BackgroundActivatedEventHandler(object sender, IBackgroundActivatedEventArgs eventArgs);
public sealed class NewWebUIViewCreatedEventArgs
public static class WebUIApplication {
public static event BackgroundActivatedEventHandler BackgroundActivated;
public static event EventHandler NewWebUIViewCreated;
}
public sealed class WebUIView : IWebViewControl
}
namespace Windows.UI.Xaml {
public class DataTemplate : FrameworkTemplate, IElementFactory {
UIElement GetElement(ElementFactoryGetContext context);
void RecycleElement(ElementFactoryRecycleContext context);
}
public sealed class DebugSettings {
bool FailFastOnErrors { get; set; }
}
public sealed class EffectiveViewportChangedEventArgs
public sealed class ElementFactoryGetContext
public sealed class ElementFactoryRecycleContext
public class FrameworkElement : UIElement {
event TypedEventHandler EffectiveViewportChanged;
void InvalidateViewport();
}
public interface IElementFactory
public class UIElement : DependencyObject {
bool CanBeScrollAnchor { get; set; }
public static DependencyProperty CanBeScrollAnchorProperty { get; }
}
public sealed class UIElementWeakCollection : IIterable, IVector
}
namespace Windows.UI.Xaml.Automation {
public sealed class AutomationElementIdentifiers {
public static AutomationProperty IsDialogProperty { get; }
}
public sealed class AutomationProperties {
public static DependencyProperty IsDialogProperty { get; }
public static bool GetIsDialog(DependencyObject element);
public static void SetIsDialog(DependencyObject element, bool value);
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public class AppBarButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider {
ExpandCollapseState ExpandCollapseState { get; }
void Collapse();
void Expand();
}
public class AutomationPeer : DependencyObject {
bool IsDialog();
virtual bool IsDialogCore();
}
public class MenuBarAutomationPeer : FrameworkElementAutomationPeer
public class MenuBarItemAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
}
namespace Windows.UI.Xaml.Controls {
public sealed class AnchorRequestedEventArgs
public class AppBarElementContainer : ContentControl, ICommandBarElement, ICommandBarElement2
public enum BackgroundSizing
public sealed class Border : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
}
public class ComboBox : Selector {
bool IsEditable { get; set; }
public static DependencyProperty IsEditableProperty { get; }
string Text { get; set; }
Style TextBoxStyle { get; set; }
public static DependencyProperty TextBoxStyleProperty { get; }
public static DependencyProperty TextProperty { get; }
event TypedEventHandler TextSubmitted;
}
public sealed class ComboBoxTextSubmittedEventArgs
public class ContentPresenter : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
}
public class Control : FrameworkElement {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
CornerRadius CornerRadius { get; set; }
public static DependencyProperty CornerRadiusProperty { get; }
bool UseSystemValidationVisuals { get; set; }
public static DependencyProperty UseSystemValidationVisualsProperty { get; }
}
public class DataTemplateSelector : IElementFactory {
UIElement GetElement(ElementFactoryGetContext context);
void RecycleElement(ElementFactoryRecycleContext context);
}
public class DatePicker : Control {
IReference NullableDate { get; set; }
public static DependencyProperty NullableDateProperty { get; }
}
public class DropDownButton : Button
public class DropDownButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider
public class Frame : ContentControl, INavigate {
bool IsNavigationStackEnabled { get; set; }
public static DependencyProperty IsNavigationStackEnabledProperty { get; }
bool NavigateToType(TypeName sourcePageType, object parameter, FrameNavigationOptions navigationOptions);
}
public class Grid : Panel {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
}
public class IconSourceElement : IconElement
public static class InputValidation
public sealed class InputValidationError
public enum InputValidationErrorEventAction
public sealed class InputValidationErrorEventArgs : RoutedEventArgs
public sealed class InputValidationTemplateSettings : DependencyObject
public enum InputValidationVisualKind
public interface IScrollAnchorProvider
public class MenuBar : Control
public class MenuBarItem : Control
public class MenuBarItemFlyout : MenuFlyout
public class NavigationView : ContentControl {
UIElement ContentOverlay { get; set; }
public static DependencyProperty ContentOverlayProperty { get; }
bool IsPaneVisible { get; set; }
public static DependencyProperty IsPaneVisibleProperty { get; }
NavigationViewOverflowLabelMode OverflowLabelMode { get; set; }
public static DependencyProperty OverflowLabelModeProperty { get; }
UIElement PaneCustomContent { get; set; }
public static DependencyProperty PaneCustomContentProperty { get; }
NavigationViewPaneDisplayMode PaneDisplayMode { get; set; }
public static DependencyProperty PaneDisplayModeProperty { get; }
UIElement PaneHeader { get; set; }
public static DependencyProperty PaneHeaderProperty { get; }
NavigationViewSelectionFollowsFocus SelectionFollowsFocus { get; set; }
public static DependencyProperty SelectionFollowsFocusProperty { get; }
NavigationViewShoulderNavigationEnabled ShoulderNavigationEnabled { get; set; }
public static DependencyProperty ShoulderNavigationEnabledProperty { get; }
NavigationViewTemplateSettings TemplateSettings { get; }
public static DependencyProperty TemplateSettingsProperty { get; }
}
public class NavigationViewItem : NavigationViewItemBase {
bool SelectsOnInvoked { get; set; }
public static DependencyProperty SelectsOnInvokedProperty { get; }
}
public sealed class NavigationViewItemInvokedEventArgs {
NavigationViewItemBase InvokedItemContainer { get; }
NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
}
public enum NavigationViewOverflowLabelMode
public enum NavigationViewPaneDisplayMode
public sealed class NavigationViewSelectionChangedEventArgs {
NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
NavigationViewItemBase SelectedItemContainer { get; }
}
public enum NavigationViewSelectionFollowsFocus
public enum NavigationViewShoulderNavigationEnabled
public class NavigationViewTemplateSettings : DependencyObject
public sealed class PasswordBox : Control {
bool CanPasteClipboardContent { get; }
public static DependencyProperty CanPasteClipboardContentProperty { get; }
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void PasteFromClipboard();
}
public class RelativePanel : Panel {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
}
public class RichEditBox : Control {
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
RichEditTextDocument TextDocument { get; }
event TypedEventHandler SelectionChanging;
}
public sealed class RichEditBoxSelectionChangingEventArgs
public sealed class RichTextBlock : FrameworkElement {
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void CopySelectionToClipboard();
}
public sealed class ScrollViewer : ContentControl, IScrollAnchorProvider {
UIElement CurrentAnchor { get; }
double HorizontalAnchorRatio { get; set; }
public static DependencyProperty HorizontalAnchorRatioProperty { get; }
bool IsAnchoredAtHorizontalExtent { get; set; }
public static DependencyProperty IsAnchoredAtHorizontalExtentProperty { get; }
bool IsAnchoredAtVerticalExtent { get; set; }
public static DependencyProperty IsAnchoredAtVerticalExtentProperty { get; }
double VerticalAnchorRatio { get; set; }
public static DependencyProperty VerticalAnchorRatioProperty { get; }
event TypedEventHandler AnchorRequested;
void RegisterAnchorCandidate(UIElement element);
void UnregisterAnchorCandidate(UIElement element);
}
public class SplitButton : ContentControl
public class SplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
public sealed class SplitButtonClickEventArgs
public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
BackgroundSizing BackgroundSizing { get; set; }
public static DependencyProperty BackgroundSizingProperty { get; }
}
public sealed class TextBlock : FrameworkElement {
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
void CopySelectionToClipboard();
}
public class TextBox : Control {
bool CanPasteClipboardContent { get; }
public static DependencyProperty CanPasteClipboardContentProperty { get; }
bool CanRedo { get; }
public static DependencyProperty CanRedoProperty { get; }
bool CanUndo { get; }
public static DependencyProperty CanUndoProperty { get; }
object Description { get; set; }
public static DependencyProperty DescriptionProperty { get; }
FlyoutBase SelectionFlyout { get; set; }
public static DependencyProperty SelectionFlyoutProperty { get; }
event TypedEventHandler SelectionChanging;
void ClearUndoRedoHistory();
void CopySelectionToClipboard();
void CutSelectionToClipboard();
void PasteFromClipboard();
void Redo();
void Undo();
}
public sealed class TextBoxSelectionChangingEventArgs
public class TimePicker : Control {
IReference NullableTime { get; set; }
public static DependencyProperty NullableTimeProperty { get; }
}
public class ToggleSplitButton : SplitButton
public class ToggleSplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IToggleProvider
public sealed class ToggleSplitButtonIsCheckedChangedEventArgs
public class ToolTip : ContentControl {
Rect PlacementRect { get; set; }
public static DependencyProperty PlacementRectProperty { get; }
}
public class TreeView : Control {
bool CanDragItems { get; set; }
public static DependencyProperty CanDragItemsProperty { get; }
bool CanReorderItems { get; set; }
public static DependencyProperty CanReorderItemsProperty { get; }
Style ItemContainerStyle { get; set; }
public static DependencyProperty ItemContainerStyleProperty { get; }
StyleSelector ItemContainerStyleSelector { get; set; }
public static DependencyProperty ItemContainerStyleSelectorProperty { get; }
TransitionCollection ItemContainerTransitions { get; set; }
public static DependencyProperty ItemContainerTransitionsProperty { get; }
object ItemsSource { get; set; }
public static DependencyProperty ItemsSourceProperty { get; }
DataTemplate ItemTemplate { get; set; }
public static DependencyProperty ItemTemplateProperty { get; }
DataTemplateSelector ItemTemplateSelector { get; set; }
public static DependencyProperty ItemTemplateSelectorProperty { get; }
event TypedEventHandler DragItemsCompleted;
event TypedEventHandler DragItemsStarting;
DependencyObject ContainerFromItem(object item);
DependencyObject ContainerFromNode(TreeViewNode node);
object ItemFromContainer(DependencyObject container);
TreeViewNode NodeFromContainer(DependencyObject container);
}
public sealed class TreeViewCollapsedEventArgs {
object Item { get; }
}
public sealed class TreeViewDragItemsCompletedEventArgs
public sealed class TreeViewDragItemsStartingEventArgs
public sealed class TreeViewExpandingEventArgs {
object Item { get; }
}
public class TreeViewItem : ListViewItem {
bool HasUnrealizedChildren { get; set; }
public static DependencyProperty HasUnrealizedChildrenProperty { get; }
object ItemsSource { get; set; }
public static DependencyProperty ItemsSourceProperty { get; }
}
public class TwoPaneView : Control
public enum TwoPaneViewConfiguration
public enum TwoPaneViewPriority
public enum TwoPaneViewTallConfiguration
public enum TwoPaneViewWideConfiguration
public sealed class WebView : FrameworkElement {
event TypedEventHandler WebResourceRequested;
}
public sealed class WebViewWebResourceRequestedEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
public enum MapTileAnimationState
public sealed class MapTileBitmapRequestedEventArgs {
int FrameIndex { get; }
}
public class MapTileSource : DependencyObject {
MapTileAnimationState AnimationState { get; }
public static DependencyProperty AnimationStateProperty { get; }
bool AutoPlay { get; set; }
public static DependencyProperty AutoPlayProperty { get; }
int FrameCount { get; set; }
public static DependencyProperty FrameCountProperty { get; }
TimeSpan FrameDuration { get; set; }
public static DependencyProperty FrameDurationProperty { get; }
void Pause();
void Play();
void Stop();
}
public sealed class MapTileUriRequestedEventArgs {
int FrameIndex { get; }
}
}
namespace Windows.UI.Xaml.Controls.Primitives {
public class FlyoutBase : DependencyObject {
bool DisableOpenCloseAnimations { get; set; }
public static DependencyProperty DisableOpenCloseAnimationsProperty { get; }
bool IsOpen { get; }
public static DependencyProperty IsOpenProperty { get; }
bool OpeningInputDevicePrefersQuickAccess { get; }
public static DependencyProperty OpeningInputDevicePrefersQuickAccessProperty { get; }
FlyoutShowMode ShowMode { get; set; }
public static DependencyProperty ShowModeProperty { get; }
public static DependencyProperty TargetProperty { get; }
void ShowAt(DependencyObject placementTarget, FlyoutShowOptions showOptions);
}
public enum FlyoutPlacementMode {
BottomEdgeAlignedLeft = 7,
BottomEdgeAlignedRight = 8,
LeftEdgeAlignedBottom = 10,
LeftEdgeAlignedTop = 9,
RightEdgeAlignedBottom = 12,
RightEdgeAlignedTop = 11,
TopEdgeAlignedLeft = 5,
TopEdgeAlignedRight = 6,
}
public enum FlyoutShowMode
public sealed class FlyoutShowOptions : DependencyObject
public class NavigationViewItemPresenter : ContentControl
}
namespace Windows.UI.Xaml.Data {
public sealed class DataErrorsChangedEventArgs
public interface INotifyDataErrorInfo
}
namespace Windows.UI.Xaml.Hosting {
public sealed class DesktopWindowXamlSource : IClosable
public sealed class DesktopWindowXamlSourceGotFocusEventArgs
public sealed class DesktopWindowXamlSourceTakeFocusRequestedEventArgs
public sealed class WindowsXamlManager : IClosable
public enum XamlSourceFocusNavigationReason
public sealed class XamlSourceFocusNavigationRequest
public sealed class XamlSourceFocusNavigationResult
}
namespace Windows.UI.Xaml.Input {
public sealed class CanExecuteRequestedEventArgs
public sealed class ExecuteRequestedEventArgs
public sealed class FocusManager {
public static event EventHandler GettingFocus;
public static event EventHandler GotFocus;
public static event EventHandler LosingFocus;
public static event EventHandler LostFocus;
}
public sealed class FocusManagerGotFocusEventArgs
public sealed class FocusManagerLostFocusEventArgs
public sealed class GettingFocusEventArgs : RoutedEventArgs {
Guid CorrelationId { get; }
}
public sealed class LosingFocusEventArgs : RoutedEventArgs {
Guid CorrelationId { get; }
}
public class StandardUICommand : UICommand
public enum StandardUICommandKind
public class UICommand : DependencyObject, ICommand
}
namespace Windows.UI.Xaml.Markup {
public sealed class FullXamlMetadataProviderAttribute : Attribute
public interface IXamlBindScopeDiagnostics
public interface IXamlType2 : IXamlType
}
namespace Windows.UI.Xaml.Media.Animation {
public class BasicConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public sealed class ConnectedAnimation {
ConnectedAnimationConfiguration Configuration { get; set; }
}
public class ConnectedAnimationConfiguration
public class DirectConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration
public enum SlideNavigationTransitionEffect
public sealed class SlideNavigationTransitionInfo : NavigationTransitionInfo {
SlideNavigationTransitionEffect Effect { get; set; }
public static DependencyProperty EffectProperty { get; }
}
}
namespace Windows.UI.Xaml.Navigation {
public class FrameNavigationOptions
}
namespace Windows.Web.UI {
public interface IWebViewControl2
public sealed class WebViewControlNewWindowRequestedEventArgs {
IWebViewControl TargetWebViewControl { get; set; }
Deferral GetDeferral();
}
}
namespace Windows.Web.UI.Interop {
public sealed class WebViewControl : IWebViewControl, IWebViewControl2 {
event TypedEventHandler GotFocus;
event TypedEventHandler LostFocus;
void AddPreLoadedScript(string script);
}
public sealed class WebViewControlProcess {
string Partition { get; }
string UserAgent { get; }
}
public sealed class WebViewControlProcessOptions {
string Partition { get; set; }
string UserAgent { get; set; }
}
}

Removals:

namespace Windows.Gaming.UI {
public sealed class GameMonitor
public enum GameMonitoringPermission
}

Announcing Windows Admin Center Insider Preview 1806 – Windows Experience Blog

Hello Windows Insiders!Today we are excited to release Windows Admin Center Preview 1806 to Windows Server Insiders. First, an explanation of our two version options:
Preview version: For IT admins who want the latest and greatest features on a regular cadence, this version is for you. Windows Admin Center Preview 1806 is the first post-GA preview release, and our intent is to provide subsequent update releases every month or so. The core platform continues to be production-ready and the license provides production use rights. However, note that you will see the introduction of new tools and capabilities which are clearly marked as PREVIEW and are suitable for evaluation and testing.
GA version: For IT admins who are not able to update frequently or who want more validation time for the releases they use in production, this version is for you. Our current GA release is Windows Admin Center 1804.25. Later this year, several months’ worth of preview releases will culminate in another GA release once new functionality receives broader validation coverage.

This first post-GA preview release of Windows Admin Center is packed with new functionality, including:
View/copy the PowerShell scripts that Windows Admin Center is using under the hood. (Our top user request!)
Manage Windows Server 2008 R2 connections with a limited set of tools (another big customer request)
New tools to manage your Software Defined Network (SDN) in Hyper-Converged Cluster Manager
New Scheduled Tasks tool (in preview; see below for known issues)
Other new features include an update notification dialog, multiple extension feeds, and a new option to redirect web traffic from port 80. See below for details.
Improvements to some existing features: gateway settings page, notifications, connection tag editing experience, and extension management experience

View script
We have delivered the #1 customer request on our UserVoice group: show the PowerShell used by Windows Admin Center. You can now navigate to a tool, click the PowerShell icon in the upper-right app bar, and select a command of interest from the dropdown to navigate to the corresponding PowerShell script. The text is shown with syntax coloring and automatically selected for you to copy.

Limited support for Windows Server 2008 R2 connections
We have added support, with limited functionality, to manage 2008 R2 servers. Adding a 2008 R2 connections has the same dependency on WMF 5.1 as 2012 and 2012 R2. The remote desktop tool is currently not available due to a bug in the HTML RD client – this should be fixed in a future release. Some other tools will not be available due to platform limitations or architectural differences.
You can use the following tools to manage your 2008 R2 servers:
Overview
Events
Local Users & Groups
Processes
Registry
Services
PowerShell

Update notification dialog
The first time a user connects after an instance of Windows Admin Center has been updated, they will see a dialog letting them know that it has been updated. This is beneficial for end users that otherwise may not know that the gateway has been updated, or for users who have opted to let the gateway be updated by Microsoft Update.

New tool – Scheduled Tasks
In the Scheduled Tasks tool, you can view, edit, enable/disable, start/stop, and create scheduled tasks. This tool is currently in preview. Currently the supported task triggers are daily, once, at logon, and at startup. You are limited to creating and editing only 1 trigger per task.
The known issues are primarily a lack of form validation and error message formatting. Please let us know if you encounter any issues so that we can make sure they are being tracked.

New tool – Virtual Networks (in Hyper-Converged Cluster Manager)
If you deployed Software Defined Network (SDN) in your hyper-converged environment, you can now monitor and manage virtual networks in the Virtual Network Tool. You can create, modify and configure virtual networks and subnets. You can also view VM connections to the virtual network subnets and access control lists applied to virtual network subnets.
This tool is currently in preview. Please let us know if you encounter any issues so that we can make sure they are being tracked.

New tool – SDN Monitoring (in Hyper-Converged Cluster Manager)
If you deployed Software Defined Network (SDN) in your hyper-converged environment, you can now monitor your SDN infrastructure in the SDN monitoring tool. You can monitor the state of the SDN services and infrastructure in real-time. You can view detailed information about the health of Network Controller, Software Load Balancer, Virtual Gateway and monitor your Virtual Gateway Pool, Public and Private IP Pool usage and SDN host status.
This tool is currently in preview. Please let us know if you encounter any issues so that we can make sure they are being tracked.

Port 80 redirection option
When installing Windows Admin Center as a gateway service, you can choose to redirect traffic from port 80 to the port configured for the HTTPS Windows Admin Center connection.
For example, if your gateway is configured on the address https://manage.contoso.com:12345 but the user only types manage.contoso.com in their browser, they will end up in the correct place.
If you are deploying Windows Admin Center on Server Core or otherwise doing a silent/command line install, you can add the SET_REDIRECT_PORT_80=1 parameter to the existing command line installation instructions.

Editing connection tags
Tags are now easier to edit! You can select one or many connections and then select “Edit tags” to easily modify the tags for selected connections.

Extension manager improvements
Several improvements have been made to Extension manager – You will be notified of available updates to installed extensions and you can now update extensions with a single button click. Also, Extension manager now supports multiple extension feeds, so that you can easily host an internal or private feed while still having the public feed available.

Hyper-Converged Cluster Connection supports SDN
Hyper-Converged Cluster Connection now supports Software Defined Networking (SDN). By adding a Network Controller REST URI to your Hyper-Converged cluster connection, you can use Hyper-converged Cluster Manager to manage your SDN resources and monitor SDN infrastructures.
This feature is currently in preview.  SDN environments with Kerberos authentication for Northbound communication are not supported in this preview. Please let us know if you encounter any issues so that we can make sure they are being tracked.

Virtual Machines (in Hyper-Converged Cluster Manager)
If you deployed Software Defined Network (SDN) in your hyper-converged environment, you can now connect a new virtual machine to a virtual network during VM creation. You can connect an existing virtual machine to a virtual network by changing the network settings of the virtual machine.
This feature is currently in preview.  Connecting virtual machine to an SDN logical network is not supported in this preview release. Please let us know if you encounter any issues so that we can make sure they are being tracked.

Gateway settings
Windows Admin Center has updated the gateway settings (gear icon in the upper right.) Settings are now split between user-level and gateway-level settings. A change to a user-level setting only affects the current user’s profile, while a change to a gateway-level setting affects all users on that Windows Admin Center gateway. Only users with administrative access to the gateway can view and change gateway-level settings. Extension configuration is always visible. The Account section shows which user account was used to sign in to the gateway. The Language section now also allows customization of the Region for date/time format customization. The Access section has also been updated to improve clarity.

Notification updates
Notifications now update in-place, so you won’t see multiple toasts for the same process – they’ll just update as the status of the process changes. The notification pane now also groups notifications by type so you can easily see All, Error & Warning, Active, or Info notifications.

Registered Insiders may download Windows Admin Center Preview 1806 directly from the Windows Server Insider Preview download page, under the Additional Downloads dropdown. If you have not yet registered as an Insider, see Getting Started with Windows Server on the Windows Insiders for Business portal.

The most important part of a frequent release cycle is to hear what’s working and what needs to be improved, so your feedback is extremely valued. Send us feedback via UserVoice. We also encourage you to visit the Windows Admin Center space on the Microsoft Tech Communities forum to collaborate, share and learn from experts.

Windows Server 2008 R2 connections – The remote desktop tool is currently not available due to a bug in the HTML RD client.
Scheduled Tasks – Lack of form validation and error message formatting.
SDN – SDN environments with Kerberos authentication for Northbound communication are not supported in this preview.
VMs on HCI – Connecting virtual machine to an SDN logical network is not supported in this preview release.
If you encounter other issues, please post on the Windows Admin Center space in the Windows Server Community for Insiders.

This is pre-release software – it is provided for use “as-is” and is not supported in production environments. Users are responsible for installing any updates made available from Windows Update for as long as this build is available   All pre-release software made available to you via the Windows Server Insider program are governed by the Insider Terms of Use, which takes precedence over any license agreement that may be in the product.
No downtime for Hustle-As-A-Service,Dona

Announcing Windows Server 2019 Insider Preview Build 17692 – Windows Experience Blog

Hello Windows Insiders!Today we are pleased to release a new build of the Windows Server vNext Long-Term Servicing Channel (LTSC) release that contains both the Desktop Experience and Server Core in all 18 server languages, as well as a new build of the next Windows Server Semi-Annual Channel release in English. In addition, the first preview of Microsoft Hyper-V Server is included with this build.
For 17692 only, we recommend a clean install. See Known Issues, below. Build-to-build upgrade is currently not supported.

Click here to see the full list of new functionality introduced in earlier builds of Windows Server.
Microsoft Hyper-V 2019 Preview
This is the first Insider Preview of Microsoft Hyper-V 2019. Microsoft Hyper-V Server is a stand-alone product that contains only the Windows hypervisor, a Windows Server driver model, and virtualization components. It provides a simple and reliable virtualization solution to help you improve your server utilization and reduce costs.
The Windows hypervisor technology in Microsoft Hyper-V Server is the same as what’s in the Hyper-V role on Windows Server. So, much of the content available for the Hyper-V role on Windows Server 2016 also applies to Microsoft Hyper-V Server.
System Insights
System Insights is a new feature available in Windows Server 2019 that brings local predictive analytics capabilities natively to Windows Server. These predictive capabilities—each backed by a machine-learning model—locally analyze Windows Server system data, such as performance counters and events, providing insight into the functioning of your deployments and helping you reduce the operational expenses associated with monitoring your Windows Server instances.
Because each of these capabilities runs locally, all your data is collected, persisted, and analyzed directly on your Windows Server instance, allowing you to use predictive analytics capabilities without any cloud connectivity. In Windows Server 2019, System Insights introduces a set of capabilities focused on capacity forecasting, predicting future usage for compute, networking, and storage.

You can manage System Insights through an intuitive Windows Admin Center extension or directly through PowerShell, and System Insights allows you to manage each capability individually. This includes configuring custom schedules to run each capability and adding remediation scripts to automatically address any issue detected by a capability.
For more information about System Insights, please visit aka.ms/SystemInsights.

Windows Admin Center Preview 1806
For full details, see the Windows Admin Center Preview 1806 Announcement.
Server Core App Compatibility Feature on Demand
This new Feature on Demand (FoD) significantly improves the app compatibility of Windows Server Core by including a set of binaries and packages from Windows Server with Desktop, without adding any of the Windows Server Desktop GUI or Windows 10 GUI experiences. The FoD package is available on a separate ISO and installs on Windows Server Core only.
Available operating system components with this build:
Performance Monitor (PerfMon.exe)
Resource Monitor (Resmon.exe)
Device Manager (Devmgmt.msc)
Microsoft Management Console (mmc.exe)
Windows PowerShell (Powershell_ISE.exe)
Failover Cluster Manager (CluAdmin.msc)
Process Monitor (Procmon.exe) and other Sysinternals
These components come with support for SQL Server Management Studio (SSMS) versions 16 and 17, which must be installed separately from SQL Server via command line.
Event Viewer is currently blocked (see Known Issues)
To install Failover Cluster Manager, launch PowerShell, and then enter the following command:
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools
To run Failover Cluster Manager, enter cluadmin at a regular command prompt.
You may download procmon from Process Monitor v3.50. For more information about Sysinternals, see Windows Sysinternals.
Please try out this FoD and verify that current applications and tools run on the preview release as expected.
Important: Also, please try any server app (MS or otherwise) that you would like to use on Server Core but currently cannot.  Let us know of any successes or failures.
The following installation procedure uses Deployment Image Servicing and Management (DISM.exe), a command-line tool. For more information about DISM commands, see DISM Capabilities Package Servicing Command-Line Options.
To install Server Core with FoD binaries
Download the FoD ISO and copy the ISO to a shared folder on your local network.
Download the ISO of the matching preview release of Windows Server and install the operating system. Do not choose Desktop Experience options; the FoD is for Server Core only.
Sign in as administrator on the newly installed preview release of Server Core.
Use net use, or some other method, to connect to the location of the FoD ISO.
Copy the FoD ISO to a local folder of your choosing.
Start PowerShell by entering powershell.exe at a command prompt.
Mount the FoD ISO by using the following command:Mount-DiskImage -ImagePath ‘drive_letter:folder_where_ISO_is_saved ‘
Enter exit to exit PowerShell.
Enter the following command:DISM /Online /Add-Capability /CapabilityName:”ServerCore.AppCompatibility~~~~0.0.1.0″ /Source:drive_letter_of_mounted_ISO: /LimitAccess
After the progress bar completes, restart the operating system at the prompt.

Windows Server 2019 Preview is available in ISO format in 18 languages, and in VHDX format in English only. This build and all future pre-release builds will require use of activation keys during setup. The following keys allow for unlimited activations:
Datacenter Edition
 6XBNX-4JQGW-QX6QG-74P76-72V67
Standard Edition
 MFY9F-XBN2F-TYFMP-CCV49-RMYVH
Windows Server vNext Semi-Annual Preview The Server Core Edition is available in English only, in ISO or VHDX format. The images are pre-keyed –  no need to enter a key during setup.
Symbols are available on the public symbol server – see Update on Microsoft’s Symbol Server blog post and Using the Microsoft Symbol Server. As before, matching Windows Server container images will be available via Docker Hub. For more information about Windows Server containers and Insider builds, click here.
This build will expire December 14th, 2018.

To obtain the Insider software downloads, registered Insiders may navigate directly to the Windows Server Insider Preview download page.  If you have not yet registered as an Insider, see GETTING STARTED WITH SERVER on the Windows Insiders for Business portal.

Use your registered Windows 10 Insider device and use the Feedback Hub application. In the app, choose the Server category and then the appropriate subcategory for your feedback. In the title of the Feedback, please indicate the build number you are providing feedback on in this format:
[Server #####] Title of my feedback
We also encourage you to visit the Windows Server Insiders space on the Microsoft Tech Communities forum to collaborate, share and learn from experts.

NEW] If a system is upgraded to a recent preview release, administrator credentials do not work. Administrator accounts are not accessible, and administrator credentials do not work for elevation of privilege. This issue affects systems that were running build 17655 or earlier before being upgraded.
[NEW] Event Viewer (eventmgr.msc) becomes unresponsive when a user attempts to view the details of an event if App Compatibility, a Feature on Demand (FoD), is installed on the system. To recover, the process (Microsoft Management Console) must be terminated.
Docker commands may fail when run on a Windows Server container. After a Docker command has failed on an affected system, subsequent Docker commands will also fail.
Creating or modifying environment variables by using setx on a system running Nano Server fails. On an affected system, setx requires a specific path in the registry, HKCUEnvironment, to exist by default.
The Virtual Machine Management Service (VMMS) may experience an error, APPLICATION_FAULT_INVALID_POINTER_READ, in Cluster Manager.
A virtual machine that uses a Microsoft Virtual BIOS may fail to start and report an error: “Failed to restore with Error ‘Indicates two revision levels are incompatible.’ (0x8007051A)”
Editing or creating policies for AppLocker can cause the MMC snap-in to crash when generated rules for a packaged app.

This is pre-release software – it is provided for use “as-is” and is not supported in production environments. Users are responsible for installing any updates made available from Windows Update for as long as this build is available   All pre-release software made available to you via the Windows Server Insider program are governed by the Insider Terms of Use, which takes precedence over any license agreement that may be in the product.
No downtime for Hustle-As-A-Service,Dona

Improved JavaScript and WebAssembly performance in EdgeHTML 17 – Microsoft Edge Dev Blog

In every release of Microsoft Edge, we tune the Chakra JavaScript engine to provide better startup and execution performance, with a leaner memory footprint, and with improved responsiveness on real-world workloads.As EdgeHTML 17 rolls out to users as part of the Windows 10 April 2018 Update, we’d like to dive into some of the optimizations we’ve made in the Chakra engine in this release. These ongoing optimizations can have a dramatic impact on the day-to-day browsing experience for end users, resulting in faster sites and web apps.

(Re-)defer parsing for arrow functions and object literals methods
Over the past two Windows releases, we have been improving Chakra’s defer- and re-defer-parsing pipeline, allowing pages to start up faster while consuming less memory.
When given a script, Chakra performs a quick pre-parse check for syntax errors and defers the full parsing of any eligible function until it is first called. Re-deferring happens at a later point when Chakra heuristics determines that a fully parsed function is unlikely to be called again, in which case Chakra releases the memory holding the metadata generated during full parsing and leaves the function effectively in a state as if it had been just pre-parsed and deferred.
In EdgeHTML 17, we have continued to invest in this pipeline, and extended the list of functions eligible to include arrow functions and methods on object literals.

// parsing of these functions are deferred until called
// arrow functions
let addOne = (x) => {x + 1};

// object literal methods
let john = {
name: ‘John Doe’,
get name() {return this.name},
greet() {console.log(‘Hello’)}
};

The impact of this change can vary depending on the sites, but our early experiments show an average memory savings of 7% from this and a few other memory improvements in EdgeHTML 17.
RegExp bytecode refactoring
Many Microsoft Edge users rely on extensions for ad blocking and related scenarios to control their experience while browsing the internet. Some ad blocking extensions are built using a considerable amount of RegExp logic, which motivated us to make a series of bytecode refactoring changes for a leaner experience when running with these extensions enabled in Microsoft Edge.
Most significant among those changes is that Chakra condensed RegExp opcodes from 4 bytes to 1 and packed the structs. While the consequential unalignment might imply a performance slowdown, data collected on various scenarios indicates that it shouldn’t cause any visible performance regression.

As a result of this refactoring, Chakra was able to reduce RegExp bytecode memory in some popular extensions in this release by up to 10%, savings that should be reflected in other apps or sites using RegExp as well.

In addition to memory savings, EdgeHTML 17 brings improvements to several JavaScript built-ins, building on optimizations initially enabled in EdgeHTML 16.
Type sharing for Object.create
Object.create is used to support JavaScript inheritance and null is also often tossed in to create a lean and mean dictionary/property bag. Chakra has an internal type system, and each object in Chakra is represented with an internal dynamic type. Many Chakra optimizations depend on objects with similar layout sharing types with each other. For example, inline caches can store fast paths for various types encountered at call sites, and objects with the same or an equivalent type are able use the same fast path as the cached type.
Type sharing between {x: 1}, {x: 2, y: 2}, {x: 3, z: 3}
Previously, however, objects created by Object.create were associated with a special null type handler in Chakra that cannot share types with other objects, so these optimizations didn’t apply to objects created using Object.create.

let dict1 = Object.create(null);
let dict2 = Object.create(null);
let dict3 = Object.create(null);
dict1.x = 1;
dict2.x = 2; dict2.y = 2;
dict3.x = 3; dict3.z = 3;
// because Object.create cannot share types, o.x in 2nd/3rd calls are cache misses
foo(dict1);
foo(dict2);
foo(dict3);

Beginning with EdgeHTML 17, Object.create returns objects with sharable types. Object.create(Object) now has the normal Object type, and Object.create(null) uses a new null type handler sharable with other Object.create(null) and compatible objects. dict1, 2 and 3 in the above example can now share types and have equivalent types, hence o.x in foo(dict2) and foo(dict3) are cache hits. This change results in an up to 25% speedup in some AngularJS workloads.
Polymorphic inline cache for Object.assign
Object.assign is an ES2015 feature often used to merge or clone objects. In EdgeHTML 16, we improved bracket access (o[prop]) by deploying polymorphic inline cache, which is able to cache multiple types and their associated fast paths at a given call site. With EdgeHTML 17, we’ve propagated the same optimization to benefit Object.assign, which upon de-sugaring involves a sequence of o[prop] style calls.

// an illustrative Object.assign polyfill
function assign(target, …sources) {
sources.forEach(src => {
for (let prop in src) {
// multiple types and fast paths can now be cached at target/src call sites
// therefore improves Object.assign performance
target[prop] = src[prop]
}
});
return target;
}

This simple optimization results in a roughly 2% improvement in some React/Redux workflows, and we expect to further improve performance for this pattern in the next release.
JSON.parse/stringify optimizations
JSON.parse and JSON.stringify are your handy JSON serialization tools in JavaScript. Interestingly, it is also a fairly common pattern to make nested JSON.parse(JSON.stringify(obj)) calls to clone data objects.
Previously, Chakra implemented JSON.stringify by first scaning the object to be serialized, creating the necessary metadata, allocating a large enough buffer for the output string, creating intermediate sub-strings (for each quote, comma, key, value, etc.), and concatenating them together one-by-one.
The creation of intermediate strings caused a lot of redundancy in terms of both time and memory, so in EdgeHTML 17, Chakra skips creating those substrings altogether, and also delays filling up the output string from the metadata until it is actually needed. In the case of a JSON.parse(JSON.stringify(obj) call, the serialized object string is never actually created, and Chakra is able to construct the output object from the metadata generated during stringify.

let obj = {a: 1, b: 2};
let str = JSON.stringify(obj); // scans obj & create metadata
let objClone = JSON.parse(str); // re-construct obj from metadata, no string created
console.log(str); // JSON string creation is delayed until here

This change leads to JSON.stringify being roughly 40% faster in internal performance tests and roughly 70% faster for nested parse/stringify calls.
Rewriting Array Iterators in JavaScript and faster for…of
For…of performance on array also received a major boost in the EdgeHTML 17, and is up to 2.5x faster according to our testing. This speedup is achieved through rewriting the C++ Array Iterators implementation in JavaScript.
We had contemplated a feature rewrite in JS before―many JS optimizations didn’t apply to the C++ implementation, plus next() calls in C++ allocate objects on the heap, which is more expensive than JS stack allocation. The major challenge with a JS implementation is that de-sugared for…of involves a try/catch/finally block to handle cases of abrupt completion, which would have disabled most Chakra optimizations.
To work around those limitations, we made efforts to turn on JIT optimizations for functions with try/catch/finally in EdgeHTML 16, and later enabled inlining for the same as well. With those pre-requisites in place, we were able to rewrite for…of in JS, which runs much faster on non-excepting path.

Microsoft has been working closely with the WebAssembly Community Group (CG) to evolve this growing technology, and we shipped the WebAssembly MVP last year in EdgeHTML 16.
In EdgeHTML 17, WebAssembly (and asm.js) gets even faster with inlining support, which speeds up the workloads we’ve been tracking by about 4.5%. For ChakraCore embedders, WebAssembly is not only available on Windows, but also on Linux and MacOS, as we fixed calling convention issues.
A number of new and exciting WebAssembly features are being discussed within the CG, such as threads, reference types (for host interop), and ES modules integration. We look forward to continuing to collaborate with the CG to move this technology forward and to landing additional features as they progress on the standards track.

It’s always exciting to share more about performance enhancements to Chakra and Microsoft Edge. As always, we’ll continue to make enhancements in future releases, and your feedback is one of the key signals for us to decide what to do next.
We encourage you to dive in and try out these improvements for yourself, and be sure to share your thoughts with us on the ChakraCore repo, or via @MSEdgeDev and @ChakraCore on Twitter!
– Limin Zhu, Program Manager, Chakra
Updated June 19, 2018 12:36 pm

Windows 10 Tip: How to start using Nearby Sharing with the Windows 10 April 2018 Update – Windows Experience Blog

Did you know the Windows 10 April 2018 Update includes a way you can now instantly share your videos, photos, documents, and websites with people and devices near you over Bluetooth or Wi-Fi?

It’s called Nearby Sharing. Here’s what you can do with it:
Share quickly. Send any video, photo, document, or webpage viewed on Microsoft Edge to people nearby by clicking on the share charm in the app or right-clicking to get the share menu. You can share a report with a colleague in your meeting room or a vacation photo with your best friend in the library.*
Take the quickest path. Your computer automatically picks the fastest way to share your file or webpage, either over Bluetooth or Wi-Fi.
See who’s available. Bluetooth allows you to quickly discover potential devices with which you could share.**
Here’s how to get started:
In your Action Center, click on Nearby Sharing to turn it on. From there, click the Share icon in your file, photo, Microsoft Edge webpage or more to share with nearby devices.
Head over here to read more about what’s new in the Windows 10 April 2018 Update!
*Sharing is only available between Windows 10 PCs. Nearby sharing must be enabled on both devices.
**Recipients can choose whether to accept the item a user wants to share.

Enhancing automated testing in Microsoft Edge with new WebDriver capabilities, W3C protocol support, and automatic updates – Microsoft Edge Dev Blog

Just last week, the WebDriver specification officially became a W3C Recommendation, defining a standard way for web developers and browser engineers to automate the browser. This is a major step forward for web site and web app testing, as well as cross-browser interoperability initiatives like web-platform-tests.Over the past few months we’ve been working to implement the updated W3C dialect for WebDriver in Microsoft Edge—a generational improvement to automated testing on the web. Today’s Windows Insider Preview release (17692) includes our updated implementation, as well as making it a Feature on Demand, so it’s easier than ever to get started.

WebDriver needs to match the version of Microsoft Edge you’re testing against, which has historically required manually matching a standalone download of WebDriver to the appropriate version of Windows on your device.
Beginning with today’s preview release, we’ve made WebDriver a Windows Feature on Demand (FoD), which ensures that it’s always up to date automatically, and enables some new ways to get Microsoft WebDriver.
The simplest way to get started is simply to enable Developer Mode. Simply open the Settings app and go to “Update & Security,” “For developers,” and select “Developer Mode.” The appropriate version of WebDriver will be automatically installed.
You can also install a standalone version of WebDriver in one of two ways:
Search “Manage optional features” from Start, then select “Add a Feature,” “WebDriver.”
Install via DISM by running the following command in an elevated command prompt: DISM.exe /Online /Add-Capability /CapabilityName:Microsoft.WebDriver~~~~0.0.1.0
This also means that we will no longer be providing standalone downloads for Microsoft WebDriver going forward, however we will keep previous releases (RS4 and down level) available on our download page.

Actions API and new commands
The Actions API allows for low level input into the browser via action sequences, allowing developers to send multiple streams of input to test complex scenarios. Our implementation currently supports both mouse and keyboard input.
We’ve also added support for new commands including Get Timeouts, Get Window Rect, Set Window Rect and Get Element Property.
Improved interoperability
We’ve also implemented new logic for a number of commands, in order to improve interoperability and reduce test flakiness when running in Microsoft Edge:
Supporting CSS pixels for Set Window Rect, so that we scale properly for high-DPI devices when resizing
Adding calculations for in-view center point to impact what is/isn’t clickable and requires scrolling
Adding proper support for implicit wait to commands that were missing it
Using the Selenium implementation for Get Element Text
Testing PWAs and WebViews
These updates also apply to automated testing of PWAs and WebViews. So if you’ve been using WebDriver to test your web app you should now be able to enjoy these new benefits and bug fixes. We’ve also enabled WebDriver support for out of process WebViews.

As we move forward, we are working our way through the WebDriver web platform tests, fixing failures, and making sure our implementation is up to spec. As of our latest run we’re now passing 783 web platform tests out of 951. We’re tracking most of the  remaining failures being as interoperability bugs or as missing features, and look forward to continuing to close the gap in future releases.
This is the most significant update since we first brought automated testing to Microsoft Edge with WebDriver. With these changes, it’s easier than ever to build interoperable web sites through cross-browser testing.
We encourage you to get started with the implementation in Windows Insider Preview build 17692 or higher, and share your feedback on Twitter or in the Feedback Hub app on Windows. Let us know what you think!
– Clay Martin, Program Manager, Microsoft Edge

Updated June 14, 2018 10:12 am

Announcing Windows 10 Insider Preview Build 17692 – Windows Experience Blog

Hello Windows Insiders!Today, we are releasing Windows 10 Insider Preview Build 17692 (RS5) to Windows Insiders in the Fast ring in addition to those who opted in to Skip Ahead.

SwiftKey intelligence comes to Windows
SwiftKey gives you more accurate autocorrections and predictions by learning your writing style – including the words, phrases and emoji that matter to you. It’s available for Android and iOS, and starting with today’s build SwiftKey will now power the typing experience on Windows when using the touch keyboard to write in English (United States), English (United Kingdom), French (France), German (Germany), Italian (Italy), Spanish (Spain), Portuguese (Brazil), or Russian.

Please take a moment to try typing and shapewriting on the touch keyboard in this build and let us know what you think
Microsoft Edge improvements
Control whether media can play automatically: One common piece of Insider feedback for Microsoft Edge is that you want more control over autoplay videos. In this build, we’ve added a new setting in Microsoft Edge to allow you to control whether sites can autoplay media. You can find an early preview of this setting under “Advanced Settings,” “Allow sites to automatically play media.” We’ll be improving these options and adding additional controls in upcoming flights and in response to your feedback, so stay tuned!
EDIT: Woops! We got a little too excited about this – this change is actually coming in a new build in the next few weeks. Stay tuned!
WebDriver improvements: Beginning with this build, we’re making it easier than ever to automate testing in Microsoft Edge using WebDriver. First, we’ve made WebDriver a Windows Feature on Demand, so you no longer need to match the build/branch/flavor manually when installing WebDriver. When you take new Windows 10 updates, your WebDriver binary will be automatically updated to match.
To install WebDriver, just turn on Developer Mode in Windows 10 Settings, or install the standalone feature under the “optional features” Settings page.
We’ve also updated WebDriver to match the latest W3C Recommendation spec with major new improvements. You can learn all about these changes over at the Microsoft Edge Dev Blog.
Ease of Access Improvements
Make Text Bigger: We’ve heard your feedback and are excited to announce that the ability to increase text size across the system is back and better than ever! When you go to Settings > Ease of Access > Display in today’s build, you’ll find a new setting called “Make everything bigger” – this slider will adjust text across the system, win32 apps, and UWP apps.

That means you can now make text bigger in Start menu, File Explorer, Settings, etc., without having to change the overall scaling of your system. Please try it out and share feedback!
Note: We’re investigating some issues with text clipping, not increasing in size everywhere, and problems when changing DPI settings.
Narrator Improvements
Based on your feedback you’ll find we’ve made a bunch of updates to Narrator with today’s build:
Narrator Standard Keyboard Layout: Narrator now ships with a new keyboard layout that is designed to be more familiar to screen reader users. Please refer to the accompanying documentation for details on these changes (Intro to New Narrator Keyboard Layout doc).
Automatic Dialog Reading: Narrator will now automatically read the contents of a dialog box when brought to the foreground.  The experience is for Narrator to speak the title of the dialog, the focused element within the dialog and the static text, if any, at the top of the dialog. For example, if you try to close a document in Word with unsaved changes, Narrator will speak the title “Microsoft Word,” the focus “Save button” and the static text within the dialog.
Narrator Find: You now have the ability to search for text using Narrator’s new Find feature. If the text is found Narrator will move to the found item. Please refer to the accompanying keyboard layout documentation for command mapping.
List of Objects: Narrator now has the ability to present a list of links, headings or landmarks present in the application or content. You are also able to filter the results by typing in the list or the text field of the window. Please refer to the accompanying keyboard layout documentation for command mapping.
Selection in Scan Mode: Along with being able to select content in Narrator’s scan mode using Shift-selection commands, you can now also select a block of data by first moving to one end of the block and pressing F9, moving to the other end of the block and pressing F10. Once F10 is pressed the entire contents between the two points will be selected.
Stop on Controls in Scan Mode: Scan mode is a feature of Narrator that lets you use just a few keys to move around your screen. Scan mode is already on by default in Edge and you can toggle it on and off by pressing Caps lock + Spacebar. While you’re in scan mode, you can press the Up and Down arrow keys to read different parts of the page. With this update, the press of a Down arrow in Scan Mode will stop on interactive elements, so that they are easier to use. An example of this new behavior is that if you are reading a paragraph with multiple links, Narrator will stop on these links when you press the Down arrow.
We would love to hear what you think as you try out these improvements. This link will take you to the Narrator section of the Feedback Hub, or you can press Caps + E while Narrator is running.
Game bar Improvements
We’re now rolling out more functionality to the RS5 Game bar. In this flight are the following new features:
Audio controls. Change your default audio output device and mute or adjust the volume of games and apps running.
Performance visualizations. See your game’s framerate (FPS), CPU usage, GPU VRAM usage, and system RAM usage.

Game Mode Improvements
New options are now available for Game Mode that are expected to improve the gaming experience on desktop PCs.  Gamers on PCs with many background processes may also see performance improvements when they toggle “Dedicate resources” in Game bar.
Search Improvements
Find software downloads faster in Search!  Continuing our theme of improving the search preview experience, we’re rolling out an update to make it easier to find official download pages for Windows software you want to install. The team is continuing to develop this experience and more is coming. Check out the example below, and let us know what you think!

This is a server-side* change so Insiders may see this update outside of Build 17692.
*Some experiences may vary by region. 
Windows Mixed Reality Improvements
Starting with this build you can stream audio to both the headset and the PC speakers simultaneously. To try it out make sure that you can hear sound from your normal PC speakers when not running the Mixed Reality Portal (MRP) and from the headset’s audio jack or built-in headphones when mixed reality is running. Then close all apps, including MRP, and go to Settings > Mixed reality > Audio and speech to turn on “When Mixed Reality Portal is running, mirror headset audio to desktop.” You should now hear audio from both the headset and PC speakers when running mixed reality.
You may also notice some new error codes in Mixed Reality Portal to be more specific to certain failures. The Mixed Reality Portal app will also begin updating through the Store as we make infrastructure changes over the next several releases to support faster updates of mixed reality.

We fixed an issue resulting in audio glitching on systems with lots of firewall rules.
We fixed an issue from the last few flights where Eye Control would fail fast and not start.
We fixed an issue resulting in certain games, such as Counter Strike: Global Offensive, to crash on launch in the last two builds.
We fixed an issue resulting in Settings crashing when attempting to open Data Usage Settings in the last few flights.
We fixed an issue resulting in an unexpected “codecpacks.vp9” entry in the Start menu.
We fixed a recent issue for some Insiders resulting in an explorer.exe crash with AppXDeploymentClient.dll.
We fixed an issue resulting in some Insiders recently experiencing a bug check (green screen) with the error SYSTEM_SERVICE_EXCEPTION in afd.sys.
With Build 17672 we made a fix for an explorer.exe crash in structuredquery.dll – that fix stopped anyone new from encountering the crash, however we heard your reports that anyone already impacted was still impacted. Today’s build has a fix for this issue that should resolve it for anyone who was already impacted.
To improve discoverability, we’ve moved Delivery Optimization Settings to now be directly listed as a category under Settings > Update & Security.
We fixed an issue in Microsoft Edge impacting websites like Facebook.com, where when starting a message only the first contact name entered was automatically resolved while typing.
We fixed an issue in Microsoft Edge where if both images and text were selected, right-clicking on the image and selecting copy wouldn’t work.
We fixed an issue resulting in the Windows Security app crashing recently when adding a process to the exclusion list.

The login screen will crash in a loop when the active sign-in method is set to Picture Password. We recommend removing your Picture Password before upgrading to this build.
This build will only be offered to Insiders running Builds 17655 and higher. You will not be able to update from RS4 to this build without first taking Build 17686 first.
We’re working on adding dark theme in File Explorer and the Common File Dialog, but we still have some things to do. You may see some unexpectedly light colors in these surfaces when in dark mode.
DRM video playback in Microsoft Edge from websites such as Netflix is broke on this build. But you should be able to use the Netflix app to play videos.
Some Insiders may find increased reliability and performance issues when launching Start on this build. We’re investigating.
When you upgrade to this build you’ll find that the taskbar flyouts (network, volume, etc) no longer have an acrylic background.
There is a bug in these builds that will impact driver testing scenarios. When executing HLK Component/Device driver tests, you may experience a bug check that blocks test execution. We are aware of the issue and actively working on a fix.
Due to a merge conflict some settings in Settings may be unexpectedly missing and / or missing their labels.
When Narrator starts you will be presented with a dialog that informs the user of the change to Narrator’s keyboard layout. This dialog may not take focus or speak after Narrator has started. We recommend that you Alt + Tab to this dialog, which should cause it to read.
The Settings for Keyboard Settings found in the Ease of Access center are missing text as well as visible values in the two combo boxes. Narrator users can interact with these controls and get some information pertaining to the settings that are available to them.
When using scan mode you may experience multiple stops for a single control. An example of this is if you have an image that is also a link. This is something we are actively working on.
If you change Narrator’s default Narrator key to just caps lock the Insert key will continue to function until the caps lock key is used as the Narrator key or if the user restarts Narrator.
If the Narrator key is set to just Insert and you attempt to send a Narrator command from a braille display then these commands will not function. As long as the Caps Lock key is a part of the Narrator key mapping then braille functionality will work as designed.
There is a known issue in automatic dialog reading where the title of the dialog is being spoken more than once.
The state of a Narrator command such as toggling Scan Mode on and off, volume up and down, voice speed, changing verbosity and context verbosity commands may not be announced when executed.
If you have previously performed a Find using Narrator’s Find feature and you bring up the dialog the text will not be cleared from the field.
Please refer to the Narrator Keyboard Layout documentation for other issues found in this release that pertain to Narrator. (Intro to New Narrator Keyboard Layout doc).
ADDED: If you have a Surface Studio, it will fail to update to Builds 17682, 17686, and 17692. This bug is fixed and you will be able to update to the next build we flight.

Please note that there is an issue in this build that regresses the time it takes to remotely deploy and debug a UWP application to a local virtual machine or an emulator. Please skip this flight if you rely on deploying or debugging to a local virtual machine or an emulator for your UWP development. Please note, this does not impact deployment and debugging on the local machine, to a physical target device, or a remote machine. We have seen the following workaround alleviate some of the performance regression here:
From an admin PowerShell window, please run the Disable-NetAdapterLso cmdlet and pass in the virtual switch information using -name attribute.
Example: PS C:> Disable-NetAdapterLso -name
You can use Get-NetAdapterLso to retrieve the virtual switch information for the corresponding Virtual Machine.
If you install any of the recent builds from the Fast ring and switch to the Slow ring – optional content such as enabling developer mode will fail. You will have to remain in the Fast ring to add/install/enable optional content. This is because optional content will only install on builds approved for specific rings. There has not yet been a RS5 build released to the Slow ring.

The Game bar may crash on x86 machines.
The framerate counter chart sometimes doesn’t show up correctly over known games.
The CPU chart shows an incorrect percentage of usage in the top left corner.
Charts in the performance panel don’t update immediately when clicking through tabs.
The user’s gamerpic doesn’t display correctly, even after signing in.

We’ve got two stories from the Insider Community we want to highlight!
What do ninja cats and dragons have in common? Find out in this story, featuring an Insider who brings her creations to life with Windows Ink and Universal Windows Platform.
The Sisters of Mercy help people in harm’s way. Their IT Director is an Insider who protects the nuns from a different kind of threat. Check out our latest Insider Story.
And heads up Boston – Brandon LeBlanc and Jason Howard will be at the Prudential Center Microsoft Store on June 23rd from 1pm EST – 4pm EST to meet with Windows Insiders for some fun discussion on Windows 10! RSVP: https://aka.ms/bostoninsiders 

Our next Bug Bash will be from June 22nd – July 1st – we will be holding a Bug Bash Webcast on our Mixer channel on June 27th, exact timing will be announced closer to the date. We’re excited to do another Bug Bash with our Windows Insiders!
No downtime for Hustle-As-A-Service,Dona