Microsoft Visual Studio Express Changelog

What's new in Microsoft Visual Studio Express 2017 (15.9.7)

Feb 13, 2019

These are the customer-reported issues addressed in 15.9.7:
Crashes when expanding variables!.
/DEBUG:FASTLINK + C7 + PCH crashes debugger.
Native C++ application crashes because of stack corruption with VS 2017 15.9.2.
Incorrect Release Mode code.
Xamarin Unobserved Task Exception WebRequest.
Link /SOURCELINK option seems to do nothing. This fixes Source Link for Managed C++ Debugging.
Fixed an issue with corruption of AVX/MPX/AVX512 registers while Debugging.
Update of Microsoft.VCLibs.140.00.UWPDestkop framework packages for C++ UWP DesktopBridge applications adding support for ARM64.
Corrected incorrect version of VCToolsRedistVersion in Microsoft.VCToolsVersion.default.props.
Corrected unsigned embedded dll for VC Redist installers.
SSDT/Web Tools: We fixed an issue where SQL LocalDB was not installed on Polish, Turkish, and Czech locales.
SSDT: We fixed an issue affecting SQL Server Aalysis Services (Method not found exception when clicking on UI).
SSDT: We fixed an accessibility issue which was causing the contents of a table not to be visible in the result window when using High-Contrast mode.

New in Microsoft Visual Studio Express 2017 (15.9.6) (Jan 26, 2019)

New in Microsoft Visual Studio Express 2017 (15.9.5) (Jan 9, 2019)

New in Microsoft Visual Studio Express 2017 (15.8.2) (Aug 29, 2018)

New in Microsoft Visual Studio Express 2015 Update 2 CTP (Feb 11, 2016)

VISUAL STUDIO TOOLS FOR APACHE CORDOVA:
This release includes Visual Studio Tools for Apache Cordova Update 5, which brings numerous bug fixes, as well as command-line integration for build and project creation, and support for the iPhone 6s simulator.
VISUAL C++:
C++ Compiler:
In this release, we've updated the C++ compiler and standard library with enhanced support for C++11 and C++14 features, as well as preliminary support for certain features expected to be in the C++17 standard. The most notable compiler changes are support for Variable Templates and Empty Base Class Optimization, in addition to constexpr improvements. With the standard library, we’ve implemented every C++ Standard Library feature that's been voted into C++11, C++14, and C++17 so far.
Additionally, more than 300 compiler bugs have been fixed, including many submitted by customers through Microsoft Connect — thank you! (Some of these bug fixes address code generation issues in the compiler, and fixing them required source-breaking changes. For more information, review the Breaking Changes in Visual C++ 2015 Update 2 list on MSDN.)
C++ IDE:
In Update 1, we introduced a faster database engine for C and C++ that speeds up operations like Go To Definition and Find All References. With Update 2, new Visual Studio installations use this new engine by default; if you’re upgrading from Update 1 to Update 2, note that you’ll continue to use whatever engine you already had selected. In any case, you can select the engine via Tools > Options > Text Editor > C/C++ > Experimental.
C# AND VISUAL BASIC:
While our focus for Update 2 was responding to customer feedback and fixing bugs (including an issue where Visual Studio would stop responding when you edited C# or Visual Basic files while debugging), we also made improvements to the following features:
We seeded the C# Interactive Window with a project context, and added Send To Interactive commands.
We improved the Add Using command to support "fuzzy" matching for misspelled types and to search the entire solution and metadata for the correct type, adding both a using and reference if necessary.
We improved the C# and Visual Basic Analyzer API to achieve better performance, and provide control over whether analyzers run in generated code.
TYPESCRIPT:
Visual Studio 2015 Update 2 includes the 1.8.1 release of TypeScript. This release of TypeScript addresses bug fixes for publishing web applications and improved compiler performance.
APPLICATION INSIGHTS:
This release includes Application Insights Tools for Visual Studio 5.0, which comes with several new features and improvements:
The ability to jump from an exception to the method in source code where the exception is happening.
More ways to search Application Insights in Solution Explorer.
A Toast popup when publishing is complete so you can view your data in production.
TEAM EXPLORER:
With Update 2, opening Team Explorer and browsing work item queries in Visual Studio is faster. Now, when you browse the query tree, Visual Studio progressively pulls the next level of query folders and items in the query hierarchy from the TFS server, so deeper tree levels are downloaded to the client when they are needed (in other words, when the hierarchy tree is expanded).
Git Improvements in Visual Studio:
New Git commands. In this update, we added support for reset (--hard and --mixed), cherry-pick, and staging.
Git LFS. Visual Studio is now compatible with Git repos that are configured to use Git LFS (Large File Storage). Learn more about Git LFS.
The Changes page now supports staging, with simple actions—such as double-click—to stage all and view diffs for changed files.
The History view supports filtering to find commits from a specific author or with keywords found in the commit comments. Selecting a commit will highlight the path to the head of the branch and the parent lineage.
The Branches page now makes it easier to fetch, pull, and push changes.
Gated Checkin for Team Foundation Version Control:
TFVC projects can now set branch policies to require a successful build before any code can be submitted into a branch.
SQL SERVER DATA TOOLS:
Visual Studio 2015 Update 2 includes the latest updates of SQL Server Data Tools, which enable support for the latest features in Azure SQL Database and SQL Server 2016.
This update brings together the ease of developing, testing, and deploying a database on all supported versions of SQL Server and database platforms, both on-premises and cloud, by using Visual Studio. The update also includes database programmability surface area enhancements, and it improves the SQL connection experience in SQL Server Data Tools, which now automatically discovers SQL Server and Azure SQL Databases that you can connect to with a simple click.
Additionally, Visual Studio 2015 Update 2 addresses new Azure SQL Database authentication types, as well as Azure Active Directory Integrated and Password authentications.
OTHER CHANGES:
Performance & Reliability:
We fixed the causes that might stop Visual Studio from responding in the following scenarios:
Using the Help Viewer on Windows 10 when Edge is the default browser.
Running setup when using read-only or disconnected drives.
Working in Visual Studio while experiencing intermittent network connection issues.
Editing C# or Visual Basic files while debugging, as described this MSDN article: Update for Microsoft Visual Studio 2015 (KB3110221).
Using the editor with custom snippets that are missing the or elements.
Updating error list entries for Managed projects during editing.
Keeping Managed projects open for long sessions.
Opening memory profiler snapshots.
Creating C++ Store applications.
Using Visual Studio when a source controlled project path is too long.
We've also made the following improvements:
Significantly reduced log file generation into the %temp% directory to save disk space and prevent application failures.
Improved the reliability of downloading and installing VS Update and additional features.
Reduced the time for Visual Studio to start when extensions are installed.
Stopped Setup failures when downloading certain packages and selecting certain features.
Added support for SQLite in our browsing database engine for C++, thereby significantly speeding up the original parsing of the user code and of all IntelliSense operations that require lookup.
Increased the speed of opening Team Explorer and browsing work item queries in Visual Studio.
FIXED BUGS:
Office Developer Tools for Visual Studio 2015:
Updates for Office Developer Tools now appear in the Notification Hub.
You can now create a document-level VSTO project for Office 2016 without experiencing errors when you use the following VSTO templates:
Excel 2013 and 2016 VSTO template
Excel 2013 and 2016 VSTO workbook
Word 2013 and 2016 VSTO template
Word 2013 and 2016 VSTO document
Visual C++:
In Visual Studio 2015, you may experience a UI delay (typically up to three seconds) when you load a Visual C++ project.

New in Microsoft Visual Studio Express 2015 Update 1 (Dec 1, 2015)

TOOLS FOR APACHE CORDOVA:
Developers using the Tools for Apache Cordova for the first time since RTM will find a richer development platform with support for iOS 9, the groundwork for Android 6 “Marshmallow”, a new plug-in for Azure AD authentication and dozens...even hundreds of bug fixes to improve the developer experience.
We also have a new destination for samples, tutorials and documentation, at http://taco.visualstudio.com. And now, docs are sourced directly from GitHub, making it possible for developers to contribute tips, tricks, and corrections by using a simple pull request.
TOOLS FOR UNIVERSAL WINDOWS APPS:
You can use Tools for Universal Windows Apps (v1.2) to build and submit apps to the Windows Store by targeting Windows 10 SDK Version 1511. Also included in this release are several developer productivity improvements to .NET Native, the XAML designer, the manifest designer, Windows Store packaging, and the debugger.
If you don't already have Tools for Universal Windows Apps installed, you can enable them by modifying the Visual Studio 2015 installation, or by directly installing them.
VISUAL C#:
The C# Interactive Window is back in Visual Studio, as well as the command-line C# REPL window. (The Interactive Window is the REPL window inside Visual Studio.)
We've also released scripting APIs that enable you to build and run C# as a script. The scripting APIs are available on GitHub.
Additionally, we've released csi.exe, which is a tool that you can use to run a C# script file (.csx) from the Developer Command Prompt. For example, simply type csi myScript.csx to run your script file. Or, you can enter the command-line REPL mode to interactively evaluate snippets of C# code. To get to this mode, run the command csi without any arguments from the Developer Command Prompt.
DEBUGGING AND DIAGNOSTICS:
VISUAL C++:
In this release, we've added Edit and Continue support for /BigObj, which means that you can now Edit and Continue to edit code while debugging Windows Store C++ projects.
IDE:
The feature we've all been waiting for is finally here! You can now right-click on an interface or abstract method definition and navigate to its implementation by using the Go To Implementation shortcut.
We've also added a new refactoring that lets you convert get methods to properties by using the Quick Action command, Ctrl + .
Additionally, we've fixed bugs around formatting, unnecessary casting, WinForms integration, crashing when searching for a class in the Solution Explorer, and go to def/MAS with "Use Tabs." And, we've made regions now auto-collapse upon first open.
CODE ANALYSIS. We now support the following scenarios in the IDE for managing the technical debt that comes from code analysis:
View analysis warnings and messages for only 'my code changes.'
Baseline' all current issues and "stay clean" moving forward.
View and manage your baseline to audit suppressions, or to address existing technical debt.
Remove duplicate instances of warnings in the error list to focus results to the unique set.
DIAGNOSTICS TOOLS WINDOW:
We've made several improvements to the Events tab of the Diagnostic Tools window to help you read through and understand its list of events even faster and more efficiently than before.
Here's what's new:
An improved filtering menu that you can customize in the following ways:
By category, by thread, or by using Just My Code.
A new search control that allows you to search all visible columns of the Events table.
New category prefixes that we've added to all events, which makes them easier to read.
PROFILE YOUR CPU USAGE WHILE DEBUGGING:
Now, you can get a detailed per-function profile of your CPU Usage while you are debugging. You can turn CPU Profiling on and off while debugging and view the results when you are in a break state, which allows you to view a per-function breakdown of CPU Usage of code that executed between breakpoints and during steps. (To use this functionality, open the Diagnostic Tools window (Debug -> Diagnostic Tools), switch to the CPU tab, and then click the "CPU Profiling" button.)
.NET FRAMEWORK 4.6.1:
Visual Studio 2015 Update 1 now includes the latest version (4.6.1) of the .NET Framework. The .NET Framework 4.6.1 includes all the features and improvements of .NET 4.6 as well as numerous reliability, stability, security, and performance fixes. These are some of the top features in 4.6.1
Windows Presentation Foundation (WPF) improvements for spell check, support for per-user custom dictionaries and improved touch performance
Cryptography: Enhanced support for Elliptic Curve Digital Signature Algorithm (ECDSA) X509 certificates
ADO.NET: Added support in SQL Connectivity for AlwaysOn and Always Encrypted
Windows Workflow Foundation: System.Transactions APIs now support distributed transactions with a non-MSDTC coordinator
Profiling improvements related to IcorProfilerInfo interface
NGen: Introduction of NGen PDBs
Added support to HttpListener API to enable server applications to use token binding
Many other performance, stability, and reliability related fixes in RyuJIT, GC, WPF, and WCF
ASP.NET:
ASP.NET 5 RC 1:
Bootstrap Toolbox
Bower Package Manager
JSX Editor
Better Colorization of Angular JS HTML attributes
Improved Razor IntelliSense and Tag Helpers
Can open MVC 4 projects
NPM Package IntelliSense (similar to how Bower.json works)
Cleaned up ASP.NET Solution Explorer
ASP.NET 5 Beta 8:
DNX Watcher allows developers who use the command line to experience the same edit and refresh browser experience that Visual Studio developers have been enjoying with ASP.NET 5 applications. DNX Watcher will watch the files in your project and show compilation errors if you have any. And as soon as your code can compile again, it will launch it and you can browse to your app
Localization . Application developers can now develop web applications that can be translated and used by many different cultures. Middleware is capable of setting a culture so that it is accessible through Thread.CurrentCulture, and APIs have been provided to read strings from resource files that can be selected based on current culture
One of the great things about the localization libraries is that the keys for your localized strings are the values in the default culture. So, for example, if you are writing an application in English, you can put English strings as the key names
TYPESCRIPT:
Visual Studio 2015 Update 1 includes features from the 1.6 and 1.7 releases of the TypeScript tools. It brings significant enhancements to TypeScript's type system and enables support for the polymorphic type, intersection types, local type declarations, generic type aliasing, and user-defined type guard functions
It also completes ES6 support in TypeScript by adding ES6 Generators and ES6 Class expressions, and brings support for new ES7 feature proposals like ES7 Exponentiation operator and ES7 Async functions
Additionally, React's JSX is now natively supported by the TypeScript compiler and tooling. This release also enables targeting Node v4's native implementations of ES6 features (--target ES6) while using Node native module system (--module commonjs), apart from an enhanced support for node module path resolution
MISCELLANEOUS:
Parallel Test Execution
Subversion support for build
Pull requests hub in Visual Studio
"Pull request required" work item policy

New in Microsoft Visual Studio Express 2015 Update 1 RC (Oct 30, 2015)

Tools for Apache Cordova:
Developers using the Tools for Apache Cordova for the first time since RTM will find a richer development platform with support for iOS 9, the groundwork for Android 6 “Marshmallow”, a new plug-in for Azure AD authentication and dozens...even hundreds of bug fixes to improve the developer experience.
Tools for Universal Windows Apps:
The Tools for Universal Windows Apps v1.2 includes updates to the following:
NET Native
XAML designer
manifest designer
store packaging
debugger
Visual C++:
In this release, we've added Edit and Continue support for /BigObj, which means that you can now Edit and Continue to edit code while debugging Windows Store C++ projects.
IDE:
The feature we've all been waiting for is finally here! You can now right-click on an interface or abstract method definition and navigate to its implementation by using the Go To Implementation shortcut.
We've also added a new refactoring that lets you convert get methods to properties by using the Quick Action command, Ctrl + .
Additionally, we've fixed bugs around formatting, unnecessary casting, WinForms integration, crashing when searching for a class in the Solution Explorer, and go to def/MAS with "Use Tabs." And, we've made regions now auto-collapse upon first open.
Visual C#:
In this release, the C# Interactive Window is back in Visual Studio, as well as the command-line C# REPL window. (The Interactive Window is the REPL window inside Visual Studio.)
We've also released scripting APIs that enable you to build and run C# as a script. The scripting APIs are available on GitHub.
Additionally, we've released csi.exe, which is a tool that you can use to run a C# script file (.csx) from the Developer Command Prompt. For example, simply type csi myScript.csx to run your script file. Or, you can enter the command-line REPL mode to interactively evaluate snippets of C# code. To get to this mode, run the command csi without any arguments from the Developer Command Prompt.
DEBUGGING AND DIAGNOSTICS:
Profile your CPU Usage while debugging:
Now, you can get a detailed per-function profile of your CPU Usage while you are debugging. You can turn CPU Profiling on and off while debugging and view the results when you are in a break state, which allows you to view a per-function breakdown of CPU Usage of code that executed between breakpoints and during steps. (To use this functionality, open the Diagnostic Tools window (Debug -> Diagnostic Tools), switch to the CPU tab, and then click the "CPU Profiling" button.)
TypeScript:
Visual Studio 2015 Update 1 includes features from the 1.6 and 1.7 releases of the TypeScript tools. It brings significant enhancements to TypeScript's type system and enables support for the polymorphic type, intersection types, local type declarations, generic type aliasing, and user define type guard functions.
It also completes ES6 support in TypeScript by adding ES6 Generators and ES6 Class expressions, and brings support for new ES7 feature proposals like ES7 Exponentiation operator and ES7 Async functions.
Additionally, React's JSX is now natively supported by the TypeScript compiler and tooling. This release also enables targeting Node v4's native implementations of ES6 features (--target ES6) while using Node native module system (--module commonjs), apart from an enhanced support for node module path resolution.
Node.js Tools for Visual Studio:
Node.js Tools for Visual Studio is a free and open-source extension that turns Visual Studio into a powerful Node.js development environment. There are many enhancements in the latest release of Node.js Tools, including:
Support for Node.js v4.x
Support for npm v3.x, which helps work around potential MAX_PATH issues
Faster and clutter-free IntelliSense, including better commit-character defaults, and the ability to opt in to a preview release of the upcoming ES6 IntelliSense engine
Improved stability during debugging, and faster project load times
Code snippet support
MISCELLANEOUS:
Subversion support for build:
You can now build from subversion-based source control repositories, which can enable teams to centralize all build and work item management in TFS without having to move their source code right away.
Pull requests hub in Visual Studio:
Team Explorer now features a new Pull Requests hub where users can see the list of pull requests that they have created, as well as the pull requests that others have assigned to them.
We've also improved the Create Pull Request experience; now, users can publish branches and create pull requests in a single action.
"Pull request required" work item policy:
We now have a branch policy that requires associated work items for any pull request. Like the code reviewer and build policies, any code submitted to the branch must be submitted via pull request. When a pull request is created, the associated commits will be inspected for work item links, and if there is at least one link, the policy will be fulfilled.
Also, you can now link work items to pull requests directly, and if the pull request is directly linked to at least one work item, the policy will be fulfilled. (If no work items are linked to the pull request or the associated commits, the policy will fail.)
FIXED BUGS (Visual Studio IDE):
Go To Definition fails when Keep tabs is selected.
Numerous formatting fixes (notably this issue).
Many false positives when you remove unnecessary cast.
Many Windows Forms integration issues.
Regions now auto-collapse on first open.
Visual Studio 2015 crashes when you search for class in Solution Explorer in a website project.
Wrong tab order in assembly information dialog box.

New in Microsoft Visual Studio Express 2015 14.0.24606.0 CTP Update 1 (Oct 9, 2015)

New in Microsoft Visual Studio Express 2015 14.0.23107.10 RTM (Jul 21, 2015)

Visual Studio Emulator for Android:
New platforms. Jellybean (API 17) and Lollipop 5.1 (API 22) images are available.
Command-line interface. Navigating to %programfiles(x86)%\Microsoft Emulator Manager\1.0\emulatorcmd.exe in a command prompt will allow you to interact with the emulator manager (list, install, start profiles, etc.) without a UI.
Drag-and-drop zip libraries. Dragging and dropping a flashable zip onto the emulator will now automatically unpack and install it.
SD Card tab. This new tab in the "Additional Tools" window allows you to push and pull data to and from the SD Card.
Acquire on its own. The emulator can be installed on a machine without requiring you to install Visual Studio. A shortcut to the Emulator Manager appears in the Start menu so that you can start it and use it from any development tool chain.
Enabling debugging of a Visual C++ Managed Test Project:
New in RTM: To enable debugging of a Visual C++ Managed Test Project, go to the "Tools | Options | Debugging | General" pane, and check the "Suppress JIT optimization on module load (Managed only)" option.
Visual Studio IDE:
Shared Accounts:
New in RTM, you can share the user accounts that you add in Visual Studio with other apps, such as with Blend for Visual Studio or with Microsoft Test Manager (and vice versa).
And now, new in RTM, we've made the following improvements to the Diagnostic Tools window that appears while Debugging:
Events from your app now appear in a single IntelliTrace Events track instead of being split between the IntelliTrace Events and Output Events tracks. Learn more about Debugging using IntelliTrace.
Events from your app now appear while your program is running; now you no longer have to press "Break All" to see events.
You can now activate Historical Debugging for Tracepoints that you have set in your code, allowing you to see the source code and call stack.
You can now see Garbage Collection and Snapshot events on the Memory Usage graph so that you can see when managed garbage collections occurred and when you took snapshots with the Memory Usage tool.

New in Microsoft Visual Studio Express 2015 14.0.22823.1 RC (Apr 30, 2015)

Visual C++ for Cross-Platform Mobile Development:
Now it's easy to share, reuse, build, deploy, and debug all but the most platform-specific code across multiple app platforms, all within a single solution in Visual Studio. Here are just a few of the things you can do:
Create projects from templates for Android Native Activity apps, or for shared code libraries that you can use on multiple platforms and in Xamarin native Android applications.
Use platform-specific IntelliSense to explore APIs and generate correct code for Android or Windows targets.
Configure your build for x86 or ARM native platforms.
Deploy your code to attached Android devices or use Microsoft's performant Android emulator for testing.
Set breakpoints, watch variables, view the stack and step through code in the Visual Studio debugger.
View the message log from an Android device by using the LogCat viewer. (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.
We've also added or updated the following:
Support for Android API Level 21 (Lollipop).
A new template that is based on make file support for Android, which allows using an external build system (including NDK- BUILD).
Precompiled headers in all templates (including Dynamic Shared Library, Static Library, and Cross-platform mobile templates).
Visual Studio Tools for Apache Cordova:
Formerly known as Multi-Device Hybrid Apps for Visual Studio, the Visual Studio Tools for Apache Cordova make it easy to build, debug, and test cross-platform apps that target Android, iOS, Windows, and Windows Phone from one simple Visual Studio project.
All of the features available in previous CTPs are now available in the Visual Studio 2015 RC, including the following improvements:
Update on save for Ripple – no need to rebuild!
Debug an iOS version of your app from Visual Studio when it is deployed to the iOS Simulator or a connected device on a Mac
Improved security and simplified configuration for the included remote iOS build agent
An improved plugin management experience that includes support for adding custom plugins to your project from Git or the filesystem
Select platform-specific configuration options from an improved config.xml designer
Support for Apache Cordova 4.0.0.
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
Then, we broadened 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.
And now, new in RC: CLI interoperability. Cordova projects in Visual Studio will now synchronize with changes made to your project folder on-disk. Changes can flow in and out of Visual Studio whether you’re working with third-party tools or on other operating systems. (The default file structure for Cordova projects is based on the structure expected by the Apache Cordova command-line tools, which makes it easier to work directly with the Apache Cordova CLI or other tools that expect that folder structure.)
Visual Studio Emulator for Android:
You can use the Visual Studio Emulator for Android either in a cross-platform project in Visual Studio (Xamarin or C++), or in Visual Studio Tools for Apache Cordova. The emulator allows you to switch between different platform emulators without Hyper-V conflicts. It supports a wide variety of sensors and simulations, including GPS/Location, accelerometer, screen rotation, zoom, SD card, camera, multi-touch, and network access. It also supports Android versions 4.4 (KitKat, API Level 19) and 5.0 (Lollipop, API Level 21).
And now, new in RC, the Visual Studio Emulator for Android supports both WiFi simulation and the ability to choose from several different device hardware configurations.
Visual Studio Tools for Universal Windows App Development:
The Visual Studio tools for Universal Windows app development are now integrated with Visual Studio setup. These tools enable you to build Windows apps that run across all Windows devices, from Windows Phone to Xbox and Windows Store. In addition, you can also use these tools to build Windows Desktop Applications that leverage Windows 10 APIs. (Note that in this release, Windows 10 is not supported as a targeted platform for production apps.)
To install the development tools for Universal Windows apps, in Visual Studio setup, select Custom, click Next, and then select "Universal Windows App Development Tools".
Also new in RC: You can create, upgrade, build, deploy, and debug Windows apps using HTML and JavaScript. And, there is Support EnC on CoreCLR for Windows 10: You can edit and continue when debugging .NET applications on Windows Phone 10.
Visual C++:
In this release, the C++ compiler and standard library have been updated with enhanced support for C++11 and initial support for certain C++14 features. They also include preliminary support for certain features expected to be in the C++17 standard.
Additionally, more than 500 compiler bugs have been fixed, including many submitted by customers through Microsoft Connect
Language Features:
Terse Range-Based For Loops: The element type specifier can now be omitted from range-based for loops. The terse form for(widget : widgets) {…} is equivalent to the longer C++11 form for(auto&& widget : widgets) {…}. Proposed for C++17 [N3994]
Resumable Functions (resume/await): The resume and await keywords provide language-level support for asynchronous programming and enables resumable functions. Currently, this feature is only available for x64 targets. Proposed for C+ +17 [N3858]
Generic (Polymorphic): Lambda Expressions Lambda function parameter types can now be specified using auto; the compiler interprets auto in this context to mean that the closure's function call operator is a member function template and that each use of auto in the lambda expression corresponds to a distinct template type parameter. C++14
Generalized Lambda: Capture Expressions Also known as init-capture. The result of an arbitrary expression can now be assigned to a variable in the capture clause of a lambda. This enables move-only types to be captured by value and enables a lambda expression to define arbitrary data members in its closure object. C++14
Binary Literals: Binary literals are now supported. Such literals are prefixed with 0B or 0b and consist of only the digits 0 and 1. C++14
Return Type Deduction: The return type of normal functions can now be deduced, including functions with multiple return statements and recursive functions. Such function definitions are preceded by the auto keyword as in function definitions with a trailing return type, but the trailing return type is omitted. C++14
decltype(auto): Type deduction using the auto keyword for initializing expressions strips ref-qualifiers and top-level cv-qualifiers from the expression. decltype(auto) preserves ref- and cv-qualifiers and can now be used anywhere that auto can be used, except to introduce a function with an inferred or trailing return type. C++14
Implicit Generation of Move Special Member Functions: Move constructors and move assignment operators are now implicitly generated when conditions allow, thus bringing the compiler into full conformance with C++11 rvalue references. C+ +11
Inheriting Constructors: A derived class can now specify that it will inherit the constructors of its base class, Base, by including the statement using Base::Base; in its definition. A deriving class can only inherit all the constructors of its base class, there is no way to inherit only specific base constructors. A deriving class cannot inherit from multiple base classes if they have constructors that have an identical signature, nor can the deriving class define a constructor that has an identical signature to any of its inherited constructors. C++11
Alignment Query and Control: The alignment of a variable can be queried by using the alignof() operator and controlled by using the alignas() specifier. alignof() returns the byte boundary on which instances of the type must be allocated; for references it returns the alignment of the referenced type, and for arrays it returns the alignment of the element type. alignas() controls the alignment of a variable; it takes a constant or a type, where a type is shorthand for alignas (alignof(type)). C++11
Extended sizeof: The size of a class or struct member variable can now be determined without an instance of the class or struct by using sizeof(). C++11
constexpr: Partial support for C++11 constexpr. Currently lacks support for aggregate initialization and passing or returning class-literal types. C++11 (partial)
User-Defined Literals (UDLs): Meaningful suffixes can now be appended to numeric and string literals to give them specific semantics. The compiler interprets suffixed literals as calls to the appropriate UDL-operator. C++11
Thread-Safe "Magic" Statics: Static local variables are now initialized in a thread-safe way, eliminating the need for manual synchronization. Only initialization is thread-safe, use of static local variables by multiple threads must still be manually synchronized. The thread-safe statics feature can be disabled by using the /Zc:threadSafeInit- flag to avoid taking a dependency on the CRT. C++11
Thread-Local Storage: Use the thread_local keyword to declare that an independent object should be created for each thread. C++11
noexcept: The noexcept operator can now be used to check whether an expression might throw an exception. The noexcept specifier can now be used to specify that a function does not throw exceptions. C++11
Inline Namespaces: A namespace can now be specified as inline to hoist its contents into the enclosing namespace. Inline namespaces can be used to create versioned libraries that expose their most-recent version by default, while still making previous API versions available explicitly. C++11
Unrestricted Unions: A Union type can now contain types with non-trivial constructors. Constructors for such unions must be defined. C++11
New Character Types and Unicode Literals: Character and string literals in UTF-8, UTF-16, and UTF-32 are now supported and new character types char16_t and char32_t have been introduced. Character literals can be prefixed with u8 (UTF-8), u (UTF-16), or U (UTF-32) as in U'a', while string literals can additionally be prefixed with raw-string equivalents u8R (UTF-8 raw-string), uR (UTF-16 raw-string), or UR (UTF-32 raw-string). Universal character names can be freely used in unicode literals as in u'\u00EF', u8"\u00EF is i", and u"\U000000ef is I". C++11
__func__: The predefined identifier __func__ is implicitly defined as a string that contains the unqualified and unadorned name of the enclosing function.
__restrict: __restrict can now be applied to references.
Typename keyword: Users can now write typename instead of class in a template template parameter.
We've added the following new features to bring the compiler closer to conformance with the standards set in Visual Studio 2012 and Visual Studio 2013:
Digit separators: Now, you can intersperse numerical literals with single quotes to make them more readable. For example, int x = 1’000’000;
Universal character names in literals: You can now write basic characters, like 'A' and the line feed character, as code points in literals. For example, const char *s = “\u0041\u000A”;
Visual C++ Library Features:
User-Defined Literals (UDLs) for Standard Library Types: The , , and headers now provide UDL-operators for your convenience. For example, 123ms means std::chrono::milliseconds(123), "hello"s means std::string("hello"), and 3.14i means std::complex(0.0, 3.14).
Null Forward Iterators: The standard library now allows the creation of forward iterators that do not refer to a container instance. Such iterators are value-initialized and compare equal for a particular container type. Comparing a value-initialized iterator to one that is not value-initialized is undefined. C++14
quoted(): The standard library now supports the quoted() function to make working with quoted string values and I/O easier. With quoted(), an entire quoted string is treated as a single entity (as strings of non-whitespace characters are in I/O streams); in addition, escape sequences are preserved through I/O operations. C++14
Heterogeneous Associative Lookup: The standard library now supports heterogeneous lookup functions for associative containers. Such functions enable lookup by types other than the key_type as long as the type is comparable to key_type. C++14
Compile-Time Integer Sequences: The standard library now supports the integer_sequence type that represents a sequence of integer values that can be evaluated at compile time to make working with parameter packs easier and to simplify certain template programming patterns. C++14
exchange(): The standard library now supports the std::exchange() utility function to assign a new value to an object and returns its old value. For complex types, exchange() avoids copying the old value when a move constructor is available, avoids copying the new value if it’s a temporary or is moved, and accepts any type as the new value taking advantage of any converting assignment operator. C++14
Dual-Range equal(), is_permutation(), mismatch(): The standard library now supports overloads for std::equal(), std::is_permutation(), and std::mismatch() that accept two ranges. These overloads check that the two sequences are the same length, which removes this responsibility from the calling code; for sequences that don't support the requirements of a random iterator, these overloads check the length while comparing elements, which is more efficient. C++14
get(): The standard library now supports the get() template function to allow tuple elements to be addressed by their type. If a tuple contains two or more elements of the same type get() the tuple can't be addressed by that type, but other uniquely-typed elements can still be addressed. C++14
tuple_element_t: The standard library now supports the tuple_element_t type alias which is an alias for typename tuple_element::type. This provides some convenience for template programmers, similar to the other metafunction type aliases in . C++14
File System "V3": Technical Specification The included implementation of the File System Technical Specification has been updated to version 3 of the specification. [N3940]
Minimal Allocators: The standard library now supports the minimal allocator interface throughout; notable fixes include std::function, shared_ptr, allocate_shared(), and basic_string. C++11
: The chrono types high_resolution_clock and steady_clock have been fixed. C++11
Visual C++ Faster Builds:
Incremental Link-Time Code Generation (LTCG): Incremental linking can now be used together with LTCG to decrease link times of applications using LTCG. Activate this feature by using the /LTCG:incremental and /LTCG:incremental_rebuild linker switches. \
Incremental Linking for Static Libraries: Changes to static libraries that are referenced by other code modules now link incrementally.
Debug:FastLink substantially decreases link times by using new PDB creation techniques.
Algorithmic improvements have been made to the linker to decrease link times.
Improvements have been made that will allow building template heavy code faster.
Fast Profile Guided Optimization (PGO) Instrumentation: A new, lightweight instrumentation mode for games and real-time systems has been introduced in PGO. Together with other new features made available through the /GENPROFILE and /FASTGETPROFILE linker switches you can now balance code quality and build speed when using PGO.
Object file size reduction: Compiler and C++ standard library enhancements result in significantly smaller object files and static libraries. These enhancements do not affect the size of dynamically-linked libraries (DLLs) or executables (EXEs) because the redundant code has historically been removed by the linker.
Visual C++ Performance and Code Quality:
Improvements to automatic vectorization. We've improved vectorization of control flow (if-then-else), vectorization when compiling under /O1 (Minimize size), and improved the vector code quality overall, including support for the Parallel STL, vectorizing more range-based for loops, and support for #pragma loop(ivdep)
Improvements to scalar optimization. We've added better code generation of bit-test operations, control flow merging and optimizations (loop-if switching), and other scalar optimizations (for example, better code generation for std::min and std::max)
Profile Guided Optimization (PGO). We've made a number of enhancements to PGO, including improved reference sets, better data layout capabilities, and the ability to reuse previously made inlining, speed vs. size, and layout decisions
Control Flow Guard (CFG). We've added a 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
Visual C++ Productivity, Debugging, and Diagnostics:
We have added refactoring support for C++ with the following features:
Rename Symbol Changes all occurrences of a symbol to a new name.
Function Extraction Move selected code into its own function. This refactoring is available as an extension to Visual Studio on the Visual Studio Gallery.
Implement Pure Virtuals Generates function definitions for pure virtual functions inherited by a class or structure. Multiple and recursive inheritance are supported. Activate this refactoring from the inheriting class definition to implement all inherited pure virtual functions, or from a base class specifier to implement pure virtual functions from that base class only.
Create Declaration or Definition Generates a declaration from an existing definition or a default definition from an existing declaration. Access this refactoring from the existing declaration or definition, or from the LightBulb indicator.
Move Function Definition Moves the body of a function between the source code and header files. Activate this refactoring from the function's signature.
Convert to Raw String Literal Converts a string containing escape sequences into a raw-string literal. Supported escape sequences are \n (new line), \t (tab), \' (single quote), \" (double quote), and \? (question mark). Activate this feature by right-clicking anywhere inside a string.
Program Database (PDB) enhancements in Visual C++ include the following:
Solution Scanning speed has been improved, especially for large solutions
Operations like Go To Definition are no longer blocked during solution scan except during the initial solution scan when a new solution is opened for the first time
Find in Files has been improved by enabling subsequent results to be appended to previous results; accumulated results can be deleted.
IntelliSense Readability Improvements: Complex template instantiations and typedefs are simplified in parameter help and quickinfo to make them easier to read.
Debugger Visualizations in C++:
Add Natvis debugger visualizations to your Visual Studio project for easy management and source control integration. Natvis files added to a project take evaluation precedence over Natvis visualizers outside the project. And now, new in RC, you can use Natvis files while debugging C++ on Android. The debugger includes visualizations for many common templates, and supports loading custom files that are added to the C++ project.
Native Memory Diagnostics:
Memory diagnostic sessions (Alt+F2) enable you to monitor the live memory use of your native application.
Memory snapshots capture a momentary image of your application's heap contents. Differences in heap state can be examined by comparing two memory snapshots. View object types, instance values, and allocation call stacks for each instance after stopping the application.
Improved deadlock detection and recovery when calling C++ functions from the Watch and Immediate windows.
Improved compiler diagnostics The compiler provides enhanced warnings about suspicious code. New warnings have been added (for example, shadowed variables and mismatched printf format-strings). Existing warning messages have been made clearer.
The /Wv flag Warnings introduced after a specific compiler version XX.YY.ZZZZ can be disabled by using the /Wv:XX.YY.ZZZZ flag. Other warnings can be specifically disabled in addition to those specified through the /Wv flag.
Improved Support for Debugging Optimized Code Debug code with the /Zi, /Zo, or /Z7 flags enabled.
Visual C++ Graphics Diagnostics:
Consecutive Capture Capture up to 30 consecutive frames with one capture.
Programmatic Capture Initiate frame capture programmatically. Programmatic capture is especially useful for debugging compute shaders in programs that never call Present, or when a rendering problem is difficult to capture manually but can be predicted programmatically from the state of the app at runtime.
Enhanced Graphics Event List A new Draw Calls view is added which displays captured events and their state in a hierarchy organized by Draw Calls. You can expand draw calls to display the device state that was current at the time of the draw call and you can further expand each kind of state to display the events that set their values.
Support for Windows Phone 8.1 Graphics Diagnostics now fully supports debugging Windows apps in Phone emulator or on tethered Phone.
Graphics Frame Analysis This tool collects performance measurements on captured frames; in addition it also performs a set of pre-defined experiments which provides insights into how performance would be affected when various texture techniques are applied. Frame Analysis also collects performance counters from hardware.
Dedicated UI for Graphics Analysis The new Visual Studio Graphics Analyzer window is a dedicated workspace for analyzing graphics frames.
Shader Edit and Apply View the impact of shader code changes in a captured log without re-running the app.
Configure capture options in Tools->Options->Graphics Diagnostics.
Command-line tool for capturing and playing back frames.
Graphics Diagnostics support for DirectX 12. The Visual Studio Graphics Diagnostics tool now supports debugging rendering problems in DirectX 12 applications.
New GPU Usage tool:
The GPU Usage tool in Visual Studio 2015 can be used to understand GPU usage of DirectX applications. Frame Time, Frame Rate, and GPU Utilization graphs are available while the applications are running live. In addition, by collecting and analyzing detailed GPU usage data, this tool can provide insights into the CPU and GPU execution time of individual DirectX events, and therefore can be useful to determine whether the CPU or GPU is the performance bottleneck.
C# AND VISUAL BASIC:
Language Features:
In this release, several new C# and Visual Basic language features help reduce boilerplate and clutter in everyday code, encourage a more declarative style of programming, and bring the two languages even closer together. For example, there are syntactic improvements to type and member declarations and to null checking. Also, local variables can be declared inside expressions, and await can be used in catch and finally blocks. Many of these features are implemented only for one of the two languages in earlier releases, but will be available to both languages in the final release.
Nameof provides a refactoring-safe way of getting the name of e.g. a parameter, member or type as a string.
Using null-conditional operators, you can get a built-in null check while accessing and invoking members and indexers.
String interpolation: String interpolation provides a concise way of describing string templates that insert expressions into format strings (C# only at Preview, both VB and C# at RTM).
Methods, getter-only properties, etc., can now have a single expression as their body, just like lambdas.
Auto-properties can have initializers and no longer require setters.
Index initializers: Inside an object initializer, you can now initialize a specific index of the new object. C# only.
Exception filters let you look at an exception and decide whether to catch it with a given catch block.
Using clauses for static classes bring their static members directly into scope, so you can call for example WriteLine() or Sqrt() without prefixing with the class name.
Await now works in catch and finally blocks, obviating some very tricky workarounds.
Code Editor UI and Editing:
The code editor UI and editing experiences for C# and Visual Basic have been replaced with new experiences built on the .NET Compiler Platform ("Roslyn"). Many of the features you love today have been improved or revamped.
Light Bulbs are the new home for all quick actions you take in the Visual Studio Editor, including fixes to common code issues and refactoring code. When you have issues in your code, a Light Bulb shows suggested fixes for those issues. All refactoring operations have been moved to the Light Bulb, which you can access any time by typing Ctrl + .
There are two new core refactoring operations: Inline temporary variable and Introduce local. Here’s an example of the new Introduce local feature.
Refactoring support for Visual Basic has been added for the first time, and has also been moved to the Light Bulb.
Renaming has also been improved; now it highlights all the instances of the identifier you want to rename, letting you type the new name to all instances at once directly in the editor.
You can get live code analysis and automatic fixes as you type, with specific code-aware guidance for the Microsoft platforms and NuGet packages that you're targeting. At Preview, you need to add the live FxCop analyzers through a NuGet package you get from the NuGet Gallery, as you would any other package. As you pull in any given live rule, it displaces the equivalent post-build FxCop rule, so you don’t get duplicate hits.
The expression evaluator for C# and Visual Basic has been rewritten. Improvements include support for LINQ and lambda expressions in the Watch and Immediate Windows.
F#:
Language and Runtime Features:
F# 4.0 contains numerous new language and runtime additions which fill in gaps, make more things "just work," and improve performance in key areas. Numerous bugs and small performance optimizations have been implemented across the compiler and runtime, as well.
Constructors as first-class functions - Class names can now be used as first-class function values, representing the constructor(s) for that class.
Unification of 'mutable' and 'ref' - The 'mutable' syntax can now be used everywhere, and captured values will be automatically converted to heap-based 'ref' values by the compiler when needed. A new optional warning has been added in case a developer wishes to be notified when this occurs.
Static parameters to provided methods - Individual methods provided by type providers can now specify static parameters.
Non-nullable provided types - Provided types can now be specified as non-nullable via the standard [].
Implicit quotation of method arguments - Method arguments of type Expr

New in Microsoft Visual Studio Express 2013 12.0.40418.0 Update 5 RC (Apr 30, 2015)

New in Microsoft Visual Studio Express 2013 12.0.40302.0 Update 5 CTP 3 (Mar 10, 2015)

New in Microsoft Visual Studio Express 2013 12.0.40121.0 Update 5 CTP 2 (Jan 27, 2015)

New in Microsoft Visual Studio Express 2013 12.0.31206.0 Update 5 CTP (Dec 19, 2014)

New in Microsoft Visual Studio Express 2013 12.0.31101.0 Update 4 (Nov 14, 2014)

New in Microsoft Visual Studio Express 2012 11.0.50727.42 (Feb 12, 2013)

A new look and feel:
From the moment you open the IDE, you'll notice things are different. The entire interface has been redesigned to streamline workflows and provide easy access to the tools you use every day. Tool bars are simplified, tab clutter reduced, and you now have new, fast ways to find code. All of this should make it easier to navigate your application and work the way you like.
Ready for Win8:
With the release of Windows 8, things have changed dramatically. Visual Studio 2012 delivers new templates, designers, and testing and debugging tools—everything you need to build addictive applications in as little time as possible. At the same time, Blend for Visual Studio gives you a visual toolkit for taking full advantage of the new (and beautiful) Windows 8 interface.
But maybe the best part of all is what you can do after you've created your application. In the old days, it wasn't always easy to get great products in front of the customers who needed them. Now you have the Windows Store, a widely available distribution channel that can reach millions of users. The terms are transparent and the potential easy to see. So you can code, sell, and maybe spend the next few years on the beach.
Web dev upgraded:
When it comes to web development, Visual Studio 2012 also has you covered with new templates, better publishing tools, and full support for emerging standards, like HTML5 and CSS3, as well as the latest advances in ASP.NET. We've also made it easier to debug with the Page Inspector by interacting with the page you're coding, right in the IDE. Going mobile? With ASP.NET you can now create applications with controls that optimize for phones, tablets, and other small screens.
Cloud capable:
In the old days, everyone had to maintain a server. Scaling required major investment in infrastructure. Now you have fast access to virtually unlimited servers in the cloud with the ability to add more storage and computing power on the fly. Visual Studio gives you great tools for taking your apps to Windows Azure, including new templates and publishing options, support for distributed caching, and a lower install footprint.
Up for serious business:
You'll also find major improvements for SharePoint, including new designers, templates, and deployment options. You can take advantage of upgraded ALM features for SharePoint like performance profiling, unit testing, and IntelliTrace. But the pleasantest surprise of all might be LightSwitch, which enables anyone to create line of business applications without having to write a lot of code.
Flexible agile processes, solid ALM:
Ok, so far we've focused mainly on development. But as applications grow more complex, you also need tools that help your team work faster and smarter. That's why we've included a flexible approach to agile. With Visual Studio and Team Foundation Server, you can adopt more productive practices at your own pace, without disrupting existing workflows. We've also invited your entire organization to the party, with new ways to track requirements and feedback from stakeholders, customers, and business team members.
You can even outsource your ALM efforts to us. With Team Foundation Service, you get ALM without the infrastructure. That way, even the smallest teams can then benefit from revision control, code reviews, and agile planning tools.