At the beginning of each new year, many people take on a challenge to learn something new or commit to reinforcing existing skills. Over the next two blogs posts, we will guide you through two amazing, free, developer training video series: C# fundamentals and UWP Development.

Both series require no prior programming experience, so they’re perfect for someone who wants to learn something new. However, since the videos span a wide array of topics, they’re also great to brush up on your existing skills.

The series are presented by Bob Tabor from Developer University (formerly learnvisualstudio.net). Bob is known for his easy-to- follow teaching style, keeping you engaged and entertained while learning the topic.

To get started, we’ll take a look at the first series: C# Fundamentals for the Absolute Beginner. In this free Microsoft Virtual Academy course, you will learn core C# concepts applicable to a wide range of classic and modern applications.

For the beginner, or if you’re coming from a different language, this series will walk you through getting the tools, writing code, debugging features, customizations and much more. For the experienced C# developer who wants to brush up on certain topics, each concept is explained in its own video so you can jump to a topic and focus on the information you want.

Here’s a list of the course modules:

Getting Started

1 | Course Introduction

2 | Installing Visual Studio

3 | Creating Your First C# Program

4 | Understanding Your First C# Program

5 | Working with Code Files, Projects, and Solutions

The Basics

6 | Understanding Data Types and Variables

7 | The if Decision Statement

8 | Operators, Expressions, and Statements

9 | for Iteration Statement

10 | Understanding Arrays

11 | Defining and Calling Methods

12 | While Iteration Statement

13 | Working with Strings

14 | Working with Dates and Times

Understanding and Writing Well Constructed Code

15 | Understanding Classes

16 | More About Classes and Methods

17 | Understanding Scope and Accessibility Modifiers

18 | Understanding Namespaces and Working with the .NET Class Library

19 | Creating and Adding References to Assemblies

Advancing

20 | Working with Collections

21 | Working with LINQ

22 | Enumerations and the Switch Decision Statement

23 | Gracefully Handling Exceptions

24 | Understanding Events and Event-Driven Programming

25 | Where to Go from Here

Microsoft Virtual Academy will keep track of your progress as you move through the modules and complete assessments. If you want to jump to a particular module, you can do that by clicking one of the links above or use the Contents tab next to the current video playing.

In the next post, we will take you through the next video course that will show you how to apply your new, or refreshed, C# skills and introduce you to XAML in a Windows 10 Universal Windows Application.

The post New Year, New Devs: Sharpen your C# Skills appeared first on Building Apps for Windows.

Microsoft’s file systems organize storage devices based on cluster size. Also known as the allocation unit size, cluster size represents the smallest amount of disk space that can be used to hold a file. Both ReFS and NTFS support multiple cluster sizes, as different sized clusters can offer different performance benefits, depending on the deployment.

In the past couple weeks, we’ve seen some confusion regarding the recommended cluster sizes for ReFS and NTFS, so this blog will hopefully disambiguate previous recommendations while helping to provide the reasoning behind why some cluster sizes are recommended for certain scenarios.

IO amplification

Before jumping into cluster size recommendations, it’ll be important to understand what IO amplification is and why minimizing IO amplification is important when choosing cluster sizes:

• IO amplification refers to the broad set of circumstances where one IO operation triggers other, unintentional IO operations. Though it may appear that only one IO operation occurred, in reality, the file system had to perform multiple IO operations to successfully service the initial IO. This phenomenon can be especially costly when considering the various optimizations that the file system can no longer make:
  • When performing a write, the file system could perform this write in memory and flush this write to physical storage when appropriate. This helps dramatically accelerate write operations by avoiding accessing slow, non-volatile media before completing every write.
  • Certain writes, however, could force the file system to perform additional IO operations, such as reading in data that is already written to a storage device. Reading data from a storage device significantly delays the completion of the original write, as the file system must wait until the appropriate data is retrieved from storage before making the write.

ReFS cluster sizes

ReFS offers both 4K and 64K clusters. 4K is the default cluster size for ReFS, and we recommend using 4K cluster sizes for most ReFS deployments because it helps reduce costly IO amplification:

• In general, if the cluster size exceeds the size of the IO, certain workflows can trigger unintended IOs to occur. Consider the following scenario where a ReFS volume is formatted with 64K clusters:
  • Consider a tiered volume. If a 4K write is made to a range currently in the capacity tier, ReFS must read the entire cluster from the capacity tier into the performance tier before making the write. Because the cluster size is the smallest granularity that the file system can use, ReFS must read the entire cluster, which includes an unmodified 60K region, to be able to complete the 4K write.
• By choosing 4K clusters instead of 64K clusters, one can reduce the number of IOs that occur that are smaller than the cluster size, preventing costly IO amplifications from occurring as frequently.

Additionally, 4K cluster sizes offer greater compatibility with Hyper-V IO granularity, so we strongly recommend using 4K cluster sizes with Hyper-V on ReFS.  64K clusters are applicable when working with large, sequential IO, but otherwise, 4K should be the default cluster size.

NTFS cluster sizes

NTFS offers cluster sizes from 512 to 64K, but in general, we recommend a 4K cluster size on NTFS, as 4K clusters help minimize wasted space when storing small files. We also strongly discourage the usage of cluster sizes smaller than 4K. There are two cases, however, where 64K clusters could be appropriate:

• 4K clusters limit the maximum volume and file size to be 16TB
  • 64K cluster sizes can offer increased volume and file capacity, which is relevant if you’re are hosting a large deployment on your NTFS volume, such as hosting VHDs or a SQL deployment.
• NTFS has a fragmentation limit, and larger cluster sizes can help reduce the likelihood of reaching this limit
  • Because NTFS is backward compatible, it must use internal structures that weren’t optimized for modern storage demands. Thus, the metadata in NTFS prevents any file from having more than ~1.5 million extents.
    • One can, however, use the “format /L” option to increase the fragmentation limit to ~6 million. Read more here.
  • 64K cluster deployments are less susceptible to this fragmentation limit, so 64K clusters are a better option if the NTFS fragmentation limit is an issue. (Data deduplication, sparse files, and SQL deployments can cause a high degree of fragmentation.)
    • Unfortunately, NTFS compression only works with 4K clusters, so using 64K clusters isn’t suitable when using NTFS compression. Consider increasing the fragmentation limit instead, as described in the previous bullets.

While a 4K cluster size is the default setting for NTFS, there are many scenarios where 64K cluster sizes make sense, such as: Hyper-V, SQL, deduplication, or when most of the files on a volume are large.

Cyber attacks involving zero-day exploits happen from time to time, affecting different platforms and applications. Over the years, Microsoft security teams have been working extremely hard to address these attacks. While delivering innovative solutions like Windows Defender Application Guard, which provides a safe virtualized layer for the Microsoft Edge browser, and Windows Defender Advanced Threat Protection, a cloud-based service that identifies breaches using data from built-in Windows 10 sensors, we are hardening the Windows platform with mitigation techniques that can stop exploits of newly discovered and even undisclosed vulnerabilities. As Terry Myerson reiterated in his blog post, we take our commitment to security innovation very seriously.

A key takeaway from the detonation of zero-day exploits is that each instance represents a valuable opportunity to assess how resilient a platform can be—how mitigation techniques and additional defensive layers can keep cyber-attacks at bay while vulnerabilities are being fixed and patches are being deployed. Because it takes time to hunt for vulnerabilities and it is virtually impossible to find all of them, such security enhancements can be critical in preventing attacks based on zero-day exploits.

In this blog, we look at two recent kernel-level zero-day exploits used by multiple activity groups. These kernel-level exploits, based on CVE-2016-7255 and CVE-2016-7256 vulnerabilities, both result in elevation of privileges. Microsoft has promptly fixed the mentioned vulnerabilities in November 2016. However, we are testing the exploits against mitigation techniques delivered in August 2016 with Windows 10 Anniversary Update, hoping to see how these techniques might fare against future zero-day exploits with similar characteristics.

CVE-2016-7255 exploit: Win32k elevation of privilege

In October 2016, the STRONTIUM attack group launched a spear-phishing campaign targeting a small number of think tanks and nongovernmental organizations in the United States. The campaign, also discussed in the previously mentioned blog post, involved the use of the exploit for CVE-2016-7255 in tandem with an exploit for the Adobe Flash Player vulnerability CVE-2016-7855.

The attack group used the Flash exploit to take advantage of a use-after-free vulnerability and access targeted computers. They then leveraged the type-confusion vulnerability in win32k.sys (CVE-2016-7255) to gain elevated privileges.

Abusing the tagWND.strName kernel structure

In this section, we’ll go through the internals of the specific exploit for CVE-2016-7255 crafted by the attacker. We will show how mitigation techniques provided customers with preemptive protection from the exploit, even before the release of the specific update fixing the vulnerability.

Figure 1. Exploit and shellcode phases of this attack

Modern exploits often rely on read-write (RW) primitives to achieve code execution or gain additional privileges. For this exploit, attackers acquire RW primitives by corrupting tagWND.strName kernel structure.  This exploit method is a trend discussed in security conferences and visible to those who investigated actual attacks. For example, we detailed similar findings in a presentation about the Duqu 2.0 exploit at Virus Bulletin 2015.

By reverse engineering its code, we found that the Win32k exploit used by STRONTIUM in October 2016 reused the exact same method. The exploit uses, after the initial Win32k vulnerability, corrupts tagWND.strName structure and uses SetWindowTextW to write arbitrary content anywhere in kernel memory.

Figure 2. SetWindowTextW as a write primitive

The exploit abuses this API call to overwrite data of current processes and copy token privileges of the SYSTEM. If successful, the exploit enables the victim process—iexplore.exe, in this example—to execute with elevated privileges.

Figure 3. Internet Explorer with SYSTEM privileges

Mitigating tagWND exploits with stronger validation

This mitigation performs additional checks for the   base and length fields, making sure that they are in  the   expected virtual address ranges and are not usable for RW primitives. In our tests on Anniversary Update, exploits using this method on the Anniversary Update to create an RW primitive in the kernel are ineffective. These exploits instead cause exceptions and subsequent blue screen error .

Figure 4. Windows 10 Anniversary Update mitigation on a common kernel write primitive

With the upcoming Windows 10 Creators Update, Windows Defender ATP introduces numerous forms of generic kernel exploit detection for deeper visibility into targeted attacks leveraging zero-day exploits. Technical details on the enhanced sensor will be shared in a forthcoming blog post.

CVE-2016-7256 exploit: Open type font elevation of privilege

As early as June 2016, unidentified actors began to use an implant detected as “Hankray” in low-volume attacks primarily focused on targets in South Korea. Later, in November 2016, these attackers were detected exploiting a flaw in the Windows font library (CVE-2016-7256) to elevate privileges and install the Hankray backdoor on targeted computers with older versions of Windows.

The font samples found on affected computers were specifically manipulated with hardcoded addresses and data to reflect actual kernel memory layouts. This indicates the likelihood that a secondary tool dynamically generated the exploit code at the time of infiltration.

Figure 5. Auto-generation of font file with exploit

executable or script tool, which has not been recovered, appears to prepare and drop the font exploit, calculating and preparing the hardcoded offsets needed to exploit the kernel API and the kernel structures on the targeted system. Through deep forensic inspection of the binary data found in samples, we extracted all the hardcoded offsets and ascertained the kernel version targeted by this exploit: Windows 8 64-bit.

Function table corruption for initial code execution

The font exploit uses fa_Callbacks to corrupt the function table and achieve initial code execution. The callback is called from the CFF parsing function. The following snippet shows a corrupted ftell pointer to a nt!qsort+0x39 location in kernel code.

Figure 6. fa_Callbacks table corruption

The following snippet shows the code that calls the corrupt function pointer leading to a kernel ROP chain.

Figure 7. fa_Callbacks.ftell function call code

When the corrupted function is called, the control jumps to the first ROP gadget at nt!qsort+0x39, which adjusts stack pointer and initializes some register values from stack values.

Figure 8. First ROP gadget

After the first gadget, the stack points to a kernel ROP chain which calls to ExAllocatePoolWithTag call to reserve shellcode memory. Another ROP gadget will copy the first 8 bytes of the stage 1 shellcode to the allocated memory.

Figure 9. Copying the first-stage shellcode

Shellcode and privilege escalation

The stage 1 shellcode is very small. Its main function is  the main body of the shellcode to newly allocated memory and run them with a JMP RAX control transfer.

Figure 10. Stage one shellcode

The main shellcode runs after the copy instructions. The main shellcode—also a small piece of code—performs a well-known token-stealing technique. It then copies the token pointer from a SYSTEM process to the target process, achieving privilege escalation. Both the SYSTEM process and target process PIDs, as well as certain offsets for the kernel APIs needed by the shellcode, are hardcoded in the font sample.

Figure 11. Token replacement technique

Mitigating font exploits with AppContainer

When opening the malicious font sample on Windows 10 Anniversary Update, font parsing happens completely in AppContainer instead of the kernel. AppContainer provides an isolated sandbox that effectively prevents font exploits (among other types of exploits) from gaining escalated privileges. The isolated sandbox  .

Figure 12. AppContainer protects against untrusted fonts in Anniversary Update

Mitigating font exploits with AppContainer

Windows 10 Anniversary Update also includes additional validation   for font file parsing. In our tests, the specific exploit code for CVE-2016-7256 simply fails these checks and is unable to reach vulnerable code.

Figure 12. Windows 10 font viewer error

Conclusion: Fighting the good fight with exploit mitigation and layered detection

While fixing a single-point vulnerability helps neutralize a specific bug, Microsoft security teams continue to look into opportunities to introduce more and more mitigation techniques. Such mitigation techniques can break exploit methods, providing a medium-term tactical benefit, or close entire classes of vulnerabilities for long-term strategic impact.

In this article, we looked into recent attack campaigns involving two zero-day kernel exploits. We saw how exploit mitigation techniques in Windows 10 Anniversary Update, which was released months before these zero-day attacks, managed to neutralize not only the specific exploits but also their exploit methods. As a result, these mitigation techniques are  that would have been available to future zero-day exploits.

By delivering these mitigation techniques, we are increasing the cost of exploit development, forcing attackers to find ways around new defense layers. Even the simple tactical mitigation against popular RW primitives forces the exploit authors to spend more time and resources in finding new attack routes. By moving font parsing code to an isolated container, we  the likelihood that font bugs are used as vectors for privilege escalation.

In addition to the techniques mentioned in this article, Windows 10 Anniversary updates introduced many other mitigation techniques in core Windows components and the Microsoft Edge browser, helping protect customers from entire classes of exploits for very recent and even undisclosed vulnerabilities.

For effective post-breach detection, including cover for the multiple stages of attacks described in this article, sign up for Window Defender ATP. The service leverages built-in sensors to raise alerts for exploits and other attack activity, providing corresponding threat intelligence. Customers interested in the Windows Defender ATP post-breach detection solution can find more information here.

Microsoft would like to thank KrCERT for their collaboration in protecting customers and for providing the sample for CVE-2016-7256.

This release is big on Bluetooth. If you’re familiar with Windows Bluetooth APIs, have been meaning to try them out, or if you’re just starting to dabble in IoT and wearables, this is a great time to take a fresh look at all things Bluetooth. To ensure the APIs we built out are functional and performant, we are working directly with Fitbit, Garmin and other device manufacturers and we would love your feedback as well.

There are three main features in this month’s Insider preview:

• GATT Server
• Bluetooth LE Peripheral
• Unpaired Bluetooth LE device connectivity

A lot of the improvements are focused on Bluetooth LE, but we have improved Bluetooth audio functionality as well. While we made a lot of changes under the hood to ensure that all your devices talk nicely with each other, we also added a couple of new features.

Call Control API support comes to desktop. This means your VoIP apps can natively take advantage of Bluetooth headset functionality like pick up, hang up, hold, call waiting, etc. You will also experience higher-quality audio for voice, thanks to Wideband speech– coming soon to desktop. Now, Cortana will sound more lifelike and your Skype sessions will sound better than ever over Bluetooth.

Now, let’s break down the LE portions of this feature set.

GATT Server

GATT (or Generic ATTribute) logically describes how data is structured and must function in a Bluetooth LE device. The device that has the interesting data is the Server, and the device that uses that data to perform a function is known as the Client. For example, a Windows Phone (Client) reads data from a heart rate monitor (Server) to track that a user is working out optimally. Windows has traditionally been a GATT Client but with the Windows 10 Creators Update, Windows can operate as the Server as well. The hierarchy of classes in the example heart rate service is described below, but you can pick and choose any logical set of characteristics and descriptors to make your custom GATT service.

Your phone or PC has notification/user credential information that a wearable device does not have. For instance, when an incoming text message comes in, Windows can act as the GATT Server and notify a nearby wearable of the text’s arrival. Diagram 1 shows a sample service structure using Bluetooth classes implemented in this release.

Diagram 1: Sample Heart Rate GattDeviceService

For a more thorough discussion of GATT and all of its intricacies, take a look at the Bluetooth SIG page or the GATT tutorial on Adafruit.

Bluetooth LE Peripheral Role

In addition to GATT roles which determine the structure of the data, Bluetooth defines Generic Access Profile (GAP) roles as well.

These GAP roles specify which device advertises as connectable and which device does the connecting. To connect a device, Windows users generally go to the Settings page, find the device they want to connect and tap to connect. This action of connecting to remote devices implies that Windows is operating in the GAP Central role. However, there are often cases where remote devices such as smart locks need to be aware of Windows, or where you’re trying to connect two Windows devices. In such cases, we need to make sure that Windows can advertise as connectable. With the new Insider preview, apps can put the system in a state to advertise support for Bluetooth LE services. With Peripheral role and GATT Server combined, Windows can operate in all four combinations of GATT and GAP roles (color choices arbitrary, of course):

Diagram 2: Windows operating in all GATT and GAP roles

Unpaired Bluetooth LE device connectivity

Traditionally, Bluetooth LE devices needed to be paired with Windows to be accessed. This either forced the user to switch context to the Settings page, or caused developers to implement in-app pairing logic within the app. Unfortunately, there were even devices that didn’t support pairing, which necessitated ugly workarounds for the developer. All that is going to change now with the new Async GATT APIs.

In the new APIs, take a look at BluetoothLEDevice.GetGattServicesAsync(), GattDeviceService.GetCharacteristicsAsync() as well as GattCharacteristic.GetDescriptorsAsync() to get an idea for how to query a remote device without pairing.

What you need to get started

It’s all in the release preview Build and SDK, available to download here. Once you install the build, take a look at the classes that were described in the previous sections and have at it. We’re a little light on the documentation right now, but we will remedy that soon.

Does this mean my can get notifications?

GATT Server will open up a myriad of Bluetooth LE device-to-device scenarios that we think are super exciting! Why limit yourself to “Notifications”? Think remote authentication, smart locks, proximity and IoT! The world is your (wireless) oyster. But yes, developers can start enabling notifications now. However, consumers will only see this functionality lit up once Windows 10 Creators Update is released and their updated app is in the store.

If you would like us to go deeper on any of the topics in this post, please let us know in the comment sections below.

The post New Bluetooth features in Windows 10 Creators Update (a.k.a. GATT Server and friends) appeared first on Building Apps for Windows.

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15003 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 15003 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum.  For new feature requests, head over to our Windows Platform UserVoice.

Things to Note:

• The SDK will require Visual Studio 2017 Preview. You can download the Visual Studio 2017 Preview.

What’s New:

• This Windows SDK includes updates and additions to the Windows namespace. See section API Updates and Additions below for the list.
• Debugging Tools for Windows has been updated with a few new features, including JavaScript scripting and extensibility. See the blogpost at https://blogs.msdn.microsoft.com/windbg/2016/10/27/new-insider-sdk-and-javascript-extensibility/ for more information.

Known Issues Windows SDK:

• There is no Emulator with this release
• I cannot specify the new SDK version 15003 when creating a new project
  This version of the SDK only works with Visual Studio 2017.  You can download the Visual Studio 2017 Preview. If you install the latest version Visual Studio 2017, you will be able to specify the build 15003.

API Updates and Additions:

The following API changes are under development and new or updated for this release of the SDK.

namespace Windows.ApplicationModel.Preview.Notes {
  public sealed class NotesWindowManagerPreview {
    void SetFocusToPreviousView();
    IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
    void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
    void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
  }
  public sealed class NotesWindowManagerPreviewShowNoteOptions
}
namespace Windows.Devices.Gpio {
  public struct GpioChangeCount
  public sealed class GpioChangeCounter : IClosable
  public enum GpioChangePolarity
  public sealed class GpioChangeReader : IClosable
  public struct GpioChangeRecord
  public enum GpioOpenStatus {
    MuxingConflict = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.I2c {
  public enum I2cTransferStatus {
    ClockStretchTimeout = 3,
    UnknownError = 4,
  }
}
namespace Windows.Devices.Pwm {
  public sealed class PwmController {
    public static IAsyncOperation FromIdAsync(string deviceId);
    public static string GetDeviceSelector();
    public static string GetDeviceSelector(string friendlyName);
  }
}
namespace Windows.Devices.SmartCards {
  public sealed class SmartCardTriggerDetails {
    SmartCard SmartCard { get; }
  }
}
namespace Windows.Devices.SmartCards {
  public enum SmartCardCryptogramAlgorithm {
    Sha256Hmac = 8,
  }
  public sealed class SmartCardCryptogramGenerator {
    IAsyncOperation GetAllCryptogramMaterialCharacteristicsAsync(SmartCardUnlockPromptingBehavior promptingBehavior, string materialPackageName);
    IAsyncOperation GetAllCryptogramMaterialPackageCharacteristicsAsync();
    IAsyncOperation GetAllCryptogramMaterialPackageCharacteristicsAsync(string storageKeyName);
    IAsyncOperation GetAllCryptogramStorageKeyCharacteristicsAsync();
    IAsyncOperation ValidateRequestApduAsync(SmartCardUnlockPromptingBehavior promptingBehavior, IBuffer apduToValidate, IIterable cryptogramPlacementSteps);
  }
  public enum SmartCardCryptogramGeneratorOperationStatus {
    ValidationFailed = 12,
  }
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult
  public sealed class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult
  public sealed class SmartCardCryptogramMaterialCharacteristics
  public sealed class SmartCardCryptogramMaterialPackageCharacteristics
  public enum SmartCardCryptogramMaterialProtectionMethod
  public sealed class SmartCardCryptogramStorageKeyCharacteristics
}
namespace Windows.Foundation.Metadata {
  public sealed class FeatureAttribute : Attribute
  public enum FeatureStage
}
namespace Windows.ApplicationModel {
  public sealed class Package {
    IAsyncOperation GetContentGroupAsync(string name);
    IAsyncOperation> GetContentGroupsAsync();
    IAsyncOperation SetInUseAsync(bool inUse);
    IAsyncOperation> StageContentGroupsAsync(IIterable names);
    IAsyncOperation> StageContentGroupsAsync(IIterable names, bool moveToHeadOfQueue);
  }
  public sealed class PackageCatalog {
    event TypedEventHandler PackageContentGroupStaging;
    IAsyncOperation AddOptionalPackageAsync(string optionalPackageFamilyName);
  }
  public sealed class PackageCatalogAddOptionalPackageResult
  public sealed class PackageContentGroup
  public sealed class PackageContentGroupStagingEventArgs
  public enum PackageContentGroupState
  public sealed class PackageStatus {
    bool IsPartiallyStaged { get; }
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    ContactPanel = 1017,
    LockScreenComponent = 1016,
  }
  public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
  public interface IContactPanelActivatedEventArgs
  public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
  public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
    int CurrentlyShownApplicationViewId { get; }
  }
}
namespace Windows.ApplicationModel.Background {
  public sealed class BackgroundTaskBuilder {
    BackgroundTaskRegistrationGroup TaskGroup { get; set; }
  }
  public sealed class BackgroundTaskRegistration : IBackgroundTaskRegistration, IBackgroundTaskRegistration2, IBackgroundTaskRegistration3 {
    public static IMapView AllTaskGroups { get; }
    BackgroundTaskRegistrationGroup TaskGroup { get; }
    public static BackgroundTaskRegistrationGroup GetTaskGroup(string groupId);
  }
  public sealed class BackgroundTaskRegistrationGroup
  public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
    public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
  }
  public sealed class GattServiceProviderTrigger : IBackgroundTrigger
  public sealed class GattServiceProviderTriggerResult
  public interface IBackgroundTaskRegistration3 : IBackgroundTaskRegistration
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactAnnotation {
    string ContactListId { get; set; }
  }
  public enum ContactAnnotationOperations : uint {
    Share = (uint)32,
  }
  public sealed class ContactAnnotationStore {
    IAsyncOperation> FindAnnotationsForContactListAsync(string contactListId);
  }
  public sealed class ContactGroup
  public static class ContactManager {
    public static bool IncludeMiddleNameInSystemDisplayAndSort { get; set; }
    public static IAsyncOperation IsShowFullContactCardSupportedAsync();
  }
  public sealed class ContactManagerForUser {
    void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
  }
  public sealed class ContactPanel
  public sealed class ContactPanelClosingEventArgs
  public sealed class ContactPanelLaunchFullAppRequestedEventArgs
  public sealed class ContactPicker {
    User User { get; }
    public static ContactPicker CreateForUser(User user);
    public static IAsyncOperation IsSupportedAsync();
  }
  public sealed class PinnedContactIdsQueryResult
  public sealed class PinnedContactManager
  public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
  public sealed class CoreApplicationView {
    IPropertySet Properties { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackage {
    event TypedEventHandler ShareCompleted;
  }
  public sealed class DataTransferManager {
    event TypedEventHandler ShareProvidersRequested;
  }
  public sealed class ShareCompletedEventArgs
  public sealed class SharePeople
  public sealed class ShareProvider
  public delegate void ShareProviderHandler(ShareProviderRequest request);
  public sealed class ShareProviderRequest
  public sealed class ShareProvidersRequestedEventArgs
  public sealed class ShareTargetInfo
}
namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
  public sealed class ShareOperation {
    SharePeople People { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public sealed class EmailMessage {
    IVector ReplyTo { get; }
    EmailRecipient SentRepresenting { get; set; }
  }
}
namespace Windows.ApplicationModel.Payments {
  public sealed class PaymentAddress
  public sealed class PaymentCurrencyAmount
  public sealed class PaymentDetails
  public sealed class PaymentDetailsModifier
  public sealed class PaymentItem
  public sealed class PaymentMediator
  public sealed class PaymentMerchantInfo
  public sealed class PaymentMethodData
  public enum PaymentOptionPresence
  public sealed class PaymentOptions
  public sealed class PaymentRequest
  public sealed class PaymentRequestChangedArgs
  public delegate void PaymentRequestChangedHandler(PaymentRequest paymentRequest, PaymentRequestChangedArgs args);
  public sealed class PaymentRequestChangedResult
  public enum PaymentRequestChangeKind
  public enum PaymentRequestCompletionStatus
  public enum PaymentRequestStatus
  public sealed class PaymentRequestSubmitResult
  public sealed class PaymentResponse
  public sealed class PaymentShippingOption
  public enum PaymentShippingType
  public sealed class PaymentToken
}
namespace Windows.ApplicationModel.Payments.Provider {
  public sealed class PaymentAppManager
  public sealed class PaymentTransaction
  public sealed class PaymentTransactionAcceptResult
}
namespace Windows.ApplicationModel.Preview.Holographic {
  public static class HolographicApplicationPreview
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
  public static class LicenseManager {
    public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
  }
  public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.Store.Preview {
  public static class StoreConfiguration {
    public static string GetEnterpriseStoreWebAccountId();
    public static string GetEnterpriseStoreWebAccountIdForUser(User user);
    public static string GetStoreWebAccountId();
    public static string GetStoreWebAccountIdForUser(User user);
    public static void SetEnterpriseStoreWebAccountId(string webAccountId);
    public static void SetEnterpriseStoreWebAccountIdForUser(User user, string webAccountId);
    public static bool ShouldRestrictToEnterpriseStoreOnly();
    public static bool ShouldRestrictToEnterpriseStoreOnlyForUser(User user);
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallManager {
    IAsyncOperation GetFreeDeviceEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation GetFreeUserEntitlementAsync(string storeId, string campaignId, string correlationVector);
    IAsyncOperation GetFreeUserEntitlementForUserAsync(User user, string storeId, string campaignId, string correlationVector);
  }
  public sealed class GetEntitlementResult
  public enum GetEntitlementStatus
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity
  public sealed class UserActivityChannel
  public sealed class UserActivitySession : IClosable
  public enum UserActivityState
  public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
  public static class CoreUserActivityManager
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    bool CanShowCreateContactGroup { get; set; }
    IRandomAccessStreamReference Icon { get; set; }
    bool IsProtectedUnderLock { get; set; }
    IPropertySet ProviderProperties { get; }
    IAsyncOperation> FindContactGroupsAsync();
    IAsyncOperation> FindUserDataTaskListsAsync();
    IAsyncOperation TryShowCreateContactGroupAsync();
  }
  public sealed class UserDataAccountStore {
    IAsyncOperation CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
  }
}
namespace Windows.ApplicationModel.UserDataTasks {
  public sealed class UserDataTask
  public sealed class UserDataTaskBatch
  public enum UserDataTaskDaysOfWeek : uint
  public enum UserDataTaskDetailsKind
  public enum UserDataTaskKind
  public sealed class UserDataTaskList
  public sealed class UserDataTaskListLimitedWriteOperations
  public enum UserDataTaskListOtherAppReadAccess
  public enum UserDataTaskListOtherAppWriteAccess
  public sealed class UserDataTaskListSyncManager
  public enum UserDataTaskListSyncStatus
  public sealed class UserDataTaskManager
  public enum UserDataTaskPriority
  public enum UserDataTaskQueryKind
  public sealed class UserDataTaskQueryOptions
  public enum UserDataTaskQuerySortProperty
  public sealed class UserDataTaskReader
  public sealed class UserDataTaskRecurrenceProperties
  public enum UserDataTaskRecurrenceUnit
  public sealed class UserDataTaskRegenerationProperties
  public enum UserDataTaskRegenerationUnit
  public enum UserDataTaskSensitivity
  public sealed class UserDataTaskStore
  public enum UserDataTaskStoreAccessType
  public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
  public sealed class UserDataTaskDataProviderConnection
  public sealed class UserDataTaskDataProviderTriggerDetails
  public sealed class UserDataTaskListCompleteTaskRequest
  public sealed class UserDataTaskListCompleteTaskRequestEventArgs
  public sealed class UserDataTaskListCreateOrUpdateTaskRequest
  public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
  public sealed class UserDataTaskListDeleteTaskRequest
  public sealed class UserDataTaskListDeleteTaskRequestEventArgs
  public sealed class UserDataTaskListSkipOccurrenceRequest
  public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
  public sealed class UserDataTaskListSyncManagerSyncRequest
  public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter
  public enum BluetoothAddressType {
    Unspecified = 2,
  }
  public sealed class BluetoothDeviceId
  public enum BluetoothError {
    TransportNotSupported = 9,
  }
  public sealed class BluetoothLEDevice : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    IAsyncOperation GetGattServicesAsync();
    IAsyncOperation GetGattServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation GetGattServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation GetGattServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation RequestAccessAsync();
  }
}
namespace Windows.Devices.Bluetooth.Background {
  public enum BluetoothEventTriggeringMode
 public sealed class GattCharacteristicNotificationTriggerDetails {
    BluetoothError Error { get; }
    BluetoothEventTriggeringMode EventTriggeringMode { get; }
    IVectorView ValueChangedEvents { get; }
  }
  public sealed class GattServiceProviderConnection
  public sealed class GattServiceProviderTriggerDetails
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
  public sealed class GattCharacteristic {
    IAsyncOperation GetDescriptorsAsync();
    IAsyncOperation GetDescriptorsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation GetDescriptorsForUuidAsync(GattUuid descriptorUuid);
    IAsyncOperation GetDescriptorsForUuidAsync(GattUuid descriptorUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue clientCharacteristicConfigurationDescriptorValue);
    IAsyncOperation WriteValueWithResultAsync(IBuffer value);
    IAsyncOperation WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
  }
  public sealed class GattCharacteristicsResult
  public sealed class GattClientNotificationResult
  public enum GattCommunicationStatus {
    ProtocolError = 2,
  }
  public sealed class GattDescriptor {
    IAsyncOperation WriteValueWithResultAsync(IBuffer value);
  }
 public sealed class GattDescriptorsResult
  public sealed class GattDeviceService : IClosable {
    DeviceAccessInformation DeviceAccessInformation { get; }
    GattSession Session { get; }
    GattSharingMode SharingMode { get; }
    public static IAsyncOperation FromIdAsync(string deviceId, GattSharingMode sharingMode);
    IAsyncOperation GetCharacteristicsAsync();
    IAsyncOperation GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation GetCharacteristicsForUuidAsync(GattUuid characteristicUuid);
    IAsyncOperation GetCharacteristicsForUuidAsync(GattUuid characteristicUuid, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelector(GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
    public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid);
    public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation GetIncludedServicesAsync();
    IAsyncOperation GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
    IAsyncOperation GetIncludedServicesForUuidAsync(GattUuid serviceUuid);
    IAsyncOperation GetIncludedServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
    IAsyncOperation OpenAsync(GattSharingMode sharingMode);
    IAsyncOperation RequestAccessAsync();
  }
  public sealed class GattDeviceServicesResult
  public sealed class GattLocalCharacteristic
  public sealed class GattLocalCharacteristicParameters
  public sealed class GattLocalCharacteristicResult
  public sealed class GattLocalDescriptor
  public sealed class GattLocalDescriptorParameters
  public sealed class GattLocalDescriptorResult
  public sealed class GattLocalService
  public enum GattOpenStatus
  public sealed class GattPresentationFormat {
    public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
  }
  public static class GattProtocolError
  public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
    IReference ProtocolError { get; }
  }
  public sealed class GattReadRequest
  public sealed class GattReadRequestedEventArgs
  public sealed class GattReadResponse
  public sealed class GattReadResult {
    IReference ProtocolError { get; }
  }
  public sealed class GattReliableWriteTransaction {
    IAsyncOperation CommitWithResultAsync();
  }
  public enum GattRequestState
  public sealed class GattRequestStateChangedEventArgs
  public sealed class GattServiceProvider
  public enum GattServiceProviderAdvertisementStatus
  public sealed class GattServiceProviderAdvertisementStatusChangedEventArgs
  public sealed class GattServiceProviderAdvertisingParameters
  public sealed class GattServiceProviderResult
  public sealed class GattSession : IClosable
  public enum GattSessionStatus
  public sealed class GattSessionStatusChangedEventArgs
  public enum GattSharingMode
  public sealed class GattSubscribedClient
  public sealed class GattUuid
  public sealed class GattWriteRequest
  public sealed class GattWriteRequestedEventArgs
  public sealed class GattWriteResponse
  public sealed class GattWriteResult
}
namespace Windows.Devices.Haptics {
  public static class KnownSimpleHapticsControllerWaveforms
  public sealed class SimpleHapticsController
  public sealed class SimpleHapticsControllerFeedback
  public enum VibrationAccessStatus
  public sealed class VibrationDevice
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScanner : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public static class BarcodeSymbologies {
    public static uint Gs1DWCode { get; }
  }
  public sealed class BarcodeSymbologyAttributes
  public enum BarcodeSymbologyDecodeLengthKind
  public sealed class CashDrawer : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    IAsyncOperation GetSymbologyAttributesAsync(uint barcodeSymbology);
    IAsyncOperation SetSymbologyAttributesAsync(uint barcodeSymbology, BarcodeSymbologyAttributes attributes);
  }
  public sealed class ClaimedLineDisplay : IClosable
  public sealed class LineDisplay : IClosable
  public sealed class LineDisplayCapabilities
  public enum LineDisplayScrollDirection
  public enum LineDisplayTextAttribute
  public enum LineDisplayTextAttributeGranularity
  public sealed class LineDisplayWindow : IClosable
  public sealed class MagneticStripeReader : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
  public enum PosConnectionTypes : uint
  public sealed class PosPrinter : IClosable {
    void Close();
    public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
  }
}
namespace Windows.Gaming.Input {
  public sealed class ArcadeStick : IGameController, IGameControllerBatteryInfo {
    public static ArcadeStick FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class FlightStick : IGameController, IGameControllerBatteryInfo
  public enum FlightStickButtons : uint
  public struct FlightStickReading
  public enum GameControllerSwitchKind
  public enum GameControllerSwitchPosition
  public sealed class Gamepad : IGameController, IGameControllerBatteryInfo {
    public static Gamepad FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class Headset : IGameControllerBatteryInfo {
    BatteryReport TryGetBatteryReport();
  }
  public interface IGameControllerBatteryInfo
  public sealed class RacingWheel : IGameController, IGameControllerBatteryInfo {
    public static RacingWheel FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
  public sealed class RawGameController : IGameController, IGameControllerBatteryInfo
  public sealed class UINavigationController : IGameController, IGameControllerBatteryInfo {
    public static UINavigationController FromGameController(IGameController gameController);
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.Gaming.Input.Custom {
  public static class GameControllerFactoryManager {
    public static IGameController TryGetFactoryControllerFromGameController(ICustomGameControllerFactory factory, IGameController gameController);
  }
  public sealed class HidGameControllerProvider : IGameControllerProvider
  public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Gaming.UI {
  public enum GameChatMessageOrigin
  public sealed class GameChatOverlay
  public enum GameChatOverlayPosition
}
namespace Windows.Globalization {
  public static class CurrencyIdentifiers {
    public static string BYN { get; }
  }
}
namespace Windows.Globalization.Collation {
  public sealed class CharacterGroupings : IIterable, IVectorView {
    public CharacterGroupings(string language);
  }
}
namespace Windows.Graphics {
  public struct PointInt32
  public struct RectInt32
  public struct SizeInt32
}
namespace Windows.Graphics.Display.Core {
  public enum HdmiDisplayColorSpace
  public struct HdmiDisplayHdr2086Metadata
  public enum HdmiDisplayHdrOption
  public sealed class HdmiDisplayInformation
  public sealed class HdmiDisplayMode
  public enum HdmiDisplayPixelEncoding
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    HolographicDisplay Display { get; }
    HolographicCameraViewportParameters LeftViewportParameters { get; }
    HolographicCameraViewportParameters RightViewportParameters { get; }
  }
  public sealed class HolographicCameraRenderingParameters {
    HolographicReprojectionMode ReprojectionMode { get; set; }
    void CommitDirect3D11DepthBuffer(IDirect3DSurface value);
  }
  public sealed class HolographicCameraViewportParameters
  public sealed class HolographicDisplay
  public enum HolographicReprojectionMode
  public sealed class HolographicSpace {
    public static bool IsAvailable { get; }
    public static bool IsSupported { get; }
    public static event EventHandler

API Removals:

namespace Windows.UI.Composition {
  public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
  }
}
namespace Windows.UI.Composition.Interactions {
  public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
  }
}

The post Windows 10 SDK Preview Build 15003 Released appeared first on Building Apps for Windows.

About a year ago we released the new work item form to Visual Studio Team Services. This was the beginning of our vision for managing work items in a more social and visual way. Over the past year, we focused on realizing this vision through continual improvements and listening to customer feedback.

We added many useful features along the way, such as:

• A discussion control with @mention support to better collaborate on a work item.
• Ability to follow a work item to be notified when it changes.
• A work item extensibility model which lets you extend the form with custom controls, groups and pages.
• A responsive links control to better visualize related work.
• Integrated development control to both track existing code assets and to create new ones.
• An attachment control that supports drag/drop , uploading multiple files and image preview.
• A more visual history control to better review changes.

With all these changes, we now have a modern and extensible work item form. And, we’re very excited that you’ll be able to access it with the TFS 2017 release.

Enabling the new form in TFS 2017

After installing TFS 2017, all newly created collections will have the new form enabled by default. However, since we know the new form is a big change we built an opt in experience for existing collections. This lets administrators enable the new work item form in stages and make changes to the layout before deploying it broadly.

Start by enabling the new form in the collection administration page

Once enabled you can configure who can see the new form:

We recommend that you start with enabling for Administrators so that you can review and apply changes until you are happy with the layout. When you are ready to share with the rest of your team, enable as opt-in for all users.

When enabled as opt-in, each user will see a link that lets them toggle to the new form and try it out. This gives the opportunity to test out the layout changes and give feedback.

Once you have made any necessary updates to the layout to address feedback, you can migrate everyone to the new form for a consistent management experience.

Anatomy of the new work item form

The new form consists of a System Header and Pages.

System header

The system header contains vital parts of the work item – this includes Title, Assigned To, Discussion indicator, Tags, Follow, as well as the History, Links and Attachment pages.

We have become more restrictive with the system header so that we can bring consistency and utility across all work item experiences. Currently, the only customization you can make to the system header is changing the labels. You can still customize the underlying fields through the rules. We are looking for your feedback on these changes, and any additional customization you may need on the system header.

Pages

All the other content of the work item is organized into Pages, represented as tabs on the form.

Each page consists of Sections – the picture below shows a page with 3 sections. The first section is allocated 60% of the page width, the other two sections are allocated 20% each.

Groups

Sections are made up of groups. For example, the second section (colored in blue) has 2 groups – Planning and Classification. You can collapse and expand groups. Also, you can maximize certain groups, such as those containing an HTML or rich-text field control.

Controls

Groups are containers of field or custom controls. For example, the Story Point field control is shown below.

By arranging the contents in sections the new form provides an adaptive experience based on the width of your screen. For wide screens, we give each section its own vertical column. However, for small screens we wrap sections to preserve space and readability.

Customizing the new work item form in TFS 2017

The new work item form has a simplified XML layout which is very easy to modify. The page, section, group and control elements map directly to what you see on the form.

When the new form is enabled you can export your work item type to see the new layout automatically added in the in the WebLayout node. This new layout is auto-generated by transforming your existing form layout. Below is an example of a simple form xml containing a couple groups and links controls:

Given that this is auto-generated, not everything may be perfect and to your liking but you can make changes and apply them using the familiar import command (witadmin importwitd).

Extensibility with the new work item form

The new form brings with it a vastly improved extensibility model. You can add your own pages, groups and controls to the form or choose from the marketplace to get ready-made extensions like an updated Multi Value Control. After installing to your collection, you can enable them in your work item type and add them to your form.

The easiest way to do this is to export your work item type after the extension is installed. We inject a comment into the exported layout describing all extensions available targeting the work item form:

You can use this information to turn on extensions for your work item type and position them. In the example below, we add an Extension node that enables the Multi Value Control extension for the type and then add a ControlContribution node to add the custom control to the planning group.

After importing the work item type the custom control extension will show on the form.

We are planning a future blog post dedicated to work item form extensibility where we’ll go into greater depth about how to build them.

Conclusion

The new form landing in TFS 2017 culminates a lot of work and we are looking forward to receiving your feedback and exploring your ideas for improvements.

Links

• Rolling out the new form
• Customizing the new form layout
• Importing/Exporting a work item type
• Add or modify a custom control for a process and WIT
• Creating Form Extension
• Using Form Extensions
• Reporting Bugs/Issue/Feedback
• Submitting new ideas and enhancements

Thanks,

Big week in the Windows Developer world!

This week we have a new SDK, news about the Windows Developer Day – Windows 10 Creators Update, some curated C# tutorials, new Bluetooth features and if all that wasn’t enough, we created a desktop background featuring our favorite Visual Studio Shortcuts. We hope this desktop background can help both new and experienced developers learn a few tricks to help them become more efficient in Visual Studio. But first, here are last week’s updates:

Windows Developer Day – Windows 10 Creators Update

New Year, New Dev – C# basics

New Bluetooth Features and GATT services

Windows 10 SDK Preview Build 15003 Released

The Windows Desktop Wallpaper Background!

And last, but certainly not least, here is the Visual Studio Shortcuts desktop background we mentioned above. Download it here: http://wndw.ms/FkkoWL

And that’s it! Have a great weekend and feel free to tweet us if you have any questions.

Download Visual Studio to get started.

The Windows team would love to hear your feedback. Please keep the feedback coming using our Windows Developer UserVoice site. If you have a direct bug, please use the Windows Feedback tool built directly into Windows 10.

The post ICYMI – Free Desktop Wallpaper Background, #WindowsDevDay, Build15003, Bluetooth appeared first on Building Apps for Windows.

Azure Automation is now available in the Azure UK and West Central US regions. These new regions give you more options for locating Automation accounts in geographic locations that work best for you.

You can use Azure Automation to create, monitor, deploy, and maintain resources in your Azure, on-premises, and third-party cloud environments, by using highly scalable and reliable process execution and desired state configuration engines.

To learn more and get started with a free trial, see the Azure Automation overview.

Did you know that you can customize your Start and New Tab pages in Microsoft Edge to show news and sites based on your preference, so you can quickly get to the content you want?

Both pages give you access to the latest news across business, entertainment, finance and more. Plus, with weather updates, sports scores, recommendations for apps and much more, the Microsoft Edge Start and New Tab Page become your personal dashboard to help you kick-start your web journey every time.

Here’s how to start personalizing your Start and New Tab pages:

On the Start page, click the “Customize” icon on the top right, below the search bar and select the type of news you would like to see displayed under “My Feed.”

On the New Tab Page, you can customize not just your news feed, but also the websites you want displayed as your Top sites. You can pin an existing tile, delete it, drag and drop them or add new ones so you can quickly jump in to your preferred content.

Have a great week!

The post Windows 10 Tip: Personalize your Start Page in Microsoft Edge appeared first on Windows Experience Blog.

~ Maanas Saran | Program Manager | Microsoft

When DPM attempts to make a recovery point or run a consistency check for a protected VMware virtual machine (VM), the job can fail with a FileFaultFault error like the one shown below.

DPM encounterd error from VMware while trying to get ChangeTracking information. Server – Vmware_Server_name.  ErrorCode – FileFaultFault (ID 33621 Details: Internal error code: 0x80990EF3)

This can occur for one of the following reasons:

1. VMware vCenter and vSphere versions 5.5 and 6.0, including all updates, are supported by Microsoft Azure Backup Server (MABS) as well as the current releases of Microsoft Data Protection Manager (DPM).  If any version less than 5.5 is connected with MABS/DPM servers, you can receive this FileFaultFault error. To resolve this error, update VMware to version 5.5 or higher. Note that the update procedure includes a reboot of the host computer. You must ensure that the reboot is complete before the problem will be resolved.

2. MABS and DPM do not support protection of VMware VMs with Independent disks. Attempting to protect a VM with Independent mode enabled (as shown below) will result in the FileFaultFault error. 

To resolve this error, complete the following:

a. Disable and then re-enable “Changed Block Tracking” (CBT) on the VM experiencing the problem. For more information see the following VMware articles:

• Enabling or disabling Changed Block Tracking (CBT) on virtual machines (1031873)     (VMware ESXi 5.5.x)
• Resetting Changed Block Tracking for VMware vSphere virtual machines (2139574)    (VMware ESXi 5.5.x  ESXi 6.0.x)

Be aware that when CBT is disabled or enabled, the VM must go through a stun/unstun cycle (power off/power on). Make sure this cycle is complete before proceeding.

b. Disable Independent mode by deselecting the Independent checkbox.

Once this is complete, creating a recovery point or running a consistency check for a protected VMware virtual machine should complete successfully.

Maanas Saran | Program Manager | Microsoft

DPM 2012 R2 DPM 2016

The ASTrace utility provides the ability to capture an Analysis Services trace and log it into a SQL Server table. The table can be queried later or read using SQL Server Profiler. The ASTrace utility runs as a Windows service that connects to Analysis Services, then creates a trace, and logs trace events into a SQL Server table using the SQL Server Profiler format. The ASTrace utility creates the trace using a standard trace template that you can author using SQL Server Profiler.

ASTrace is available in the Analysis Services Git repo.

Thanks to Karan Gulati and Greg Galloway (Artis Consulting).

Analysis Services tabular models can store data in a highly-compressed, in-memory cache for optimized query performance. This provides fast user interactivity over large data sets.

Large data sets normally require table partitioning to accelerate and optimize the data-load process. Partitioning enables incremental loads, increases parallelization, and reduces memory consumption. The Tabular Object Model (TOM) serves as an API to create and manage partitions. TOM was released with SQL Server 2016 and is discussed here. Model Compatibility Level 1200 is required.

The sample,

• Is intended to be generic and configuration driven.
• Works for both Azure Analysis Services and SQL Server Analysis Services tabular models.
• Can be leveraged in many ways including from an SSIS script task, Azure Functions and others.

Thanks to Marco Russo (SQLBI) and Bill Anton (Opifex Solutions) for their contributions to the whitepaper and code sample.

Summary: Use a script to enable metrics logging for PaaS resources.

Azure Platform as a Service (PaaS) resources, like Azure SQL and Web Sites (Web Apps), can emit performance metrics data natively to OMS. This script allows users to enable metrics logging for PaaS resources at a the level of a subscription or resource group. Today, there is no way to enable metrics logging for PaaS resources through the UI. Therefore, customers need to use a PowerShell script. This native metrics logging capability and OMS monitoring enable customers to monitor Azure Resources at scale. For example, you can now use OMS to monitor hundreds of thousands of SQL Azure databases in one OMS workspace.

Prerequisites

Make sure that you have the following AzureRM modules installed on your workstation before you begin:

• Insights
• OperationalInsights
• Resources
• AzureRM.profile

Note: We recommend that all your Azure Resource Manager modules are the same version to ensure compatibility when you run Azure Resource Manager commands from PowerShell.

To install the latest set of AzureRM modules on your workstation:

PS C:\>install-module -Name AzureRM -Force

1. Open PowerShell in Administrator mode: Run As Administrator.
2. To save the Enable-AzureRMDiagnostics.ps1 script file locally, run the following command and provide a path to store the script.

PS C:\>save-script -Name Enable-AzureRMDiagnostics -Path "C:\users\\desktop\temp"

3. Go to the folder where you saved the script, and execute Enable-AzureRMDiagnostics.ps1.

PS C:\users\\Desktop\temp>.\Enable-AzureRMDiagnostics.ps1

Notes:

• If you want to enable metrics logging for a specific Resource Group instead of the entire subscription, you can use these advanced steps.
• If you have not already authenticated to Azure, this script will prompt you for your credentials.
• For a synopsis with examples for the script, just type get-help -Examples.

4. Select the Azure Subscription that has the Azure resources that you want to monitor.

5. Select the OMS Log Analytics Workspace that you want to have for this data set.

6. Select the Azure Resource Type that you would like to enable. For example, if you type 5, you enable the metrics data collection for SQL Azure Databases.

7. Type Y to enable metrics logging for all databases in that subscription.

The PowerShell script will run against each database and enable the metrics collection for those resources. After it’s finished, you will see a Complete message.

After completion, you will start to see metrics data in OMS Log Search as shown in the following screenshot. The data from the Azure PaaS resource can be found under Type=AzureMetrics. The new Azure SQL and Web App solutions will use this data.

Advanced scenarios

Enable metrics for a specific Resource Group

The following steps enable you to specify the resource group for which you would like to enable metrics logging.

Run the following command:

PS C:\>.\Enable-AzureRMDiagnostics.ps1-ResourceGroup "anugup"

The rest of the prompt will remain the same as previously shown in step 5.

You can find the resource group name in the Azure portal as shown in the following screenshot.

Update a resource to send data to another workspace

If you have a resource type that is already sending metrics to a workspace, but you want to change it to another workspace, you can use the -Update switch.

Run the following command:

PS C:\>.\Enable-AzureRMDiagnostics.ps1-Update

-or-

PS C:\>.\Enable-AzureRMDiagnostics.ps1-Update -ResourceGroupName “Leyla”

The rest of the prompt will remain the same as previously shown in step 5.

Examples for the PowerShell script

For a synopsis with examples for the script, you can also just type GET-HELP .\Enable-AzureRMDiagnostics.ps1 -Examples.

The complete script is available in the PowerShell Gallery.

Jim Britt
Senior Program Manager

Today Season 3 starts to wrap up with the first in a pair of outtakes episodes its all the best stuff we couldnt fit into the other shows, but its just too good to leave on the cutting room floor.

In this episode, I talk withJim Fowler, (CIO,General Electric), Paul Fipps (CIO & EVP,Under Armour), and Mark Russinovich (CTO, Microsoft Azure). We cover why its such a big deal that GE finally chose a CIO with a technology background, the initial terror oftaking your hands off the wheel of a self-driving car, and why enterprise productivity has (statistically) flat-lined, and what IT can do about that. Mark also spends a couple minutes talking really candidly about why Azure is seeing so much success in a very competitive public cloud market.

.

To learn more about how top CIOs stay secure + productive,check out this new report.

In the next episode, close out Season 3 with one last set of outtakes its some pretty great stuff.

You can subscribe to these videoshere, or watch past episodes here: www aka.ms/LunchBreak.

Today’s workforce is spread across more locations than ever before: 37 percent of workers telecommuted to some degree in 2015. Companies occupy multiple locations, and business partnerships span the globe. In addition to physical separation, teams in the same company are separated by projects and departments. These barriers unfortunately lead to communication silos, furthering separation and limiting teamwork and collaboration.

Silos can have a significant (and detrimental) effect on your business. They create barriers between teams, often disrupting communications across your entire organization. But that’s not all. Let’s look at the wider impact silos can have across your company.

• Limits communication and impedesculture—Siloed teams eventually inhibit your company’s culture. Employees crave communication, collaboration and a thriving work environment. They want to feel comfortable being themselves and feel like they’re part of a team. In fact, 47 percent of workers find it motivating when colleagues discuss workplace success.
• Creates repeat work—Often, you frustratingly discover that someone else at your company (most likely on another team or in a different department) is doing the same work or looking for the same information. When teams are in the dark on other teams’ projects, it can severely impact your business’s productivity
• Blocks information from those who need it—The average interaction worker spends nearly 20 percent of their workweek looking for internal information or tracking down colleagues who can help with specific tasks.

Here’s how you can harness communication tools to break down these silos and enable employees to share ideas like never before.

Streamline file management and storage

Sharing files should be seamless between teams, tools, devices and departments. A platform or suite of well-integrated tools will allow clear connections between people, content and business apps across the organization. As a part of such a suite, team sites can help employees collaborate on documents, store information and manage projects. This will allow for cross-team, real-time document sharing and editing to support collaboration on several levels, while providing one easy place to find it all.

To improve productivity, team sites should be accessible from virtually anywhere, making information securely available and enabling collaboration across distances and from mobile devices.

5 faces of today’s employees

There’s more you can do to bring diverse teams closer. If you have employees who work from remote locations, use different devices or simply have different collaboration preferences—you still need to figure out the right tools. Ready to learn how to support them all?

Get the free eBook

Broaden the use of team- or project-based communication tools

Teams that don’t interact on a regular basis are often unaware of what the other is working on. Enterprise social networks built for cross-organization communication can help break down these silos and walls. Employees can create cross-company and cross-department groups on topics of shared interest, successes and learnings to solve problems or crowdsource ideas.

Organizations also often face management and executive silos, created by organizational hierarchy, internal communication practices and company culture. These hierarchical barriers can be broken down by creating groups within team-based communication tools to empower employees to engage in two-way conversations with executives.

Improve interpersonal relationships

Easily accessible communication tools, such as IM, voice calls and video conferencing, give employees multiple ways to reach out to their peers. If they are allowed to choose their method of communication—and can connect with peers from nearly anywhere—employees are more likely to reach out and build stronger interpersonal relationships.

The right collaboration tools can help reduce barriers to communication, provide better access to resources and help teams be more productive. To learn more on how to help a diverse team work together, get our free eBook, “5 Faces of Today’s Employees.”

The post Breaking down silos—tools for better communication and collaboration appeared first on Office Blogs.

Today, we are pleased to announce the availability of several advanced capabilities in Office 365 that are new for the U.S. Government Community. The U.S. Government Community Cloud complies with federal requirements for cloud services, including FedRAMP, as well as with requirements for criminal justice and federal tax information systems.

The new capabilities—including Skype for Business cloud voice, video and meetings services; advanced security workloads; and data analytics tools—together with the core productivity and collaboration capabilities of Office 365, will enable U.S. Government workers to collaborate in new ways and drive digital transformation across all areas of agency operations, all while meeting stringent compliance standards.

Communication-powered productivity

Productivity today is centered on conversations, whether it’s a quick instant message, an impromptu phone call or a scheduled meeting with voice, video and content sharing. But government employees’ ability to connect, especially between agencies, has always been limited. Now Skype for Business cloud-based voice, video and meetings in Office 365 enable U.S. Government Community Cloud customers to replace their legacy meeting and phone systems with modern voice and meetings that are integrated with the work civil servants are already doing in Office, providing greater continuity as they collaborate and communicate throughout their day. The new Skype for Business services include:

• PSTN Conferencing—Provides the ability to dial in to a meeting from a traditional phone, as well as the option to join a meeting with a single click on your PC or mobile device.
• Cloud PBX—Enables companies to eliminate separate PBX systems and transition to the cloud with Office 365 as the central location to manage users for communication.
• PSTN Calling—Gives Office 365 customers the ability to subscribe to Microsoft-managed calling plans and phone numbers.

With Skype for Business cloud voice and meetings in Office 365, U.S. Government Community Cloud customers can now simplify their infrastructure, lower costs and empower employees like never before.

Advanced security to protect your organization

We are also now offering U.S. Government Community Cloud customers significant security capabilities aimed at dramatically improving their ability to protect their organization’s information. The new capabilities include:

• Customer Lockbox—Gives customers new approval rights, transparency and control over their data in the cloud.
• Advanced eDiscovery—Integrates Equivio machine learning, predictive coding and text analytics capabilities, to reduce the costs and challenges that come along with sorting through large quantities of data for eDiscovery purposes.
• Advanced Threat Protection—Protects against unknown malware and viruses by applying behavioral analysis.

Data-fueled insights

Finally, we are now offering advanced data analytics capabilities in Office 365 to U.S. Government Community Cloud customers that will enable the government to reduce costs and uncover data insights to provide better services to citizens.

• Power BI Pro (now available as preview in U.S. Government Community Cloud)—A business analytics service that enables information workers to visualize and analyze data with greater speed, efficiency and understanding through live data dashboards, interactive reports and compelling visualizations.
• Microsoft MyAnalytics—Empowers individuals through rich dashboards that provide insights on time and relationships, with the goal of helping individuals get time back and spend it more effectively.

U.S. Government Community Cloud customers can now use the most secure, most comprehensive productivity solution on the market, with the assurance that Office 365 will continue to evolve to meet their changing needs.

Connect with a Microsoft representative to find out how Office 365 enhanced workloads can support your digital transformation efforts or sign up for a free trial to experience the new capabilities yourself.

The post Advanced Office 365 capabilities now available to U.S. Government Community Cloud customers appeared first on Office Blogs.

Re-posted from the Microsoft Transform blog.

Ros Harvey has been a pioneer when it comes to using technology to improve the lives of millions of people. After having recently upended oyster farming in Australia with her work on the “Internet of Oysters”, she decided to expand her business, which is called The Yield, to help agricultural farmers feed the planet in a more sustainable way. Learn more about this plucky entrepreneur’s cutting-edge work, which involves sensors, IoT and analytics in the cloud, and – more importantly – the tenacity to find sustainable business models that work for communities.

Internet of Oysters

Tasmanian marine farmers produce about 36 million oysters a year. But one challenge they face is that regulators shut down harvesting during heavy rains, when contaminants may enter into oyster bays. Harvey’s solution used sensors connected to the Azure IoT Suite to analyze the water that oysters drink. By analyzing this information using machine learning and advanced analytics in the cloud, her team is able to make data-driven predictions that are shared with growers and regulators in real-time. The Yield’s technology reduces unnecessary harvesting closures by 30 percent, saving Tasmanian growers millions of dollars. Two government food authorities and over 300 oyster growers already rely on The Yield in its first year of operation.

How to Feed the World (without Wrecking the Planet)

Not one to think small, Harvey has expanded her sights to tackle one of our biggest global challenges, namely how to feed the planet. To do so, we need to increase food production 70 percent by 2050. Meanwhile, agricultural productivity has been stagnant for decades and we are forced to cope more input constraints and climate change. Farmers struggle with the uncertainty of weather and its impact on the business of growing food. This is especially true for irrigated perennials such as cherries, apples, avocados, mangoes, nuts and grapes, which are high-margin and need intensive support. Micro climate conditions drastically affect decisions on when to plant, harvest, irrigate, feed and protect these crops but the world’s weather forecasting systems are done on a “very coarse, 25-by-25-kilometer grid,” Harvey says.

So The Yield’s newest IoT effort has to do with dealing with the weather on each farm, each field, each row and even each plant, to help growers optimize decisions that save money and make farming more sustainable. The system predicts the weather and converts it into crop-specific knowledge. The idea is use this data and these models and predictions to develop apps that take the guesswork out of farming, starting with when and how much to water crops. Learn more about her latest effort in the video clip below:

 As Harvey says, “Technologists are in love with the technology, but with my background in international development, my starting point is always the business problem that needs to be solved. International development is littered with examples of donors throwing money at something, and when the money dries up, it all collapses. So you need to find a sustainable business model and work with the community you’re serving to make sure you’re meeting a real need and a real purpose. And that underpins how I think about technology.”

Read more about Harvey’s remarkable story at the original blog post here.

CIML Blog Team

Software Company, IncaX, uses Bing Maps as part of its CopTrax solution, which streams live video from a police officer’s vehicle or body camera and stores it in the cloud. To better pinpoint officers’ locations and reconstruct details of police activity, IncaX incorporated mapping into its solution. Now, IncaX law enforcement customers use CopTrax to make more informed day-to-day decisions, reduce IT administration, and respond more quickly to critical incidents.

"We had a lot of considerations, and Bing Maps ticked all the boxes for us. With it, we get a completely flexible mapping solution," says Phil Bishop, IncaX Owner and Chief Technology Officer.

Read the full story at https://customers.microsoft.com/en-us/story/incax-technology-bing-maps.

For more information about the Bing Maps for Enterprise solutions, go to https://www.microsoft.com/maps.

• Maps APIs
• Mobile Asset Management
• Licensing Options

- The Bing Maps Team