Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17686 or greater). The Preview SDK Build 17686 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 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.
• This build of the Windows SDK will only install on Windows 10 Insider Preview builds.

What’s New:

MSIX Support

It’s finally here! You can now package your applicatiinsons 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

• MSIX: MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.

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.

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 sealed class BooleanTensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class DoubleTensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class FeatureValueProvider
  public sealed class Float16TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class FloatTensorValue : IClosable, IFeatureValue, ITensorValue
  public interface IFeatureDescriptor
  public interface IFeatureValue
  public interface IMachineLearningModel : IClosable
  public interface IMachineLearningOperator
  public sealed class ImageDescriptor : IFeatureDescriptor, ITensorDescriptor
  public sealed class ImageTensorValue : IClosable, IFeatureValue, ITensorValue
  public interface IModelEvaluationResult
  public interface IModelSubmitEvaluationResult
  public sealed class Int16TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class Int32TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class Int64TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class Int8TensorValue : IClosable, IFeatureValue, ITensorValue
  public interface ITensorDescriptor : IFeatureDescriptor
  public interface ITensorValue : IClosable, IFeatureValue
  public struct MachineLearningContract
  public sealed class MachineLearningModel : IClosable, IMachineLearningModel
  public sealed class MachineLearningOperatorContext
  public sealed class MapDescriptor : IFeatureDescriptor
  public sealed class ModelBinding
  public enum ModelDataKind
  public sealed class ModelDevice : IClosable
  public enum ModelDeviceKind
  public enum ModelFeatureKind
  public sealed class ModelSession : IClosable
  public sealed class SequenceDescriptor : IFeatureDescriptor
  public sealed class StringTensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class TensorDescriptor : IFeatureDescriptor, ITensorDescriptor
  public sealed class UInt16TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class UInt32TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class UInt64TensorValue : IClosable, IFeatureValue, ITensorValue
  public sealed class UInt8TensorValue : IClosable, IFeatureValue, ITensorValue
}
namespace Windows.ApplicationModel {
  public sealed class AppInstallerFileInfo
  public sealed class LimitedAccessFeatureRequestResult
  public static class LimitedAccessFeatures
  public enum LimitedAccessFeatureStatus
  public sealed class Package {
    IAsyncOperation<PackageUpdateAvailabilityResult> CheckUpdateAvailabilityAsync();
    AppInstallerFileInfo GetAppInstallerFileInfo();
  }
  public enum PackageUpdateAvailability
  public sealed class PackageUpdateAvailabilityResult
}
namespace Windows.ApplicationModel.Calls {
  public sealed class VoipCallCoordinator {
    IAsyncOperation<VoipPhoneCallResourceReservationStatus> ReserveCallResourcesAsync();
  }
}
namespace Windows.ApplicationModel.Chat {
  public static class ChatCapabilitiesManager {
    public static IAsyncOperation<ChatCapabilities> GetCachedCapabilitiesAsync(string address, string transportId);
    public static IAsyncOperation<ChatCapabilities> GetCapabilitiesFromNetworkAsync(string address, string transportId);
  }
  public static class RcsManager {
    public static event EventHandler<object> 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.Store.Preview {
  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.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<ILampArrayEffect>, IVectorView<ILampArrayEffect>
  public enum LampArrayEffectStartMode
  public enum LampArrayRepetitionMode
  public sealed class LampArraySolidEffect : ILampArrayEffect
  public sealed class LampArrayUpdateRequestedEventArgs
}
namespace Windows.Devices.Sensors {
  public sealed class SimpleOrientationSensor {
    public static IAsyncOperation<SimpleOrientationSensor> 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.Graphics.Capture {
  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<DeploymentResult, DeploymentProgress> 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 void SetPolicyAtPath(string accountId, string area, string name, NamedPolicyValue policyValue);
    public static void SetPolicyAtPathForUser(User user, string accountId, string area, string name, NamedPolicyValue policyValue);
  }
  public sealed class NamedPolicyValue
  public static class NamedPolicyValueFactory
}
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; }
  }
}
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 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.Core {
  public sealed class CameraIntrinsics {
    public CameraIntrinsics(Vector2 focalLength, Vector2 principalPoint, Vector3 radialDistortion, Vector2 tangentialDistortion, uint imageWidth, uint imageHeight);
  }
}
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<DateTime> HardwareDRMDisabledAtTime { get; }
    public static IReference<DateTime> 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<ConnectionProfileDeleteStatus> TryDeleteAsync();
  }
  public enum ConnectionProfileDeleteStatus
}
namespace Windows.Security.Authentication.Web.Provider {
  public sealed class WebAccountProviderInvalidateCacheOperation : IWebAccountProviderBaseReportOperation, IWebAccountProviderOperation
  public enum WebAccountProviderOperationKind {
    InvalidateCache = 7,
  }
  public sealed class WebProviderTokenRequest {
    string Id { get; }
  }
}
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.Services.Cortana {
  public sealed class CortanaActionableInsights
  public sealed class CortanaActionableInsightsOptions
}
namespace Windows.Services.Store {
  public sealed class StoreContext {
    IAsyncOperation<StoreRateAndReviewResult> RequestRateAndReviewAppAsync();
    IAsyncOperation<IVectorView<StoreQueueItem>> SetInstallOrderForAssociatedStoreQueueItemsAsync(IIterable<StoreQueueItem> 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<bool> LaunchFolderPathAsync(string path);
    public static IAsyncOperation<bool> LaunchFolderPathAsync(string path, FolderLauncherOptions options);
    public static IAsyncOperation<bool> LaunchFolderPathForUserAsync(User user, string path);
    public static IAsyncOperation<bool> 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.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.Composition {
  public sealed class AnimatablePropertyInfo : CompositionObject
  public enum AnimationPropertyAccessMode
  public enum AnimationPropertyType
  public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
    void SetAnimatableReferenceParameter(string parameterName, IAnimatable source);
  }
  public enum CompositionBatchTypes : uint {
    AllAnimations = (uint)5,
    InfiniteAnimation = (uint)4,
  }
  public sealed class CompositionGeometricClip : CompositionClip
  public class CompositionObject : IAnimatable, IClosable {
    void GetPropertyInfo(string propertyName, AnimatablePropertyInfo propertyInfo);
  }
  public sealed class Compositor : IClosable {
    CompositionGeometricClip CreateGeometricClip();
    CompositionGeometricClip CreateGeometricClip(CompositionGeometry geometry);
  }
  public interface IAnimatable
}
namespace Windows.UI.Composition.Interactions {
  public sealed class InteractionTracker : CompositionObject {
    IReference<float> PositionDefaultAnimationDurationInSeconds { get; set; }
    IReference<float> ScaleDefaultAnimationDurationInSeconds { get; set; }
    int TryUpdatePosition(Vector3 value, PropertyUpdateOption options);
    int TryUpdatePositionBy(Vector3 amount, PropertyUpdateOption options);
    int TryUpdatePositionWithDefaultAnimation(Vector3 value);
    int TryUpdateScaleWithDefaultAnimation(float value, Vector3 centerPoint);
  }
  public enum PropertyUpdateOption
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotification {
    public ScheduledToastNotification(DateTime deliveryTime);
    IAdaptiveCard AdaptiveCard { get; set; }
  }
  public sealed class ToastNotification {
    public ToastNotification();
    IAdaptiveCard AdaptiveCard { get; set; }
  }
}
namespace Windows.UI.Shell {
  public sealed class TaskbarManager {
    IAsyncOperation<bool> IsSecondaryTilePinnedAsync(string tileId);
    IAsyncOperation<bool> RequestPinSecondaryTileAsync(SecondaryTile secondaryTile);
    IAsyncOperation<bool> TryUnpinSecondaryTileAsync(string tileId);
  }
}
namespace Windows.UI.StartScreen {
  public sealed class StartScreenManager {
    IAsyncOperation<bool> ContainsSecondaryTileAsync(string tileId);
    IAsyncOperation<bool> TryRemoveSecondaryTileAsync(string tileId);
  }
}
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 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 NewWebUIViewCreatedEventArgs
  public static class WebUIApplication {
    public static event EventHandler<NewWebUIViewCreatedEventArgs> NewWebUIViewCreated;
  }
  public sealed class WebUIView : IWebViewControl
}
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();
  }
}
namespace Windows.UI.Xaml.Controls {
  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 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 DropDownButton : Button
  public class Grid : Panel {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public class NavigationView : ContentControl {
    bool IsTopNavigationForcedHidden { get; set; }
    NavigationViewOrientation Orientation { get; set; }
    UIElement TopNavigationContentOverlayArea { get; set; }
    UIElement TopNavigationLeftHeader { get; set; }
    UIElement TopNavigationMiddleHeader { get; set; }
    UIElement TopNavigationRightHeader { get; set; }
  }
  public enum NavigationViewOrientation
  public sealed class PasswordBox : Control {
    bool CanPasteClipboardContent { get; }
    public static DependencyProperty CanPasteClipboardContentProperty { get; }
    void PasteFromClipboard();
  }
  public class RelativePanel : Panel {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public class RichEditBox : Control {
    RichEditTextDocument RichEditDocument { get; }
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    event TypedEventHandler<RichEditBox, RichEditBoxSelectionChangingEventArgs> SelectionChanging;
  }
  public sealed class RichEditBoxSelectionChangingEventArgs
  public sealed class RichTextBlock : FrameworkElement {
    void CopySelectionToClipboard();
  }
  public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
    BackgroundSizing BackgroundSizing { get; set; }
    public static DependencyProperty BackgroundSizingProperty { get; }
  }
  public sealed class TextBlock : FrameworkElement {
    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; }
    FlyoutBase SelectionFlyout { get; set; }
    public static DependencyProperty SelectionFlyoutProperty { get; }
    event TypedEventHandler<TextBox, TextBoxSelectionChangingEventArgs> SelectionChanging;
    void CopySelectionToClipboard();
    void CutSelectionToClipboard();
    void PasteFromClipboard();
    void Redo();
    void Undo();
  }
  public sealed class TextBoxSelectionChangingEventArgs
  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; }
    DataTemplate ItemTemplate { get; set; }
    public static DependencyProperty ItemTemplateProperty { get; }
    DataTemplateSelector ItemTemplateSelector { get; set; }
    public static DependencyProperty ItemTemplateSelectorProperty { get; }
    event TypedEventHandler<TreeView, TreeViewDragItemsCompletedEventArgs> DragItemsCompleted;
    event TypedEventHandler<TreeView, TreeViewDragItemsStartingEventArgs> DragItemsStarting;
  }
  public sealed class TreeViewDragItemsCompletedEventArgs
  public sealed class TreeViewDragItemsStartingEventArgs
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler<WebView, WebViewWebResourceRequestedEventArgs> 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 IsOpen { get; }
    FlyoutShowMode ShowMode { get; set; }
    public static DependencyProperty ShowModeProperty { get; }
    public static DependencyProperty TargetProperty { get; }
    void Show(FlyoutShowOptions showOptions);
  }
  public enum FlyoutPlacementMode {
    BottomLeftJustified = 7,
    BottomRightJustified = 8,
    LeftBottomJustified = 10,
    LeftTopJustified = 9,
    RightBottomJustified = 12,
    RightTopJustified = 11,
    TopLeftJustified = 5,
    TopRightJustified = 6,
  }
  public enum FlyoutShowMode
  public sealed class FlyoutShowOptions : DependencyObject
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class XamlBridge : IClosable
}
namespace Windows.UI.Xaml.Input {
  public sealed class FocusManager {
    public static event EventHandler<GettingFocusEventArgs> GettingFocus;
    public static event EventHandler<FocusManagerGotFocusEventArgs> GotFocus;
    public static event EventHandler<LosingFocusEventArgs> LosingFocus;
    public static event EventHandler<FocusManagerLostFocusEventArgs> 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; }
  }
}
namespace Windows.UI.Xaml.Markup {
  public sealed class FullXamlMetadataProviderAttribute : Attribute
  public interface IXamlBindScopeDiagnostics
}
namespace Windows.UI.Xaml.Media.Animation {
  public class BasicConnectedAnimationConfiguration : ConnectedAnimationConfiguration
  public sealed class BrushTransition : Transition
  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.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl {
    event TypedEventHandler<WebViewControl, object> GotFocus;
    event TypedEventHandler<WebViewControl, object> LostFocus;
  }
  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
}

The post Windows 10 SDK Preview Build 17686 available now! appeared first on Windows Developer Blog.

Today we are excited to announce preview of three new features in Azure Monitor that let you enumerate alerts at scale across log, metric or activity log alerts, filter alerts across subscriptions, manage alert states, look at alert instance specific details, and troubleshoot issues faster using SmartGroups that automatically group related alerts. These features continue to enhance the unified alerts configuration experience announced earlier this year. We look forward to your feedback to refine the functionality further.

The new alert enumeration experience and API allows observing alerts across Azure deployments. Alerts across multiple subscriptions can be queried and pivoted on severity, signal types, resource type, and more allowing a performant and easy summary-to-drill down experience. The new enumeration experience also supports multi-select filtering on any relevant dimension, allowing for example, looking up alerts across a set of resource groups or specific resource types.

Alert state management provides users a way to change the state of the alert to reflect the current situation of the issue in their environment. Currently three alert states are supported – New, Acknowledged, and Closed.

Alert states are separate from the monitoring condition, which is updated by the underlying monitoring service that detected the issue. Monitoring condition supports two values – fired and resolved.

The history of both monitor condition and alert state changes, as well as the details of the event such as target resource uri, alert rule, monitor condition, and link to query for log alerts, are captured in the payload of the alert to aid in triaging and auditing.

Smart Groups are system generated alerts that encapsulate many related alerts to reduce alert noise and help in mitigating events faster. These Smart Groups are automatically created using machine learning algorithms looking for similarity and co-occurrence patterns among alerts originating from a monitor service (e.g. LA or Platform). Smart Groups have the same properties as an individual alert such as user defined states or history. For an operator, smart groups significantly reduce the number of alerts to analyze by focusing on only a handful of groups. For example, if % CPU on several virtual machines in a subscription simultaneously spikes leading to many individual alerts, and if such alerts have occurred together anytime in the past, these alerts will likely be grouped into a single Smart Group, suggesting a potential common root cause. This technology has gone through extensive testing against hyperscale Azure services with very good results.

Learn more about these features and how to onboard to these exciting new features in preview.

They say time flies when you're having fun, and as I approach two years working on containers in Azure, I see the truth in that saying. Over the last two years we have launched a Kubernetes service in Azure, acquired Deis, joined the Linux foundation, launched the Draft and Brigade open source projects, launched the first serverless container infrastructure in the major public clouds, and most recently acquired GitHub where Kubernetes was born. We've also seen incredible growth in Kubernetes on Azure, with five times the number of customers and ten times the usage of a year ago. To say that the excitement never ends at Microsoft and Azure is an understatement!

Today, I’m incredibly excited to announce that the Azure Kubernetes Service (AKS) is now generally available. We are also adding five new regions including Australia East, UK South, West US, West US 2, and North Europe. AKS is now generally available in ten regions across three continents, and we expect to add ten more regions in the coming months!

With AKS in all these regions, users from around the world, or with applications that span the world, can deploy and manage their production Kubernetes applications with the confidence that Azure's engineers are providing constant monitoring, operations, and support for our customers’ fully managed Kubernetes clusters. Azure was also the first cloud to offer a free managed Kubernetes Service and we continue to offer it for free in GA. We think you should be able to use Kubernetes without paying for our management infrastructure.

Going from preview to general availability requires dedication and hard work by both the AKS engineering team as well as the customers who volunteered their time and patience to try out our new service. I'm extremely grateful to everyone inside and outside of Microsoft who contributed their time to improving AKS and making the general availability possible. The product that we ship today is better because of your hard work. Thank you!

In addition to the work on AKS, the team has also been engaged with the upstream open source Kubernetes community. With open source, it is insufficient to just consume software, it is critical to be engaged with and contributing to the projects that you use. Consequently, I'm incredibly proud of the nearly seventy Microsoft employees who have made contributions to Kubernetes.

The Kubernetes API is just the beginning. From its inception, a core component of Microsoft's DNA has been building the platforms to empower and enable developers to become more productive. It has been awesome to see this heritage pull through into a new generation of tools to enable builders of cloud native applications. As we showed this past May at the Microsoft Build conference, Azure is the most complete and capable cloud for cloud native application development. On Azure, our tools make it easier to build and debug your containerized applications with Kubernetes. To make this even better, we're excited to announce even more features now available in all AKS regions including Kubernetes resource-based access control (RBAC), Azure Active Directory based identity, the ability to deploy clusters into pre-existing custom virtual networks, and more. Furthermore, you can even deploy and manage your clusters using both open source tools like Terraform and Azure's own Resource Manager templates. Come check them out!

In addition to making Azure an industry leading place to run Kubernetes, we are also strongly committed to giving back to the Kubernetes user community, no matter where they want to run Kubernetes. To that end:

• We lead and support the development of the Helm package manager for Kubernetes, which was recently elevated to be a top-level project in the Cloud Native Compute Foundation.
• We have built and released Draft and Brigade to make Kubernetes more approachable for novice users.
• We continue to improve the Kubernetes plugins for Visual Studio and Visual Studio Code, enabling an intuitive, easy to use integration between development and operations environments.
• These integrations extend into DevOps tools where you can simply integrate AKS into your favorite CI/CD tools such as Jenkins and Visual Studio Team Services.
• Additionally, with our work on the virtual kubelet, we are leading a cross-industry effort that brings Kubernetes management to environments without VMs using innovative technology like Azure Container Instances.

All of this work wouldn't mean anything unless we delivered a useful service that meets users where they are and enables them to achieve great things. It's awesome to see companies like Maersk, Siemens, and Varian Health find success using Kubernetes on Azure.

As proud as I am about everything that the Azure Kubernetes team has done to get us to this point, I'm even more excited to see what production applications our customers build on top of our production-grade, worldwide Azure Kubernetes Service. As for the team, we're already hard at work on the next set of exciting features for all our AKS users and Kubernetes friends around the world!

If you want to learn more, I encourage you to come create a cluster, deploy some applications, and see what Azure Kubernetes Service has to offer, or try out one of our sample apps.

Thanks!

Brendan

During the Build 2018 keynote, Scott Hanselman, with help from Scott Guthrie, showed developers the new features available in Azure Kubernetes Service (AKS) and Azure Dev Spaces. To help you learn how to deploy microservices written in any framework to AKS we've updated the SmartHotel360 back-end microservices source code and deployment process to optimize it for AKS. You can clone, fork, or download the AKS and Azure Dev Spaces demo on GitHub.

Azure Kubernetes Service gives developers the best experience for building microservices in any platform including Java, .NET Core, or Node.js, to name a few used in this demo's source code, using Kubernetes and containers. The diagram below shows a high-level snapshot of the back-end APIs housed in the AKS cluster once you deploy this repository's source code to AKS.

Sample queries shipped with the demo can be saved and executed in an AKS cluster to get deep visibility into how each service is running. The query below, for example, results with a bar chart showing how often a certain pattern appears in the execution logs.

Azure Dev Spaces provides a rapid, iterative Kubernetes development experience for teams. With minimal dev machine setup, you can iteratively run and debug containers directly in Azure Kubernetes Service. Develop on Windows, Mac, or Linux using familiar tools like Visual Studio, Visual Studio Code, or the command line. The diagram below shows how the Visual Studio family of IDEs can connect to AKS to enable debugging within a developer’s Azure Dev Space without impacting production or teammate code.

The AKS Cluster created by the demo contains support for Azure Dev Spaces, so that you can debug the individual services live in the Kubernetes cluster. There's a pre-wired error in the hotels microservice you'll fix during the demo, then debug in your own Azure Dev Space to validate the fix worked.

Demo contents

The sample repository contains:

• The source code and deployment for the back-end services and the public web app.
• The demo script and the setup instructions, written in bash, so it can be easily executed on Linux, Mac, or in Windows using WSL.
• Helm charts for each service.
• Sample queries for use in with AKS Log Search.
• A preloader script that can be used to generate log/CPU data.

The SmartHotel360 public web site was originally written to demonstrate the features that make Azure App Service the best place in the cloud to host ASP.NET Core applications, with amazing diagnostics, deployment, and devops features.

AKS is a great place to host ASP.NET Core applications, too, so to give you great examples of both scenarios, we've moved the public web site into the AKS cluster for this sample. If you're investigating the variety of options for hosting your ASP.NET Core apps in Azure, you'll have the original App Service-focused version of the demo source code, and you'll learn from the new demo repository how to publish an ASP.NET Core app into AKS.

Azure Kubernetes Service brings so many amazing features for developers. The container health dashboard, deep log search features enabling you to really see how your code's executing in the cluster, and IDE/debugger integration that makes it possible for you to edit and debug code live in the cluster without impacting production or teammate code all make AKS the greatest experience for building apps with Kubernetes.

We hope this demo is useful in your process of learning how to publish microservices to AKS and to make the most use of the amazing portal and debugging features. As with all of the SmartHotel360 repositories, these are open and we encourage pull requests. If you experience any issues setting it up, send us an issue in GitHub and we'll resolve it quickly.

We hope you enjoy this AKS-optimized demonstration.

Technology is changing the way people get things done. We’ve picked up the pace. Our work is more collaborative. And we’re blurring the boundaries of time and place. When we ask customers why they continue to choose Office for their most important work, they tell us that they love the power the Office apps offer. The breadth and depth of features is unmatched in the industry and allows them to do things that they just can’t do with other products. But they also tell us that they need Office to adapt to the changing environment, and they’d love us to simplify the user experience and make that power more accessible. Today, we’re pleased to announce user experience updates for Word, Excel, PowerPoint, and Outlook rolling out gradually over the next few months. These changes are inspired by the new culture of work and designed to deliver a balance of power and simplicity.

Office is used by more than a billion people every month, so while we’re excited about these changes, we also recognize how important it is to get things right. To guide our work, we came up with “The Three Cs”—a set of guiding principles that we use as a north star. Because these principles will make this process feel different than any previous user experience update, we thought it would be useful to share them with you.

Customers—We’re using a customer-driven innovation process to co-create the design of the Office apps. That process consists of three phases: initial customer research and analysis; concepting and co-creation; and validation and refinement.

Context—Customers love the power of Office, but they don’t need every feature at the same time. We want our new designs to understand the context that you’re working in, so you can focus on the job at hand. That means surfacing the most relevant commands based on the work you’re doing and making it easy to connect and collaborate with others.

Control—We recognize that established skills and routines are powerful—and that the way someone uses the apps often depends on specific parts of the user interface. So we want to give users control, allowing them to toggle significant changes on and off.

These updates are exclusive to Office.com and Office 365—the always up-to-date versions of our apps and services. But they won’t happen all at once. Instead, over the next several months we will deploy new designs to select customers in stages and carefully test and learn. We’ll move them into production only after they’ve made it through rigorous rounds of validation and refinement.

The initial set of updates includes three changes:

Simplified ribbon—A new, updated version of the ribbon is designed to help users focus on their work and collaborate naturally with others. People who prefer to dedicate more screen space to the commands will still be able to expand the ribbon to the classic three-line view.

The first app to get this new experience will be the web version of Word and will start to roll out to select consumer users today on Office.com. Select Insiders will then see the simplified ribbon in Outlook for Windows in July.

Word, Excel, and PowerPoint for Windows offer our deepest, richest feature set—and they’re the preferred experience for users who want to get the most from our apps. Users have a lot of “muscle memory” built around these versions, so we plan on being especially careful with changes that could disrupt their work. We aren’t ready to bring the simplified ribbon to these versions yet because we feel like we need more feedback from a broader set of users first. But when we do, users will always be able to revert back to the classic ribbon with one click.

New colors and icons—Across the apps you’ll start to see new colors and new icons built as scalable graphics—so they render with crisp, clean lines on screens of any size. These changes are designed to both modernize the user experience and make it more inclusive and accessible.

The new colors and icons will first appear in the web version of Word for Office.com. Then, later this month, select Insiders will see them in Word, Excel, and PowerPoint for Windows. In July, they will go to Outlook for Windows, and in August they will begin rolling out to Outlook for Mac.

Search—Search will become a much more important element of the user experience, providing access to commands, content, and people. With “zero query search,” simply placing your cursor in the search box will bring up recommendations powered by AI and the Microsoft Graph.

Commercial users can already see this experience in action in Office.com, SharePoint Online, and the Outlook mobile app, and it will start rolling out to commercial users of Outlook on the web in August.

For an overview of these changes, check out the video below by Jon Friedman, our chief designer for Office.

To develop these initial designs, Jon’s team worked closely with customers. They collected data on how people use the apps and built prototypes to test new concepts. While we have plenty of work left to do, we’ve definitely heard encouraging things from customers using early builds:

“It’s simpler and I feel like I can open it and immediately get my bearings and move forward. Not a lot of extra information. The tasks are obvious on this screen.”

“The toolbar provides the most frequently used features…maximizing the screen real estate for the actual content.”

“I like the extra space. What I do find is that the feature to toggle it off/on is helpful because occasionally I can’t figure out (quickly) where something went.”

We plan on carefully monitoring usage and feedback as the changes roll out, and we’ll update our designs as we learn more.

Technology is changing the way people get things done at work, at school, and at home, resetting expectations for productivity. Inspired by these changes, these updates are designed to deliver a balance of power and simplicity. But what’s most exciting for us is that over the next few months we’ll be co-creating and refining these new experiences with our customers—and making the power of Office more accessible for everyone.

The post Power and simplicity—updates to the Office 365 user experience appeared first on Microsoft 365 Blog.

In this blog, I will go over how you can use the Bing Visual Search API, in combination with Bing Entity Search API to build an enhanced viewing experience in your video app.

General availability of Bing Visual Search API was announced at Build 2018, in this blog. Bing Visual Search API enables you to use an image as a query to get information about what entities are in the image, along with a list of visually similar images from the image index built by Bing. GA of Bing Entity Search was announced in this blog, published on March 1st, 2018. Bing Entity Search API enables you to brings rich contextual information about people, places, things, and local businesses to any application, blog, or website for a more engaging user experience.

By combining the power of these two APIs, you can build a more engaging experience in your video app, by following the steps listed below

• Write a JavaScript function that triggers when the user clicks the pause button in your video app. In this JavaScript function, grab the paused video frame as an image. Take a look at this discussion to learn more about how to do this.
• Pass the captured video frame via AJAX to a server-side function.
• In your server side function, you can now call the Bing Visual Search API, with that image as input. Bing Visual Search documentation page provides code samples in multiple languages for this.
• Bing Visual Search API will return a JSON string with insights for the image. The response format is well documented on this documentation page.
• The entities can be found in “actions” tag with “_type” = “ImageEntityAction”. As an example, for this image, which has Tom Hanks and his wife, you will see two “actions” tag with “_type” = “ImageEntityAction”.
• You can now use the “displayName” for these entities to call the Entity Search API. Code samples for Bing Entity Search API can be found on this documentation page, which you can then pass back to the video app, to render it in the UI.

Entities in Bing are not limited to people. As an example, the Visual Search API identifies “Yosemite National Park” as an entity in this image. Depending on the types of videos you intend on showcasing in your video app, you can decide if you want to focus on certain or all types of entities.

The Developer Economics Q2 2018 survey is here in its 15^th edition to shed light on the future of the software industry. Every year more than 40,000 developers around the world participate in this survey, so this is a chance to be part of something big, voice your thoughts, and make your own contribution to the developer community.

Is this survey for me?

The survey is for all developers engaging in the following software development areas: cloud, mobile, desktop, IoT, AR/VR, machine learning, data science, web, backend, and gaming.

What questions am I likely to be asked?

The survey asks questions about the status and the future of the software industry.

• What’s going up and what’s going down in the software industry?
• Are you working on the projects you would like to work on?
• Where do you think development time should be invested?
• Which are your favorite tools and platforms?

What’s in it for me?

There are some perks to go with your participation. Have a look at what you can get our hands on:

• Amazing prizes up for grabs: A Samsung S9 Plus phone, an iPhone X, an HP Windows Mixed Reality Headset with Motion Controllers, an HTC Vive Pro, a Lenovo Tablet Yoga Tab 3 10, subscription vouchers, and more
• A personalized card with your responses
• A free State of the Developer Nation report, 15th Edition Q2 2018

What’s in it for Microsoft?

This is an independent survey from SlashData, an analyst firm in the developer economy that tracks global software developer trends. We’re interested in seeing the report that comes from this survey, and we want to ensure the broadest developer audience participates.

Of course, any data collected by this survey is between you and SlashData. You should review their Terms and Conditions page to learn more about the awarding of prizes, their data privacy policy, and how SlashData will handle your personal data.

Ready to go?

The survey is open until Sunday, June 24, 2018.

Take the survey today.

The survey is available in English, Chinese (Simplified and traditional), Spanish, Portuguese, Vietnamese, Russian, Japanese, and Korean.

We’re extremely excited to announce the Windows Template Studio 2.2! 

For the next few releases, we are doing smaller updates to add in new pages and fixes. The reason being is we are working toward multi-project solution support for 3.0 and adjusting our templates to support that. This is a large sum of work but want to be sure we are still improving where we can now.

As always, we love how the community is helping. If you’re interested, please head over to head over to WTS’s Github.

What’s new:

For the full list of adjustments in the 2.2 release, WTS’s Github has a full changelog.

Included in this version:

• 3D Launcher feature
• Wizard enhancements
• Improved documentation
• Improved testing
• Bug fixes

Dev platform updates:

• Updated Microsoft.NETCore.UniversalWindowsPlatform to 6.15
• Updated Newtonsoft.Json to 11.0.2
• Updated Microsoft.Toolkit.Uwp, Microsoft.Toolkit.Uwp.Notifications and Microsoft.Toolkit.Uwp.UI.Controls to 3.0.0
• Update Telerik.UI.for.UniversalWindowsPlatform to 1.0.1

How to get the update:

There are two paths to update to the newest build.

• Already installed: Visual Studio should auto update the extension. To force an update, Go to Tools->Extensions and Updates. Then go to Update expander on the left and you should see Windows Template Studio in there and click “Update.”
• Not installed: Head to https://aka.ms/wtsinstall, click “download” and double click the VSIX installer.

What else is cooking for next versions?

We love all the community support and participation. In addition, here are just a few of the things we are currently building out that will be in future builds:

• Menubar navigation pattern template
• WinUI Library nuget package integration
• Continued refinement with Fluent Design in the templates
• Work for supporting multiple projects in a single solution
• Ink templates
• User Activity APIs for Timeline support
• Improved Right-click->add support for existing projects

With partnership with the community, we will continue cranking out and iterating new features and functionality. We’re always looking for additional people to help out and if you’re interested, please head to our GitHub at https://aka.ms/wts. If you have an idea or feature request, please make the request!

The post Windows Template Studio 2.2 released! appeared first on Windows Developer Blog.

Today, we are releasing the June 2018 Security and Quality Rollup.

Security

No new security fixes. See .NET Framework May 2018 Security and Quality Rollup for the latest security updates.

Quality and Reliability

This release contains the following quality and reliability improvements.

CLR

• Fix the binary serialization compatibility issue for CultureAwareComparer class [620693]

Note: Additional information on these improvements is not available. The VSTS bug number provided with each improvement is a unique ID that you can give Microsoft Customer Support, include in StackOverflow commentsor use in web searches.

Getting the Update

The Security and Quality Rollup is available via Windows Update, Windows Server Update Services, and Microsoft Update Catalog.

Microsoft Update Catalog

You can get the update via the Microsoft Update Catalog. For Windows 10, .NET Framework updates are part of the Windows 10 Monthly Rollup.

Previous Monthly Rollups

The last few .NET Framework Monthly updates are listed below for your convenience:

• .NET Framework May 2018 Preview of Quality Rollup for Windows 10 April 2018 Update (version 1803)
• .NET Framework May 2018 Preview of Quality Rollup for Windows 10 1709 (Fall Creators Update)
• .NET Framework May 2018 Preview of Quality Rollup for Windows 10
• .NET Framework May 2018 Preview of Quality Rollup
• .NET Framework May 2018 Security and Quality Rollup

A new switch parameter has been introduced to vswhere. You can now pass -utf8 to force output to write text using UTF-8 to the console, though it’s important to note that what the console host does with that encoded can vary greatly. powershell.exe, for example, when redirecting to a file will always encode Unicode regardless of the [Console]::OutputEncoding or program output encoding.

The problem is that while Visual Studio 2017 instance data is stored as UTF-8 and the query API parses this text into Unicode strings in memory, vswhere writes these strings using the console APIs which transcode text based on the active code page or text written to a file or to a pipe is incorrectly transcoded into gibberish…or at least a bunch of question marks (fallback character). After much discussion, to avoid breaking changes the new switch parameter -utf8 was added to force text to use UTF-8 expecting that the caller will handle it appropriately as in the following example.

const cp = require('child_process');
cp.execFile('vswhere.exe', ['-latest', '-format', 'json', '-utf8'], (err, stdout, stderr) => {
  var instances = JSON.parse(stdout);
  if (instances.length > 0) {
    // do something with instances[0].description
  }
});

Install vswhere and give it a try.

I posted about Using .NET and Docker Together last year. With DockerCon 2018 being this week, it seemed like a great time to give you an update.  Since my last post, we’ve enabled a set of Docker workflows with guidance and samples for .NET Core and .NET Framework, for development, CI/CD, and production. We also offer many more images for both Windows and Linux. If you haven’t taken a look at Docker and .NET recently, now is a good time.

Docker and containers come up more and more in conversations that we have with .NET developers. It has become the way to deploy server applications for many people, due to its primary benefits of consistency and a light-weight alternative to virtual machines. In the DockerCon keynote, there were multiple .NET demos showing how you can use Docker for modern applications and for older applications that use traditional architectures. It has become a lot easier to containerize .NET applications using tools from both Microsoft and Docker.

Trying out Docker

We maintain samples repositories for both .NET Core and .NET Framework. With just a few commands at the command line, you can test out Docker with these sample images.

The easiest (and supported on the most operating systems) is the .NET Core console app sample. All you need to do is type the following command:

docker run --rm microsoft/dotnet-samples

There are other samples you can try, both console and ASP.NET:

• .NET Core Docker Samples
• .NET Framework Docker Samples

How to Approach using Docker

Docker is flexible, enabling you to use it in lots of different ways. There are three major scenarios to consider when looking at adopting Docker:

• Building source code
• Testing binaries
• Running applications/services in production

You can adopt Docker for all of these roles or just a subset. From what we’ve seen, most developers start with the production scenario and then adopt more of Docker in their build infrastructure as they find it useful. This approach makes sense, since the choice to use Docker is usually centered around using it to run applications.

On the .NET Team, we’ve been making heavy use of Docker for both building code and testing. The value of a high-fidelity and instant-on computing environment is super high. There is no need to put off a product investigation on Debian, for example, when you can boot up the exact right environment in seconds.

The following sections show a mixture of .NET Core and .NET Framework examples for these three scenarios.

Building container images with built binaries

The primary requirement for running Docker in production is containerizing your application. The simplest way to create an image within existing build infrastructure is to copy build artifacts into an image. The primary value with this model is consistency between environments, like staging and production.

The following Dockerfile copies build assets from the current directory into a new image that is based on the .NET Core Runtime image on Docker Hub.

FROM microsoft/dotnet:2.1-runtime
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet","app.dll"]

The following command creates a new image, called app using the Dockerfile above, assuming the command is run from the directory where the Dockerfile and app.dll are located:

docker build --pull -t app .

The following command creates a running container based on the app image:

docker run --rm app

Note: The --rm argument removes the container after it terminates. Preserving containers is only useful when you want to investigate why they behaved a certain (undesired) way.

Building container images with source

Docker makes it easy to build source for an application and produce a container image in one step. This is called multi-stage build. The value of building source within a container follows:

• Consistency between build and runtime/production.
• Potentially faster for incremental building than even your own build system, due to Docker layer caching.
• docker build doesn’t rely on an external build to function (if you build from source within Docker).

The following Dockerfile copies source files from the current directory into a new image based on the .NET Framework SDK image on Docker Hub. The Dockerfile commands build the source with NuGet and MSBuild. The binaries are copied from the build stage into a new image based on the .NET Framework Runtime image. The build stage image is discarded. The selected image name is used only for the image generated from the last stage.

FROM microsoft/dotnet-framework:4.7.2-sdk AS build
WORKDIR /app

# copy csproj and restore as distinct layers
COPY *.sln .
COPY aspnetapp/*.csproj ./aspnetapp/
COPY aspnetapp/*.config ./aspnetapp/
RUN nuget restore

# copy everything else and build app
COPY aspnetapp/. ./aspnetapp/
WORKDIR /app/aspnetapp
RUN msbuild /p:Configuration=Release


# copy build artifacts into runtime image
FROM microsoft/aspnet:4.7.2 AS runtime
WORKDIR /inetpub/wwwroot
COPY --from=build /app/aspnetapp/. ./

The second section, above, is an example where Docker shines. Each command in Docker creates a distinct layer in your Docker image. If Docker finds that all the inputs for a given layer are unchanged, then it doesn’t rebuild that layer for subsequent invocations of docker build. The second section copies msbuild assets, like project files, and then runs nuget restore. If the msbuild assets have not changed, then the RUN line that performs restore is skipped. That ends up being a large time savings. It also explains why the Dockerfile is written the way it is.

The following command creates a new image, called aspnetapp using the Dockerfile above, assuming the command is run from the directory where the Dockerfile and the source are located:

docker build --pull -t aspnetapp .

The --pull parameter pulls new microsoft/dotnet-framework images, for example, if they exist on Docker Hub. This parameter takes maybe 1s longer (if no new images exist) on each docker build but keeps your environment up-to-date. In the long run, being up-to-date is incredible useful since it keeps your environment in sync with environments that don’t have cached images.

The following command creates a container based on the aspnetapp image:

docker run --rm -it -p 8000:80 aspnetapp

The -p parameter maps local host machine ports to Docker guest ports.

See the following examples for more detail on building source with Docker:

• ASP.NET Docker (.NET Framework) Sample
• ASP.NET Core Docker Sample

Testing binaries with Docker

The testing scenario showcases the value of Docker since testing is more valuable when the test environment has high fidelity with target environments. Imagine you support your application on multiple operating systems or operating system versions. You can test your application in each of them within Docker. It is easy to do and incredibly valuable.

Up until now in this post, you’ve seen Dockerfile files with RUN commands that described required logic that is executed with docker build and the final result executed with docker run. Running tests via docker build is useful as a means of getting early feedback, primarily with pass/fail results printed to the console/terminal. This model works OK for testing but doesn’t scale well for two reasons:

• docker build will fail if there are errors, which are inherent to testing.
• docker build doesn’t allow volume mounting, which is required to collect test logs.

Testing with docker run is a great alternative, since it doesn’t suffer from either of these two challenges. Testing with docker build is only useful if you want your build to fail if tests fail. The instructions in this document show you how to test with docker run.

The following Dockerfile in its normal use is similar to the Dockerfile for .NET Framework that you saw above. This one, however, includes something of a trick to enable testing. It includes a testrunner stage that is normally very close to a no-op, but that is very useful for testing.

For testing, build an image to the testrunner stage, which will include all the content that has been built to that point. The resulting image is based on the .NET Core SDK image, which includes all of the .NET Core testing infrastructure. The trick in this Dockerfile is that the testrunner stage presents an alternative ENTRYPOINT, which calls dotnet test to kick off testing. If you run the Dockerfile all the way through (not targeting a specific stage), then this first ENTRYPOINT is replaced by the last one, which is the ENTRYPOINT for the application.

FROM microsoft/dotnet:2.1-sdk AS build
WORKDIR /app

# copy csproj and restore as distinct layers
COPY dotnetapp/*.csproj ./dotnetapp/
COPY utils/*.csproj ./utils/
WORKDIR /app/dotnetapp
RUN dotnet restore

# copy and publish app and libraries
WORKDIR /app/
COPY dotnetapp/. ./dotnetapp/
COPY utils/. ./utils/
WORKDIR /app/dotnetapp
RUN dotnet publish -c Release -o out


# optional stage - build to stage to run tests
FROM build AS testrunner
WORKDIR /app/tests
COPY tests/. .
ENTRYPOINT ["dotnet", "test", "--logger:trx"]


# copy build artifacts into runtime image
FROM microsoft/dotnet:2.1-runtime AS runtime
WORKDIR /app
COPY --from=build /app/dotnetapp/out ./
ENTRYPOINT ["dotnet", "dotnetapp.dll"]

The following command creates a new image, called dotnetapp:test, using the Dockerfile above and building only to and including the testrunner stage, assuming the command is run from the directory where the Dockerfile and the source are located:

docker build --pull --target testrunner -t dotnetapp:test .

In order to collect test logs on your local machine, you need to use volume mounting. In short, you can project a directory on your machine into the container as the same directory. Volume mounting is a great way to get content in or out of a container.

The following command creates a container based on the dotnetapp:test image. It volume mounts the C:appTestResults local directory into the /app/tests/TestResults in the app. The local directory must exist already and the C drive must be shared to Docker.

docker run --rm -v C:appTestResults:/app/tests/TestResults dotnetapp:test

After running the command, you should see a .trx file in the C:appTestResults file.

The Running .NET Core Unit Tests with Docker shows you how to test in a container with more detail. It includes instructions for Windows, macOS, and Linux. It also includes a script that manages the testing workflow described in this section.

Developing in a Container

The scenarios above are focused on producing or validating a container image. The use of Docker can be moved further upstream to development.

Visual Studio enables development in a container. You can add a Dockerfile to a .NET project, with either Windows or Linux containers. The experience is nearly seamless. It is hard to tell that you are using Docker at all, as you can see in the following image.

You can also develop in a container at the command line. The .NET Core SDK image includes a lot of functionality that you can use without bothering with creating a Dockerfile. In fact, you can run, build, or test your application only using the command line.

Develop ASP.NET Core Applications in a Container explains how you can build and rebuild ASP.NET Core applications within Docker as you edit them on your local machine, from within Visual Studio Code, for example.

The following commandline hosts an ASP.NET Core application with dotnet watch on macOS or Linux. Everytime you edit and save the application on your local machine, it will be rebuilt within the container. I haven’t tried doing that 1000 times in a row, but you probably can. This scenario relies on volume mounting, to project localy resident source code into a running container. As you can see, volume mounting is a powerful alternative to going through the effort of writing a Dockerfile.

docker run --rm -it -p 8000:80 -v ~/git/aspnetapp:/app/ -w /app/aspnetapp microsoft/dotnet:2.1-sdk dotnet watch run

A similar set of instructions is available for Developing .NET Core Applications in a Container.

ASP.NET Core and HTTPS

It is important to host web applications with HTTPS. In many cases, you will terminate HTTPS requests before they get to your ASP.NET Core site. In the case that ASP.NET Core needs to directly handle HTTPS traffic and you are running your site in a container, then you need a solution.

Hosting ASP.NET Core Images with Docker over HTTPS describes how to host our sample ASP.NET Core sample images with HTTPS. The model described is very similar to how you would host your own images with your own certificate.

The following commands can be used to run the ASP.NET Core sample images with a dev certificate on Windows with Linux containers:

dotnet dev-certs https -ep %USERPROFILE%.aspnethttpsaspnetapp.pfx -p crypticpassword
dotnet dev-certs https --trust
docker pull microsoft/dotnet-samples:aspnetapp
docker run --rm -it -p 8000:80 -p 8001:443 -e ASPNETCORE_URLS="https://+;http://+" -e ASPNETCORE_HTTPS_PORT=8001 -e ASPNETCORE_Kestrel__Certificates__Default__Password="crypticpassword" -e ASPNETCORE_Kestrel__Certificates__Default__Path=/https/aspnetapp.pfx -v %USERPROFILE%.aspnethttps:/https/ microsoft/dotnet-samples:aspnetapp

The Hosting ASP.NET Core Images with Docker over HTTPS instructions can be used on Windows, macOS, and Linux.

Closing

You can probably see that we’re much farther along in our approach of using .NET and Docker together than our initial 2017 post on the topic. We’re far from done everything that one can imagine with the container space, but have provided a much more complete foundation for you to use as you adopt Docker.

Tell us how you are using Docker and the improvements you would like to see, either with guidance and samples or with .NET itself. We’ll continue to make improvements to make the container experience better.

Microsoft has launched a brand new set of Go-To-Market (GTM) benefits that will be automatically offered to partners with new listings in marketplace, for either Azure Marketplace or AppSource. Benefits are designed to promote awareness and visibility of new listings and will be free of charge to partners.

Microsoft’s cloud marketplace is a big focus point for Microsoft. Our customers are telling us that they want trial and purchase their cloud solutions using our marketplaces. We want to enable our customers to discover, try and buy in their preferred method.

Microsoft has always been dedicated to partnering with solution providers. We recognize that selling through our marketplace may be a new motion for many our partners. So, starting March 1, 2018 all new listings in Azure Marketplace and AppSource have been extended a set of free Go-To-Market (GTM) services. These benefits are designed to help our partners jumpstart discoverability of their offer in marketplaces.

We know customers prefer looking through marketplace with rich listings. So, our benefits are tiered by the offer listing status. Additional benefits will be unlocked at zero cost when partners elect to include a trial.

No action is required by partners to initiate these benefits. Upon listing, Microsoft will reach out to the partner to kick-off discussions. Our GTM team will work closely with our partner’s marketing team to determine a plan for delivering these benefits in a way that works best with their campaign plans.

Benefits are offered at the solution level. So, there is no restriction on partners who’ve already published to marketplace. Every new offer is eligible to receive this benefits package.

Learn more about these benefits by talking with your Microsoft Partner Development Manager (PDM) today.

Marketplace Resources

Check out the Azure Marketplace and AppSource Publisher Guide for the latest guidance on publishing to Marketplace or contact cloudmarketplace@microsoft.com for general questions.

We are excited to announce that SQL Data Warehouse (SQL DW) now supports User-Defined Restore Points! SQL DW is a flexible and secure analytics platform for the enterprise optimized for running complex queries fast across petabytes of data.

Previously, SQL DW supported only automated snapshots guaranteeing an eight-hour recovery point objective (RPO). While this snapshot policy provided high levels of protection, customers asked for more control over restore points to enable more efficient data warehouse management capabilities leading to quicker times of recovery in the event of any workload interruptions or user errors. 

Now, with user-defined restore points, in addition to the automated snapshots, you can initiate snapshots before and after significant operations on your data warehouse. With more granular restore points, you ensure that each restore point is logically consistent and limit the impact and reduce recovery time of restoring the data warehouse should this be needed. User-defined restore points can also be labeled so they are easy to identify afterwards. 

You can seamlessly create a restore point with a single statement in PowerShell, so it’s easy to integrate with your data warehouse management operations. You can have up to 42 restore points at any point, and as all restore points expire after seven days there’s no need to manage them individually. 

#Create Restore point
New-AzureRmSqlDatabaseRestorePoint -ResourceGroupName $ResourceGroupName -ServerName $ServerName -DatabaseName $DatabaseName -RestorePointLabel $RestorePointName

Next Steps

• Visit our online documentation for more details on user-defined restore points.
• For feature requests, please vote on our UserVoice.
• Create an Azure SQL Data Warehouse to get started today.
• Stay up-to-date on the latest Azure SQL Data Warehouse news and features by following us on Twitter @AzureSQLDW.

The Azure Marketplace is the premier destination for all your software needs, optimized to run on Azure. The Azure Government Marketplace includes many of the same solutions for use in Azure Government, an exclusive instance of Microsoft Azure that enables government customers to safely transfer mission-critical workloads to the cloud.

Software companies that want to bring their solutions into Azure Government can learn more by watching this episode of the Azure Government video series. Publish your solutions to Azure Government - What, Why and How (Video).

In this episode Steve Michelotti, Senior Program Manager, Azure Government talks with Sarah Weldon, Program Manager, Azure Government about the Azure Government Marketplace. In this video they cover the "what, why and how" of using this platform reaching new government customers.

You’ll learn about the compliance benefits of Azure Government, and how to move into this space if you’ve already published software in the Azure Marketplace. Steve and Sarah include a demo of the publishing process for the Azure Government Marketplace with additional guidance to help ensure your success.

Also, be sure to subscribe to the Microsoft Azure YouTube Channel to see the latest videos on the Azure Government playlist.

About Azure Government

Azure Government is an exclusive instance of Microsoft Azure with world-class security and controls designed for highly sensitive data. It enables government customers to safely transfer mission-critical workloads to the cloud.

Azure Government has over 38 services included in our FedRAMP high compliance program and robust networking throughout the United States with eight announced regions, including two DoD regions certified at impact level five, all connected via private dark fiber. Each region is over 500 miles apart with data replication across regions for business continuity.

To stay up to date on all things Azure Government, subscribe to our RSS feed and sign up to receive emails by clicking “Subscribe by Email!” on the Azure Government Blog.

Watch the video version of this post on VS Toolbox

Let's get started

In this post, we're going to walk through a sample project that demonstrates scripting a C++ application with Python using CPython, PyBind11 and Visual Studio 2017. The sample code is available at github.com/zooba/ogre3d-python-embed and setup instructions are below.

Ogre3d is an open-source game engine written in C++ that has been used in games such as Hob and Torchlight 2. Both the engine and its source code are freely available from their website. For this sample, we have taken one of their character animation demos and extended it with Python. Rather than using the keyboard to move the character around, we can use Python code to call into the C++ functions that control him.

To build and run this sample on your own machine, you will require Visual Studio 2017 with the Python workload, the Python Native Development option, and Python 3.6 32-bit. If you already have Visual Studio 2017, these can be added by launching "Visual Studio Installer" and modifying the existing install.

Note: When you install Python 3.6 32-bit through Visual Studio, it automatically includes debugging symbols. If you install it yourself, you will need to select "Customize installation" and include debugging symbols. If you have already installed it, you can use Programs and Features to modify your install and add debugging symbols.

Clone our repository using git clone --recurse-submodules https://github.com/zooba/ogre3d-python-embed.git or using Team Explorer in Visual Studio. There is a PowerShell script in the root of the repository called get_externals.ps1 that will download and extract the version of the Ogre3d and SDL2 runtimes needed, and will prompt if you are missing either Python 3.6 32-bit or the DirectX redistributables (you can download the latter here, but be aware that this is a very old installer that will offer to install a browser toolbar - feel free to deselect that).

Once everything is installed, open srcPythonCharacter.sln in Visual Studio 2017 and press Ctrl+F5 to build and run the sample. While running, the sample will capture your mouse cursor, but you can use Alt+Tab to switch to another window. We will do that next to look at some of the code.

In Visual Studio, open Solution Explorer and then open the following files. We will be looking at each in the next few sections.

• ogre.pyi
• ogre_module.h
• SinbadCharacterController.h
• ai.py

Modifying without recompiling

The Python module ai.py is where we define the behavior of Sinbad, our dancing ogre. Collapse the command definitions region by clicking the "-" symbol to the left of #region Command definitions and look at the SCRIPT variable. Each item in this list is the movement we want Sinbad to do, including the amount of time he should do it for. There are already some extra movements listed but commented out, so try uncommenting them or adding your own. You can do this while the demo is running in the background.

Once you've made changes, save this file, use Alt+Tab to go back to the running sample, and press F5. The F5 key will reload the script, and you will see your changes (or an error) immediately. Compare this to normal C++ development, where you would have had to stop running, modify the code, recompile (and wait!), start running again, and return to the same state you were previously.

This is possible because of CPython's support for embedding, and made simple by the powerful pybind11 library. Embedding allows you to host the Python runtime in any native application, on any platform and using any compiler supported by CPython. So rather than launching "python.exe" with a script, you can load python36.dll into your own application and use it directly.

It is very easy to make Python representations of your C++ classes with pybind11. Switch to the ogre_module.h file to see what we did for this sample.

This file defines the mapping between a Python module named "ogre" and the classes and functions we want to make available. Using the metaprogramming features added in C++11, the pybind11 library automatically generates code to do the type conversions necessary to make Python code transparently interact with your C++ code. If you switch back to ai.py, you will see that the ogre.CharacterController class is imported and used in Python code to call back into C.

But how can we be sure that it is really doing all this? It seems pretty magical, and barely enough work on our part to make a game engine suddenly support Python scripting. In the next section, we will look at the proof that it is doing what we claim.

Debugging Python and C++

If you've got the demo running, now is the time to exit it by clicking on the Stop Debugging button. Visual Studio is famous for its debugging features, and this one is pretty cool. When you installed the Python Native Development option, we included the ability to do mixed Python/C++ debugging, whether you're in a Python project or a C++ project. You can find information about doing this from Python project in our documentation, but in this case we are going to launch a C++ project with Python debugging enabled.

Find the Start debugging button on the toolbar. Depending on your settings and the file you have open, it be labelled "Start", "Local Windows Debugger", "Python/Native Debugging" or "Attach...". Clicking the small down arrow next to the button will display your options.

Select "Python/Native Debugging" here to make it your new default. All the settings required to make the sample correctly load are already configured for this project (see this page for the details), so you can now press F5 to launch the sample again, but this time with the debugger attached.

Open ai.py again and set a breakpoint in the on_frame function near the end of the file. This function is called for each frame, but normally returns quickly until it's time to run the next step in the script. So while the demo is running, sooner or later this function will be hit. When it is, you'll see a mixed call stack showing both Python and C++ frames. (In this screenshot, I've hidden external code, so you may see some extra frames from pybind11.)

As you press F11 to step through the code, you will jump between Python and C++ just as naturally as either language on its own, and anywhere you view a Python object you'll be able to see the regular Python view. Breakpoints set in native code or Python code will be hit, and switching up and down the call stack will let you view both kinds of frames.

Type hints for Python code

Finally, let's take another look at the Python code and how Visual Studio helps you be a productive developer. In general, when you have defined a Python class in C++ you are not going to get IntelliSense when editing the code using it. This is unfortunate, as IntelliSense is most useful when using code that does not have easily read sources, but we now have the ability to provide IntelliSense separately.

Open the ogre.pyi file. While it looks very much like Python code, it's actually a type stub file that exists solely for its type hints. We include class and function definitions, but no bodies. With function annotations, we can specify the expected types and the return type of each function, and we will also extract and present documentation strings.

As this file is named ogre.pyi, when the ai.py module imports the native ogre module, IntelliSense will import the type stub instead. Without the type stub, we would not be able to resolve the ogre module at all, as it is generated at runtime by pybind11 and there is no other way for us to find it.

Switch back to ai.py and find the on_frame function. As this is called from C++, we have no information about the arguments that are passed to it, so to get IntelliSense we use type annotations to specify the parameter types. If you start typing character. within this function then you will see all the members that were specified in the type stub.

While this is very convenient and necessary in some situations, most of the time we are able to show you good IntelliSense without needing type hints. If you hover over command in this function you will see all the possible command types; using Go To Definition (F12) on command.execute will take you to either of the implementations of that function; and even though there are no type hints on these functions, we are still able to provide all the completions on character through our type analysis engine. Type stub files are useful for when you want to provide users with IntelliSense for code that cannot be automatically analyzed, and annotations can fill in the gaps that occur when using complex or unusual Python code.

Summary

If you develop native applications that have frequently-changing logic or business rules, it is easy to move that logic from C or C++ into Python, where it can be easily modified and updated without needing to recompile or restart your application. The combination of Visual Studio 2017 with the official CPython releases and pybind11 is the most productive way to develop and debug all aspects of your hybrid C++ and Python project. Download the free Visual Studio 2017 Community to get started today.

Microsoft has a long history of working with the community to help improve OpenStreetMap . This includes being the first company to provide aerial imagery to the community for editing and, more recently, our release of almost ten million building footprints. We continue to have an interest in fostering a thriving and growing community of both contributors and users of OpenStreetMap.

This week Microsoft is integrating its Streetside imagery for the United States into iD, a popular web-based editor for contributing to OpenStreetMap. This is the same imagery currently visible on Bing Maps now embedded into a popular editing application initially developed and now maintained by Mapbox. Our aim is that it continues to encourage the community to contribute and improve OpenStreetMap.

The Streetside imagery covers more than 80% of the US population with 360 degree views. The massive imagery dataset covers approximately 1.6 million kilometers and takes nearly 5PB of storage! This imagery when viewed in conjunction with Bing imagery along with existing data in OpenStreetMap represents a significant increase in verifiable ground truth for OpenStreetMap contributors.

- Bing Maps Team

Microsoft’s teams have been working over the last few years to bring Python developer tools to the Azure cloud and our most popular developer tools: Visual Studio Code and Visual Studio. Python is one of the fastest growing languages, with both beginner and expert developers taking to it. What makes it attractive is its easy-to-learn semantics with powerful capabilities for a wide variety of applications from writing scripts, to building web services, to building machine learning models. In this post we’ll take a tour of Python Developer tools in Visual Studio, Visual Studio Code, Azure, and more.

Visual Studio Code

The Python Extension for Visual Studio Code is fully open source and integrates other open source Python packages for developers to provide rich editing, debugging, and testing capabilities. Python is the fastest growing language in Visual Studio Code, and the Microsoft Python Extension for Visual Studio Code is one of the most popular extensions on the Visual Studio Code marketplace!

To get started, first download Visual Studio Code and then from there you can follow our Getting Started with Python tutorial to install the extension and get the basic features working. Let’s take a quick look at some of the feature highlights.

The first thing you’ll want to do is make sure that Visual Studio Code is using the desired Python interpreter. You can easily select and switch between different Python interpreters by clicking on the Python version in the status bar:

The selector supports many different interpreters and Python environments: Python 2, 3, virtualenv, Anaconda, Pipenv and pyenv environments. Once you have picked your interpreter, the extension will use it for IntelliSense, refactoring, linting, running code, and debugging.

To run a Python script locally, you can use the “Python: Create Terminal” command (CTRL + Shift + P to open the command box, or CMD + Shift + P on a Mac) to create a terminal with the environment activated. Or, if you want to run a Python file you simply can right-click on it and select “Run Python File in Terminal”:

Which will then run the file using the selected Python interpreter, in this case a Python 3.6 virtual environment:

The Python extension also includes debugging templates for many popular application types. You can head over to the debug tab, and select “Add Configuration…” from the debug configuration dropdown:

You will then see preset configurations for debugging the current file, attaching to a remote debug server, or debugging Flask, Django, Pyramid, PySpark or Scrapy apps. You can then select your debug configuration and press the green Play button (or F5 on your keyboard, FN + F5 on a Mac) to start debugging.

The Python extension has support for various code linters that can be configured to run when you save your Python file. By default, PyLint is enabled and you can select your linter of choice by using the “Python: Select Linter” command:

That’s not all as there’s also support for unit testing with unittest, pytest and nose; refactoring; and you can use Visual Studio Live Share to remotely collaborate on Python code with other developers!

Python in Visual Studio

Visual Studio provides most of the functionality of Visual Studio Code, with additional powerful IDE capabilities that allow you to do more without having to drop to the command line. Visual Studio also provides unparalleled capabilities when mixing Python projects with C# or C++ projects.

You can Install Python support in Visual Studio on Windows by selecting either the Python Development workload and/or the Data science and analytical applications workload in the Visual Studio installer:

You can choose to install various versions of Python and Anaconda by selecting optional components (on the right-hand side in the screenshot above).

After installing the Python workload, you can start working with Python by creating a Python project in File -> New Project and selecting Python in the installed list:

To start from a blank application, you can start with the Python Application template and start writing Python code. You can also create a project from existing Python code, or you can use web templates for Flask, Django, and Bottle. Be sure to check out our Flask Tutorial and Django Tutorial for an in-depth tour of developing web apps using these frameworks with Visual Studio.

If you have the data science workload installed, there are also templates for machine learning projects with Tensorflow and CNTK.

After you have created a project, you can manage your virtual environments and conda environments using the “Python Environments” node in solution explorer and the Python Environments window. You can right->click on the active Python environment and install additional packages:

The real power of Visual Studio shines when you mix Python with other languages. You can have a solution with both Python and C++ projects, or even embed .py files in your C++ or C# projects!

You can even debug both languages in the same debug session, for example with C++ you can change the debug type to Python/Native debugging:

For a detailed walkthrough of embedding Python in a C++ application, be sure to check out Embedding Python in a C++ Project on the Python blog to learn more.

Finally, also worth mentioning that Visual Studio includes a Python profiler and supports Python unit tests in the Test Explorer.

Python in Azure

You can use Python to create, manage and interact with services in Azure using the Python Azure SDK. In fact, the Azure CLI itself is written in Python, which means almost all things you can do with the CLI you can do programmatically using the Python SDK.

You can install individual libraries, for example to install the SDK to interact with Azure Storage:

    pip install azure-storage

It’s recommended that you only install the packages you need, but for convenience you can install the entire azure SDK by running:

    pip install azure

Once you have the SDK installed there are many great services you can use, from using Machine Learning APIs with Azure Cognitive Services to hosting globally distributed data with Azure Cosmos DB.

If you’re building web applications, you can deploy them to Azure Web App for Containers: be sure to check out From Zero to Azure with Python and Visual Studio Code for an end-to-end video tutorial deploying a Flask application using Visual Studio Code, or the quick-start tutorial on deploying a Flask application using the command line.

You can also run freely hosted Jupyter notebooks on Azure, so that you don’t need to install Jupyter locally. You can optionally share notebooks publicly, for example you can view a preview of this publicly shared notebook that generates handwriting using machine learning:

You can sign-in to clone and run notebooks, so head on over to notebooks.azure.com and sign-in to try it out!

Other Links and Information

Visual Studio Team Services is now able to build cross-platform Python builds using the hosted build agents and the Use Python Version tool tasks. Microsoft has also donated build time to enable CI Builds of the CPython project running on VSTS.

Something else you may not be aware of: SQL Server Machine Learning Services allows you to run Python code within a SQL Server to deliver advanced analytics at scale and avoid having to pull data across the network.

Finally, be sure to check out Microsoft on PyPI for all our Python packages we produce, and check out our Python at Microsoft blog for the latest news on everything Python at Microsoft.

Dan Taylor, Senior Program Manager Dan Taylor has been at Microsoft for 5 years working on performance improvements to .NET and Visual Studio, as well as profiling and diagnostic tools in Visual Studio and Azure

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 is now a Feature On Demand

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.

New capabilities with the updated WebDriver dialect

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.

What’s next for WebDriver and Microsoft Edge

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

The post Enhancing automated testing in Microsoft Edge with new WebDriver capabilities, W3C protocol support, and automatic updates appeared first on Microsoft Edge Dev Blog.