Accenture to upgrade over 400,000 employees to Windows 10 by 2018

It’s remarkable how much technology can play a role in digitally transforming a business at a global scale. The way we work and collaborate is shifting, and I experience this firsthand every day at Microsoft. I enjoy working closely with customers across all industries who are so committed to their employees and dedicated to empowering them with the latest Microsoft technologies to do more and achieve more anytime, anywhere, like Accenture.

An Enhanced Way of Working

It’s Accenture’s mission to drive digital transformation for their clients, which also means they have to empower their own workforce of over 400,000 employees and become a prime example of what digital transformation can bring. At Accenture, they walk the walk, and talk the talk.

Accenture is preparing the future workforce and enabling their current workforce, which is now 75 percent millennial with a modern desktop. This offers Accenture employees access to the latest productivity apps while keeping their PC always secure and up to date. The way they work is changing and the kind of services they need are “cloud-first” that allow real-time engagement and collaboration. Windows 10, Office 365 and the Microsoft Enterprise Mobility + Security Suite are at the heart of the digital worker at Accenture and helping to increase productivity for them. OneDrive has transformed the way employees work across the company in different time zones, enabling them to collaborate and communicate in real time in a virtualized project environment. In fact, Accenture has the biggest OneDrive in the world at over 6 Peta-bites! Accenture has also seen maturity in Microsoft’s security value proposition with Windows 10 and EMS, allowing employees to operate in both a mobile and secure way.

“Office 365 and Windows 10 are at the heart of a digital worker proposition which is really speeding up our workforce.” – Andrew Wilson, chief operating officer at Accenture

Accenture is displaying the art of what’s possible with Microsoft technologies and the company is the largest deployment of Windows 10 – and I’m pleased to share Accenture will be completing over 400,000 Windows 10 upgrades by 2018. Let me share how Accenture is making this all possible.

Windows 10 Deployment

A global Windows 10 project team began the upgrade project in September 2015, which first tested all business applications and validated compatibility with Windows 10. Then, the team proceeded with Windows 10 deployment to employees. By April 2016, initial deployment began with a “two-lane” deployment approach. First, they upgraded all new PCs with Windows 10 and provided a manual upgrade option for early adopters. The second deployment began in August 2016, which addressed existing PCs running Windows 7 and allowed employees to utilize an In-Place Upgrade tool and process that uses OneDrive for file distribution to perform a Windows 10 upgrade.

The In-Place Upgrade Tool played a key part in supporting deployments at pace and scale. The best part is the tool eliminated the need to come into an Accenture office to have an IT person perform the upgrade. Employees could make the upgrade wherever and whenever.

It’s incredible seeing Accenture accomplish the upgrade to Windows 10 in just a span of two years. Check out their case study to learn more.

Windows 10 SDK Preview Build 16225 Released

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 16225 or greater). The Preview SDK Build 16225 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 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 Creators build or earlier to the store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.

Known Issues

  • Designer fails to render: When viewing the XAML in the Designer Window in Visual Studio, the controls fail to render. This can be resolved by using Visual Studio 2017.3 Preview.
  • Compilation fails on non-Windows 10 platforms: When building apps on previous platforms, you may get a build error:

C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll:C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll(0,0): Error WMC0621: Cannot resolve ‘GenXbf.dll’ under path ‘C:program files (x860Windows Kits10bin10.0.16225.0x86genxbf.dll’. Please install the latest version of the Windows 10 Software Development Kit.
Process ‘msbuild.exe’ exited with code ‘1’.

This will occur if the minimum target platform version is set to 10.0.16225.0. To work around this, right click on your project file and choose properties or open your project file in your favorite editor, and change the version to a previous released SDK. For example:


Breaking Changes

API Updates and Additions

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.

namespace Windows.ApplicationModel.Calls {
public sealed class VoipCallCoordinator {
VoipPhoneCall SetupNewAcceptedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
public sealed class VoipPhoneCall {
void TryShowAppUI();
namespace Windows.ApplicationModel {
public enum StartupTaskState {
DisabledByPolicy = 3,
namespace Windows.Devices.SmartCards {
public sealed class SmartCardCryptogramGenerator {
public static bool IsSupported();
public enum SmartCardCryptogramGeneratorOperationStatus {
NotSupported = 13,
public sealed class SmartCardEmulator {
public static bool IsSupported();
namespace Windows.ApplicationModel {
public static class DesignMode {
public static bool DesignMode2Enabled { get; }
public sealed class PackageCatalog {
IAsyncOperation<PackageCatalogRemoveOptionalPackagesResult> RemoveOptionalPackagesAsync(IIterable<string> optionalPackageFamilyNames);
public sealed class PackageCatalogRemoveOptionalPackagesResult
namespace Windows.ApplicationModel.Activation {
public enum ActivationKind {
CommandLineLaunch = 1021,
GameUIProvider = 1019,
PrintWorkflowForegroundTask = 1018,
StartupTask = 1020,
public sealed class CommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
public sealed class CommandLineActivationOperation
public interface ICommandLineActivatedEventArgs : IActivatedEventArgs
public interface IStartupTaskActivatedEventArgs : IActivatedEventArgs
public sealed class StartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
namespace Windows.ApplicationModel.Appointments {
public sealed class AppointmentStore {
AppointmentStoreChangeTracker GetChangeTracker(string identity);
public sealed class AppointmentStoreChangeTracker {
bool IsTracking { get; }
namespace Windows.ApplicationModel.AppService {
public sealed class AppServiceTriggerDetails {
IAsyncOperation<bool> CheckCallerForCapabilityAsync(string capabilityName);
namespace Windows.ApplicationModel.Background {
public sealed class GeovisitTrigger : IBackgroundTrigger
public sealed class PaymentAppCanMakePaymentTrigger : IBackgroundTrigger
namespace Windows.ApplicationModel.Contacts {
public sealed class ContactChangeTracker {
bool IsTracking { get; }
public sealed class ContactList {
ContactListLimitedWriteOperations LimitedWriteOperations { get; }
ContactChangeTracker GetChangeTracker(string identity);
public sealed class ContactListLimitedWriteOperations
public enum ContactListOtherAppWriteAccess {
Limited = 2,
public sealed class ContactStore {
ContactChangeTracker GetChangeTracker(string identity);
namespace Windows.ApplicationModel.Contacts.DataProvider {
public sealed class ContactDataProviderConnection {
event TypedEventHandler<ContactDataProviderConnection, ContactListCreateOrUpdateContactRequestEventArgs> CreateOrUpdateContactRequested;
event TypedEventHandler<ContactDataProviderConnection, ContactListDeleteContactRequestEventArgs> DeleteContactRequested;
public sealed class ContactListCreateOrUpdateContactRequest
public sealed class ContactListCreateOrUpdateContactRequestEventArgs
public sealed class ContactListDeleteContactRequest
public sealed class ContactListDeleteContactRequestEventArgs
namespace Windows.ApplicationModel.Core {
public sealed class AppListEntry {
string AppUserModelId { get; }
public enum AppRestartFailureReason
public static class CoreApplication {
public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
public sealed class CoreApplicationView {
DispatcherQueue DispatcherQueue { get; }
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataTransferManager {
public static void ShowShareUI(ShareUIOptions options);
public sealed class ShareUIOptions
public enum ShareUITheme
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
public sealed class ShareOperation {
IVectorView<Contact> Contacts { get; }
namespace Windows.ApplicationModel.Email {
public sealed class EmailMailbox {
EmailMailboxChangeTracker GetChangeTracker(string identity);
namespace Windows.ApplicationModel.Payments {
public sealed class PaymentCanMakePaymentResult
public enum PaymentCanMakePaymentResultStatus
public sealed class PaymentMediator {
IAsyncOperation<PaymentCanMakePaymentResult> CanMakePaymentAsync(PaymentRequest paymentRequest);
public sealed class PaymentRequest {
public PaymentRequest(PaymentDetails details, IIterable<PaymentMethodData> methodData, PaymentMerchantInfo merchantInfo, PaymentOptions options, string id);
string Id { get; }
namespace Windows.ApplicationModel.Payments.Provider {
public sealed class PaymentAppCanMakePaymentTriggerDetails
namespace Windows.ApplicationModel.UserActivities {
public interface IUserActivityContentInfo
public sealed class UserActivity
public sealed class UserActivityAttribution
public sealed class UserActivityChannel
public sealed class UserActivityContentInfo : IUserActivityContentInfo
public sealed class UserActivitySession : IClosable
public enum UserActivityState
public sealed class UserActivityVisualElements
namespace Windows.ApplicationModel.UserActivities.Core {
public static class CoreUserActivityManager
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothDevice : IClosable {
BluetoothDeviceId BluetoothDeviceId { get; }
public sealed class BluetoothDeviceId {
public static BluetoothDeviceId FromId(string deviceId);
public sealed class BluetoothLEDevice : IClosable {
BluetoothDeviceId BluetoothDeviceId { get; }
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
public sealed class GattClientNotificationResult {
ushort BytesSent { get; }
namespace Windows.Devices.Geolocation {
public sealed class Geovisit
public sealed class GeovisitMonitor
public sealed class GeovisitStateChangedEventArgs
public sealed class GeovisitTriggerDetails
public enum VisitMonitoringScope
public enum VisitStateChange
namespace Windows.Devices.PointOfService {
public sealed class ClaimedLineDisplay : IClosable {
LineDisplayCustomGlyphs CustomGlyphs { get; }
Size MaxBitmapSizeInPixels { get; }
IVectorView<int> SupportedCharacterSets { get; }
IVectorView<Size> SupportedScreenSizesInCharacters { get; }
event TypedEventHandler<ClaimedLineDisplay, LineDisplayStatusUpdatedEventArgs> StatusUpdated;
IAsyncOperation<string> CheckHealthAsync(UnifiedPosHealthCheckLevel level);
IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
LineDisplayAttributes GetAttributes();
IAsyncOperation<string> GetStatisticsAsync(IIterable<string> statisticsCategories);
IAsyncOperation<bool> TryClearDescriptorsAsync();
IAsyncOperation<LineDisplayWindow> TryCreateWindowAsync(Rect viewport, Size windowSize);
IAsyncOperation<bool> TrySetDescriptorAsync(uint descriptor, LineDisplayDescriptorState descriptorState);
IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap);
IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
IAsyncOperation<LineDisplayStoredBitmap> TryStoreStorageFileBitmapAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
IAsyncOperation<bool> TryUpdateAttributesAsync(LineDisplayAttributes attributes);
public sealed class LineDisplay : IClosable {
public static LineDisplayStatisticsCategorySelector StatisticsCategorySelector { get; }
IAsyncOperation<LineDisplayPowerStatus> CheckPowerStatusAsync();
public sealed class LineDisplayAttributes
public sealed class LineDisplayCursor
public sealed class LineDisplayCursorAttributes
public enum LineDisplayCursorType
public sealed class LineDisplayCustomGlyphs
public enum LineDisplayDescriptorState
public enum LineDisplayHorizontalAlignment
public sealed class LineDisplayMarquee
public enum LineDisplayMarqueeFormat
public enum LineDisplayPowerStatus
public sealed class LineDisplayStatisticsCategorySelector
public sealed class LineDisplayStatusUpdatedEventArgs
public sealed class LineDisplayStoredBitmap
public enum LineDisplayVerticalAlignment
public sealed class LineDisplayWindow : IClosable {
LineDisplayCursor Cursor { get; }
LineDisplayMarquee Marquee { get; }
IAsyncOperation<uint> ReadCharacterAtCursorAsync();
IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap);
IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment);
IAsyncOperation<bool> TryDisplayStorageFileBitmapAtCursorAsync(StorageFile bitmap, LineDisplayHorizontalAlignment horizontalAlignment, LineDisplayVerticalAlignment verticalAlignment, int widthInPixels);
IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels);
IAsyncOperation<bool> TryDisplayStorageFileBitmapAtPointAsync(StorageFile bitmap, Point offsetInPixels, int widthInPixels);
IAsyncOperation<bool> TryDisplayStoredBitmapAtCursorAsync(LineDisplayStoredBitmap bitmap);
namespace Windows.Devices.Sensors {
public sealed class Accelerometer {
public static IAsyncOperation<Accelerometer> FromIdAsync(string deviceId);
public static string GetDeviceSelector(AccelerometerReadingType readingType);
public sealed class AccelerometerReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Altimeter {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public sealed class AltimeterReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Barometer {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<Barometer> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public sealed class BarometerReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Compass {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<Compass> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public sealed class CompassReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Gyrometer {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<Gyrometer> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public sealed class GyrometerReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Inclinometer {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<Inclinometer> FromIdAsync(string deviceId);
public static string GetDeviceSelector(SensorReadingType readingType);
public sealed class InclinometerReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class LightSensor {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<LightSensor> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public sealed class LightSensorReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class Magnetometer {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<Magnetometer> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public sealed class MagnetometerReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
public sealed class OrientationSensor {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public static IAsyncOperation<OrientationSensor> FromIdAsync(string deviceId);
public static string GetDeviceSelector(SensorReadingType readingType);
public static string GetDeviceSelector(SensorReadingType readingType, SensorOptimizationGoal optimizationGoal);
public sealed class OrientationSensorReading {
IReference<TimeSpan> PerformanceCount { get; }
IMapView<string, object> Properties { get; }
namespace Windows.Devices.Sensors.Custom {
public sealed class CustomSensor {
uint MaxBatchSize { get; }
uint ReportLatency { get; set; }
public sealed class CustomSensorReading {
IReference<TimeSpan> PerformanceCount { get; }
namespace Windows.Devices.WiFi {
public sealed class WiFiAdapter {
IAsyncOperation<WiFiConnectionResult> ConnectAsync(WiFiAvailableNetwork availableNetwork, WiFiReconnectionKind reconnectionKind, PasswordCredential passwordCredential, string ssid, WiFiConnectionMethod connectionMethod);
IAsyncOperation<WiFiWpsConfigurationResult> GetWpsConfigurationAsync(WiFiAvailableNetwork availableNetwork);
public enum WiFiConnectionMethod
public sealed class WiFiWpsConfigurationResult
public enum WiFiWpsConfigurationStatus
public enum WiFiWpsKind
namespace Windows.Gaming.Input {
public sealed class RawGameController : IGameController, IGameControllerBatteryInfo {
string DisplayName { get; }
string NonRoamableId { get; }
IVectorView<SimpleHapticsController> SimpleHapticsControllers { get; }
namespace Windows.Gaming.UI {
public sealed class GameMonitor
public enum GameMonitoringPermission
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
PresentationLayerDrmMode DrmMode { get; set; }
PresentationLayerConfig CreateLayerConfig();
PresentationLayers GetPresentationLayers();
void SetLayerConfig(PresentationLayerConfig layerConfig);
public sealed class HolographicCameraRenderingParameters {
PresentationLayerRenderingParametersQuad GetPresentationLayerRenderingParameters(PresentationLayerQuad layer);
public sealed class HolographicDisplay {
double RefreshRate { get; }
public sealed class HolographicSpace {
public static bool IsConfigured { get; }
public sealed class PresentationLayerConfig
public enum PresentationLayerDrmMode
public sealed class PresentationLayerQuad
public sealed class PresentationLayerReference
public sealed class PresentationLayerRenderingParametersQuad
public sealed class PresentationLayers
public sealed class PresentationLayerSettings
public enum PresentationLayerType
namespace Windows.Graphics.Printing.PrintTicket {
public sealed class PrintTicketCapabilities
public sealed class PrintTicketFeature
public enum PrintTicketFeatureSelectionType
public sealed class PrintTicketOption
public enum PrintTicketParameterDataType
public sealed class PrintTicketParameterDefinition
public sealed class PrintTicketParameterInitializer
public sealed class PrintTicketValue
public enum PrintTicketValueType
public sealed class WorkflowPrintTicket
public sealed class WorkflowPrintTicketValidationResult
namespace Windows.Graphics.Printing.Workflow {
public sealed class PrintWorkflowBackgroundSession
public sealed class PrintWorkflowBackgroundSetupRequestedEventArgs
public sealed class PrintWorkflowConfiguration
public sealed class PrintWorkflowForegroundSession
public sealed class PrintWorkflowForegroundSetupRequestedEventArgs
public sealed class PrintWorkflowObjectModelSourceFileContent
public sealed class PrintWorkflowObjectModelTargetPackage
public enum PrintWorkflowSessionStatus
public sealed class PrintWorkflowSourceContent
public sealed class PrintWorkflowSpoolStreamContent
public sealed class PrintWorkflowStreamTarget
public sealed class PrintWorkflowSubmittedEventArgs
public sealed class PrintWorkflowSubmittedOperation
public enum PrintWorkflowSubmittedStatus
public sealed class PrintWorkflowTarget
public sealed class PrintWorkflowTriggerDetails
public sealed class PrintWorkflowUIActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser
public sealed class PrintWorkflowXpsDataAvailableEventArgs
namespace Windows.Management.Deployment {
public enum AddPackageByAppInstallerOptions : uint
public sealed class PackageManager {
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> ProvisionPackageForAllUsersAsync(string packageFamilyName);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageByAppInstallerFileAsync(Uri appInstallerFileUri, AddPackageByAppInstallerOptions options, PackageVolume targetVolume);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions options, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> packageUrisToInstall, IIterable<Uri> relatedPackageUris);
namespace Windows.Media.Capture {
public sealed class AppCapture {
public static IAsyncAction SetAllowedAsync(bool allowed);
namespace Windows.Media.Capture.Frames {
public sealed class MediaFrameReader : IClosable {
MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
public enum MediaFrameReaderAcquisitionMode
public sealed class MultiSourceMediaFrameReader : IClosable {
MediaFrameReaderAcquisitionMode AcquisitionMode { get; set; }
namespace Windows.Media.Core {
public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
string Label { get; set; }
public interface IMediaStreamDescriptor2 : IMediaStreamDescriptor
public sealed class InitializeMediaStreamSourceRequestedEventArgs
public static class LowLightFusion
public sealed class LowLightFusionResult : IClosable
public sealed class MediaSource : IClosable, IMediaPlaybackSource {
public static MediaSource CreateFromMediaFrameSource(MediaFrameSource frameSource);
public sealed class MediaSourceAppServiceConnection
public sealed class MediaStreamSource : IMediaSource {
bool IsLive { get; set; }
public sealed class MseStreamSource : IMediaSource {
IReference<MseTimeRange> LiveSeekableRange { get; set; }
public sealed class SceneAnalysisEffectFrame : IClosable, IMediaFrame {
SceneAnalysisRecommendation AnalysisRecommendation { get; }
public enum SceneAnalysisRecommendation
public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
string Label { get; set; }
namespace Windows.Media.DialProtocol {
public sealed class DialReceiverApp
namespace Windows.Media.MediaProperties {
public sealed class MediaEncodingProfile {
IVector<AudioStreamDescriptor> GetAudioTracks();
IVector<VideoStreamDescriptor> GetVideoTracks();
void SetAudioTracks(IIterable<AudioStreamDescriptor> value);
void SetVideoTracks(IIterable<VideoStreamDescriptor> value);
namespace Windows.Media.Playback {
public sealed class MediaPlaybackSessionBufferingStartedEventArgs
public sealed class MediaPlayer : IClosable {
event TypedEventHandler<MediaPlayer, object> SubtitleFrameChanged;
bool RenderSubtitlesToSurface(IDirect3DSurface destination);
bool RenderSubtitlesToSurface(IDirect3DSurface destination, Rect targetRectangle);
namespace Windows.Media.Protection.PlayReady {
public enum PlayReadyEncryptionAlgorithm {
Aes128Cbc = 5,
Unspecified = 65535,
public enum PlayReadyHardwareDRMFeatures {
Aes128Cbc = 3,
namespace Windows.Media.SpeechRecognition {
public sealed class SpeechRecognizer : IClosable {
public static IAsyncOperation<bool> TrySetSystemSpeechLanguageAsync(Language speechLanguage);
namespace Windows.Media.SpeechSynthesis {
public sealed class SpeechSynthesizer : IClosable {
public static IAsyncOperation<bool> TrySetDefaultVoiceAsync(VoiceInformation voice);
public sealed class SpeechSynthesizerOptions {
double AudioPitch { get; set; }
double AudioVolume { get; set; }
double SpeakingRate { get; set; }
namespace Windows.Media.Streaming.Adaptive {
public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
HResult ExtendedError { get; }
public enum AdaptiveMediaSourceDiagnosticType {
FatalMediaSourceError = 8,
namespace Windows.Networking.BackgroundTransfer {
public struct BackgroundTransferFileRange
public sealed class BackgroundTransferRangesDownloadedEventArgs
public enum BackgroundTransferStatus {
PausedRecoverableWebErrorStatus = 8,
public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
IReference<WebErrorStatus> CurrentWebErrorStatus { get; }
bool IsRandomAccessRequired { get; set; }
IVector<WebErrorStatus> RecoverableWebErrorStatuses { get; }
Uri RequestedUri { get; set; }
event TypedEventHandler<DownloadOperation, BackgroundTransferRangesDownloadedEventArgs> RangesDownloaded;
IVector<BackgroundTransferFileRange> GetDownloadedRanges();
IRandomAccessStreamReference GetResultRandomAccessStreamReference();
namespace Windows.Networking.Connectivity {
public sealed class ConnectionProfile {
IAsyncOperation<IVectorView<ProviderNetworkUsage>> GetProviderNetworkUsageAsync(DateTime startTime, DateTime endTime, NetworkUsageStates states);
public sealed class ProviderNetworkUsage
namespace Windows.Networking.NetworkOperators {
public sealed class MobileBroadbandAntennaSar
public sealed class MobileBroadbandCellCdma
public sealed class MobileBroadbandCellGsm
public sealed class MobileBroadbandCellLte
public sealed class MobileBroadbandCellsInfo
public sealed class MobileBroadbandCellTdscdma
public sealed class MobileBroadbandCellUmts
public sealed class MobileBroadbandModem {
IAsyncOperation<bool> GetIsPassthroughEnabledAsync();
IAsyncOperation<MobileBroadbandModemStatus> SetIsPassthroughEnabledAsync(bool value);
public sealed class MobileBroadbandModemConfiguration {
MobileBroadbandSarManager SarManager { get; }
public enum MobileBroadbandModemStatus
public sealed class MobileBroadbandNetwork {
IAsyncOperation<MobileBroadbandCellsInfo> GetCellsInfoAsync();
public sealed class MobileBroadbandSarManager
public sealed class MobileBroadbandTransmissionStateChangedEventArgs
namespace Windows.Networking.Sockets {
public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
TimeSpan ActualUnsolicitedPongInterval { get; }
Certificate ClientCertificate { get; set; }
TimeSpan DesiredUnsolicitedPongInterval { get; set; }
MessageWebSocketReceiveMode ReceiveMode { get; set; }
public sealed class MessageWebSocketMessageReceivedEventArgs {
bool IsMessageComplete { get; }
public enum MessageWebSocketReceiveMode
public enum SocketProtectionLevel {
Unspecified = 9,
public sealed class StreamSocketControl {
SocketProtectionLevel MinProtectionLevel { get; set; }
public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
TimeSpan ActualUnsolicitedPongInterval { get; }
Certificate ClientCertificate { get; set; }
TimeSpan DesiredUnsolicitedPongInterval { get; set; }
namespace Windows.Security.Authentication.Web.Provider {
public static class WebAccountManager {
public static IAsyncAction InvalidateAppCacheForAccountAsync(WebAccount webAccount);
public static IAsyncAction InvalidateAppCacheForAllAccountsAsync();
namespace Windows.Services.Maps {
public sealed class MapRoute {
bool IsScenic { get; }
public enum MapRouteOptimization {
Scenic = 3,
public sealed class PlaceInfo
public sealed class PlaceInfoCreateOptions
namespace Windows.Storage {
public sealed class StorageLibrary {
IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
public sealed class StorageProvider {
IAsyncOperation<bool> IsPropertySupportedForPartialFileAsync(string propertyCanonicalName);
namespace Windows.Storage.Search {
public enum IndexerOption {
OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
namespace Windows.Storage.Streams {
public enum FileOpenDisposition
public sealed class FileRandomAccessStream : IClosable, IInputStream, IOutputStream, IRandomAccessStream {
public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode);
public static IAsyncOperation<IRandomAccessStream> OpenAsync(string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode);
public static IAsyncOperation<IRandomAccessStream> OpenForUserAsync(User user, string filePath, FileAccessMode accessMode, StorageOpenOptions sharingOptions, FileOpenDisposition openDisposition);
public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath);
public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath);
public static IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteForUserAsync(User user, string filePath, StorageOpenOptions openOptions, FileOpenDisposition openDisposition);
namespace Windows.System {
public sealed class AppDiagnosticInfo {
AppResourceGroupInfoWatcher CreateResourceGroupWatcher();
public static AppDiagnosticInfoWatcher CreateWatcher();
IVector<AppResourceGroupInfo> GetResourceGroups();
public static IAsyncOperation<DiagnosticAccessStatus> RequestAccessAsync();
public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync();
public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForAppAsync(string appUserModelId);
public static IAsyncOperation<IVector<AppDiagnosticInfo>> RequestInfoForPackageAsync(string packageFamilyName);
public sealed class AppDiagnosticInfoWatcher
public sealed class AppDiagnosticInfoWatcherEventArgs
public enum AppDiagnosticInfoWatcherStatus
public sealed class AppMemoryReport {
ulong ExpectedTotalCommitLimit { get; }
public sealed class AppResourceGroupBackgroundTaskReport
public enum AppResourceGroupEnergyQuotaState
public enum AppResourceGroupExecutionState
public sealed class AppResourceGroupInfo
public sealed class AppResourceGroupInfoWatcher
public sealed class AppResourceGroupInfoWatcherEventArgs
public sealed class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs
public enum AppResourceGroupInfoWatcherStatus
public sealed class AppResourceGroupMemoryReport
public sealed class AppResourceGroupStateReport
public enum DiagnosticAccessStatus
public sealed class DispatcherQueue
public sealed class DispatcherQueueController
public delegate void DispatcherQueueHandler();
public enum DispatcherQueuePriority
public sealed class DispatcherQueueShutdownStartingEventArgs
public sealed class DispatcherQueueTimer
public static class MemoryManager {
public static ulong ExpectedAppMemoryUsageLimit { get; }
namespace Windows.System.Diagnostics {
public sealed class DiagnosticActionResult
public enum DiagnosticActionState
public sealed class DiagnosticInvoker
public sealed class ProcessDiagnosticInfo {
bool IsPackaged { get; }
IVector<AppDiagnosticInfo> GetAppDiagnosticInfos();
public static ProcessDiagnosticInfo TryGetForProcessId(uint processId);
namespace Windows.System.Profile {
public enum SystemIdentificationSource {
Registry = 3,
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
string ManufacturerDisplayName { get; }
string ModelDisplayName { get; }
public static class RemoteSystemKinds {
public static string Iot { get; }
public static string Laptop { get; }
public static string Tablet { get; }
namespace Windows.System.UserProfile {
public static class GlobalizationPreferences {
public static bool TrySetHomeGeographicRegion(string region);
public static bool TrySetLanguages(IIterable<string> languageTags);
namespace Windows.UI.Composition {
public sealed class AmbientLight : CompositionLight {
float Intensity { get; set; }
public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
InitialValueExpressionCollection InitialValueExpressions { get; }
public sealed class CompositionColorGradientStop : CompositionObject
public sealed class CompositionColorGradientStopCollection : IIterable<CompositionColorGradientStop>, IVector<CompositionColorGradientStop>
public enum CompositionColorSpace {
HslLinear = 3,
RgbLinear = 4,
public enum CompositionDropShadowSourcePolicy
public class CompositionGradientBrush : CompositionBrush
public enum CompositionGradientExtendMode
public class CompositionLight : CompositionObject {
VisualUnorderedCollection ExclusionsFromTargets { get; }
public sealed class CompositionLinearGradientBrush : CompositionGradientBrush
public class CompositionObject : IClosable {
DispatcherQueue DispatcherQueue { get; }
public sealed class CompositionTarget : CompositionObject {
public sealed class Compositor : IClosable {
CompositionColorGradientStop CreateColorGradientStop();
CompositionColorGradientStop CreateColorGradientStop(float offset, Color color);
CompositionLinearGradientBrush CreateLinearGradientBrush();
SpringScalarNaturalMotionAnimation CreateSpringScalarAnimation();
SpringVector2NaturalMotionAnimation CreateSpringVector2Animation();
SpringVector3NaturalMotionAnimation CreateSpringVector3Animation();
public sealed class DistantLight : CompositionLight {
float Intensity { get; set; }
public sealed class DropShadow : CompositionShadow {
CompositionDropShadowSourcePolicy SourcePolicy { get; set; }
public sealed class InitialValueExpressionCollection : CompositionObject, IIterable<IKeyValuePair<string, string>>, IMap<string, string>
public sealed class LayerVisual : ContainerVisual {
CompositionShadow Shadow { get; set; }
public class NaturalMotionAnimation : CompositionAnimation
public sealed class PointLight : CompositionLight {
float Intensity { get; set; }
public class ScalarNaturalMotionAnimation : NaturalMotionAnimation
public sealed class SpotLight : CompositionLight {
float InnerConeIntensity { get; set; }
float OuterConeIntensity { get; set; }
public sealed class SpringScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
public sealed class SpringVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
public sealed class SpringVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
public class Vector2NaturalMotionAnimation : NaturalMotionAnimation
public class Vector3NaturalMotionAnimation : NaturalMotionAnimation
namespace Windows.UI.Composition.Effects {
public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource {
SceneLightingEffectReflectanceModel ReflectanceModel { get; set; }
public enum SceneLightingEffectReflectanceModel
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionTracker : CompositionObject {
void ConfigureVector2PositionInertiaModifiers(IIterable<InteractionTrackerVector2InertiaModifier> modifiers);
public sealed class InteractionTrackerInertiaNaturalMotion : InteractionTrackerInertiaModifier
public class InteractionTrackerVector2InertiaModifier : CompositionObject
public sealed class InteractionTrackerVector2InertiaNaturalMotion : InteractionTrackerVector2InertiaModifier
namespace Windows.UI.Core {
public enum CoreCursorType {
Person = 15,
Pin = 14,
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
CoreWindowActivationMode ActivationMode { get; }
DispatcherQueue DispatcherQueue { get; }
public enum CoreWindowActivationMode
namespace Windows.UI.Input {
public sealed class RadialControllerConfiguration {
public static RadialController AppController { get; set; }
public static bool IsAppControllerEnabled { get; set; }
namespace Windows.UI.Input.Inking.Core {
public sealed class CoreIncrementalInkStroke
public sealed class CoreInkPresenterHost
namespace Windows.UI.Input.Preview.Injection {
public sealed class InjectedInputGamepadInfo
public sealed class InputInjector {
void InitializeGamepadInjection();
void InjectGamepadInput(InjectedInputGamepadInfo input);
public static InputInjector TryCreateForAppBroadcastOnly();
void UninitializeGamepadInjection();
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionController {
IAsyncOperation<IRandomAccessStreamWithContentType> TryGetRenderableModelAsync();
public sealed class SpatialInteractionSource {
SpatialInteractionSourceHandedness Handedness { get; }
public enum SpatialInteractionSourceHandedness
public sealed class SpatialInteractionSourceLocation {
IReference<Vector3> AngularVelocity { get; }
SpatialInteractionSourcePositionQuality PositionQuality { get; }
SpatialPointerInteractionSourcePose SourcePointerPose { get; }
public enum SpatialInteractionSourcePositionQuality
public sealed class SpatialPointerInteractionSourcePose {
Quaternion Orientation { get; }
SpatialInteractionSourcePositionQuality PositionQuality { get; }
namespace Windows.UI.Shell {
public static class AdaptiveCardBuilder
public interface IAdaptiveCard
public interface IAdaptiveCardBuilderStatics
public sealed class TaskbarManager
namespace Windows.UI.StartScreen {
public sealed class SecondaryTileVisualElements {
TileMixedRealityModel MixedRealityModel { get; }
public sealed class TileMixedRealityModel
namespace Windows.UI.Text.Core {
public enum CoreTextInputScope {
Digits = 28,
PinAlphanumeric = 65,
PinNumeric = 64,
namespace Windows.UI.ViewManagement {
public enum UIElementType {
AccentColor = 1000,
NonTextHigh = 1005,
NonTextLow = 1009,
NonTextMedium = 1007,
NonTextMediumHigh = 1006,
NonTextMediumLow = 1008,
OverlayOutsidePopup = 1012,
PageBackground = 1010,
PopupBackground = 1011,
TextContrastWithHigh = 1004,
TextHigh = 1001,
TextLow = 1003,
TextMedium = 1002,
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView
public sealed class CoreInputViewOcclusion
public enum CoreInputViewOcclusionKind
public sealed class CoreInputViewOcclusionsChangedEventArgs
namespace Windows.UI.WebUI {
public static class WebUIApplication {
public static IAsyncOperation<AppRestartFailureReason> RequestRestartAsync(string launchArguments);
public static IAsyncOperation<AppRestartFailureReason> RequestRestartForUserAsync(User user, string launchArguments);
public sealed class WebUICommandLineActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICommandLineActivatedEventArgs
public sealed class WebUIStartupTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IStartupTaskActivatedEventArgs
namespace Windows.UI.Xaml {
public class FrameworkElement : UIElement {
ElementTheme ActualTheme { get; }
public static DependencyProperty ActualThemeProperty { get; }
event TypedEventHandler<FrameworkElement, object> ActualThemeChanged;
public enum TextAlignment {
End = 2,
Start = 1,
public class UIElement : DependencyObject {
public static RoutedEvent CharacterReceivedEvent { get; }
IVector<KeyboardAccelerator> KeyboardAccelerators { get; }
public static RoutedEvent PreviewKeyDownEvent { get; }
public static RoutedEvent PreviewKeyUpEvent { get; }
event TypedEventHandler<UIElement, CharacterReceivedRoutedEventArgs> CharacterReceived;
event KeyEventHandler PreviewKeyDown;
event KeyEventHandler PreviewKeyUp;
event TypedEventHandler<UIElement, ProcessKeyboardAcceleratorEventArgs> ProcessKeyboardAccelerators;
virtual IIterable<DependencyObject> GetChildrenInTabFocusOrder();
virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
namespace Windows.UI.Xaml.Automation.Peers {
public enum AutomationNotificationKind
public enum AutomationNotificationProcessing
public class AutomationPeer : DependencyObject {
void RaiseNotificationEvent(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string displayString, string activityId);
public class ColorPickerSliderAutomationPeer : SliderAutomationPeer
public class ColorSpectrumAutomationPeer : FrameworkElementAutomationPeer
public class AutomationPeer : ListViewItemAutomationPeer
public class PersonPictureAutomationPeer : FrameworkElementAutomationPeer
public class RatingControlAutomationPeer : FrameworkElementAutomationPeer
public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer
public class TreeViewListAutomationPeer : SelectorAutomationPeer
namespace Windows.UI.Xaml.Controls {
public class BitmapIconSource : IconSource
public enum CharacterCasing
public sealed class ColorChangedEventArgs
public class ColorPicker : Control
public enum ColorPickerHsvChannel
public enum ColorSpectrumComponents
public enum ColorSpectrumShape
public class ComboBox : Selector {
Brush PlaceholderForeground { get; set; }
public static DependencyProperty PlaceholderForegroundProperty { get; }
public class ContentDialog : ContentControl {
IAsyncOperation<ContentDialogResult> ShowAsync(ContentDialogPlacement placement);
public enum ContentDialogPlacement
public class Control : FrameworkElement {
virtual void OnCharacterReceived(CharacterReceivedRoutedEventArgs e);
virtual void OnPreviewKeyDown(KeyRoutedEventArgs e);
virtual void OnPreviewKeyUp(KeyRoutedEventArgs e);
public enum DisabledFormattingAccelerators : uint
public class FontIconSource : IconSource
public class Grid : Panel {
double ColumnSpacing { get; set; }
public static DependencyProperty ColumnSpacingProperty { get; }
double RowSpacing { get; set; }
public static DependencyProperty RowSpacingProperty { get; }
public class IconSource : DependencyObject
public sealed class IsTextTrimmedChangedEventArgs
public class MediaTransportControls : Control {
bool IsRepeatButtonVisible { get; set; }
public static DependencyProperty IsRepeatButtonVisibleProperty { get; }
bool IsRepeatEnabled { get; set; }
public static DependencyProperty IsRepeatEnabledProperty { get; }
bool ShowAndHideAutomatically { get; set; }
public static DependencyProperty ShowAndHideAutomaticallyProperty { get; }
void Hide();
void Show();
public class NavigationView : ContentControl
public enum NavigationViewDisplayMode
public sealed class NavigationViewDisplayModeChangedEventArgs
public class NavigationViewItem : NavigationViewItemBase
public class NavigationViewItemBase : ListViewItem
public class NavigationViewItemHeader : NavigationViewItemBase
public sealed class NavigationViewItemInvokedEventArgs
public class NavigationViewItemSeparator : NavigationViewItemBase
public class NavigationViewList : ListView
public sealed class NavigationViewSelectionChangedEventArgs
public enum ParallaxSourceOffsetKind
public class ParallaxView : FrameworkElement
public sealed class PasswordBox : Control {
event TypedEventHandler<PasswordBox, PasswordBoxPasswordChangingEventArgs> PasswordChanging;
public sealed class PasswordBoxPasswordChangingEventArgs
public class PathIconSource : IconSource
public class PersonPicture : Control
public class RatingControl : Control
public class RatingItemFontInfo : RatingItemInfo
public class RatingItemImageInfo : RatingItemInfo
public class RatingItemInfo : DependencyObject
public class RichEditBox : Control {
CharacterCasing CharacterCasing { get; set; }
public static DependencyProperty CharacterCasingProperty { get; }
DisabledFormattingAccelerators DisabledFormattingAccelerators { get; set; }
public static DependencyProperty DisabledFormattingAcceleratorsProperty { get; }
TextAlignment HorizontalTextAlignment { get; set; }
public static DependencyProperty HorizontalTextAlignmentProperty { get; }
event TypedEventHandler<RichEditBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
event TypedEventHandler<RichEditBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
public sealed class RichTextBlock : FrameworkElement {
TextAlignment HorizontalTextAlignment { get; set; }
public static DependencyProperty HorizontalTextAlignmentProperty { get; }
bool IsTextTrimmed { get; }
public static DependencyProperty IsTextTrimmedProperty { get; }
IVector<TextHighlighter> TextHighlighters { get; }
event TypedEventHandler<RichTextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
public sealed class RichTextBlockOverflow : FrameworkElement {
bool IsTextTrimmed { get; }
public static DependencyProperty IsTextTrimmedProperty { get; }
event TypedEventHandler<RichTextBlockOverflow, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
public class SplitView : Control {
event TypedEventHandler<SplitView, object> PaneOpened;
event TypedEventHandler<SplitView, object> PaneOpening;
public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
double Spacing { get; set; }
public static DependencyProperty SpacingProperty { get; }
public enum SwipeBehaviorOnInvoked
public class SwipeControl : ContentControl
public class SwipeItem : DependencyObject
public sealed class SwipeItemInvokedEventArgs
public class SwipeItems : DependencyObject, IIterable<SwipeItem>, IVector<SwipeItem>
public enum SwipeMode
public enum Symbol {
GlobalNavigationButton = 59136,
Print = 59209,
Share = 59181,
XboxOneConsole = 59792,
public class SymbolIconSource : IconSource
public sealed class TextBlock : FrameworkElement {
TextAlignment HorizontalTextAlignment { get; set; }
public static DependencyProperty HorizontalTextAlignmentProperty { get; }
bool IsTextTrimmed { get; }
public static DependencyProperty IsTextTrimmedProperty { get; }
IVector<TextHighlighter> TextHighlighters { get; }
event TypedEventHandler<TextBlock, IsTextTrimmedChangedEventArgs> IsTextTrimmedChanged;
public class TextBox : Control {
CharacterCasing CharacterCasing { get; set; }
public static DependencyProperty CharacterCasingProperty { get; }
TextAlignment HorizontalTextAlignment { get; set; }
public static DependencyProperty HorizontalTextAlignmentProperty { get; }
Brush PlaceholderForeground { get; set; }
public static DependencyProperty PlaceholderForegroundProperty { get; }
event TypedEventHandler<TextBox, TextBoxBeforeTextChangingEventArgs> BeforeTextChanging;
event TypedEventHandler<TextBox, TextControlCopyingToClipboardEventArgs> CopyingToClipboard;
event TypedEventHandler<TextBox, TextControlCuttingToClipboardEventArgs> CuttingToClipboard;
public sealed class TextBoxBeforeTextChangingEventArgs
public sealed class TextControlCopyingToClipboardEventArgs
public sealed class TextControlCuttingToClipboardEventArgs
public class TreeView : Control
public sealed class TreeViewExpandingEventArgs
public class TreeViewItem : ListViewItem
public sealed class TreeViewItemClickEventArgs
public class TreeViewList : ListView
public class TreeViewNode : DependencyObject, IBindableIterable, IBindableObservableVector, IBindableVector
public enum TreeViewSelectionMode
public sealed class XamlBooleanToVisibilityConverter : IValueConverter
public sealed class XamlIntegerToIndentationConverter : IValueConverter
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapControl : Control {
IVector<MapLayer> Layers { get; set; }
public static DependencyProperty LayersProperty { get; }
bool TryGetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
bool TryGetLocationFromOffset(Point offset, out Geopoint location);
public class MapElement : DependencyObject {
string MapStyleSheetEntry { get; set; }
public static DependencyProperty MapStyleSheetEntryProperty { get; }
string MapStyleSheetEntryState { get; set; }
public static DependencyProperty MapStyleSheetEntryStateProperty { get; }
object Tag { get; set; }
public static DependencyProperty TagProperty { get; }
public sealed class MapElement3D : MapElement
public sealed class MapElementsLayer : MapLayer
public sealed class MapElementsLayerClickEventArgs
public sealed class MapElementsLayerContextRequestedEventArgs
public sealed class MapElementsLayerPointerEnteredEventArgs
public sealed class MapElementsLayerPointerExitedEventArgs
public class MapLayer : DependencyObject
public class MapModel3D : DependencyObject
public enum MapModel3DShadingOption
public static class MapStyleSheetEntries
public static class MapStyleSheetEntryStates
namespace Windows.UI.Xaml.Controls.Primitives {
public class ColorPickerSlider : Slider
public class ColorSpectrum : Control
public class FlyoutBase : DependencyObject {
virtual void OnProcessKeyboardAccelerators(ProcessKeyboardAcceleratorEventArgs args);
void TryInvokeKeyboardAccelerator(ProcessKeyboardAcceleratorEventArgs args);
public sealed class LayoutInformation {
public static Size GetAvailableSize(UIElement element);
public class ListViewItemPresenter : ContentPresenter {
Brush RevealBackground { get; set; }
public static DependencyProperty RevealBackgroundProperty { get; }
bool RevealBackgroundShowsAboveContent { get; set; }
public static DependencyProperty RevealBackgroundShowsAboveContentProperty { get; }
Brush RevealBorderBrush { get; set; }
public static DependencyProperty RevealBorderBrushProperty { get; }
Thickness RevealBorderThickness { get; set; }
public static DependencyProperty RevealBorderThicknessProperty { get; }
namespace Windows.UI.Xaml.Data {
public enum UpdateSourceTrigger {
LostFocus = 3,
namespace Windows.UI.Xaml.Documents {
public class Block : TextElement {
TextAlignment HorizontalTextAlignment { get; set; }
public static DependencyProperty HorizontalTextAlignmentProperty { get; }
public sealed class Hyperlink : Span {
bool IsTabStop { get; set; }
public static DependencyProperty IsTabStopProperty { get; }
int TabIndex { get; set; }
public static DependencyProperty TabIndexProperty { get; }
public class TextHighlighter
public class TextHighlighterBase : DependencyObject
public struct TextRange
namespace Windows.UI.Xaml.Input {
public sealed class CharacterReceivedRoutedEventArgs : RoutedEventArgs
public class KeyboardAccelerator : DependencyObject
public sealed class KeyboardAcceleratorInvokedEventArgs
public sealed class PointerRoutedEventArgs : RoutedEventArgs {
bool IsGenerated { get; }
public sealed class ProcessKeyboardAcceleratorEventArgs
namespace Windows.UI.Xaml.Markup {
public class MarkupExtension
public sealed class MarkupExtensionReturnTypeAttribute : Attribute
namespace Windows.UI.Xaml.Media {
public enum AcrylicBackgroundSource
public class AcrylicBrush : XamlCompositionBrushBase
public class RevealBackgroundBrush : RevealBrush
public class RevealBorderBrush : RevealBrush
public class RevealBrush : XamlCompositionBrushBase
public enum RevealBrushState
namespace Windows.Web {
public enum WebErrorStatus {
InsufficientRangeSupport = 22,
MissingContentLengthSupport = 23,
namespace Windows.Gaming.Preview.GamesEnumeration {
public static class GameList {
public static IAsyncOperation<GameListEntry> MergeEntriesAsync(GameListEntry left, GameListEntry right);
public static IAsyncOperation<IVectorView<GameListEntry>> UnmergeEntryAsync(GameListEntry mergedEntry);
public sealed class GameListEntry : IGameListEntry {
GameModeConfiguration GameModeConfiguration { get; }
GameListEntryLaunchableState LaunchableState { get; }
IStorageFile LauncherExecutable { get; }
string LaunchParameters { get; }
string TitleId { get; }
IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile);
IAsyncAction SetLauncherExecutableFileAsync(IStorageFile executableFile, string launchParams);
IAsyncAction SetTitleIdAsync(string id);
public enum GameListEntryLaunchableState
public sealed class GameModeConfiguration
public sealed class GameModeUserConfiguration
namespace Windows.Graphics.Printing3D {
public sealed class Printing3D3MFPackage {
Printing3DPackageCompression Compression { get; set; }
public enum Printing3DPackageCompression
namespace Windows.Media.Capture {
public sealed class AppBroadcastBackgroundService {
string BroadcastChannel { get; set; }
string BroadcastLanguage { get; set; }
string BroadcastTitle { get; set; }
event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastChannelChanged;
event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastLanguageChanged;
event TypedEventHandler<AppBroadcastBackgroundService, object> BroadcastTitleChanged;
public sealed class AppBroadcastBackgroundServiceSignInInfo {
event TypedEventHandler<AppBroadcastBackgroundServiceSignInInfo, object> UserNameChanged;
public sealed class AppBroadcastBackgroundServiceStreamInfo {
void ReportProblemWithStream();
namespace Windows.Security.EnterpriseData {
public sealed class FileProtectionInfo {
bool IsProtectWhileOpenSupported { get; }
namespace Windows.Services.Maps.Guidance {
public sealed class GuidanceRoadSegment {
bool IsScenic { get; }
namespace Windows.Services.Maps.LocalSearch {
public static class PlaceInfoHelper
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapControlDataHelper : DependencyObject {
public static MapControl CreateMapControl(bool rasterRenderMode);
namespace Windows.System.Profile.SystemManufacturers {
public sealed class OemSupportInfo
public static class SystemSupportInfo
namespace Windows.System {
public static class DateTimeSettings
namespace Windows.UI.Xaml.Hosting {
public sealed class DesignerAppManager : IClosable
public sealed class DesignerAppView : IClosable
public enum DesignerAppViewState
public sealed class ProcessExitedEventArgs

Cumulative Update rolling out to Insiders in Slow ring

Hello Windows Insiders,

If you are in the Slow ring, we’ve released KB4022716 to keep you up to date with the latest Windows 10 Creators Update fixes as we prepare to release a new Windows 10 Fall Creators Update build in the coming weeks. As a result of receiving this update, your PC will be required to reboot to complete the update.

With the forth coming release of a new Windows 10 Fall Creators Update build to the Slow ring, we are testing a new update targeting framework and will be delivering the build in staggered phases. This will simulate the rollout process we use when we release major Windows 10 feature updates to retail customers.

When we release a new Windows 10 Fall Creators Update build to Insiders in the Slow ring, they can wait to be targeted to install the new build, or instead of waiting Insiders can manually check for updates via Windows Update to get the new build. We know this is different from our usual “everyone at once” model to the WIP rings, however this testing will provide invaluable insights to ensure this new targeting framework is functioning as expected.

We thank you for your patience while we complete this testing!

Keep hustling team,
Dona <3

How can IT put PowerShell Integrated Scripting Environment to use?

PowerShell Integrated Scripting Environment is a tool that can benefit all levels of users, which is why many developers and administrators use it almost exclusively when working with PowerShell — often skipping the original console altogether.

With PowerShell ISE, which provides a graphical user interface (GUI) for writing and fixing PowerShell scripts, IT administrators and developers can write, edit and run PowerShell scripts and commands. It provides a more user-friendly way to work with the wide range of features available for creating and testing PowerShell codes.

For example, PowerShell ISE includes IntelliSense for autocompleting commands and for matching cmdlets, variables, parameters and other language elements. The GUI also provides quick access to a variety of snippets that make it easier to construct command logic, such as looping structures. In addition, admins get multiple execution environments, selective code execution and the ability to run commands from either the PowerShell script or the console pane.

What else can PowerShell ISE do?

PowerShell script development

PowerShell Integrated Scripting Environment provides many other features to support PowerShell script development, such as drag-and-drop editing, tab completion, block selection, syntax coloring, keyboard shortcuts and Unicode support. Plus, admins can open PowerShell script files by dragging them from Windows Explorer to the PowerShell ISE GUI. They can even extend the PowerShell Integrated Scripting Environment object model to customize the deployment and add functionality.


Admins can also use PowerShell Integrated Scripting Environment to troubleshoot and debug PowerShell scripts. Although this goes hand in hand with script development, sometimes admins must fix an existing script and want to use PowerShell ISE’s debugging capabilities. Not only do they get features such as selective execution and multiple execution environments, but they can also set up breakpoints, step through code, check variable values and display call stacks. In addition, PowerShell Integrated Scripting Environment displays parsing errors as admins type.

PowerShell Integrated Scripting Environment is also useful as a learning tool.

Running complicated commands

Admins might also use PowerShell Integrated Scripting Environment when they want to run complex ad hoc commands and prefer to avoid the inherent clunkiness of the PowerShell console. With PowerShell ISE, they can type all their code in the script pane and then, when they’re ready, run part or all of the code. This also makes it easier to tweak the script if admins need to run it multiple times, incorporating slight modifications with each execution.


PowerShell Integrated Scripting Environment is also useful as a learning tool. Someone new to PowerShell can benefit a great deal from built-in features, such as IntelliSense, snippet access and parse error displays.

Powered by WPeMatico

Tricks and tools to prevent data loss in Office 365

online service, instead of wrestling with day-to-day tasks. This doesn’t mean that IT teams can ignore the possibility of data loss in Office 365.

While there is a sense of security that comes with a cloud service, organizations need to develop their own data retention plans for some Office 365 features.

Businesses rely on their email systems to stay in touch with employees, clients and suppliers. SharePoint remains an integral component for enterprise content management in many organizations. Companies that shift these workloads — and their data — to Microsoft’s cloud platform should be aware that email and content stored in SharePoint or OneDrive are not, by default, protected against accidental or intentional deletions.

With a move to Office 365, some in IT have abandoned disaster recovery (DR) and business continuity plans (BCP) that were required to recover on-premises email and SharePoint platforms. IT teams only need redundant connectivity to the cloud and must trust that Microsoft’s infrastructure, data centers and systems will provide necessary data protection from hardware and software failures.

In Exchange Online, IT teams can only restore an entire mailbox within 30 days after deletion; after that point, they can ask Microsoft for an additional 14 days for a 44-day window of data recovery. SharePoint and OneDrive face similar challenges, as they do not offer easy or efficient ways to restore site collections or lists that have been deleted and removed from the recycle bin.

Filling Office 365’s DR and BCP gaps

Many companies have gaps in their DR plans; an inability to restore data from a specific point of time can lead to risks. While Microsoft offers service-level agreements of 99.9%, Office 365 has limited capabilities around backups — even though some suggest that on-hold features and retention or preservation policies can prevent data loss in Office 365. These options, however, are limited and do not offer easy ways to recover or restore data.

There are several tools on the market – based both in the cloud and on premises — for Office 365 data protection and DR, including SkyKick, Datto, Spanning and AvePoint. These tools offer automated backup of emails, calendars, OneDrive and, in some cases, SharePoint site collections — without the need for any on-premises infrastructure.

Many of the third-party tools can help IT address some of their backup needs around the Office 365 workloads — email, SharePoint and OneDrive. Admins can be confident that some of their digital assets are protected and that their DR plans are complete. But, in reality, as more users expand into other Office 365 services — such as Planner, Office Groups, PowerApps and Flow — Microsoft or other third-party tools need to play catch-up to protect data stored in those services. Currently, those services don’t offer any backup methods.

When evaluating Office 365, plan for Office 365 backups and implement them immediately after going live. Skipping that step would lead to serious risks and an incomplete DR plan. Those organizations that make the switch without the use of backup services put themselves at risk for data loss in Office 365.

Powered by WPeMatico

Smooth Interaction and Motion with the Visual Layer in Windows 10 Creators Update

The Composition APIs come with a robust animation engine that provides quick and fluid motion running in a separate process from your Universal Windows Platform (UWP) app. This ensures a consistent 60 frames per second when running your app on an IoT device as well as on a screaming gaming machine. It is, quite simply, fast. This is an essential capability for implementing the Fluent Design System which calls on us to create a sense of cinematic motion in our UWP apps.

The Composition APIs also provide something you probably have never had access to before: the ability to create high-performing, low-level manipulation-driven custom animations like the one shown above.  In the same way that we that want our visuals to be fast and smooth, we want our touch interactions to be sticky and responsive. Moving a visual with a finger or a digital pen should result in the visual element clinging to us no matter how fast we push and pull it across the display.

Even if a motion looks good, it also needs to feel good under the finger. It needs to maintain the illusion that we are interacting with a real object. It ought to possess the proper physics so that when we drag a visual across the screen and let go, it continues with the proper inertial movement. Similarly, user controls should provide the right amount of resistance when we pull and release them.

A fast and fluid animation system

The Visual Layer supports both keyframe animations as well as expression animations. If you have worked with XAML animations before, then you are probably already familiar with how keyframes work. In a keyframe animation, you set values for some property you want to change over time and also assign the duration for the change: in the example below, a start value, a middle value and then an ending value. The animation system will take care of tweening your animation – in other words, generating all the values between the ones you have explicitly specified based on the easing function you select. Whether Linear, or a Cubic Bezier, the animation system will use that to determine the values when interpolating.

CubicBezierEasingFunction cubicBezier = _compositor.CreateCubicBezierEasingFunction(new Vector2(.17f, .67f), new Vector2(1f, 1f));
ScalarKeyFrameAnimation blurAnimation = _compositor.CreateScalarKeyFrameAnimation();
blurAnimation.InsertKeyFrame(0.0f, 0.0f);
blurAnimation.InsertKeyFrame(0.5f, 100.0f);
blurAnimation.InsertKeyFrame(1.0f, 0.0f);
blurAnimation.Duration = TimeSpan.FromSeconds(4);
blurAnimation.IterationBehavior = AnimationIterationBehavior.Forever;
_brush.StartAnimation(&amp;quot;Blur.BlurAmount&amp;quot;, blurAnimation);

A keyframe animation is a fire-and-forget mechanism that is time based. There are situations, however, when you need your animations to be coordinated and driving each other instead of simply moving in synchronized fashion.

In the animation above (source code), each gray gear is animated based on the animation of the gear preceding it. If the preceding gear suddenly goes faster or reverses direction, it forces the following gear to do the same. Keyframe animations can’t create motion effects that work in this way, but expression animations can. They are able to do so because, while keyframe animations are time based, expression animations are reference based.

The critical code that hooks up the gears for animation is found in the following code sample, which uses the new Expression Builder Library—an open source component released alongside of the Creators Update to construct expression animations. The expression below says that the animation should reference and be driven by the RotationAngleInDegrees property of the Visual that is indicated by the parameter “previousGear”. In the next line, the current Visual’s RotationAngleInDegrees property is finally animated based on the value referred to in an expression.

private void ConfigureGearAnimation(Visual currentGear, Visual previousGear)
// If rotation expression is null then create an expression of a gear rotating the opposite direction
var _rotateExpression = previousGear.GetReference().RotationAngleInDegrees;
// Start the animation based on the Rotation Angle in Degrees.
currentGear.StartAnimation(&amp;quot;RotationAngleInDegrees&amp;quot;, _rotateExpression);

But if an animation can be driven by another animation, you may be wondering, couldn’t we also drive an animation with something more concrete like user input? Why, yes. Yes, we can.

The beauty of the ScrollViewer ManipulationPropertySet

Driving an animation from a ScrollViewer using XAML-Composition interop is fairly easy. With just a few lines of code, you can enhance the visuals of a pre-existing ScrollViewer control with a CompositionAnimation by taking advantage of the GetScrollViewerManipulationPropertySet method on the ElementCompositionPreview class. Using an animation expression, you can tie your animation to the Position of your ScrollViewer component.

You would use this technique if you wanted to add a parallax effect to your XAML or to create a sticky header that stays in place as content scrolls beneath it. In the demo illustrated below (source code), a ScrollViewer is even used to drive a parallax effect on a ListView.

Adding parallax behavior to a XAML page can be accomplished in just a few lines.

// Note: We're not using the ScrollViewer's offset values directly. Instead, we use this PropertySet which holds the position values of the ScrollViewer in real-time.
var scrollPropSet = _scrollProperties.GetSpecializedReference&amp;lt;ManipulationPropertySetReferenceNode&amp;gt;();
var startOffset = ExpressionValues.Constant.CreateConstantScalar(&amp;quot;startOffset&amp;quot;, 0.0f);
var parallaxValue = 0.5f;
var itemHeight = 0.0f;
var parallax = (scrollPropSet.Translation.Y + startOffset - (0.5f * itemHeight));
_parallaxExpression = parallax * parallaxValue - parallax;
_parallaxExpression.SetScalarParameter(&amp;quot;StartOffset&amp;quot;, (float)args.ItemIndex * visual.Size.Y / 4.0f);
visual.StartAnimation(&amp;quot;Offset.Y&amp;quot;, _parallaxExpression);

The even more beautiful InteractionTracker

Driving expression animations with a ScrollViewer is extremely powerful, but what if you want to drive animations using touch gestures that aren’t limited to a pan/zoom gesture? Additionally, when using the ScrollViewer’s manipulations, your animations are linked to the UI thread responsiveness and can lose that buttery-smooth feel when the UI thread gets bogged down.

What if you want to pull items toward you with your finger, as in the demo below (source code), or animate multiple flying images across and into the screen as happens in the demo at the top of this post (source code)?

In order to achieve these effects, you would use the new InteractionTracker and VisualInteractionSource classes. InteractionTracker is a state machine that can be driven by active input. InteractionTracker also maintains a series of properties like Position and ScalePosition as part of maintaining the state. This is what you hook up to your animations. The VisualInteractionSource class, on the other hand, determines what kind of input you will use to drive your InteractionTracker and also when to start handling input (touch in particular).

The following sample code demonstrates a basic implementation of an InteractionTracker. The viewportVisual is simply the backing Visual for the root element on the page. You use this as the VisualInteractionSource for the tracker. In doing so, you specify that you are tracking X and Y manipulations. You also indicate that you want to track inertial movement.

_tracker = InteractionTracker.Create(_compositor);
var interactionSource = VisualInteractionSource.Create(viewportVisual);
interactionSource.PositionXSourceMode = InteractionSourceMode.EnabledWithInertia;
interactionSource.PositionYSourceMode = InteractionSourceMode.EnabledWithInertia;

Hooking the tracker up to an expression animation works basically the same way as hooking up a gear Visual to another gear Visual, as you did earlier. You call the CreateExpressionAnimation factory method on the current Compositor and reference the Position property of the tracker.

ar positionExpression = _compositor.CreateExpressionAnimation(&amp;quot;-tracker.Position&amp;quot;);
positionExpression.SetReferenceParameter(&amp;quot;tracker&amp;quot;, _tracker);
contentVisual.StartAnimation(&amp;quot;Offset&amp;quot;, positionExpression);

This code uses the InteractionTracker’s position to produce a smooth animation for the Offset of the Visual. You can also power your Blur and Opacity animations for your other Visuals as well. This will have a result where all three animations work together, with values based on how far the user dragged their finger, to result in an amazingly fluid visual experience. Run the demo and try it for yourself (source code).

Those are the basics of driving any animation from any input. What you do with this amazing new power is entirely up to you.

Wrapping up

Expression animations and Visual Layer Interactions are both topics that can become very deep very fast. To help you through these deeper waters, we highly recommend the following videos and articles: