For Mac developers , Xamarin Studio is now available as a benefit of Visual Studio Professional or Enterprise subscriptions. Developers can use the newly-created Xamarin Studio Community Edition for free.

Another big announcement it is that The Mono Project it is added to the .NET Foundation, including some previously-proprietary mobile-specific improvements to the Mono runtime. Mono will also be re-released under the MIT License, to enable an even broader set of uses for everyone. More details to the Mono Project blog.

The changes to Mono remove all barriers to adopting a modern, performing .NET runtime in any software product, embedded device, or engine, and open the door to easily integrate C# with apps and games on iOS, Android, Mac, and Windows and any emerging platforms developers want to target in future.

Xamarin it is the Manufacturer of tools for cross-platform development based on C#. In the company, there are also the developers, the Mono and Moonlight had developed as an open-source alternative to .NET and Silverlight.

The Californian company Xamarin provides a app-development environment based on the C # programming language and .NET classes. In addition to iOS, OS X, Android and Windows Xamarin supports now also TVOS, WatchOS and Playstation. Basis for Xamarin products is Mono , an open source implementation of Microsoft’s .NET Framework, which have existed since 2,001th

Come together what belongs together?

Mono is a different implementation because Microsoft then the source code of .NET is not declared as “open source”, but as “Shared Source”, the “Just look, do not touch” after the motto further use of the source code is not allowed. The Mono Project has in complex work the .NET runtime environment, the C # compiler and a large part of the .NET class library rebuilt and endeavored thus to remain compatible with Microsoft’s model.

Now is true – Microsoft has Xamarin, a manufacturer of tools for cross-platform development, adopted

Why two implementations!

.NET Developers can now hope that the two platforms together grow closer. While many base classes are uniform, there has been no sophisticated user interface technology that can run on all platforms. With Windows Presentation Foundation (WPF) , Windows runtime XAML and Xamarin Forms instead there are three dialects of markup language extensible Application Markup Language (XAML) , but which are not entirely compatible. Xamarin Forms running at least iOS and Android as well as Windows 10 Universal apps, still lies in the development far behind other XAML dialects.

Also appears in times when Microsoft .NET Framework as .NET Core itself open source and platform-neutral development, the continuation of Mono as competition for .NET Core no longer meaningful.

This is kind of like how you can get Adobe Creative Cloud or Office 365, if you’re familiar with that. You pay a monthly or yearly fee like Office 365 and get Visual Studio and a bunch of other benefits.

And if you’re doing really serious IoT or embedded work, native Android libraries, Linux kernel modules, or small boards like Raspberry PIs, check out http://visualgdb.com which is an amazing and very complete 3rd party add in for Visual Studio!

If you’re doing Arduino development, check out http://www.visualmicro.comwhich has a brand new version and really lights up Visual Studio with some powerful features like an automatic Arduino Board Downloader.

Today @Build conference is announced the release of Visual Studio 2015 RC. This version includes many new features and updates, such as tools for Universal Windows app development, cross-platform mobile development for iOS, Android, and Windows, including Xamarin, Apache Cordova, and Unity, portable C++ libraries, native activity C++ templates for Android, and more.

Windows Holgografic is another Announcement regarding the vision of HoloLense and integration with all from IOC to Home Media .

Important: Most applications you build with Visual Studio 2015 RC are considered “go-live” and can be redistributed and used in production settings as outlined in the license agreement. However, those that are built for Windows 10 cannot be distributed or uploaded to the Windows Store. Instead, you will have to rebuild applications built for Windows 10 by using the final version of Visual Studio 2015 before submitting to the Windows Store. Also, please note that ASP.NET 5 is still in preview and is not recommended for production use at this time. You are free to use ASP.NET 4.6 in production.

Last November, Microsoft said that it would bring some of the core features of its .NET platform — which has traditionally been Windows-only — to Linux and Mac. Today, at its Build developer conference, the company announced its first full preview of the .NET Core runtime for Linux and Mac OS X.

In addition, Microsoft is making the release candidate of the full .NET framework for Windows available to developers today.

The highlight here, though, is obviously the release of .NET Core for platforms other than Windows. As Microsoft VP of its developer division S. “Soma” Somasegar told me earlier this week, the company now aims to meet developers where they are — instead of necessarily making them use Windows — and .NET Core is clearly part of this move.

Microsoft says it is taking .NET cross-platform in order to build and leverage a bigger ecosystem for it. As the company also noted shortly after the original announcement, it decided that, to take .NET cross-platform, it had to do so as an open source project. To shepherd it going forward, Microsoft also launched the .NET Foundation last year.

While it’s still somewhat of a shock for some to see Microsoft active in the open-source world, it’s worth remembering that that the company has made quite a few contributions to open source projects lately.

Even before the .NET framework announcement, the company had already open-sourced theRoslyn .NET Compiler platform. Earlier this year, Microsoft shuttered its MS OpenTechsubsidiary, which was mostly responsible for its open source projects, in order to bring these projects into the overall Microsoft fold.

With this ebook, the ALM Rangers share their best practices in managing solution requirements and shipping solutions in an agile environment, an environment where transparency, simplicity, and trust prevail. The ebook is for Agile development teams and their Scrum Masters who want to explore and learn from the authors’ “dogfooding” experiences and their continuous adaptation of software requirements management. Product Owners and other stakeholders will also find value in this ebook by learning how they can support their Agile development teams and by gaining an understanding of the constraints of open-source community projects.

Below you’ll find the ebook’s Foreword and a few helpful sections from its Introduction:

Foreword

The ALM Rangers are a special group for several reasons. Not only are they innovative and focused on the real world, providing value-added solutions for the Visual Studio developer community, but they live and work in all four corners of the globe. The ALM Rangers are a volunteer organization. Talk about dedication! When we were offered the opportunity to write a foreword for this book, we knew we’d be part of something special.

The ALM Rangers don’t pontificate that they’ve found the one true way. This is practical advice and examples for producing great software by those who’ve done it and–most importantly–are still innovating and coding. Readers will find that they have virtual coworkers who share their experiences with honesty and humor, revealing learnings and what has worked for them. This doesn’t mean that this book lacks prescriptive guidance. The Rangers have embraced Visual Studio Online as their one and only home. They are evolving with the product, embracing open source software in GitHub to learn how successful OSS projects are run there and what the community values most. They’ve created an ecosystem that identifies the “low hanging fruit” and tracks it from idea to solution, and they never fail to recognize the Rangers and the ALM VPs who dedicate their personal time and passion to their OSS projects.

The extensive guidance shared here is not an end-to-end plan for everyone, although it could be used as a definitive guide for some teams. One of the many assets of this book is its organization into practical walkthroughs of typical ALM Ranger projects from idea to solution, presented as an easy to consume reference. Other bonuses are an appendix to quick-start your own project and reference checklists to keep you on track.

Among the authors, this book was called the “v1 dawn edition.” True to their core value of “learn from and share all experiences,” the ALM Rangers are always mindful that producing great software means continuous refinements from new learnings and feedback and that there will be more versions of this book. But first we invite you to immerse yourself in Managing Agile Open-Source Software Projects with Microsoft Visual Studio Online.

In the true spirit of Agile, ongoing innovation,

Sam GuckenheimerClemri Steyn

Introduction
This book assumes that you have at least a minimal understanding of Agile, Lean, and Scrum development concepts and are familiar with Team Foundation Server (TFS) and Visual Studio Online (VSO). To go beyond this book and expand your knowledge of Agile practices or Visual Studio technologies, MSDN and other Microsoft Press books offer both complete introductions and comprehensive information.

This book might not be for you if …
This book might not be for you if you are looking for an in-depth discussion focused on the process, development, or architecture of software requirements, tooling, or practices.

Similarly, if you are looking for source code or guidance on ALM, DevOps, or proven and official frameworks such as Agile, Scrum and Kanban, this book will not be fully relevant, and we recommend that you consider these publications instead:

The Subject of Operations (DevOps) it is meanwhile an Hot aspect in the ALM of any application from the point of view of Delivery, Quality, Costs and Reliability. That is the first part of an series regarding this topic.

I will use a dummy MVC Web Application that’s basically the Visual Studio 2013 template plus a small modification to the web.config so that we can demo the workflow but The same Flow can be , sure with depending complexity with any kind of Application (Native, Multiplatform, Managed or hybrid combinations).

The example I have is to show a message on the home page from a setting in the web.config. This setting then varies based on the environment (dev, prod, etc) the application is running on, and this will be the variable that will be changed by web.config transformations and Release Manager.

Although I’m using an AppSettings key, you can use it for other settings and connection strings as well. The same rules apply.

I made the following modifications:

Index.cshtml

HomeController.cs

Web.config

The application should show the msg from the web.config settings as per below (running from Visual Studio);

Setting up web.config transforms

The strategy that I used here was to structure my transformations so that:

The original web.config file has the settings needed for the developer to run in debug mode in Visual Studio

I added a new configuration (Release) that will have the proper web.config transformations to put tokens in the key/values that I need to be changed later by Release Management:

The same transformed config using Release configuration will be used by Release Management (RM) to deploy to all the environments in the release path.RM will then substitute the “__EnvLabel__” token with the appropriate value for each target deployment environment.

TFS Build

You can use any template for the build, including the RM template to trigger a release directly from the build.

The trick here is to force the web config transformation to happen during build, so you end up with a web.config that has the tokens RM is expecting. By default, web config transformations only happen during deployment.

In order for you to add this behaviour, you can add the following arguments to MSBuild:

/p:UseWPP_CopyWebApplication=true /p:PipelineDependsOnBuild=false

Also, make sure that you’re building the correct configuration that has the transforms to add the token (in our example is Any CPU and Release):

Once the build finishes, the output should look like this (noticed the web.config transformed to include the token):

Release Path setup

Now, we have to take that config and replace the tokens with the proper values according to the target environment. In this example, I’m going to use an Agent-based setup. I’ll update this later to also include an Agent-less deployment using PowerShell Desired State Configuration (DSC).

I used the same target server to simulate both DEV and PROD IIS environments, by using two different ports:

Then I configured a server in RM to point to that box:

Next I configured the two environments, DEV and PROD:

Next step is to configure a release path where we have a DEV -> PROD deployment flow:

The setup above is, of course, overly simplistic for demo purposes. What you should have in mind is that you can configure who can approve (individuals or groups), who can validate and whether those steps are automated or not. In my example, I don’t need approvals for DEV, but need one for PROD. When the deployment workflow is initiated, DEV will be deployed automatically while PROD will wait for an approval before proceeding.

Next step is to configure the components to be deployed, in this case our web application:

I chose to use the “builds with application” option, since I’m going to use the build definition that will be defined in the release path.

Next, I’ll setup the deployment tool. In my case, XCopy, but you can use MS Deploy or other tool as appropriate:

The secret of the web.config token replacement happens here on the Configuration Variables. We specify that the replacement happens “Before Installation”, so that the config file is updated before being copied to the target server. We also specify the wildcard to tell RM what files we want RM to look for tokens: in this case *.config.

Next we define the release template. In this example:

You can see the DEV -> PROD workflow

Servers in the deployment (I only have one in this example, but you might have multiple most likely)

Components: the application being deployed (you might have to manually add it by right-clicking Components

I included optional steps to backup current site, and to rollback in case deployment fails (more of a best practice, but they’re not necessary)

Notice that the “EnvLabel” token we specified before gets a value here, depending on the environment, along with the other variables like target and backup folders:

Deploying

Let’s get some action going!

We initiate the release manually, choosing the template we configured previously, PROD as the last stage and selecting the last build as the one to deploy:

After a while we should see the following results:

Notice that the deployment to DEV was completed, but deployment to PROD is waiting for approval.

DEV has been successfully deployed:

While PROD has not yet:

The reason is that we’re waiting for approval. Let’s go ahead and open the approval window using the RM web client:

Clicking on the “Approve” for the selected release, we get the following dialog:

If we want to approve, but delay the deployment for later (off-hours deployment), we can click on the “Deferred Deployment” and select a day/time for when the deployment will execute:

After approval is given, the workflow resumes and finishes deploying to PROD:

The Marketing Team of VS has announcing the editions of Visual Studio 2015 that will be available when we release the final product this summer.

Focus is to improve upon the power and productivity of Visual Studio, making it easier to use, no matter what platform you’re on, no matter what app you’re building and make it easier for you to choose which edition of Visual Studio is the right one for you.

More value will deliver bringing Visual Studio Premium and Visual Studio Ultimate into one single offering called Visual Studio Enterprise with MSDN. It includes all the high value features you’re already familiar with in Visual Studio Ultimate, along with new innovation that’s coming with the 2015 release. So, in addition to Visual Studio Community and Visual Studio Professional with MSDN, our new Visual Studio Enterprise with MSDN rounds out the three primary Visual Studio 2015 offerings.

The Visual Studio Professional, Team Foundation Server, Team Foundation Server Express, Visual Studio Express and MSDN Platforms will be continued to offer as a part of the complete Visual Studio 2015 and MSDN portfolio.

Getting Visual Studio 2015

Customers who have an active subscription for Visual Studio Premium with MSDN or Visual Studio Ultimate with MSDN will automatically get upgraded to Visual Studio Enterprise with MSDN. And the pricing of Visual Studio Enterprise with MSDN will be significantly less than the current price of Visual Studio Ultimate with MSDN. Check out the Visual Studio 2015 Product Editions for detailed feature and pricing information, including the current promotions ,so you can get the most value out of Visual Studio today.

CTP 6

UI debugging tools for XAML

Are added two new tools—the Live Visual Tree and the Live Property Explorer—that you can use to inspect the visual tree of your running WPF application, as well as the properties on any element in the tree. In short, these tools will allow you to select any element in your running app and show the final, computed and rendered properties. Here’s more:

Live Visual Tree. Now, you can view the full visual tree of a running application during a debug session. The Live Visual Tree is available when you press F5 in Visual Studio or attach to a running application. You can use the Live Visual Tree to select elements in a running application for inspection in the Live Property Explorer. Descendant count is displayed, and if the source information is available, you can instantly find the file and location of the element’s definition.

Live Property Explorer. Use this new tool to inspect the properties set on any element in a running application, grouped by the scope in which they are set. You can modify these properties during a debugging session and immediately see their changes in the running application.

Picking apart how properties override each other and figuring out winning behavior can prove difficult at design time. Now, by using our new UI debugging tools for XAML, you can perform these inspections at runtime, when you can take everything into account.

(Support for Windows Store apps will be released in a future update.)

Single sign-in

You, like many other developers today, take advantage of multiple cloud services when developing your applications. For example, you’ve probably added a cloud backend to your applications to store data, stored your source code in the cloud, or published an application to a store.

In the past, each of these services required a separate sign-in process, and each service managed the signed-in user state separately.

With this release, we are reducing the authentication prompts required to access many integrated cloud services in Visual Studio. Now, when you authenticate to the first cloud service in Visual Studio, we will automatically sign you in, or reduce the authentication prompts for other integrated cloud services.

CodeLens

With CodeLens, you can find out more about your code while staying focused on your work in the editor. In CTP 6, you can now see the history of your C++, SQL, or JavaScript files versioned in Git repositories by using CodeLens file-level indicators. When working with source control in Git and work items in TFS, you can also can get information about the work items associated with C++, SQL, or JavaScript files by using CodeLens file-level work items indicators.

Code Maps

When you want to understand specific dependencies in your code, visualize them by creating Code Maps. You can then navigate these relationships by using the map, which appears next to your code. This helps you track your place in the code while you work.

Performance improvements. With this release, now you can get reactive Code Maps more quickly: drag and drop operations produce an immediate result, and the links between nodes are created much more quickly, without affecting subsequent user-initiated operations such as expanding a node or requesting more nodes. When you create Code Maps without building the solution, all the corner cases—such as when assemblies are not built—are now processed.

Code Map filtering. Now you can quickly unclutter your Code Maps by filtering for nodes and groups. You can show or hide code elements on a map based on their category, as well as group code elements by solution folders, assemblies, namespaces, project folders, and types.

Dependency links. Dependency links no longer represent the inheritance from System.Object, System.ValueType, System.Enum, and System.Delegate, which makes it easier to see external dependencies in your code map.

Improved top-down diagrams. For a medium to large Visual Studio solutions, you can now use a simplified Architecture menu to get a more useful Code Map for your solution. The assemblies of your solution are grouped alongside the solution folders, so you can see them in context and leverage the effort you’ve put in structuring the solution. you’ll immediately see project and assembly references, and then the link types appear. Also, the assemblies external to your solution are grouped in a more compact way.

Improved link filtering. Link filtering now applies to cross group links, which makes working with the filter window less intrusive than it was in previous releases.

Diagnostics Tools

In CTP 6, the Diagnostic Tools debugger window has the following improvements:

Supports 64-bit Windows Store apps

The timeline zooms as necessary so the most recent break event is always visible

Exception Settings

You can configure debugger exception settings by using the Exception Settings tool window. The new window is non-modal and includes improved performance, search, and filter capabilities.

JavaScript Editor

Task List support. You can use the Task List feature to review task comments, such as // TODO, in your JavaScript code. Learn more about the Task List in Visual Studio.

Object literal IntelliSense. The JavaScript editor now provides you with IntelliSense suggestions when passing an object literal to functions documented using JSDoc.

Unit Tests

In Visual Studio 2015 preview, we introduced Smart Unit Tests, which explores your .NET code to generate test data and a suite of unit tests. In CTP 6,are added the following functionality:

Parameterized Unit Tests. Smart Unit Tests enables support for an API that you can use to guide test data generation, specify correctness properties of the code under test, and direct the exploration of the code under test. This API is available in the Microsoft.Pex.Framework namespace and can be used in the test methods (parameterized unit tests, factory methods) generated by Smart Unit Tests. Consequently, the “Smart Unit Tests” context menu command is now available from the generated test methods as well.

Test stubs creation. “Create Unit Tests” is now available on the context menu as a command that provides the ability to create and configure a test project, a test class, and a test stub.

Visual Studio Emulator for Android

In CTP 6, the Visual Studio Emulator for Android now supports the following:

OpenGL ES

Android Version 5.0 (Lollipop, API Level 21)

Camera interaction using image files or your webcam

Multi-touch input

Visual Studio Tools for Apache Cordova

Over the last few releases, we listened to your feedback and broadened the number of devices you can debug to, as follows:

Android 4.4, Android 4.3 and earlier with jsHybugger

iOS 6, 7, and 8

Windows Store 8.1

With CTP6, we are broadening our debugging support further. You can now debug your Apache Cordova apps that target Windows Phone 8.1

You can set breakpoints, inspect variables, use the console, and perform other debugging tasks on your Windows Phone 8.1 emulator or attached device.
Learn more about the Visual Studio Tools for Apache Cordova.

Visual Studio C++ for Cross-Platform Mobile Development

You can use Visual Studio to share, reuse, build, deploy, and debug your cross-platform mobile code, all within a single solution. And in CTP 6, also added or updated the following:

Support for Android API Level 21 (Lollipop).

Improvements to Android Logcat. (Logcat is a diagnostic tool and essential for a good edit->build->debug experience.)
Use Logcat to do the following:

Search for specific log messages by using search bar.

Use Toggle Autoscroll to view upcoming log messages easily.

Clear previous log output messages.

Choose between various log levels.

A new template that is based on make file support for Android, which allows using an external build system (including NDK-BUILD).

Visual C++

Are added the following new features to Visual C++ in CTP 6:

Control Flow Guard (CFG). With this new security feature, simply add a new option to your project, and the Visual C++ compiler will now inject extra security checks into your binaries to help detect attempts to hijack your code. When the check fires, it will stop execution of your code before a hijacker can do damage to your data or PC. Learn more about Control Flow Guard.Note: We have updated the command options. Instead of using the /d2guard4 switch as you did in CTP 5, you should now use /guard:cf in CTP 6.

Typename keyword. Users can now write typename instead of class in a template template parameter. Learn more about typename.

Related releases

CTP 5

XAML Language Service

The XAML language service is rebuild on top of .NET Compiler Platform (“Roslyn”) so that we can provide you with a fast, reliable, and modern XAML editing experience that includes IntelliSense.

This makes the XAML authoring experience equal to other first-class languages in Visual Studio. We’ll also be able to deliver powerful feature sets around cross-language refactoring to you at a much faster cadence.

Timeline Tool

Our new Timeline tool in CTP 5 provides you with a scenario-centric view of the resources that your applications consume, which you can use to inspect, diagnose, and improve the performance of your WPF and Windows Store 8.1 applications.

The Timeline tool, which is in the Performance and Diagnostics hub, shows you how much time your application spends in preparing UI frames and in servicing networks and disk requests, and it does so in the context of scenarios such as Application Load and Page Load.

Diagnostics Tools

Are added a new Diagnostic Tools window in CTP 5 that appears when you start debugging (press F5). The Diagnostics Tools window contains the following features:

Debugger Events (with IntelliTrace)
Debugger Events (with IntelliTrace) gives you access to all Break, Output, and IntelliTrace events collected during your debugging session. The data is presented both as a timeline and as a tabular view. The two views are synchronized and can interact with each other.
Learn more about IntelliTrace in Visual Studio 2015.

Memory Usage
The Memory Usage tool allows you to monitor the memory usage of your app while you are debugging. You can also take and compare detailed snapshots of native and managed memory to analyze the cause of memory growth and memory leaks.

CPU Usage
The CPU Usage tool allows you to monitor the CPU usage of your application while you are debugging.
(This tool replaces the CPU time PerfTip that was available in the Preview release of Visual Studio 2015.)

The Diagnostics Tools window supports the following project types and debugging configurations:

Managed WPF, WinForms, and Console projects

Native Win32, Console, and MFC projects

ASP.NET 4 using IIS express only
(ASP.NET 5 and IIS are not supported at this time)

Managed or Native 32-bit Windows Store projects running locally
(Windows Store projects that are 64-bit, using JavaScript, running on a remote device, or running on a phone are not supported at this time)

We’ve improved our support of client-side task runners (such as Grunt and Gulp) that run alongside the Task Runner Explorer.

For ASP.NET 5 projects, you can select the browser you want while running or debugging a project.

You can define custom commands in project.json file, which you can launch by using the ASP.NET 5 command-line tools. And now, you can also run and debug your custom commands directly in Visual Studio 2015.

Are updated our ASP.NET 5 templates to include a project.json file that uses the latest packages, and fixed some bugs in the template content.

Are two main differences between Visual Studio 2013 Community Edition and the Express Editions

1) Visual Studio Express Editions are targeting specific platforms: Express for Web allows you to develop Web apps; Express for Windows allows you to develop Windows apps; Express for Windows Desktop allows you to develop desktop apps. But with Visual Studio Community Edition, you can develop projects targeting cross-platforms.

2) Visual Studio Express Editions do not allow users to use extensions (aka. plugins). There are over 5000 great plugins for Visual Studio in Visual Studio Gallery. Plugins such as Developer Assistant can boost developers’ productivity. Unfortunately, they are not available to Visual Studio Express users. With Visual Studio Community Edition, you can access and use All !

Visual Studio Community Edition may retire Visual Studio Express Editions in future, but this is not decided yet.

Using Team Foundation Server , Visual Studio, to increase productivity and transparency into your application as well as increase the rate at which you can ship high quality software throughout the application lifecycle.

The Scaled Agile Framework, or SAFe, is popular among organizations looking to scale Agile practices to the enterprise level. SAFe is a comprehensive framework, covering practices from portfolio level planning to release planning to coding practices.

While TFS does not provide full support for all SAFe practices, TFS can be used to implement many of the planning practices. This whitepaper also provides practical guidance on how to implement SAFe practices using TFS. It covers the following topics:

The first two sections are conceptual and provide a quick overview of how TFS supports SAFe.The last two sections are guidance and provide detailed steps for the TFS Administrator to configure and customize TFS to support SAFe.

SAFe supports a portfolio view of multiple agile teams. SAFe illustrates how a portfolio vision is met by a hierarchy of teams, all of whom have their own specific objectives. This framework breaks down Epics into Features and Stories, which teams work on in Sprints and deliver through Program Increments (PIs) and Release Trains. Also, the portfolio backlog can track how deliverables map to Strategic Themes and associated budgets.

The examples in this paper illustrate how to add the Epic WIT and backlog, configure a three-level team hierarchy, and map teams to their respective area and iteration paths. The examples build from the TFS Agile process template. However, the changes can be applied to any TFS process template.

Because TFS supports a hierarchical team structure, each team has its own view of their work which rolls up to the next level within the team hierarchy.

In the section, “Customize TFS process to support SAFe”, details the changes to our Scrum, Agile, and CMMI process templates which enable SAFe support. The goal is not to create a SAFe Process Template, but modify existing process templates to enable SAFe practices. This changes are minimal and don’t encumber teams who choose not to use SAFe.

Now, you have the following options to update the templates to include these changes :

You can download the standard Scrum, Agile, CMMI process templates with changes for SAFe here.

If you have customized process templates, you can follow the instructions in the guidance. Additionally, in this blog post shows how to automate the process with PowerShell.