You are here

Feed aggregator

Ninja Troubleshooting- User Interface freezing during SQL Server database restore.

MSDN Blogs - Fri, 07/31/2015 - 09:43

Hello world :)

To sum up, i was working with one of my customers regarding the UI (User Interface) freezing while restoring (Symantec NetBackup) a database into SQL Server 2012, leading to a unresponsive behavior from the server.

Scenario (VMware guest – WS2012R2):

Started with gathering performance counters to jump into the analysis and even though there wasn’t clear CPU pressure (all green above :) ), found spikes that matched the UI Freeze on a specific CPU (11) as observed bellow:

Basically the Processor % Privileged Time indicates the percentage of time a thread runs in privileged mode also known as kernel mode. When your application calls operating system functions (for example to perform file or network I/O or to allocate memory), these operating system functions are executed in privileged mode. I recommend using the Performance Analysis of Logs (PAL) Tool to assist on performance counter analysis.

The PFE (Premier Field Engineering) has the culture to do Root Cause Analysis…So... Let’s dig a little deeper :) , using WPR (Windows Performance Recorder) that is included on Windows Assessment and Deployment Kit and do a trace while the issue is being reproduced…

Analyze the trace with Windows Performance Analyzer:

First trace, without any change on the Operating System:
Since we want to focus on % Privilege Time, we want to analyze the DPC Duration by Module and Processor:


Hummm… Interesting… The NDIS.SYS is taking most of compute time, more precisely the function ndisInterruptDpc , that leaded to RSS - Receive Side Scaling (improves the system performance related to handling of network data on multiprocessor systems)

Since this is a virtualized multiprocessor system, it was to time check if RSS was enabled on the NIC used for Backup (, it wasn’t enabled.

At this point, it was clear that this Vcore (CPU 11) wasn’t able to cope with all the Network Related Workload. 

Next step, enable RSS on NIC used for backup, reproduce the workload, trace it and analyze again in WPA, the result can be clearly observed in the data bellow:


Conclusion, when RSS is enabled on the Backup NIC, the Network Stack workload is scaled out by 4 CPUs thus reducing the “spike workload” from +/-5 seconds to +/- 1 second spread across 4 CPUS and no longer having UI Freezes.

Interesting that VMware also has an article related with this situation:

“Receive Side Scaling (RSS) RSS is a mechanism which allows the network driver to spread incoming TCP traffic across multiple CPUs, resulting in increased multi-core efficiency and processor cache utilization. If the driver or the operating system is not capable of using RSS, or if RSS is disabled, all incoming network traffic is handled by only one CPU. In this situation, a single CPU can be the bottleneck for the network while other CPUs might remain idle.“

Tools used:
Performance Counters
Performance Analysis of Logs
Windows Performance Recorder
Windows Performance Analyzer

Paulo Condeça

Spotlight on Critical Situation Support

MSDN Blogs - Fri, 07/31/2015 - 09:42

If you write software or manage infrastructure, unplanned downtime will occur. Even with the very best people and process that money can buy, the unexpected still happens.

At Premier, we support Microsoft’s most innovative and talented customers but nobody is immune—not even Microsoft. We all deal with system outages and downtime of critical business systems. The causes are many: bad software, bad hardware, failed networks, people, process, hackers, market pressure—the list goes on and on. While it is true you can mitigate many risks and greatly reduce the likelihood of a system outage, a disaster plan is not something you want to create under crisis. Always be prepared and know for what comes next.

As a support organization, our mission is heavily focused on preventing outages. Monthly planning with our customers identifies risks, technical gaps, and support trends. As a result, we regularly propose services or training to bring in advisory resources and head off problems before they occur. In fact, we rarely emphasize the reactive side of our business, but it’s a big part of our commitment to customers. Problem Resolution Support is part of every Premier Support contract and provides a predictable, consistent way to engage Microsoft if problems arise or systems go down.

Problem Resolution Services

Premier customers can engage Microsoft for help via a phone call or over the web using Premier Online. As a customer, you set the incident priority which determines how important an issue is to your business. Incident severity also helps Microsoft prioritize the effort. A standard response for a Premier case is within 4 hours, but the response times get smaller as priority increases. Critical issues are handled with highest priority, often a live/immediate handoff, or within 1 hour.

Critical Situations

Top priority incidents are referred to as Critical Situations or “CritSits” and they take on a special life of their own. They often represent a system outage but can represent just about any loss of business scenario (unable to ship software, significant performance degradation, system instability, etc.). When a critical case is opened under Premier, it is a mutual, 24x7 commitment that nobody goes home until the problem is solved. Both Microsoft and customer are expected to keep staff engaged until service is restored. 

Tactical resources need to focus on troubleshooting, but management always needs to know what is going on. In addition the technical resource working with your team, your Technical Account Manager (TAM) or Application Development Manager (ADM) is required to take ownership of critical issues. They provide management support for things like status communication and dispatch decisions if onsite resources are needed to expedite a resolution. Critical situations are managed from start to finish with priority. After a CritSit is resolved, Premier can help with post-mortem assessments to understand WHY a problem happened and recommend services to avoid a repeat of the scenario. It’s all part of our commitment to keep our top customers focused on what they do best – running their business.

Confidence: In the Cloud and More

A Premier relationship drives the ongoing communication and support planning required to stay ahead of most crisis situations. If and when a business experiences an outage, the collective mindshare of Microsoft can be engaged through Premier to quickly restore service. Many customers are making game-changing transitions into the cloud. Premier can help minimize that risk through important support planning and critical response capabilities. Major Incident Response Plans are part of helping our cloud customers mitigate complex solutions in Azure. Premier offerings like Azure Rapid Response can reduce response times down to minutes and provide dedicated teams to support your most important business apps. Microsoft offers comprehensive support options, for on premises, cloud, and hybrid solutions. If it’s a supported Microsoft product or technology, it’s covered under Premier Support.


If your business does not have a relationship with Premier but depends on infrastructure or applications using Microsoft technology, think about what downtime of this system would cost for 1 day? For many companies, the cost of a major business outage for 1 day (even hours) and the repercussions of that crisis can easily exceed the cost of Premier Support. What if you don’t have a crisis? Use Premier to invest in your team through training, operational and process improvements, development guidance, performance testing, and more. Customers often turn to Premier under crisis, but they stay with us to avoid it.

Premier Support for Developers provides strategic technology guidance, critical support coverage, and a range of essential services to help teams optimize development lifecycles and improve software quality.  Contact your Application Development Manager (ADM) or email us to learn more about what we can do for you.

Roaming Extension Manager: Control and Consistency down to the last Extension

MSDN Blogs - Fri, 07/31/2015 - 09:30

On July 28th, we released Roaming Extension Manager, an extension that will help you better manage your Visual Studio extensions across multiple machines. Hold the applause! For those of you who are unfamiliar, the Roaming Extension Manager “roams” your list of extensions, so now when you are setting up a new development environment or simply trying to push a few extensions from one machine to another, you don’t have to remember the names of the extensions or take screen shots. Instead, we provide you with a list displaying all of your extensions installed across all of your environments and allow you to download directly from that list.

How does this actually work? We create a cloud based Roaming List that tracks the extensions you have installed across all of your Visual Studio development environments looking just like this:

Extensions in your Roaming List can be in 3 different statuses. At the top of the list shown in the above screenshot you see, Roamed Extensions . These are extensions that are set to be roamed, but have not yet been downloaded onto this machine. In other words, these extensions are being roamed from another machine, and are available for download on this machine. In the middle, , are extensions that have been installed on this machine and are roaming to other machines. If another machine is missing this extension it will appear in that machine's list as a Roamed extension . The last icon you see in the list above, , indicates extensions that are installed on this machine, but are not set as roamed. These will not appear on any other machine as they are not being roamed.

Autonomy without loss of control

While developing this tool we focused on creating an extension that provides you with not only autonomy, but also the ability to fully self-manage your extensions as needed.

From our earlier conversations with you, we learned that it’s best to automatically set all downloaded extensions to roam by default. That is, any extension that you download while signed in will automatically be added to your Roaming List as Roamed-Installed (). If you download an extension when not signed into the IDE, on your next sign in we will add these extensions to your Roaming List.

At this point you can just sit back and let us handle the rest. When you want to add an already installed extension onto another machine, just go to the Roaming Extension Manager to download your extension.

Now, every so often you might have an extension you don't want to be roamed to other machines. Controlling what is and isn't being roamed is easy to do, via Stop Roaming/Start Roaming buttons. An extension changes from to when Stop Roaming is applied; conversely an extension will change from to when Start Roaming is applied. Don’t worry if you accidentally stop roaming an extension by mistake, all installed extensions will be viewable in your Roaming List for you to easily start roaming at any time.

Not on the Gallery, Not a Problem

We have you covered in the case when you have created your own extension or are using an extension not currently available on the gallery. Any such extensions will also be roamed for you, with the caveat that the Roaming Extension Manager cannot download them for you. What you will see instead is a name and description of the extension, so you can easily search for it and install it.

Moving Forward

We plan on continuing to update and iterate on this extension. In fact we are already getting ready to release some additional functionality in the coming week, so stay tuned! Additionally, if you have any bugs, possible improvements, or additional functionality you would like to see in the extension let us know by adding suggestions on UserVoice, visit us on Stack Overflow with tag “visual-studio-extensions”, or leave a comment below.




Peaky Yuter, Program Manager Intern, Visual Studio IDE Extensibility Team


Peaky is a Program Manager Intern on the Visual Studio IDE Extensibility Team. He is currently a rising senior at Cornell University majoring in Computer Science.

PowerShell Direct & Waiting for an IP Address

MSDN Blogs - Fri, 07/31/2015 - 09:03

Here is an interesting problem.  With PowerShell Direct it is possible to get connected to a PowerShell session inside a virtual machine before the virtual machine has received an IP address.  While this is cool - it can result in annoying script failures.  To handle this - if I am using PowerShell Direct and I need to get something from the network I first run this:

# Wait for DHCP
while ((Get-NetIPAddress | ? AddressFamily -eq IPv4 | ? IPAddress -ne -ne "Dhcp") {sleep -Milliseconds 10}

The nice thing about this snippet is that it is not looking for a specific subnet or IP address - it is just waiting to receive a DHCP lease from somewhere.  This means that it works no matter what network I am connected to.


The Itanium processor, part 5: The GP register, calling functions, and function pointers

MSDN Blogs - Fri, 07/31/2015 - 07:00

We saw a brief mention of the gp register last time, where we saw it used when we calculated the address of a global variable.

The only addressing mode supported by the Itanium processor is register indirect (possibly with post-increment). There is no absolute addressing mode. If you want to access a global variable, you need to calculate its address, and the convention for this is that the gp register points to the module's global variables. If you want to access a global variable stored at offset n in the global data segment, you do it in two steps:

addl r30 = n, gp ;; // r30 -> global variable ld4 r30 = [r30] // load 4 bytes from the global variable

The name gp stands for global pointer since it is the pointer used to access global variables. (Note that since immediates are signed, the range of values of n is −2MB to +2MB.)

Those of you familiar with the PowerPC will recognize this model, since it is very similar to the Table of Contents model, except that Itanium uses a single table of contents for the entire module, as opposed to the PowerPC which gives each function its own table of contents.

The Itanium addl instruction is limited to a 22-bit immediate, which provides a reach of 4MB. This means that the above pattern is viable only for 4MB of global variables. Since some modules have more than 4MB of global data, the compiler separates global data into two categories, large and small. Small data objects are stored directly in the global data segment, but large data objects are not. Instead, the large data object is placed outside the global data segment, and all that is placed in the global data segment is a pointer to the large object. This means that accessing a large object actually takes three instructions.

addl r30 = n, gp ;; // r30 -> global variable forwarder ld8 r30 = [r30] ;; // r30 -> global variable ld4 r30 = [r30] // load 4 bytes from the global variable

We see that it is vitally important that the gp register be set properly. Otherwise, the code has no idea where its global variables are. The Itanium calling convention says that on entry to a function, the gp register must be set to that function's global pointer.

Okay, so if you're going to call a function, how do you know what global pointer it expects?

Since all functions in the same module share the same global variables, the answer is easy if you are calling a function within the same module: You don't need to do anything special with gp, since the caller's gp is the same as the callee's gp. You also don't need to perform an indirect call; you know where the target is and can use a direct OtherFunction.¹

On the other hand, if you are calling a function through a function pointer, then the target of the call might belong to another module. How are you supposed to know what the target function wants gp to be?

The answer is that on Itanium, a function pointer is not the address of the first instruction. Rather, it is a pointer to a structure containing two pointers. The first pointer in the structure points to the first instruction of the target function. The second pointer is the target function's gp. Therefore, calling a function through a function pointer looks like this:

// suppose the function pointer is in r30 ld8 r31 = [r30], 8 ;; // get the function address // then add 8 to r30 ld8 gp = [r30] // get the function's gp mov b6 = r31 // move to branch register rp = b6 ;; // call function in b6 or gp = r41, r0 // gp = r41 OR 0 = r41

First, we load the address of the first instruction into the r31 register, using a post-increment addressing mode so that r30 after the instruction points to the callee's gp.

Next, we load the gp register with the caller's gp. Simultaneously, we move r31 to b6 so that we can use it as the target of the (Branch registers cannot be the target of a ld8 instruction, which is why we needed to use r31 as a middle-man.)

Now that gp is set up properly, we can call the function through the branch register.

After the call returns, the gp register is now whatever value is left over by the function we called. We need to set gp to the current function's global pointer, which for the sake of example we'll assume had been saved in the r41 register.

There's yet another wrinkle: The naïve imported function. In the case of an imported function not declared with the dllimport attribute, the compiler doesn't know that the function is imported. It acts as if the function is part of the current module. On x86, this is simulated by making a stub function which jumps to the real (imported) function. On Itanium, the same thing is done, with a stub function that looks like this:

.ImportedFunction: addl r30 = n, gp ;; // r30 -> function descriptor ld8 r31 = [r30], 8;; // get the function address // then add 8 to r30 ld8 gp = [r30] // get the function's gp mov b6 = r31 // move to branch register br.cond.sptk.many b6 ;; // jump there

The stub function loads the gp register with the value expected by the imported function then jumps to the imported function. Unconditional computed jumps are encoded as conditional jumps where the qualifying predicate is p0, which is always true.

The possibility that any function is really a stub function for an imported function this creates a problem for the compiler: Since any function could be an imported function in disguise, the compiler must assume that any function is potentially imported and therefore may result in the gp register being trashed. Therefore, the compiler needs to restore the gp register after any function call.

Now, the above pessimistic assumption can be relaxed if the compiler has other information available to it. For example, if the function being called is in the same translation unit, then the compiler can see by inspection that the target function is not a stub and therefore can elide the restoration of gp. Similarly, if link-time code generation is enabled, then the linker can see all the code in the module and see whether the target function is a stub or a real function.

Exercise: How does tail-call elimination affect this optimization?

Bonus reading: Programming for 64-bit Windows which spends nearly all its time talking about the gp register.

¹ The direct call instruction has a reach of 16MB, so if the function you want to call is too far away, the linker redirects the to a stub function which in turn jumps to the final destination. stub_for_OtherFunction ... stub_for_OtherFunction: ... jump to OtherFunction ...

You have a few options for jumping to the function.

  • If the stub is within 16MB of the target, it can use a br.cond direct jump:
stub_for_OtherFunction: br.cond.sptk.many OtherFunction
  • The stub can load the target address from the data segment and use an indirect jump:
stub_for_OtherFunction: addl r3 = n, gp ;; // look up the function address ld8 r3 = [r3] ;; // fetch it mov b6 = r3 ;; // prepare to jump there br.cond.sptk.many b6 ;; // and off we go
  • The stub can load the target address offset from data stored in the code segment, then apply the offset to the current instruction pointer to determine the target:
stub_for_OtherFunction: mov r3 = iip ;; // get current location addl r3 = n, r3 ;; // find the offset ld8 r2 = [r3] ;; // load the offset addl r2 = r2, r3 ;; // apply to current location mov b6 = r2 ;; // prepare to jump there br.cond.sptk.many b6 ;; // and off we go

This last case is tricky because the Itanium conventions forbid relocations in the code segment; all code is position-independent. Therefore, the data in the code segment must not be relocatable. We work around this by storing an offset rather than the absolute address and applying the offset at runtime.

Dev/Test in Azure and Deploy to Production On-premises

MSDN Blogs - Fri, 07/31/2015 - 04:46

Easily provision the required resources in Azure using the Azure Resource Manager templates, and deploy Web applications and SQL Server Databases to the Azure VMs using PowerShell scripts or PowerShell-DSC modules, and run tests that are automatically distributed across VMs using the Visual Studio Test Agent. Once the application functionality is verified, deploy the application to on-premises machines using the same PowerShell that was used to deploy the app to the Azure VMs.

The blog explains how to setup a Build definition in the Build hub in VSO and configure tasks in the definition to dev/test in Azure and deploy to production on-premises.The Azure tasks described in the blog are in private preview on VSO, and if you would like to join the private preview then please send an email with your VSO's account name to devops_tools at Microsoft dot com.

Azure Subscription

To deploy to Azure, an Azure subscription has to be linked to VSO using the Services tab in the Account Administration section.

Add the Azure subscription to use in the Build tasks by opening the Account Administration screen (gear icon on the top-right of the screen) and then click on the Services tab. Select Azure from the Add New Service Connection dropdown.

 Figure: Opening the Account Administration Screen.


Figure: Selecting an Azure connection from the Add New Service Connection.


Fill in the required details from the Azure account, and select credentials for authentication as certificates are not supported by Azure Resource Manager. The credentials have to be a work account because Microsoft accounts like or are not supported.   

Figure: Adding the details of the Azure subscription. The data displayed in the dialog is not actual data and is for informational purpose only.

Build Agent

A build agent has to be deployed on a machine to build the code and to run the tasks. The build agent is xcopy deployable, and does not need any installation. The agent can be deployed on machines behind the Firewall and also on Azure VMs. The build agent uses the HTTPS protocol to communicate with VSO and can work across proxies and firewalls. VSO also provides Hosted build agents that can be used to build code and to deploy the application. The Hosted build agents are made available on-demand and run on

Deploy the Windows build agent as per the instructions in the Build docs. The following are some of the issues that needs to be taken care of:

  1. Either use the default queue or create a new queue.
  2. Provide the rights to the account, under which the Build agent running, in VSO’s Control Panel named Agent Pools. The account that the build agent is running as should be added to the Agent Pool Service Accounts group.
  3. Download and configure the agent by following the instructions.    
  4. The tasks described in the blog need Azure PowerShell to be installed on the build agent, and that can be done easily using the Web Platform Installer.  
Dev/Test Applications on Azure

Click on the Build Hub and then add the tasks as described below to deploy and test applications on Azure resources.

MSBuild/Visual Studio Build Task

The MSBuild/Visual Studio Build task is used to build the code.

Figure: MSBuild task in the Build Definition to build the solution.

Use the MSBuild or the Visual Studio Build task to build the app and test code. The Build documentation provides detailed instructions on how to build code. From this blog’s perspective, use the Source Code browser next to the parameter named Solution and select the solution file. Rest all parameters can be kept to their default values.

Azure Resource Group Deployment Task

The Azure Resource Group Deployment task is used to deploy Resource Groups in Azure using the Azure Resource Manager templates.

Figure: Azure Resource Group Deployment task in the Build Definition to deploy a Resource Group on Azure.

The different parameters of the task are as described below:

Azure Subscription: Select the Azure Subscription where the Resource Group will be deployed. This is a dropdown of the subscriptions that have been added in the Services tab.

Resource Group, Location: The name of the Resource Group and its location. If this is an existing Resource Group then the task will update the Resource Group with the Resources specified in the Azure template. If no Resource Group with the name exists in the Subscription then a new one will be created.

Template and its Parameters: The templates and the templates parameters file are the Azure templates available at GitHub or in the Azure gallery. To get started immediately use this template that is available on GitHub. These files can be either checked in the Version Control of they can be part of the build itself. If the files are part of the Build, use the pre-defined system variables provided by the Build to specify their location. The variables to use are $(Build.Repository.LocalPath), if the templates are checked-in but are
not built, or $(Agent.BuildDirectory), if the templates are built as part of the solution. Be sure to specify the full path like $(Build.Repository.LocalPath)\Azure Templates\AzureRGDeploy.json. Wildcards like **\*.json or **\*.param.json are also supported and there needs to be only file that matches the search pattern at the location. If more than one file matches the search pattern then the task will error out.

Override Template Parameters: The Override template parameters is used to override the parameters, like –storageAccountName azurerg –adminUsername $(vmusername) –azureKeyVaultName $(fabrikamFibre). 

Advanced Deployment Options: This section can be confusing if one does not understand the rationale behind the options. The following information will help in understanding the parameters and the proper use of them:

  • Refresh SAS Token: Azure provides in-built ability to deploy applications using Resource Extensions (RE) for PowerShell-DSC or Custom Script Extension for any of the scripting languages for Linux (Python, Shell scripts). The scripts and application files need to be available on an Azure storage account because the RE downloads them to the VMs and then runs them. The storage accounts are normally secured, and a Shared Access Signature (SAS) token is needed to access them. More information about
    the Azure SAS token is here. This SAS token has an expiration date and the storage account cannot be accessed after the SAS token expires. This will break the Continuous Integration (Build) pipeline because the task will fail as it cannot access the storage account. The Refresh SAS token parameter refreshes the SAS token in the Azure template prior to sending it to Azure each time the Build is run. To do that it needs the name of the parameters for Azure Blob and SAS token as they have been specified in the Azure template parameters file. Multiple of these can be provided in Azure Blob Parameter and SAS Token Parameter by using the semi-colon delimiter like azurestore1; azurestore2; azurestore3. For example, the template parameters file has the following key-value pairs for Azure Storage account and SAS token. Then fill in azureStorage in the Azure Blob Parameter in the Azure Resource Deployment task and sasToken in the SAS Token Parameter.Note that Refresh SAS token is optional and only needed if deployment is being done to the Azure VMs using the Azure Resource Extension. As demonstrated in this blog, if the PowerShell on Target Machines task is being used to deploy the app then this Refresh SAS token is not needed.

"azureStorage": {
"value": "fabrikamfibre"
"sasToken": {
"value": " ?sv=2014-02-14&sr=c&sig=Dj1QOJups1%2Bf%2Beq989j%2FomowbmNS8Q2Qmf5eJEU9FGg%3D&st=2015-03-26T18%3A30%3A00Z&se=2015-04-03T18%3A30%3A00Z&sp=r"

  • Virtual Machine Credentials: These are the Admin credentials for the Azure VMs that have been specified in the Azure template. The VM credentials are stored securely in the Deployment service, so that any subsequent tasks that need to access the VMs will not have to take this as an input. In this walkthrough, the tasks that need the credentials are Azure File Copy, PowerShell on Remote Machines, and Visual Studio Test Agent Deployment.  
  • Test Certificate: The test certificate parameter requires background knowledge that is explained below. This parameter will be explained post the sections below.

Setting-up WinRM HTTPS on Azure VMs: Tasks like Azure File Copy, PowerShell on Target Machines, Visual Studio Test Agent Deployment run on the Build Agent machine and copy files or deploy apps to Azure VMs using the WinRM HTTPS protocol. For
these tasks to work properly the WinRM HTTPS port (default port is 5986) needs to be opened and configured properly on the VMs. Opening the ports and configuring them with the certificates is done using the Azure templates. The sample template uploaded on GitHub shows how to enable the WinRM HTTPS port on Azure VMs and map them to a Public IP using the Azure resource provider’s wiz. Network Interfaces, Load Balancers and Virtual Machines. In addition, it also shows how to specify the Azure Key Vault and its secret, to download and install the certificate on the VM.

Azure Key Vault and Test Certificates: Azure Key Vault provides a secure way of storing certificates in Azure that can be easily downloaded and installed on the Azure VMs to enable WinRM HTTPS communication protocol. To create test certificates and to upload the certificates to Azure Key Vault follow the steps given below. Note that the Azure Key Vault can be in its own resource group and does not need to be in the resource group that is being dynamically created using the Azure Resource Group Deployment task. This way, once a certificate has been uploaded to the Azure Key Vault it can be reused across different Azure resource group deployments.

  • Run the following commands from the developer command prompt to create the test certificate. Replace the Common Name (CN) with the Resource Group name and the password with the real password.
makecert -sv armtest.pvk -n "cn=*" armtest.cer -b 06/06/2015 -e 06/06/2016 -r
pvk2pfx -pvk armtest.pvk -spc armtest.cer -pfx armtest.pfx -po password
  • For uploading the certificate to the Azure Key Vault follow the steps given below:
    • Download the KeyVaultUrl.ps1available with this blog to the local disk.
    • Open Windows Azure PowerShell
    • Change directory to where the KeyVaultUrl.ps1 file was copied to.
    • Run the following commands:
Select-AzureSubscription -SubscriptionName <name>
Switch-AzureMode AzureResourceManager
Import-Module .\KeyVaultUrl.ps1 –Force
  • To generate the secret Id run the command given below:
$a = Generate-KeyVaultUrl -resourceGroupName <resourceGroupName> -keyVaultName <KeyVaultName> -secretName <secretName> -location <location> -certificatePath <certPath> -password <password>
  • Example:
$a = Generate-KeyVaultUrl -resourceGroupName nikhilnew13 -keyVaultName nikhilkeyvalut13 -secretName test -location "West US" -certificatePath "D:\cert\ArmTest.pfx" -password password

Test Certificate: The Build Agent uses the WinRM_HTTPS communication protocol to deploy apps to the Azure VMs. For secure communication, certificates are used and they need to be installed on the VMs. For developing and testing apps, usually test certificates are used, and by checking-off the Test Certificate parameter, the trusted certificate authority (CA) validation is skipped. Note that the Common Name (CN) of the certificate has to be same as that of the Fully Qualified Domain Name (FQDN) of the VM. If
the CN and FQDN different then the task will error out.    

Azure File Copy

The task is used to copy application files and other artifacts that are required to install the application on Azure VMs like PowerShell scripts, PowerShell-DSC modules etc.

Figure: Azure File Copy for copying files to Azure blobs or Azure VMs.

The task provides the ability to copy files to an Azure blob or directly to Azure VMs. Even when the target is Azure VMs, Azure blobs are used as an intermediary and the files are copied to it first and then downloaded to the VMs. The tasks uses AzCopy,
the command-line utility built for fast copying of data from and into Azure storage accounts. The different parameters for copying files to Azure VMs are as described below:

Azure Subscription: The name of Azure subscription, where the Azure storage account is located. The storage account is accessed using the stored credentials of the Azure account in the Services tab.

Source: The source of the files. As described above using pre-defined system variables like $(Build.Repository.LocalPath) make it easy to specify the location of the build on the Build Automation Agent machine. The variables resolve to the working folder on the agent machine, when the task is run on it. Wild cards like **\*.zip are supported and should resolve to a single file or a folder.

Storage Account: The name of an existing storage account in the Azure Subscription specified earlier.

Destination: The target for copying the files and is either an Azure blob or VMs. The section below details the parameters that need to be filled-out if the target is Azure VMs. Note that for copying the files to VMs, they are first copied to an automatically generated container in the Azure storage account, and then from there to the VMs. The container is deleted after the files are copied successfully to the VMs.

  • Resource Group: Name of the resource group that contains the Azure VMs.
  • Select Machines By: The parameter is used to copy the files to a subset of VMs and the subset can be specified by the names of the machines or the tags on them.  
  • Copy to Machines: If copying to a subset of machines provide a comma separated list of the VMs here, else if using tags then provide the tags in the format Role:Web; OS:win7. The default is to copy to all the VMs in the Resource Group.
  • Destination Folder: The folder in the Azure VMs where the files will be copied to. Environment variables are also supported like $env:windir, $env:systemroot etc. An example of the destination folder is $env:windir\FabrikamFibre\Web.
  • Clean Target: Checking this option will clean the destination folder prior to copying the files to it.
  • Copy Files in Parallel: Checking this option will copy files to all the VMs in the Resource Group in-parallel, hence speeding up the process of copying.

Destination: If the target is Azure blob then the following parameters need to be filled out.

  • Container Name: The name of the container where the files will be copied to. If the container does not exist then a new one will be created with the name provided in this parameter.
  • Blob Prefix: A prefix for the Blobs that can be used to filter the blobs like appending the Build number to the blobs, so that all the blobs with the same build number can be downloaded from the Container.
PowerShell on Target Machines

The task is used run PowerShell on the target machines. The task can run both PowerShell scripts and PowerShell-DSC scripts. For PowerShell scripts, PowerShell 2.0 is needed on the machines and for PowerShell-DSC scripts Windows Management Framework 4.0 needs to be installed on the machines. WMF 4.0 ships in-the-box in Windows 8.1 and Windows Server 20012 R2.

Figure: PowerShell on Target Machines task runs on the machines to install applications

The different parameters of the task are explained below:

  • Machine Group: The name of the Azure Resource Group.
  • Select Machines By: The parameter is used to specify the subset of VMs, where the PowerShell will be run and the subset can be specified by the names of the machines or the tags on them.  
  • Deploy to Machines: If deploying to a subset of machines provide a comma separated list of the VMs here, else if using tags then provide the tags in the format Role:Web; OS:win7. The default is to deploy to all the VMs in the Resource Group.
  • PowerShell Script: The location of the PowerShell script on the target machine like c:\FabrikamFibre\Web. Environment variables can be also used like %systemdrive%\Web or %temp%\ FabrikamFibre\Web
  • Script Arguments: The arguments needed by the script, if any provided in the following format -applicationPath $(applicationPath) -username $(vmusername) -password $(vmpassword).
  • Initialization Script: The location of the data script that is used by PowerShell-DSC and the location has to be on the target machine. It is advisable to sue arguments in place of the initialization script. 
  • Advanced Options: The advanced options provide more fine-grained control on the deployment.
  • Run PowerShell in Parallel: Checking this option will execute the PowerShell in-parallel on all VMs in the Resource Group.
  • Session Variables: Used for setting-up the session variables for the PowerShell scripts and the input is a comma separated list like $varx=valuex, $vary=valuey. This is mostly used for backward compatibility with the earlier versions of Release Management product and it is advisable to use arguments in place of the session variables.     
Visual Studio Test Agent Deployment

The task is used to deploy the Visual Studio Test Agent on the machines. The task runs on the Build Agent machine and uses PowerShell to deploy the Test Agent to the machines.

Figure: Visual Studio Test Agent Deployment task runs on the machines to install and configure the test agent.

The different parameters of the task are explained below:

  • Machine Group: The name of the Azure Resource Group.
  • Select Machines By: The parameter is used to specify the subset of VMs, where the test agent will be installed, and the subset can be specified by the names of the machines or the tags on them.  
  • Deploy to Machines: If deploying to a subset of machines provide a comma separated list of the VMs here, else if using tags then provide the tags in the format Role:Web; OS:win7. The default is to deploy to all the VMs in the Resource Group.
  • Username: The credentials that the test agent will use to run on the machine.
  • Password: The password of the user.
  • Interactive Process: Checking this option will configure the test agent to run as an interactive process and this is needed for running the Coded UI tests.
  • Test Agent Location: The test agent is downloaded and installed on the machines from The default behavior can be overridden by manually downloading the test agent and then providing the test agent’s location as a UNC or local path.
  • Update Test Agent: Checking this option will update the test agent and its configuration.
  • Enable Data Collection Only: Checking this option will configure the test agent to only collect data, and no tests can be run using the test agent. Useful when data needs to be collected from the application-under-test. 
Visual Studio Test using Test Agent

The task is used to run tests on the machines where the test agent has been deployed.

Figure: Visual Studio Test using Test task runs tests on the machines where the test agent has been deployed.

The different parameters of the task are explained below:

  • Test Machine Group: The name of the Azure Resource Group where the tests will be run. The test agent should have been already deployed and configured on the VMs using the Visual Studio Test Agent Deployment task.
  • Test Drop Location: The folder on the VMs where the test binaries are located. Environment variables can be also used like %systemdrive%\Tests or %temp%\Tests etc.
  • Test Assembly: The test binaries for running the tests. Wild cards can be used like **\*FabrikamTests*.dll that will use all test assemblies with FabrikamTests in their name.
  • Test Filter Criteria: Used to specify the test filter criteria like ‘Owner=Tom&Priority=0’.
  • Platform: The platform against which the tests will be reported like any cpu or x86 or x64.
  • Configuration: The configuration against which the tests will be reported like any debug or release.
  • Run Settings File: The location of the run setting file on the Build Automation Agent machine. Predefined variables like $(Build.Repository.LocalPath) can be also used.
  • Override Test Run Parameters: Used to override parameters in the TestRunParameters section of the run setting file like WebAppURL=$(appURL);Port=8080. Here the $(appURL) is a variable that has been defined in the Variables tab of the
  • Test Configurations: Used to associate a test case filter against a test configuration ID. The syantax is <Filter1>:<ID1>; DefaultTestConfiguration:<ID3>, like FullyQualifiedName~Chrome:12.
  • Code Coverage Enabled: Checking this option will enable code coverage during the testing.
  • Application Under Test Machine Group: The name of resource group where the Application under Test is running. If the same resource group is being used for deploying applications and running tests then the name of Test Machine Group and
    Application Under Test Machine Group will be same.   
Machine Group Actions

The task is used to start/stop/restart/delete Azure Resource Groups.

Figure: Machine Group Actions task to start/stop/restart/delete Azure Resource Groups.

The different parameters of the task are explained below:

  • Azure Subscription: The Azure Subscription, where the resource group is located.
  • Machine Group: The name of the Azure resource group.
  • Action: The action to be performed on the resource group wiz. start, stop, restart, or delete. The block and unblock actions currently do not work with Azure resource groups and once that has been fixed, the updates will be posted to the blog.
  • Select Machines By: The parameter is used to specify the subset of VMs on which the action will be performed, and the subset can be specified by the names of the machines or the tags on them.  
  • Apply to Machines: If deploying to a subset of machines provide a comma separated list of the VMs here, else if using tags then provide the tags in the format Role:Web; OS:win7. The default is to deploy to all the VMs in the Resource Group.

UWP: New Controls (part 5 – Media)

MSDN Blogs - Fri, 07/31/2015 - 04:30

Of course, the existing Media controls are not new but I cannot overlook them due to number of new features there. I have developed lots of applications which work with video and I know about disadvantages of Media controls in Windows 8.x like:

  • Problem with adaptive streaming – in order to start working with adaptive streaming you needed to use external libraries like Player Framework and Smooth Streaming SDK because Windows 8.x SDK doesn’t support embedded features for adaptive streaming. Even if you use these libraries you will get support for Smooth Streaming only;
  • No support of existing formats for closed captions – Windows 8.x SDK doesn’t support closed captions at all. SMPTE-TT and TTML were introduced in Player Framework SDK only;
  • No way to change template for existing media player control – Windows 8.x supports SystemMediaTransportControls but there were not many ways to change something. So, you had to design your own player from scratch or use existing player from Player Framework with less ability to change anything there;

Let’s see how Microsoft fixed all these disadvantages in Universal Windows Platform.

Adaptive Streaming

HTTP Live Streaming (HLS), Dynamic Adaptive Streaming over HTTP (DASH) and Microsoft Smooth Streaming are the most popular technologies for adaptive streaming. New MediaElement control supports all of them.

If you want to test how it works it’s better to use Azure account (you can use trial) and create Media Service instance there. Media Service supports dynamic packaging, so you can upload your video there and encode it using one of profiles which are ready for adaptive streaming.

Pay special attention that you need to create at least one streaming unit. Once video is encoded, thanks to dynamic packaging, you can stream it using any format that I mentioned previously (HLS, Dash, Smooth).

Let’s test, how to work DASH. In order to do it you need just add MediaElement to XAML page:

<MediaElement Name="media" AreTransportControlsEnabled="True" />

In order to create adaptive media source you can use AdaptiveMediaSource class like this:

AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(new Uri("", UriKind.Absolute));
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
var astream = result.MediaSource;

My video works fine and thanks to MediaTransportControls I have great interface for my media player:


If you want to add closed captions it’s easy to do with new controls as well. Just use the following code to associate TTM file with existing adaptive stream:

AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(new Uri("", UriKind.Absolute));
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
var astream = result.MediaSource;
var ttmSource = TimedTextSource.CreateFromUri(new Uri("ms-appx:///assets/captions.ttm"));
var mediaSource=MediaSource.CreateFromAdaptiveMediaSource(astream);

var mediaElement = new MediaPlaybackItem(mediaSource);


You can see that we use TimedTextSource class to create source based on file with captions. In order to associate the captions with media source we used MediaSource class and MediaPlaybackItem class to prepare source for MediaElement.

Template for Media

Starting with Windows 10 the MediaTransportControls class has its own states and a template according to modern design. It allows to change anything there by modifying  the existing XAML template. So you should not create buttons from scratch, implement logic etc. There are three ways to get existing template for MediaTransportControl: visit MSDN, find generic.xaml file on your computer or use Blend.

Because I have written this post before release of Windows 10 SDK there was no information on MSDN but I hope that you can find it right after release.

Generic.xaml file you can find using the following path C:\Program Files (x86)\Windows Kits\10\DesignTime\CommonConfiguration\Neutral\UAP\10.0.10069.0\Generic. Just open generic.xaml and find template for MediaTransportControls there (don't edit generic.xaml - just copy the template). 

Finally, you can extract template using Blend tool. I would like recommend this way because it’s easy not just to create copy of template but to modify it as well. In order to extract template for MediaTransportControls you need to create a new project (or open existing) in Blend and add MediaTransportControls to a page. Using context menu select Edit Template -> Edit a Copy menu item.

Blend will propose to select location and name for new style. So, select it and click OK.


Right after it you can open XAML and modify new template there or use powerful editor in Blend to see and modify everything there:



Windows 10 est enfin arrivé ! Voici l’essentiel pour vous, les développeurs.

MSDN Blogs - Fri, 07/31/2015 - 04:06

Visual Studio 2015 a été lancé le 20 juillet et Windows 10, le Windows 10 SDK et les outils de développement de l’application Windows Visual Studio Universal Windows l’ont été il y a quelques jours, le 29 juillet.

Il est temps à présent de commencer à créer des applications Windows universelles qui pourront fonctionner sur les PC, smartphones, Xbox One, appareils Internet des choses sous Windows et même le très attendu Microsoft Hololens ! Les développeurs iOS et Android pourront également faire tourner leurs applications sur les appareils sous Windows 10 avec de légères modifications grâce aux « platform bridges ». Les logiciels Windows classiques (Win32, .NET and COM) peuvent également être convertis en un package APPX pouvant être distribué via le Windows Store, c’est le meilleur moyen pour que votre logiciel atteigne vos utilisateurs ! Enfin, les éditeurs de sites web peuvent publier leurs pages web telles quelles dans le Windows Store de Windows 10 que les utilisateurs trouveront. Avec l’aide d’un manifeste XML et de JavaScript, les sites web « installés » seront en mesure d’utiliser les fonctions avancées de Windows telles que Live Tiles, Cortana integration ou la possibilité d’envoyer de nouveaux rendez-vous à l’application calendrier, pour ne citer que celles ci.

Il n’y a plus d’obstacle entre vous et votre application Windows 10 maintenant ! Nous avons fait une liste des principales vidéos d’apprentissage pour vous mettre à jour sur les nouveautés destinées aux développeurs dans Windows 10.

Présentation du modèle d’applications Windows 10

Windows 10 étend largement les possibilités des développeurs pour créer des applications et des jeux en ajoutant de nombreux nouveaux modèles de programmation et en permettant au modèle d’application de prendre en charge un nombre plus important de scénarios de développeur. Andrew va y revenir en profondeur et vous donne les informations dont vous avez besoin pour commencer à créer vos applications Windows en utilisant les nouvelles fonctionnalités.

Design : modèles UX et Responsive Techniques pour applications Universal Windows

Découvrez les avantages clés et fonctions interactives de la création d’applications sur la plateforme universelle Windows. Avec moins de restrictions au niveau de la publication et une base de code partagée, vous disposez d’une plus grande flexibilité de conception avec de nouveaux éléments interactifs et visuels qui s’adaptent aux différents contextes d’une large palette d’appareils.

Extensibilité de Cortana dans les applications Universal Windows

Les responsables de l’équipe Cortana montreront aux développeurs comment exploiter Cortana sur Windows 10 pour rendre leurs propres applications Universal Windows plus facilement détectables et encourager un engagement plus profond des utilisateurs. Nous échangerons sur la manière dont l’extensibilité s’intègre dans la vision globale de Cortana et comment vos applications peuvent profiter des nouvelles fonctions de commande vocale. La présentation sera suivie d’une brève session de questions-réponses avec l’équipe.

Passage à la plateforme Windows universelle : portage d’une application de Windows 8.1 XAML ou Windows Phone Silverlight vers Windows 10

Vous avez une application Windows 8.1 ou Silverlight actuellement ? Vous désirez profiter de la possibilité de passer à une base de code unique et pouvoir ainsi distribuer votre application sur différents appareils Windows ? Venez découvrir les stratégies de portage de votre code actuel vers Universal Windows Platform (UWP) pour Windows 10. Ce qui fonctionne, ce qui pose problème et comment être le plus rapidement productif avec Windows 10.

Stratégies de développement d’applications multiplateformes avec Visual Studio 2015

Cette session aborde les décisions stratégiques que vous devez prendre en tant que développeur lorsque vous ciblez plusieurs plateformes pour votre application. Nous passerons en revue les outils et technologies à votre disposition dans Visual Studio 2015 pour le Web et les applications natives qui doivent fonctionner sur des appareils Windows, iOS et Android.

Convertir vos applications classiques sous Windows (Win32, .Net, COM) en une application Universal Windows pour une distribution via le Windows Store

Permettre aux applications Windows classiques (Win32, .NET, COM) de faire partie de l’écosystème du Store est un point essentiel dans Windows 10. Cette session abordera en détail les technologies qui vous permettront de convertir votre application en un package APPX pour qu’elle puisse être distribuée par le Store et de profiter de l’avantage de Universal Windows Platform.

Créer d’étonnantes applications Windows avec votre code Android

Cette session vous fera découvrir les nouveautés dans Windows 10 SDK pour vous aider à intégrer votre application Android au Windows store. Cette session abordera les thèmes suivants : 1. Apprendre comment adapter votre code actuel pour créer une application Universal Windows 2. Utiliser la page de compatibilité des applications Windows pour évaluer votre application Android actuelle 3. Adapter le workflow Android actuel pour déboguer votre application sur un Windows Phone 4. Utiliser les services Microsoft dans votre application 5. Améliorer vos outils actuels qui faciliteront le développement d’applications pour Windows.

Si vous cherchez une formation exhaustive avec plus de 20 heures de cours, couvrant tous les aspects de Windows 10 pour développeurs, la formation de l’académie virtuelle de Microsoft est exactement ce dont vous avez besoin. Vous pouvez visionner les 23 modules depuis chez vous et dans l’ordre que vous voulez.

Guide du développeur pour Windows 10

Vous désirez en savoir beaucoup plus sur Universal Windows Platform (UWP) ? Les experts Jerry Nixon et Andy Wigley vous montrent comment les possibilités de Windows et l’intégration sociale peuvent vous aider à créer des expériences incroyables sur des appareils sous Windows 10, y compris les téléphones, tablettes, PC et même (bientôt) Xbox ! Jerry et Andy proposent une démo sur les avantages de 10, explorent les nouvelles fonctionnalités et donnent des conseils pratiques. Chaque module dure environ 30 minutes, vous pouvez donc choisir les thèmes qui vous intéressent le plus.

Remarque : Pour rafraîchir vos connaissances de base sur les langues de développement, consultez Programmer en C# ou découvrez les modules XAML dans Créer des applications Universal Windows avec C# et XAML.

Pour en découvrir davantage sur les nouvelles fonctionnalités dans Visual Studio 2015, veuillez consulter le site Visual Studio, regarder la série vidéo Visual Studio sur Channel 9 ou suivre l’enregistrement du lancement de Visual Studio 2015.

Windows 10 ist endlich da! Hier das Wichtigste für Sie als Entwickler.

MSDN Blogs - Fri, 07/31/2015 - 04:01

Visual Studio 2015 kam am 20. Juli heraus, und Windows 10, das Windows 10-SDK sowie die Visual Studio Universal Windows-App-Entwicklungstools wurden am 29. Juli, also erst vor einigen Tagen, endlich herausgegeben.

Jetzt ist es an der Zeit, mit der Entwicklung von Windows 10 Universal Apps zu beginnen, die auf mit Windows 10 laufenden PCs, Smartphones, der Xbox One, Internet-of-Things-Geräten und sogar auf der neuen und mit Spannung erwarteten Microsoft Hololens ausgeführt werden können. iOS- und Android-Entwickler können ihre Apps mit nur geringen Änderungen auf Windows 10-gestützten Geräten lauffähig machen , indem sie die neuen «Platform Bridges» verwenden. Klassische Windows-Software (Win32, .NET und COM) kann ebenfalls zu einem APPX-Paket umgewandelt werden, das über den Windows Store – die beste Möglichkeit, seine Software an den Benutzer zu bringen – verteilt werden kann. Und schliesslich können Herausgeber von Websites ihre unveränderten Webseiten an den Windows Store publizieren, damit Windows-10-Benutzer sie finden. Mithilfe eines XML-Manifests und JavaScript können «installierte» Websites moderne Windows-Features wie Live Tiles, Cortana-Integration oder die Fähigkeit, neue Termine an die Kalender-App zu schicken, nutzen, um nur einige zu nennen.

Nun gibt es kein Hindernis mehr, das zwischen Ihnen und Ihrer eigenen Windows 10-App steht! Wir haben eine Liste anschaulicher Lernvideos zusammengestellt, damit Sie schnell alles erfahren, was es in Windows 10 für Entwickler an Neuem gibt.

Einführung in das Windows 10-App-Modell

Windows 10 erweitert drastisch die Möglichkeiten, wie Entwickler Apps und Games erstellen können, indem einige neue Programmiermodelle hinzugefügt werden und indem das App-Modell so erweitert wird, dass es ein breiteres Spektrum von Entwicklerszenarios unterstützt. Andrew stellt sie im Detail vor und vermittelt Ihnen die nötigen Informationen, damit Sie noch heute mit der Entwicklung von Windows-Apps, die diese Funktionen nutzen, beginnen können.

Design: UX Patterns und responsive Methoden für Universal Windows-Apps

Lernen Sie hier einige der wesentlichen Vorteile und Interaktionsfunktionen kennen, wenn eine App auf der Universal Windows Platform entwickelt wird. Neben weniger Einschränkungen bei der Veröffentlichung und einer gemeinsamen Codebasis geniessen Sie eine grössere Flexibilität beim Design, wie zum Beispiel neue interaktive und visuelle Elemente, die über ein breites Spektrum von Geräten hinweg auf Kontextänderungen reagieren können.

Erweiterbarkeit von Cortana in Universal Windows-Apps

Die Leiter des Cortana-Teams zeigen hier, wie Entwickler Cortana in Windows 10 dafür nutzen können, ihre Universal Windows-Apps besser zugänglich zu machen und eine intensive Nutzerbindung zu bewirken. Wir zeigen, wie Erweiterbarkeit in die allgemeine Cortana-Vision passt und wie Ihre Apps von neuen Sprachsteuerungsfunktionen profitieren können. Auf die Präsentation folgt eine kurze Fragestunde mit dem Team.

Wechsel zur Universal Windows Platform: eine App von Windows 8.1 XAML oder Windows Phone Silverlight zu Windows 10 portieren

Haben Sie bereits eine Windows 8.1- oder Silverlight-App? Möchten Sie davon profitieren, nur eine Codebasis zu haben und Ihre App problemlos an zahlreiche Windows-Geräte bereitstellen zu können? Hier erfahren Sie mehr über Portierungsstrategien für den Umzug Ihres bestehenden Codes auf die Universal Windows Platform (UWP) für Windows 10. Was funktioniert, was ist schwierig und wie ist man am produktivsten, wenn es darum geht, den Wechsel zu Windows 10 schnell zu vollziehen.

Strategien für die Entwicklung von plattformübergreifenden Anwendungen mit Visual Studio 2015

In dieser Sitzung geht es um die strategischen Entscheidungen, die Sie als Entwickler treffen müssen, wenn Ihre Anwendung für verschiedene Plattformen bestimmt ist. Wir schauen uns die Tools und Technologien an, die Ihnen in Visual Studio 2015 sowohl für Web- als auch für native Anwendungen, die auf Windows-, iOS- und Android-Geräten laufen sollen, zur Verfügung stehen.

Konvertierung Ihrer klassischen Windows-Anwendung (Win32, .NET, COM) zu einer Universal Windows-App, um sie über den Windows Store zu verteilen

Ein zentrales Merkmal von Windows 10 ist, dass es die Aufnahme bestehender klassischer Windows-Anwendungen (Win32, .NET, COM) in das Store-Ökosystem ermöglicht. Diese Sitzung stellt detailliert die Technologien dar, die es Ihnen ermöglichen, Ihre App zu einem Windows-APPX-Paket zu konvertieren, so dass sie über den Store verteilt werden und die Universal Windows Platform nutzen kann.

Tolle Windows-Apps aus vorhandenem Android-Code erstellen

Diese Sitzung nimmt Sie mit auf eine Reise, bei der Sie das neue Windows 10-SDK dafür nutzen, Ihre Android-App in den Windows Store zu bringen. In dieser Sitzung geht es um Folgendes: 1. Wie man aus vorhandenem Code eine Universal Windows-App erstellt. 2. Verwendung der Windows-App-Kompatibilitätsseite zur Bewertung Ihrer bestehenden Android-Anwendung. 3. Nutzung des bestehenden Android-Workflows zum Debuggen Ihrer App auf einem Windows Phone. 4. Nutzung von Microsoft-Diensten in Ihrer Anwendung. 5. Nutzung von aufregenden neuen Tools, die Ihnen die Anwendungsentwicklung für Windows erleichtern.

Wenn Sie nach einem umfassenden und gründlichen Training mit über 20 Stunden Inhalt suchen, das jeden Aspekt von Windows 10 für Entwickler abdeckt, sind Sie beim folgenden kostenlosen Training der Microsoft Virtual Academy richtig. Sie können sich die 23 Module in Ihrem eigenen Tempo und geordnet nach deren Relevanz für Sie ansehen.

Eine Windows 10-Anleitung für Entwickler

Möchten Sie sich die Universal Windows Platform (UWP) gründlich ansehen? Die Experten Jerry Nixon und Andy Wigley zeigen Ihnen auf anschauliche Weise, wie Windows-Funktionen und soziale Integration Ihnen helfen können, ansprechende Benutzererfahrungen auf mit Windows 10 laufenden Geräten zu schaffen, wie zum Beispiel Telefone, Tablets, PCs und (in Kürze) sogar die Xbox! Jerry und Andy stellen die Windows 10-Stärken anhand zahlreicher Beispiele dar, erkunden coole neue Funktionen und geben praktische Anleitung. Jedes Modul dauert etwa 30 Minuten – so können Sie die Themen auswählen, die Sie am meisten interessieren.
Hinweis: Wollen Sie Ihr grundlegendes Wissen über Entwicklungssprachen auffrischen, schauen Sie sich Programmieren in C# an oder erkunden Sie die XAML-Module in Universal Windows-Apps mit C# und XAML entwickeln.

Wenn Sie mehr über die neuen Funktionen in Visual Studio 2015 erfahren möchten, besuchen Sie die Visual Studio-Website oder schauen Sie sich die Visual Studio-Videoserie auf Channel 9 oder die Aufzeichnung der Veranstaltung zur Markteinführung von Visual Studio 2015 an.

Visual Studio Tipps & Tricks, Teil 56: Mehrere Projekte starten

MSDN Blogs - Fri, 07/31/2015 - 02:39

In einer Solution in Visual Studio befindet sich typischerweise mehr als nur ein Projekt. In vielen Fällen ist es so, dass man als Entwickler einzelne Komponenten in Projekte auslagert, die dann als Referenz der eigentlichen Anwendung hinzugefügt werden.

Bisweilen ist es aber auch so, dass sich innerhalb einer Visual Studio Solution mehrere eigenständig lauffähige Projekte verbergen. Wenn ich nun als Entwickler das eine oder andere Projekt ausführen will – beispielsweise um zu Debuggen – dann wähle ich "Set as Startup Project" im Solution Explorer, drücke F5 und die Software läuft los.

Nun mag es sein, dass man gerne zwei oder mehrere unterschiedliche Projekte laufen lassen möchte. Auf den ersten Blick mag das unmöglich sein, da die Oberfläche zunächst nur ein Startup-Projekt zuzulassen scheint. Wenn wir allerdings auf den Solutionknoten einen Rechtsklick machen und und die Properties anzeigen lassen, dann sehen wir, dass es hier die Möglichkeit gibt "Mutliple Startup Projects" auszuwählen. Hier können wir genau sagen welche Projekte wir meinen, wenn wir über F5 den Start aufrufen.

Falls wir später dennoch wieder umschalten möchten und nur ein einzelnes ausführen wollen, können wir das wie gehabt über den Rechtsklick aufs Projekt mit "Set as Startup Project". Oder wir wählen einfach in der DropDown Liste im Menü von Viusal Studio aus, ob wie eines oder mehrere starten wollen.

Gerade für Windows Universal App Entwickler kann noch ein weiterer Aspekt hier sehr interessant sein. Ich kann innerhalb der Projekteinstellungen projektspezifisch festlegen, wo die Projekte gestartet werden sollen. So kann ich in den Properties der einzelnen Projekte angeben, dass z.B. App1 auf meinem Arbeitsrechner local gestartet werden soll, während App2 auf einer Remotemaschine gestartet wird und App3 auf mein am Rechner angeschlossenes Windows Phone deployed wird.

Das erleichtert mir die Arbeit, insbesondere wenn es darum geht die Kommunikation zwischen den unterschiedlichen Apps auf verschiedenen Geräten zu testen.


Über die Solution Properties lassen sich mehrere Projekte als Startprojekt festlegen.


Kurzer Text am Rande:

Dieser Post ist Teil einer längeren Serie, in der ich ein paar der vielleicht nicht ganz so bekannten Features von Visual Studio vorstellen werde. Ich hoffe, für Euch ist der ein oder andere Kniff dabei, den Ihr noch nicht kanntet. Und wenn ihr ihn doch schon kennt: Seid stolz auf Euch und verratet den Trick auch dem Entwickler neben Euch.

Guest post: Pubblicare e migrare la vostra prima Universal Windows app per Windows 10

MSDN Blogs - Fri, 07/31/2015 - 02:13

Questo post è stato scritto da Matteo Pagani, Support Engineer in Microsoft per il programma AppConsult.

Le ultime due settimane sono state molto importanti per gli sviluppatori Microsoft e non: il 20 Luglio è stata rilasciata la RTM di Visual Studio 2015, mentre il 29 Luglio, oltre al rilascio ufficiale di Windows 10, è stata distribuita la versione finale dell'SDK che consente lo sviluppo e la pubblicazione di Universal Windows app per Windows 10.

A partire da tale data, infatti, il Dev Center ha aperto le porte alla pubblicazione di applicazioni Windows 10 sullo Store. Se negli ultimi mesi avete sfruttato le preview per iniziare a sviluppare (o a migrare) la vostra prima Universal Windows app per Windows 10, ora finalmente avete la possibilità di pubblicarla e farla scaricare alle tantissime persone che in questi giorni stanno aggiornando, in maniera completamente gratuita, il loro PC dotato di Windows 7 o Windows 8.1 (è di ieri la notizia che, a 24 ore dal lancio, Windows 10 è già stato installato su oltre 14 milioni di computer).

Se provate, però, ad aprire il vostro progetto dopo aver installato la versione finale di Visual Studio 2015 e dei tool di Windows 10, vi accorgerete di una serie di problemi che vi impediranno di preparare il pacchetto da caricare sullo Store, da quelli più semplici da risolvere (come il fatto che il progetto non si apra perché cerca una versione dell'SDK che non esiste più) a quelli invece all'apparenza più misteriosi (come la mancanza di classi fondamentali del framework .NET).

Il motivo è che la struttura del progetto Universal Windows app ha subito delle sostanziali modifiche, collegate in particolar modo alle novità introdotte dalla nuova versione di NuGet. La soluzione più semplice per risolvere il problema è creare un nuovo progetto di tipo Universal Windows app e copiare tutti i file che fanno parte della vostra soluzione attuale (classi, asset, ecc.). Questa soluzione è documentata direttamente su MSDN, all'indirizzo

In alcuni casi, però, si tratta di una strada non percorribile. Pensiamo, ad esempio, ad un progetto sotto source control: il fatto di dover eliminare il vecchio progetto e sostituirlo con uno nuovo potrebbe essere difficile da gestire. Vediamo perciò i passaggi da seguire per modificare un progetto già esistente e renderlo compatibile con il nuovo formato introdotto con la versione finale dei tool di sviluppo.

I prerequisiti: i tool di sviluppo

Le informazioni riportate in questo paragrafo, in realtà, sono utili a chiunque voglia sviluppare un'applicazione per Windows 10 e non solo a chi è già pronto per pubblicare la sua prima applicazione.

Il primo requisito è quello di avere Windows 10: non è indispensabile, dato che i tool di sviluppo possono essere utilizzati anche su un PC con Windows 8.1, ma è sicuramente la strada più semplice, dato che potrete gestire la fase di sviluppo e di testing sulla stessa macchina. In caso contrario, potete continuare ad utilizzare Windows 8.1 per lo sviluppo, ma avrete bisogno di un altro device con Windows 10 (un altro computer, un tablet, ecc.) per testare e fare debug della vostra app.

La distribuzione di Windows 10 è iniziata il 29 Luglio come aggiornamento gratuito per chiunque abbia una copia valida di Windows 7 o Windows 8.1. Trovate tutte le informazioni necessarie all'indirizzo Se, invece, siete iscritti al programma Insider, assicuratevi che il vostro PC sia aggiornato e che siate sulla build 10240 (potete verificarlo aprendo un prompt dei comandi, in cima viene sempre riportata l'indicazione sul numero di versione).

Il secondo requisito è installare Visual Studio 2015: ne esistono diverse versioni, a seconda delle vostre esigenze, che trovate sul sito ufficiale È importante sottolineare, però, la presenza di una versione, definita Community, che è completamente gratuita per gli sviluppatori indipendenti e per i progetti open source, che offre le stesse funzionalità della versione Professional.

Nel momento in cui lanciate il setup di Visual Studio 2015, è importante non procedere con l'installazione standard ma utilizzare questa personalizzata: questo perché, come impostazione predefinita, l'SDK di Windows 10 non viene installata. Assicuratevi, perciò, che l'opzione rappresentata nella schermata seguente sia abilitata prima di procedere:

Una volta terminata l'installazione, siete pronti per creare un nuovo progetto per Windows 10 (grazie ai template presenti nella categoria Windows Universal) o a migrarne uno già esistente.

Il primo passo: modificare i progetti

Una delle novità più importanti di Windows 10 è la Universal Windows Platform (abbreviata, UWP): una piattaforma per gli sviluppatori che è disponibile, in maniera trasversale, su tutti i device Windows 10, siano essi computer, tablet, telefoni o Raspberry PI 2. La Universal Windows Platform ha la peculiarità di potersi evolvere in maniera indipendente dal sistema operativo: ciò significa che, in futuro, come Microsoft potremo rilasciare delle nuove versioni della UWP, senza per questo rilasciare però una nuova versione di Windows. Di conseguenza, le Universal Windows app per Windows 10 non hanno più come target di riferimento una versione specifica del sistema operativo, ma una versione della UWP.


Ecco il motivo per cui, una volta aperta la soluzione che avete creato con Visual Studio 2015 RC, vi comparirà un messaggio di errore e il Solution Explorer vi mostrerà il vostro progetto (o progetti) con, di fianco, la dicitura Update Required.

L'installazione di Visual Studio 2015 e dell'SDK finale di Windows 10, infatti, si fa carico di eliminare tutte le versioni precedenti della UWP, le quali erano in Preview. Di conseguenza, la versione corrente del vostro progetto sarà configurata per utilizzare una versione della UWP (come la 10069 o la 10166) che sul vostro computer non esiste più.

Potete verificare tutte le versioni della Universal Windows Platform installate sul vostro computer aprendo il percorso C:\Program Files (x86)\Windows Kits\10\Platforms\UAP. Se avete installato correttamente i tool in versione finale, dovreste trovare solamente una cartella relativa alla versione 10240.


Il primo passaggio, perciò, è quello di modificare il progetto per utilizzare la versione 10240 della UWP: dovete intervenire manualmente, modificando il file .csproj che contiene la configurazione del progetto. Dato che, al momento, il progetto non è attivo, potete farlo direttamente da Visual Studio: fatevi click con il tasto destro e scegliete la voce Edit, che sarà seguite dal nome del file di progetto. In questo modo, direttamente in Visual Studio si aprirà il file .csproj in versione testuale, che non è altro che un file XML che contiene tutte le informazioni sulla struttura del progetto (nome, file e reference, configurazioni, ecc.)

All'interno, troverete le due seguenti proprietà:



All'interno, troverete la versione della UWP su cui è basata la vostra applicazione, che dovrete modificare indicando la più recente, ovvero la versione 10240. La proprietà più importante è TargetPlatformVersion, che dovrete impostare su 10.0.10240.0: grazie a questa modifica, avrete la possibilità di aprire il progetto in Visual Studio, semplicemente facendoci clic sopra con il tasto destro e scegliendo la voce Reload project. La proprietà TargetPlatformMinVersion specifica, invece, la versione minima della Universal Windows Platforms su cui l'applicazione è in grado di funzionare. Nella maggior parte dei casi, in questo momento, le due proprietà avranno lo stesso valore, in quanto la versione 10240 coincide con la prima release ufficiale di Windows 10 (le versioni precedenti erano accessibili in forma di preview solamente agli iscritti al programma Insider). In futuro, invece, con l'evoluzione di Windows 10 e il rilascio di nuove versioni della UWP, invece, sarà plausibile che queste due proprietà possano differire.

Il secondo passo: modificare il file di manifest

Una delle novità che sicuramente noterete con maggiore piacere della versione finale dei tool di sviluppo è il ritorno dell'editor visuale del file di manifest. Facendo doppio clic sul file Package.appxmanifest, infatti, si aprirà una comoda interfaccia visuale, che vi permetterà con semplicità di configurare le capability, gli asset predefiniti, ecc.

Dietro le quinte, però, il file di manifest non è altro che un file XML che, a sua volta, contiene anche lui l'informazione su quale sia la UWP di riferimento. Tale informazione, però, non è accessibile dall'interfaccia grafica; dovrete, perciò, fare click con il tasto destro sul file Package.appxmanifest e scegliere la voce View code. All'interno del file XML troverete le seguenti righe:


<TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.10069.0" MaxVersionTested="10.0.10240.0" />


Anche in questo caso, dovrete specificare:

  1. La versione della UWP utilizzata, tramite la proprietà MinVersion. Un dispositivo con una versione della UWP inferiore non sarà in grado di utilizzare l'applicazione.
  2. La versione massima della UWP con cui abbiamo testato la nostra applicazione e per la quale siamo sicuri non ci siano problemi di compatibilità, tramite la proprietà MaxVersionTested.

Anche in questo caso vale il ragionamento fatto in precedenza: essendo la 10240 la prima versione ufficiale di Windows 10, in questo momento le due proprietà probabilmente coincideranno nella maggior parte dei casi.

Goodbye packages.config, welcome project.json

La novità forse più importante della versione finale dei tool di sviluppo è l'utilizzo di un nuovo formato per la gestione delle dipendenze di un progetto, legato all'introduzione della versione 3.0 di NuGet, il celebre package manager di Visual Studio.

Le versioni precedenti erano basate su un file, incluso nella root del progetto, chiamato packages.config: si tratta di un XML che contiene la descrizione di tutti i pacchetti che sono stati installati tramite NuGet. Le nuove applicazioni Windows 10, invece, fanno uso di un nuovo file di nome project.json che, usando il formato JSON, descrive tutte le dipendenze che sono necessarie all'applicazione per essere compilata correttamente.

Ecco un esempio di file project.json:


"dependencies": {

"Microsoft.ApplicationInsights": "1.1.0",

"Microsoft.ApplicationInsights.PersistenceChannel": "1.1.0",

"Microsoft.ApplicationInsights.WindowsApps": "1.1.0",

"Microsoft.NETCore.UniversalWindowsPlatform": "5.0.0",

"Newtonsoft.Json": "7.0.1",


"frameworks": {

"uap10.0": {}


"runtimes": {

"win10-arm": {},

"win10-arm-aot": {},

"win10-x86": {},

"win10-x86-aot": {},

"win10-x64": {},

"win10-x64-aot": {}



Come vedete, contiene la definizione dei pacchetti NuGet (dependencies), dei framework utilizzati (frameworks) e dei runtime per cui viene compilata l'app (runtimes). Se osservate le dipendenze, ne noterete una particolare: .NET Core, ovvero la libreria che vi permette di sfruttare il bridge specifico di .NET per la Universal Windows Platform.

Questo è il motivo per cui, se cercherete di compilare il vostro progetto otterrete una serie di errori, all'apparenza misteriosi, relativi alla mancanza di classi base del framework .NET, come Object o string. Di conseguenza, anche se avete un progetto che non contiene alcuna riferimento a librerie esterne (e, di conseguenza, non ha un file packages.config) avrete comunque bisogno di un file project.json: senza di esso, mancherà il fondamentale riferimento a .NET Core.

Il modo più semplice per migrare il vostro progetto è seguire questi passaggi:

  1. Annotatevi da qualche parte il contenuto del file packages.config, così da avere un riferimento di tutte le librerie che avete installato.
  2. Dall'interfaccia di NuGet, disinstallate tutte le librerie installate. Per visualizzarle, scegliete la voce Installed dal menu a tendina Filter: ora, una per una, selezionatala e, dal menu a tendina Action, scegliete l'opzione Uninstall.



  3. Eliminate dal vostro progetto il file packages.config.
  4. Ora create un file di nome project.json e aggiungetelo al progetto, con la seguente definizione base:


"dependencies": {

"Microsoft.NETCore.UniversalWindowsPlatform": "5.0.0",


"frameworks": {

"uap10.0": {}


"runtimes": {

"win10-arm": {},

"win10-arm-aot": {},

"win10-x86": {},

"win10-x86-aot": {},

"win10-x64": {},

"win10-x64-aot": {}



  1. Chiudete Visual Studio e riaprite la soluzione.
  2. Ora riaprite l'interfaccia di NuGet e, aiutandovi con il contenuto del vecchio file packages.config che avete annotato in precedenza, reinstallate tutte le librerie utilizzate dal vostro progetto. In questo modo, andrete in automatico ad utilizzare la nuova versione di NuGet e noterete che i riferimenti alle librerie non saranno più aggiunti nel file packages.config, ma all'interno del nodo dependencies del file project.json.
Gestire le Extension SDK

Se avete già iniziato a sviluppare Universal Windows app per Windows 10, dovreste conoscere il concetto di Extension SDK. La UWP, come già detto, è una piattaforma di sviluppo in comune tra tutti i device con Windows 10. A volte, però, si ha la necessità di sfruttare delle funzionalità che sono disponibili solamente su una tipologia di device: ad esempio, non avrebbe senso utilizzare le API per interagire con i GPIO di un micro computer come Raspberry PI 2 su un pc o un tablet. Di conseguenza, all'interno del menu Add reference di Visual Studio, alla voce Extensions, troverete una serie di librerie in grado di aggiungere alla UWP una serie di funzionalità specifiche in base alla famiglia di device (mobile, desktop, IoT, ecc.).

Nel passaggio alla versione 10240 della UWP anche queste extension sono state aggiornate: di conseguenza, se ne facevate uso, dovrete rimuovere nella sezione References del progetto il riferimento a quelle vecchie e aggiungere, invece, quella nuova.


È giunta l'ora di pubblicare!

Se avete seguito correttamente i passaggi fin qui riportati, ora il vostro progetto dovrebbe compilare senza errori e sarete in grado di lanciare la vostra applicazione sia sul vostro PC che sull'emulatore della versione mobile di Windows 10. A questo punto, potete procedere con la pubblicazione con le stesse modalità utilizzate per le applicazioni 8.1: fate clic con il tasto destro sul vostro progetto e, alla voce Store, scegliete l'opzione Create app packages. Seguendo il wizard (che vi guiderà passo per passo chiedendovi una serie di informazioni, come il numero di versione dell'applicazione) otterrete alla fine un pacchetto di tipo .appxupload, che dovrete caricare sul Dev Center quando vi sarà richiesto durante la procedura di invio.

Non vediamo l'ora di vedere e provare le vostre Universal Windows app! Happy coding!

Windows 10 : dix raisons de ne pas mettre à jour !

MSDN Blogs - Fri, 07/31/2015 - 01:40

À chaque nouvelle version de Windows, j’ai pu lire çà et là des messages plus ou moins bien intentionnés vous incitant à ne pas installer ou utiliser cette nouvelle version. Au moment de la crise de Windows Vista, je me souviens avoir retrouvé des articles très critiques sur Windows XP, dont chacun connaît aujourd’hui le succès. Windows 10 ne fait pas exception. Je vais reprendre les arguments utilisés, notamment par Yohann POIRON sur son blog, qui, contrairement à moi, travaille la plupart du temps sur un Mac sous MacOS.

Comme dans d’autres textes que j’ai pu écrire ici, je précise que je ne suis ni juriste, ni en charge de la communication de Microsoft et, donc, ces propos n’engagent que le simple utilisateur passionné que je suis.

1. Il est encore en chantier (sous entendu : il est plein de bug)

Le mode de conception de Windows 10 a considérablement évolué par rapport à ces prédécesseurs : jamais la mise au point d’un système d’exploitation n’avait eu recours à autant de testeurs et sur une durée aussi longue. Microsoft connais le marché de ses utilisateurs et sais que la diversité des matériels utilisés est telle que les probabilités de tomber sur des combinaisons jamais testées sont très élevées. Contrairement à certains concurrents qui contrôlent de bout en bout le matériel et le logiciel, ce n’est pas une nouveauté pour Microsoft que d’évoluer dans ce contexte. Attendre un peu plus longtemps pourrait permettre d’espérer que LA combinaison que VOUS utilisez sera également utilisée par quelqu’un d’autre et que ce quelqu’un d’autre remontera un dysfonctionnement qui sera corrigé. C’est un pari, mais un pari risqué. Si vous utilisez une combinaison plutôt classique, il y a une très forte probabilité que cette combinaison a déjà été testée et validée.

2. Il y a trop de questions sans réponses (gratuité, durée du support de cette version, etc.)

Beaucoup de questions se posent lors de la sortie d’un nouveau logiciel, mais Microsoft n’en est pas à sa première sortie. Certes, il y a eu, dans le passé, des revirements tels que le niveau de support d'Internet Explorer que j’ai évoqué ici. Mais globalement, les questions les plus fréquemment posées possèdent des réponses claires.

La première : celle de la gratuité fait l’objet de réponses qui sont très juridiques. En termes non juridiques, pour les utilisateurs particuliers qui ont déjà acheté leur version de Windows avec leur matériel et qui sont sur des versions récentes (Windows 7 et ultérieurs), il n’y a rien à payer si vous faites la mise à jour dans l’année à venir.

La seconde : celle de la durée de support est également juridique. Depuis très longtemps, Microsoft a clarifié la situation avec les deux phases de 5 ans, soit 10 ans de support, globalement. Par ailleurs, ne pas migrer aujourd’hui parce que l’on ne sait pas quel sera la date exacte de fin de support de la nouvelle version serait plutôt étrange par rapport aux dates de fin de support des versions précédentes qui sont connues et beaucoup plus proches que celle de Windows 10.

3. Non, toutes les applications, et les composants ne sont pas compatibles !

Comme pour le premier point, le programme de développement de Windows 10 a duré suffisamment longtemps et mobilisé suffisamment de monde pour tenter d’identifier les problèmes potentiels. En repoussant la migration, le problème ne se résoudra pas tant qu’il ne sera pas connu. Comme souvent mentionné, le retour en arrière est toujours possible, mais mieux vaudrait s’attaquer au problème que de le masquer en réutilisant un ancien système.

La compatibilité des applications n’est pas une découverte pour Microsoft, mais a fait l’objet de nombreuses améliorations au fur et à mesure des nouvelles versions de Windows. Beaucoup de solutions existent qui ne sont pas toujours connues.

4. Le menu Démarrer

Il est de retour ! Mais il a aussi évolué ! À une certaine époque, il était question du meilleur des deux mondes. C’est également le cas de ce menu qui, comme toujours, peut faire l’objet de nombreuses personnalisations, y compris de revenir au menu démarrer de Windows 8 en plein écran et avec ses tuiles plus ou moins grosses.

Selon les systèmes que j’utilise, mon menu n’est pas identique : sur l’ordinateur avec lequel je travaille et qui n’est pas tactile (et oui, même encore aujourd’hui, c’est possible sous Windows), j’utilise énormément le clavier et compose plutôt le nom des applications que je souhaite lancer. Sur l’ordinateur des loisirs, je suis plutôt à naviguer avec les doigts sur l’écran. Microsoft offre le choix d’utiliser ce qui est le plus confortable pour chacun et dans chacun des contextes d’utilisation.

5. Une forte influence sur le mobile

Il est évident que Microsoft souhaiterait avoir une part de marché supérieure dans le domaine des téléphones, mais ce n’est pas une raison pour reprocher le progrès que l’interface de Windows Phone a pu apporter. J’ai pu lire que certains concurrents s’en étaient inspirés et que la convergence faisait qu’il était de plus en plus difficile à distinguer chaque système d’exploitation. À chaque époque, ses modes et la tendance actuelle se retrouve à peu près partout. La prise en main finit toujours par être facilitée ; ce qui est le principal.

6. Applications

Le catalogue des applications présentes dans le Windows Store ne doit pas faire oublier l’immense catalogue d’applications compatibles avec Windows. La présence de nombreuses applications inutiles n’est pas, loin de là, l’apanage du Windows Store.

7. Fonctionnalités manquantes

Il est plutôt amusant de lire à la fois fréquemment que Windows est trop gros et que certaines fonctions très rarement utilisées qui ne sont pas reconduites manquent dans Windows 10. Il existe beaucoup de partenaires qui gravitent autour de Microsoft qui sont prêt à combler les zones d’ombre. Si certaines fonctions disparaissent et qu’il existe un réel besoin, je suis persuadé qu’un partenaire se lancera ou qu’une astuce permettra de retrouver la fonctionnalité disparue.

Pour information, ainsi, j’utilise toujours le bon vieux Windows Live Writer pour composer ce billet qui ne s’installe plus directement sur Windows 10. L’astuce à utiliser est de lancer la commande d’installation suivante :

Téléchargez WLW depuis

Puis lancez

wlsetup-all.exe /AppSelect:Writer /q /log:C:\temp\Writer.Log /noMU /noHomepage /noSearch

J’ai pu lire, par ailleurs, qu’Internet Explorer disparaissait de Windows 10 ; ce qui est complètement faux. La présence de Microsoft Edge ne fait pas disparaître Internet Explorer dont la version 11 équipes Windows 10 ainsi que les précédentes versions de Windows depuis Windows 7.

8. Windows 7 est toujours aussi bon – ou mieux

Ma calculatrice que j’utilisais en terminale n’a jamais été dépassée par les différentes calculatrices de Windows. Entre temps, mes usages ont évolué et l’environnement dans lequel j’évolue également. Compte tenu de la vitesse à laquelle l’informatique et les nouvelles technologies évoluent, continuer à utiliser un système d’exploitation conçu il y a plus de 6 ans serait comme tenter de traverser la Manche avec l’avion de Blériot. Certains le font pour le plaisir et le goût du risque. Je suis trop concentré sur mon travail pour y mêler plaisir et risque, mais j’ai encore un Macintosh Performa 630 sous System 7 et un PC sous Windows ME que j’allume de temps à autre.

9. Des mises à jour forcées

Les mises à jour ne sont pas forcées, du moins, pour ce qui est des évolutions du système d’exploitation. Les différentes moutures permettent de choisir le rythme d’évolution auquel chacun pourra accéder. À titre personnel, je préfèrerais recevoir de multiples mises à jour fréquentes et minimes plutôt que d’attendre jusqu’à plus de 10 ans avant de faire un grand saut beaucoup plus risqué.

Au passage, l’article kb3080351 de la base de connaissances de Microsoft précise les moyens à mettre en œuvre pour empêcher les utilisateurs de migrer leurs ordinateurs vers Windows 10. Je suis persuadé que des moyens similaires seront proposés ultérieurement pour Windows, au-delà du choix tel que Current Branch (CB), Current Branch for Business (CBB) ou Long Term Servicing Branch (LTSB), disponibles en fonction des éditions de Windows 10.

Pour ce qui est des mises à jour de sécurité, je suis plutôt rassuré de savoir qu’elles s’installent rapidement et sans intervention de ma part.

10. Il est toujours Schizophrenic

Pour arriver à satisfaire un maximum d’utilisateurs, il est utile de mettre à disposition de multiples manières de faire la même chose. Pendant des années, les Linuxiens reprochaient à Windows de ne pas pouvoir être piloté en ligne de commande. C’est aujourd’hui complètement possible, notamment à travers PowerShell.

Le respect de la vie privée !

Comme les 3 mousquetaires qui étaient 4, les 10 raisons de ne pas utiliser Windows 10 ont fait l’objet d’une onzième attaque, auprès de la CNIL, prétendant que Microsoft, à travers Windows 10, ne respectait pas la vie privée.

Il est utile de savoir que, de manière identique à l’initiative sur la sécurité, Microsoft a pris, il y a déjà plus de 10 ans, des décisions qui protègent les utilisateurs de ses logiciels et services en matière de respect de la vie privée. Ces décisions ont conduit à ne pas mettre en œuvre de collecte sans le consentement des utilisateurs et de laisser la possibilité de revenir sur des choix (notion, en anglais de OptOut).

Si vous lisez l’anglais, je vous invite à consulter les informations disponibles à partir de l’emplacement suivant :

Dans le contexte des révélations d’Edward SNOWDEN, il est utile de savoir que la plupart des informations collectées par Microsoft sont “anonymisées” et/ou protégées. Je suis plutôt convaincu que cette situation est loin d’être identique chez certains concurrents dont les données privées collectées et leur exploitation constituent l’essentiel de leur richesse, voire de leur chiffre d’affaire.

OneNote Class Notebooks for IT Admins webcast series – register now

MSDN Blogs - Fri, 07/31/2015 - 01:30

Over the last year we've seen a rising tide in the use of OneNote in education, and with the arrival of the Class Notebook Creator, teachers and students have enjoyed a wealth of collaborative learning possibilities. As part of Microsoft in Education's continued mission to enable anytime, anywhere, learning for all, the team at OneNote are running a series of webcasts tailored specifically for IT Admins.

Dates and registration links below

During these 60 minute webcasts you'll learn just how easy it is for your users, educators or staff leaders, to utilise OneNote Class Notebook and OneNote Staff Notebook

Focussing on the new features coming to OneNote Class Notebooks and OneNote Staff Notebooks, along with the future roadmap for the notebooks, the OneNote Class Notebooks for IT Admins webcasts will provide you with valuable information, and the opportunity to engage in an open Q&A with the OneNote engineering team on IT Admin and deployment topics.

These sessions are provided by our team in the USA, which means that due to the time difference they'll be running from 8pm-9pm GMT. We do hope that many of you will be able to find the time to join these sessions, but for those of you with busy social lives (or simply those who are already in bed by 8pm!) that aren't able to make the webcasts, the sessions will be recorded and shared on our channels in due course.

The dates for the webcasts are listed below, please follow the link to register your place:

Wednesday August 5th
Tuesday August 18th
Wednesday September 2nd
Wednesday September 16th
Wednesday September 30th

If you have any questions, please do not hesitate to contact your account manager.


OneNote is free with Office 365, which is also available to students and teachers at no cost through their academic institution’s existing Microsoft Education Subscription. You can check your eligibility at

OneNote Class Notebooks for IT Admins webcast series – register now

MSDN Blogs - Fri, 07/31/2015 - 01:30

Over the last year we've seen a rising tide in the use of OneNote in education, and with the arrival of the Class Notebook Creator, teachers and students have enjoyed a wealth of collaborative learning possibilities. As part of Microsoft in Education's continued mission to enable anytime, anywhere, learning for all, the team at OneNote are running a series of webcasts tailored specifically for IT Admins.

Dates and registration links below

During these 60 minute webcasts you'll learn just how easy it is for your users, educators or staff leaders, to utilise OneNote Class Notebook and OneNote Staff Notebook

Focussing on the new features coming to OneNote Class Notebooks and OneNote Staff Notebooks, along with the future roadmap for the notebooks, the OneNote Class Notebooks for IT Admins webcasts will provide you with valuable information, and the opportunity to engage in an open Q&A with the OneNote engineering team on IT Admin and deployment topics.

These sessions are provided by our team in the USA, which means that due to the time difference they'll be running from 8pm-9pm GMT. We do hope that many of you will be able to find the time to join these sessions, but for those of you with busy social lives (or simply those who are already in bed by 8pm!) that aren't able to make the webcasts, the sessions will be recorded and shared on our channels in due course.

The dates for the webcasts are listed below, please follow the link to register your place:

Wednesday August 5th
Tuesday August 18th
Wednesday September 2nd
Wednesday September 16th
Wednesday September 30th

If you have any questions, please do not hesitate to contact your account manager.


OneNote is free with Office 365, which is also available to students and teachers at no cost through their academic institution’s existing Microsoft Education Subscription. You can check your eligibility at

OneNote Class Notebooks for IT Admins webcast series – register now

MSDN Blogs - Fri, 07/31/2015 - 01:30

Over the last year we've seen a rising tide in the use of OneNote in education, and with the arrival of the Class Notebook Creator, teachers and students have enjoyed a wealth of collaborative learning possibilities. As part of Microsoft in Education's continued mission to enable anytime, anywhere, learning for all, the team at OneNote are running a series of webcasts tailored specifically for IT Admins.

Dates and registration links below

During these 60 minute webcasts you'll learn just how easy it is for your users, educators or staff leaders, to utilise OneNote Class Notebook and OneNote Staff Notebook

Focussing on the new features coming to OneNote Class Notebooks and OneNote Staff Notebooks, along with the future roadmap for the notebooks, the OneNote Class Notebooks for IT Admins webcasts will provide you with valuable information, and the opportunity to engage in an open Q&A with the OneNote engineering team on IT Admin and deployment topics.

These sessions are provided by our team in the USA, which means that due to the time difference they'll be running from 8pm-9pm GMT. We do hope that many of you will be able to find the time to join these sessions, but for those of you with busy social lives (or simply those who are already in bed by 8pm!) that aren't able to make the webcasts, the sessions will be recorded and shared on our channels in due course.

The dates for the webcasts are listed below, please follow the link to register your place:

Wednesday August 5th
Tuesday August 18th
Wednesday September 2nd
Wednesday September 16th
Wednesday September 30th

If you have any questions, please do not hesitate to contact your account manager.


OneNote is free with Office 365, which is also available to students and teachers at no cost through their academic institution’s existing Microsoft Education Subscription. You can check your eligibility at

Issues with Visual Studio Online Code Lens service - 7/31 - Resolved

MSDN Blogs - Fri, 07/31/2015 - 01:27

Final Update: Friday, 31 July 2015 08:30 UTC

We experienced issues with Code Lens service. Customers may have experienced service availability issues between 07:10 AM and 07:35 AM UTC. We have identified the issue and immediately took necessary steps to mitigate the issue. We’ve confirmed that all systems are back to normal with no customer impact as of 07/31/2015 07:35 AM UTC.

We understand that customers rely on VS Online as a critical service and apologize for any impact this incident caused.

VS Online Service Delivery Team

用Visual C++ 2015开发Windows 10应用

MSDN Blogs - Fri, 07/31/2015 - 01:27
[原文发表地址] Developing for Windows 10 with Visual C++ 2015 [原文发表时间] 2015/07/29 8:41 PM 入门 Windows 10引入了新的通用Windows应用程序的平台,它允许一个单一代码库可以跨多个Windows10的设备重复使用。早前的一篇 博文 描述了通用Windows应用程序预览版的设置以及一些新功能。现在 Windows10 RTM已经发布 ,下面的步骤将有助于你设置好你的机器,使用Visual Studio 2015 RTM 开发 Windows10应用程序. 1. 如果从早期的Windows版本开发应用程序,首先安装官方发布的 Windows10 或者 Windows10 SDK和Windows10 手机模拟器。 2. 安装 Visual Studio 2015 RTM 。 如果你在今天之前就已经安装了,你可以再次运行安装程序,现在会有个选项来安装Windows 10 开发 工具。 3. 创建一个通用Windows 应用程序: 在工程属性中为 Store Apps选择SDK版本...(read more)

Microsoft Imagine Cup 2015 World Finals - Tag 4

MSDN Blogs - Fri, 07/31/2015 - 00:35
Heute war es soweit: Die Bekanntgabe der Gewinner in den drei Kategorien stand an. Pro Kategorie wurden die Top 3 Teams und zudem die Gewinner des Ability Awards, sowie People’s Choice Awards bekanntgegeben. Schon die Begrüßung auf dem Microsoft Campus mit roten Teppich und Musik stimmte die Teams auf die Award Ceremony ein. Mit dieser ging es auch direkt am Morgen los. Nach der Bekanntgabe von Platz 2 und 3 pro Kategorie, kam Steven Guggenheimer, Corporate Vice President Developer Experience &...(read more)

Microsoft Student Partner Opportunity - Academic Year 2015-2016

MSDN Blogs - Fri, 07/31/2015 - 00:03

Microsoft Pakistan Liaison Office is looking for the right candidate for MSPs for the coming Academic year.

Interested students can email us your CVs at by Tuesday, 4th August 2015.

...(read more)

140+ sessions for Ignite NZ

MSDN Blogs - Thu, 07/30/2015 - 23:03


     : :  View as Webpage  : :  Go to News Events Apps MVA 140+ technical sessions for Ignite NZ! In a few short weeks SKYCITY transforms into Ignite and becomes the epicentre of technology in NZ. There will be some amazing keynote speakers, plenty of networking amongst peers, a couple of coffee carts to keep you going and, of course, some swag.

The main reason we all gather for this event is the sessions. The chance to catch up on all the new tools, find better ways of building apps and software, get a glimpse of what the future might look like - and how we get there. We’ll have 140+ sessions this year, covering a range of topics – including the return of our highly popular “make yourself more awesome” style sessions.

This is a big year for Microsoft – a number of new products are being unleashed. This week saw the release of Visual Studio 2015 - the best IDE for running on Windows – and Visual Studio Code – which is fast becoming the best free modern editor across multiple platforms. Next week is the “RTM” of Windows 10 for the desktop, bringing with it a huge opportunity for software developers to build for the next generation of devices.

We’ll have sessions to cover these new tools and platforms. We’ll take a closer look at ASP.NET 5 and the unification of MVC and Web API. We’ll be showing you how to build the Internet of Things, and how to hack it. You’ll be speaking in Node.js, Angular, TypeScript, and you’ll learn how to torment your colleagues by taking advantage of Roslyn. With so many different data platform choices now, a session on data patterns for the cloud coupled with a drill down into next-gen web applications and patterns for high availability + scalability might be just what you’re looking for. Shipping that code will be covered too, with deep dives into DevOps and continuous delivery. Of course a major component of any good app or website is the UX. Be sure to catch one of the sessions on how to identify and avoid bad UX, or how to craft unique, immersive, experiences for your LOB or consumer audiences.

If you want to take a ‘deep dive’ into the session catalogue catch the session release on the Ignite website!

MSA -->   Regan Murphy
Technical Evangelist
Microsoft New Zealand Back to top... News Are you FIT to be a Dev/IT Pro?
The best Devs are always learning. This week, we started a competition that gives you the chance to win one of five FitBit Flexes or fifty snazzy Microsoft Virtual Academy tees. Check out @MSDevNZ next Monday morning to answer the question and to be in to win! Each week will be a new chance to win until they're all gone!   Bring a friend to see Joe Belfiore at Ignite Kick-Off, for FREE!
Did you have a shot at this week’s question? On Monday our ‘Bring a friend to Kick-Off’ competition got rolling. Every week, for four weeks, Ignite NZ attendees will get a chance to win a free ticket for a freebie-loving friend to attend the Ignite Kick-Off event at Vector Arena. Stay tuned for the next question from @IgniteNZ. Check out the full Ts&Cs.   New in the world of Visual Studio
The final release of Visual Studio 2015 is now available and it’s easier to use regardless of platform or what app you're building. See the Q&A sessions and technical details on Channel9. @BizSparkNZ startups have had their Visual Studio Ultimate with MSDN subscription become Visual Studio Enterprise 2015. All startups will now need to sign in to Visual Studio 2013 and 2015 with the Microsoft account associated their active MSDN subscription, meaning startups will need to renew their MSDN subscriptions for each user running Visual Studio after graduation.   Develop with Windows 10
Windows 10, arriving next week, will empower you to build a single universal app experience that can reach every device running Windows 10—every phone, tablet, PC, and soon Xbox. Take a look at building Windows 10 Universal Apps. And if you haven't already, make sure you check out the //build/ videos for announcements, sessions, and demos to learn more about advances across all Microsoft platforms, including Windows 10 and the Universal Windows Platform. Back to top... Upcoming Events Auckland .NET User Group
28 July (Auckland)
Kevin Isom is giving presentation on React.js and ASP.Net MVC. React has been receiving a lot of attention lately and with good reason. In this talk he will introduce React, what makes it different to a lot of the other frameworks and libraries out there and how you can take advantage of it in your ASP.Net MVC apps.

Ellerslie .NET User Group
29 July (Auckland)
In this session you will learn practical techniques for real world database development and deployment. This session will be presented by Darren Hall aka @nakedgeek, he is a senior .Net developer focussing on database development and the data access layer in enterprise systems.

Ignite NZ
1-4 September (Auckland)
The Kick-Off event begins with the keynote lineup featuring four Titans of Tech: Joe Belfiore, Laura Butler, James Staten and Chris Ford. Attendees are then invited to a fully themed entertainment and networking event with refreshments and live music. This is just where is begins. The 140+ technical sessions which make up the meaty filling of Ignite NZ are coming next week!

AgileNZ Conference 2015
1-2 September (Wellington)
The focus for AgileNZ Conference 2015 is transformation. Lean|Agile approaches are not only continuing to transform software delivery, they're being adopted outside of software to transform entire businesses. The event will explore the latest thinking in Agile, the development of the 'Agile Enterprise' and what might be learnt from New Zealand's digital transformation. Back to top... Recommended Apps When there's a break in the harsh Winter weather, make sure you grab the chance to get outdoors! Keep an eye on what's going on up there with the Aotearoa Weather app. No matter what the weather's doing, it's easy to enjoy a night out with Zomato which helps you find places to eat. If you're looking to try something new that's not of the edible variety, don't miss the exclusive chance to use the TradeMe Mall app.     Have a Windows project on the side? Show it off! Share it with the rest of the community in the Kiwi Windows Apps Facebook Group or send us an email at Back to top... Skill Up With Microsoft Virtual Academy (MVA) and Channel9   Join Azure Fridays!
Scott Hanselman sits down with the actual engineers who build Microsoft Azure on his journey to learn how to program the cloud. No marketing, just two engineers and a laptop in short managable chunks. Join in every Friday to the see some of the 180 episodes and counting.

Visual Studio 2015 release event
Watch the keynote 'Any app, any Developer' as well as on demand videos to learn about the latest features and technologies. See the Visual Studio developer team create an end-to-end solution for an open-source project and see how they tackled problems along the way. Haven't subscribed to this newsletter yet? Join us! Free Trial Downloads Seize the future of development and download Visual Studio 2013 for a free 90 day trial. Sign up for a free one-month trial and get USD $250 to spend on all Azure services. 2015 Microsoft Corporation     Terms of Use  : :   Trademarks

Microsoft respects your privacy. To learn more, please read our online Privacy Statement.
If you would prefer not to receive this newsletter any longer, click here to unsubscribe.
To set your contact preferences for other Microsoft communications click here.

The Privacy Officer  : :  Microsoft New Zealand Ltd, PO Box 8070 Symonds St, Auckland 1150, New Zealand  


Subscribe to Randy Riness @ SPSCC aggregator
Drupal 7 Appliance - Powered by TurnKey Linux