The Visual Studio logo with a picture of Bit the Raccoon on the right.

As we like to change edition names and move functionality around from time to time, here’s a concise summary of the differences between Visual Studio 2015 Enterprise and Visual Studio 2015 Professional.

[Looking for a version of this article that reflects what’s new in Visual Studio 2017? You can find that here!]

As we like to change edition names and move functionality around from time to time I thought it might be useful to try and concisely summarise the differences between Visual Studio 2015 Enterprise and Visual Studio 2015 Professional.

By way of background, the 2015 release made some changes to the Visual Studio IDE line-up, replacing both the Premium and Ultimate editions with the new Enterprise edition. That means that a lot of people who had Premium are now entitled to Enterprise, and so as well as looking at the reasons you might choose Enterprise, this should also help answer the question of “now I’ve got Enterprise as an upgrade, what’s in it?”.



IntelliTest is a brand new capability for 2015 that analyses your source code and then creates unit tests to achieve 100% code coverage for each path through that code.

That means that you can get a lot more of your code covered by unit tests for less effort, helping you to add unit tests to code that doesn’t have any, and making it easy to keep on top of creating unit tests for new code. It doesn’t mean that you’ll never write a unit test again, but I’d consider this a means of getting the core unit tests generated for you, allowing you to concentrate on specific tests and scenarios based on your domain knowledge.

You can tailor it to allow exceptions, override object creation and much more.

It will work with MS Test, NUnit, xUnit and any other testing framework that provides an adapter for use in Visual Studio. It is currently limited to C#.

Here’s a 35 min video walking through IntelliTest.



IntelliTrace is a historical or post-mortem debugging technology that helps to address the “I can’t reproduce it” problems, typically across dev and test environments. It was introduced in 2010 so it’s not new, and it can be used across dev, test and production environments.

A simple example of its use is:

A tester finds a bug in the test environment. The tester reproduces the bug with IntelliTrace collection enabled, and the bug raised then includes the IntelliTest log file. That log file includes the calls and events from the test environment.

The developer opens the bug and the IntellITrace log file in Visual Studio Enterprise, and can view the exceptions raised, and for each of those exceptions see the stack trace. The developer can choose to debug any of those exceptions, in which case Visual Studio will go into debug mode with the execution halted at the line of code that threw the chosen exception. The developer can then step both forward and backwards through the source code to understand what happened.

Key advantage – the developer doesn’t need to work out how to reproduce the conditions to replicate the bug in order to then start understanding how to fix it. IntelliTrace allows the developer to debug as if attached for debug, even though this takes place later and on a different environment. For a problem where it’s environment based (e.g. can be reproduced in test but not in dev) this can save a lot of time.

This requires .NET 2.0 or higher C# or VB.NET and works in ASP.NET, Microsoft Azure, Windows Forms, WCF, WPF, Windows Workflow, SharePoint and 64-bit apps. You don’t need Enterprise to collect IntelliTrace data, but you do need Enterprise to use it.

There’s a lot more to it. Here’s the MSDN documentation and a 12 min overview video.


Architecture Tools

Enterprise includes the architecture tools and these really fall into 2 camps; UML and non-UML tools.

The UML tools provide support for a range of diagram types such as Class, Sequence, Activity, Use Case and Component diagrams, and allows both forward and reverse engineering.

The non-UML tools are Code Maps and Layer Diagrams. These differ from the UML tools in being fundamentally related to the underlying source code. Code Maps allows you to understand and explore your source code visually.

An example of a Code Map in Visual Studio

Why is that useful? It allows you to build your understanding of the relationships between different aspects of your code without needing to read the source. Code Maps allows you to drill from assemblies down to namespaces, classes, methods and down to the underlying source, as well as filter out those elements you’re not interested in, such as test code or system assemblies.

You can add your own annotations and groupings, rearrange the diagrams and share them with others, via email, saved as diagrams or directly within Visual Studio. A Professional user can view CodeMaps but not author them.

This is useful for people that are new to a project, or when you’re going to be making changes to code that you aren’t familiar with or perhaps can’t remember.

One often overlooked capability is that you can also debug using Code Maps and this can really help in not having to keep track in your head of where you are in the code base whilst debugging.

An example of debugging a Code Map

Code Maps work for .NET and C/C++. For a demo, here’s a 9 min overview video and some more documentation.


Release Management

Would you like to continuously deploy your code to multiple heterogeneous environments, with whatever mix of automated and human approval you require, and carry out any activities in each of those environments (provisioning, deployment, testing etc.)?

That’s what the new release management tooling provides in Visual Studio 2015. Release management forms a core part of the Visual Studio DevOps support, providing continuous deployment support, and complementing the new build system, sharing the same cross-platform agents.

The process new releases of Visual Studio move through

Enterprise is required to create and edit the release definitions, defining the environments, the deployment steps required, approvals and more. Here’s an introduction as well as a 2 min high-level overview video, or this 30 min video for more depth.


Testing Tools

To summarise simply, you get all the testing tools in Enterprise. In other words:

  • Test case management
  • Manual testing
  • Exploratory testing
  • Automated functional testing
  • Load and performance testing

The first three of these are included as Microsoft Test Professional is a part of the Enterprise edition. I won’t cover that now, but you can find out more here. What’s unique to Enterprise are automated functional testing and load and performance testing.

The Visual Studio automated functional testing tool is Coded UI. As the name suggests, this creates automated tests (i.e. including automated verification) and records them as code – either C# or VB.NET. You can record them as you perform actions, or create tests by reusing test methods at a code level. You can also promote manual tests to create the automated test and then add verifications.

A screenshot of the Coded UI Test Builder

Coded UI allows you to build regression suites that drive the UI of the application under test (web and thick clients), and to run those regression tests remotely, such as on a test environment and even as part of the release management capability discussed above. Note that executing a CodedUI test remotely doesn’t require Enterprise edition, so other users can run them. For more info on CodedUI here are the docs.

Load and Performance Testing has been around for a long time in Visual Studio, and has evolved over the years. The core capabilities are the same; create a scenario that tests performance using a certain number of virtual users running a set of tests over a given time. You can factor in network conditions (e.g. 10% of the users are on a very poor network connection, what’s their experience?) and collect system performance counter information (CPU, memory, disk I/O and much more):

A screenshot of Load and Performance Testing

Here’s a walkthrough of creating and running a load test.

The latest changes have included the ability to choose to use Azure to generate the load i.e. you don’t need to find the hardware and set up the test rig. That’s without making any changes to the load test, as it’s just a radio button for choosing between the cloud and on-premise. Using the cloud means you can also choose where the load is coming from using the Azure data centres:

Choosing a region for Azure data centres.

Here are some more details on cloud load testing, as well as a 10 min video.



Last but not least are the extra benefits (over Professional) that you get from Enterprise in MSDN. I’d highlight:

  • More Azure credit (£95 per month vs £35 pre month for Professional) so you can use more Azure services for free each month, such as running virtual machines.
  • eDevTech’s modern requirements management partner products
  • Office 365 developer subscription
  • Dev and Test downloads for SharePoint, Exchange, Dynamics, Office production use and PowerBI.
  • 45 Pluralsight courses vs 30 for Professional
  • 2 collections of 10 courses of Microsoft e-learning (1 in Professional)
  • 4 support incidents (vs 2)

You can find even more details on this in the MSDN comparison matrix.

Hopefully this gives you a flavour of the differences, and if you’re in the position of either deciding which edition to get, or having become entitled to Enterprise from an upgrade, then you’ll have a better idea of the key additional capabilities.