Visual Studio 2015 Preview ~ dev

Visual Studio 2015 Preview adds significant value including cross-platform development in C++, the new open-source .NET compiler platform, C++ 11 and C++ 14 support, Apache Cordova tooling, and ASP.NET 5.

Download Visual Studio 2015 preview

This update showcases the new functionality and significant technology improvements of Visual Studio 2015:

Download Visual Studio 2015 preview

What's in Visual Studio 2015 Preview

Visual Studio:

Other changes:

Bug Fixes & Known Issues

In addition, several Visual Studio 2015 Preview products are available for download, including the following:

To get more details on these releases, see the Related Releases section below.

Connect with the Microsoft engineering teams

Dive deeper into the technical details behind Visual Studio 2015 Preview and more with over 50 on-demand technical sessions at Connect().

Visual C++ for Cross-Platform Mobile Development

You can use Visual Studio to share, reuse, build, deploy, and debug your cross-platform mobile code. 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. The LogCat viewer displays the message log from an Android device. Share all but the most platform-specific code across multiple app platforms, and build them all with a single solution in Visual Studio.

Visual Studio Tools for Apache Cordova

Formerly known as Multi-Device Hybrid Apps for Visual Studio, 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. Learn more here.

All of the features available in CTP3 are now available in the Visual Studio 2015 Preview, including the following improvements over CTP2:

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.

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 GPS/Location, accelerometer, screen rotation, zoom, SD card, and network access. Learn more about the Visual Studio Emulator for Android.

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 400 compiler bugs have been fixed, including 179 bugs submitted by Visual Studio users throughMicrosoft Connect — thank you!

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.

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

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.

Performance and Code Quality

Improvements to automatic vectorization Now includes vectorization of control flow (if-then-else), vectorization when compiling under /O1 (Minimize size), and improvements to overall vector code quality, including support for the Parallel STL, vectorizing more range-based for loops, and support for #pragma loop(ivdep).
Improvements to scalar optimization 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) A number of enhancements have been made to PGO, including improved reference sets, better data layout capabilities, and the ability to reuse previously made inlining, speed vs. size, and layout decisions.

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 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

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. For more information, see Create custom views of native objects in the debugger.

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.

Graphics Diagnostics

Graphics Diagnostics has been improved with the following features:

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 Phone 8.1 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.

New GPU Usage tool

The GPU Usage tool in Visual Studio 2015 Preview 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 Preview, 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:

And an example of Inline temporary variable:
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. You can find the NuGet packages at .NET Compiler Platform SDK Templates and Roslyn Syntax Visualizer.

Here is an example from the Code Analysis for Azure package.
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.

.NET Framework 4.6

The newest version of the .NET Framework is 4.6. In Preview, the version number still appears in some places as 4.5.3. It will be updated to 4.6 before the final version ships.

Base class library changes

We have added many new APIs to enable key scenarios, particularly cross platform scenarios. They include the following changes and additions:

New cryptography APIs such as AsymmetricAlgorithm.KeyExchangeAlgorithm, AsymmetricAlgorithm.SignatureAlgorithm, and System.Security.Cryptography.X509Certificates.X509Certificate.
Additional collections implement System.Collections.ObjectModel.ReadOnlyCollection, including System.Collections.Generic.Queue and System.Collections.Generic.Stack.
Additional members to support the task-based asynchronous pattern (TAP), including Task.CompletedTask and NamedPipeClientStream.ConnectAsync.

Support for code page encodings

.NET Core primarily supports Unicode encodings, and by default it provides limited support for code page encodings. You can add support for code page encodings that are available in the .NET Framework but unsupported in .NET Core by registering code page encodings with the Encoding.RegisterProvider method. For more information, see CodePagesEncodingProvider.

Improvements to event tracing

An EventSource object can now be constructed directly, and you can call one of the Write() methods to emit a self-describing event.

Resizing in Windows Forms controls

This feature has been expanded to include the System.Windows.Forms.DomainUpDown, System.Windows.Forms.NumericUpDown, System.Windows.Forms.DataGridViewComboBoxColumn, System.Windows.Forms.DataGridViewColumn and System.Windows.Forms.ToolStripSplitButton types.
This is an opt-in feature. To enable it, set the EnableWindowsFormsHighDpiAutoResizing element to true in the application configuration (app.config) file.

64-bit JIT compiler for managed code

This release includes a new version of the 64-bit JIT Compiler, which provides significant performance improvements over the legacy 64bit JIT Compiler. While we have tried to make the transition to the new Compiler as transparent as possible, you may see changes in behavior.

Support for converting DateTime to or from Unix time

New methods have been added to support converting DateTime to or from Unix time. The following APIs have been added to DateTimeOffset:

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long ToUnixTimeSeconds()
long ToUnixTimeMilliseconds()

ASP.NET Model Binding supports Task returning methods

ASP.NET Model Binding methods that were previously Task returning were not supported and threw an exception at runtime if configured. If applications are deployed with such methods, these methods will now be executed correctly. This change applies only to applications specifically targeting .NET 4.6 or later.

Channel support for managed EventSource instrumentation

In this release, managed developers can re-use their existing managed EventSource instrumentation in order to log significant administrative or operational messages to the event log, in addition to any existing ETW sessions created on the machine. It includes APIs that specify a destination channel for ETW event methods defined on custom event sources, take the channel into account when testing whether an event will be logged, and support static ETW manifest registration, which is required for channel support.

Assembly loader improvements

The assembly loader now uses memory more efficiently by unloading IL assemblies after a corresponding NGEN image is loaded. This change decreases virtual memory, which is particularly beneficial for large 32-bit apps (such as Visual Studio), and also saves physical memory.

Entity Framework

This release includes a preview version of Entity Framework 7 and an update of Entity Framework 6 that primarily includes bug fixes and community contributions. For more information, see Visual Studio 2015 Preview and Entity Framework.

Entity Framework 7

The new version of Entity Framework enables new platforms and new data stores. Windows Phone, Windows Store, ASP.NET 5, and traditional desktop application can now use Entity Framework. This version of the framework supports relational databases as well as non-relational data stores such as Azure Table Storage and Redis. It includes an early preview of the EF7 runtime that is installed in new ASP.NET 5 projects. For more information on EF7, see What is EF7 all about.

Entity Framework 6.x

This release includes the EF6.1.2-beta1 version of the runtime and tooling. EF6.1.2 includes bug fixes and community contributions; you can see a list of the changes included in EF6.1.2 on our Entity Framework CodePlex site.

The Entity Framework 6.1.1 runtime is included in a number of places in this release.

The runtime will be installed if you create a new model using the Entity Framework Tools in a project that does not already have the EF runtime installed.
The runtime is pre-installed in new ASP.NET projects, depending on the project template you select.

Visual Studio IDE

Shared Projects

In this release, new templates are available to create empty shared projects for Visual Basic, C#, and JavaScript. These shared projects can now be referenced by several project types:

Any un-flavored VB/C# projects (e.g. console apps, class libraries, Win form app)
Windows Store 8.1 and Windows Phone 8.1 (VB/C#/JavaScript)
Windows Phone Silverlight 8.0/8.1 (VB/C#)
WPF and PCL

You can add/remove references to shared projects via the Reference Manager, on the Shared Projects tab. The shared project reference shows up under the References node in the Solution Explorer, but the code and assets in the shared project are treated as if they were files linked into the main project.

Code Editor (All Languages)

Touch support is now available in the Visual Studio editor for the following gestures:

Scrolling (tapping-and-dragging on the editor surface on the regular and enhanced scrollbars)
Pinch-to-Zoom
Select a whole line by tapping in the editor margin, and select words by double-tapping them
Invoking the editor context menu by pressing-and-holding

We are aware of one issue with touch, in that the double-tap gesture is not always reliable at lower zoom levels. We would like to hear feedback on the new touch support, and in particular any issues you may find.

XAML Designer

Visual Studio customers will now be able edit their Templates and Styles stored in external resource dictionaries within the context of their usage. This experience has been further refined to use Peek to enable a true in-situ resource editing in the XAML designer.

Custom Window Layouts

You can now save custom window layouts by clicking Save Window Layout from the Window menu, and apply a custom layout by clicking Apply Window Layout from the Window menu. You can also apply a layout by using the pre-assigned keyboard shortcuts. The first nine layouts also have keyboard shortcuts from Ctrl+Alt+1 to Ctrl+Alt+9. Other tasks you can perform include deleting, renaming, and reordering layouts by clicking Manage Window Layout from the Window menu.

JSDoc Support

Documentation comments written using the JSDoc format are now understood by the editor and shown when using IntelliSense. For an intro to JSDoc comments, go here.

High-Resolution Icons

Visual Studio supports high resolution icons in command bars, tool window toolbars (standard), the main menus, error list, status bar, and some Solution Explorer project types when your device is running at greater than 100% DPI scaling.

UI Improvements

Menus now appear in Title Case style instead of ALL CAPS style.
The Configuration and Platform dropdown values for the Visual C++ Property Page dialog have been changed to remember the last user selection when the property page is closed and reopened.

Visual Studio Feedback

The Send a Frown experience has been enhanced with better tools to report slowness, hangs, and crashes. You can now attach files or tag your feedback, to better describe the issue as well. Furthermore, the Feedback icons and menu items have been updated to improve discoverability.

Visual Studio Extensibility

You can now use high-resolution icons In your Visual Studio extensions.
Add-ins are no longer supported in this release. Visual Studio add-in project templates and the Add-in Manager have been removed. You should convert your add-ins to VSPackage extensions. For more information, see FAQ: Converting Add-ins to VSPackage Extensions.

Blend

In this release Blend has been redesigned, and it is now more than ever the preferred tool for creating beautiful user interfaces for XAML apps. Blend has many new features, including:

A sleek new look resembling Visual Studio that improves the workflow between the two products
A new Blend-exclusive Dark theme that improve the contrast between your content and the Blend user interface
XAML IntelliSense
Basic debugging capabilities
Peek in XAML, which allows you to view and edit XAML controls and resources within the context in which they are used
An improved file reload experience to minimize workflow interruptions as you work on your projects in both Blend and Visual Studio
Custom window layouts that can be synchronized across machines that have Blend installed
Better Solution Explorer and source control support
Support for NuGet
Better accessibility in several areas of the Blend user interface, including top level menus, Solution Explorer, and Team Explorer

Debugging and Diagnostics

Breakpoint Configuration

The new Breakpoint Settings window allows you to specify conditions and actions for your breakpoints. The window includes improved IntelliSense support for breakpoint conditions and actions. You can use undo (CTRL+Z) to restore deleted breakpoints. For more information, see New Breakpoint Configuration Experience.

Lambda Expressions in Debugger Windows

You can now use lambda expressions in the Watch, Immediate, and other debugger windows in C# and Visual Basic.

PerfTips

You can use the PerfTips feature to see how long code took to execute directly in the editor when code execution exceeds a specified threshold. For more information, see Dev 14 PerfTips: Performance Information at-a-glance while Debugging with Visual Studio.

GPU Usage

The GPU Usage tool 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 each individual DirectX event, and therefore can be useful to determine whether the CPU or GPU is the performance bottleneck.

Improvements in the C++ Debugger

When the C++ debugger is stopped at breakpoints, it can execute code in order to compute results, such as to show you data in the Watch and Immediate windows. If the debugger detects that a called function is deadlocked, it will attempt to resolve the issue.

When a C++ debugger launches a process, Windows now allocates memory using the normal heap rather than the debug normal heap. This results in a faster start for debugging. For more information, see C++ Debugging Improvements in Visual Studio "14".

ASP.NET

ASP.NET 5 Preview runtime

This release of Visual Studio supports creating and developing ASP.NET 5 Preview applications. ASP.NET 5 Preview is a lean and composable .NET stack for building modern web applications for both cloud and on-premises servers. It includes the following features:

ASP.NET MVC and Web API have been unified into a single programming model.
A no-compile developer experience.
Environment-based configuration for a seamless transition to the cloud.
Dependency injection out-of-the-box.
NuGet everything, even the runtime itself.
Run in IIS, or self-hosted in your own process.
All open source through the .NET Foundation, and takes contributions in GitHub.
ASP.NET 5 runs on Windows with the .NET Framework or .NET Core.
.NET Core is a new cloud optimized runtime that supports true side-by-side versioning.
ASP.NET 5 runs on OS X and Linux with the Mono runtime.

Visual Studio 2015 Preview includes Beta1 runtime packages for ASP.NET 5. You can find all the details on the specific enhancements added and issues fixed in the published release notes on GitHub.

ASP.NET 5 Preview tooling features

Templates

The new project templates ASP.NET 5 Class Library and ASP.NET 5 Console Application are added to the New Project dialog under Visual C#/Web.
ASP.NET 5 templates use the new ASP.NET 5 project structure, which contains the project.json configuration file and the “.kproj” project file.
ASP.NET 5 project templates support modern project layout. They create a project folder under \src. The ASP.NET 5 web project template also puts static contents under the wwwroot folder that is determined by the webroot element of project.json.
The ASP.NET 5 Starter Web template now contains bower.json to use with Bower to get frontend packages, package.json to use with NPM to get Grunt, and gruntfile.js to manage tasks defined by project.json scripts.
The ASP.NET 5 Starter Web”template’s project.json contains postrestore and prepare scripts to use npm, grunt and bower to install necessary packages to the project during build. It also uses the packExclude element to define the folders and files that should be excluded during “KPM pack”.
The ASP.NET 5 Application template contains target frameworks as aspnet50 and aspnetcore50.
The ASP.NET 5 web template uses Xunit as test framework if a unit test project is to be created at the same time.
ASP.NET 5 project templates put a global.json file on the same level as the solution file, to provide support for project-to-project references.
The ASP.NET 5 Starter Web template uses Entity Framework 7.0.0-beta1’s code first migration.

Projects and Builds

The ASP.NET 5 project uses the .kproj file as visual studio’s project file. The .kproj file doesn’t include any file from the current and sub directories, because Visual Studio automatically include and monitor the ASP.NET 5 project directory files.
Visual Studio uses project.json file for reference and package dependencies, version definitions, framework configurations, compile options, build events, package creation Meta data, and run commands.
The Solution Explorer for ASP.NET 5 Web Applications has a Dependencies node showing Bower and NPM dependencies. The bower dependencies are from bower.json in the project folder. The NPM dependencies are from package.json in the project folder.
Under Dependencies Bower and NPM’s package nodes, you can uninstall a package through context menu command, which will automatically change the corresponding JSON file.
The References node in the Solution Explorer for a ASP.NET 5 Web Application displays all the frameworks that are defined in the project.json file.
The property page for an ASP.NET 5 Application is a tool window and can be used to specify the KRE target version, and whether binaries and NuGet packages should be created during a Visual Studio build.
Visual Studio uses the Roslyn engine to compile ASP.NET 5 projects at design time. Therefore the project has already been compiled when you issue a build request. In Visual Studio 2015 Preview, Visual Studio simply passes the design time compiler output to the build request. This avoids another build and improves performance when you build, run, or debug ASP.NET 5 projects.
Visual Studio supports the NuGet Package Manager and console for ASP.NET 5 projects.
Visual Studio supports running and debugging for ASP.NET 5 Xunit tests through test explorer.
Task Runner Explorer is integrated to Visual Studio, which can be enabled by select “gruntfile.js” file’s context menu item “Task Runner Explorer”, or using the Visual Studio menu item View->Other Windows->Task Runner Explorer.\

IntelliSense and Error list

The IntelliSense displayed in the code editor is a combination of the IntelliSense for all frameworks. An IntelliSense item that exists in one framework but not in the other will be listed in IntelliSense with a warning sign. The IntelliSense tooltip indicates which framework supports it and which framework doesn’t.
Build errors shows which target framework the error is from.

Nuget Package Manager

The Nuget Package Manager has been rewritten as a tool window and shows separate data per project and solution. Each project can open a NuGet Package Manager window at the same time. This change applies to all projects that use Nuget Package Manager.

ASP.NET tooling

JSON Editor Improvements

We have made some improvements in JSON editor, including performance improvements such as loading JSON schema asynchronously, caching of the child schemas, and supporting better IntelliSense. Additionally, there are the following new features:

JSON Schema validation. Add JSON schema validation feature, based on the schema that is defined in the schema drop-down list.
Un-minify context menu. You can right-click the JSON editor and select Un-minify context menu to un-minify any long arrays in the JSON file.
Reload Schemas context menu. Visual Studio will cache the schema that is downloaded from Internet and will use the cache even after you restart Visual Studio. If you know the schema is changed, you can use the context menu Reload Schemas Ctrl+Shift+J to re-download the current used schema in the active JSON document, and then use it immediately on the current document.
Intellisense for package.json/bower.json. In addition to proving IntelliSense and validation for both package.json and bower.json files, Visual Studio also provides live IntelliSense for both Bower and npm packages directly within the JSON editor.
Duplicate property validation. The JSON editor will now provide validation for any duplicate properties. This helps catch a common problem with JSON file authoring.

HTML Editor Improvements

The HTML editor has been improved updated IntelliSense for web standards and introduced the following new features:

Better client template formatting. The HTML editor no longer parses or formats double-curly syntax {{…}}. This is to make sure that the content of that syntax is not treated as being HTML and therefore being invalidated, nor does it try to format the content, which cannot be done correctly by using the HTML formatter. This is great for Angular, Handlebars, Mustache, and other double-curly template syntaxes.
Support for custom elements, polymer-elements and attributes. The HTML Editor no longer validates unknown attributes for custom elements, because different frameworks have many custom tags. There will no longer be squiggles under the unknown elements.
Basic IntelliSense for Web Components. The HTML Editor has IntelliSense for that is part of the Web Components standard.
HTML element tooltips. Tooltips are supplied for HTML elements in the editor.
#region support. The HTML editor now supports region folding. You can use the surrounding snippet to surround the current selection as well.
Todo/Hack comment support in the Task List.
Angular icons. Both Angular directives (ex. ) and attributes (ex. ng-controller) is now shows in Intellisense with an Angular logo to make it easy to identify them.
Bootstrap icons. The Intellisense provided in HTML class attributes are now shows with the Bootstrap logo if the class name was defined by the Bootstrap CSS file.

CSS/LESS/Sass Editor Improvements

Todo/Hack comment support in the Task List.
@viewport fix for the LESS edito.r In the LESS editor, @viewport no longer shows verification warnings.
Provide many more snippets. The CSS/LESS/Sass editor now provides more snippets to make your developing experience easier.

Browser Link

CSS is automatically synchronized. Saving the CSS file or changing it externally (for example, by using a LESS/SASS compiler) causes the entire CSS file to reload in the browser. If the file cannot auto-sync, Ctrl + S causes an automatic reload, which should put it back into a good state without having to refresh the linked browsers (Ctrl + Alt + Enter). The feature can be disabled in the toolbar.

WebJobs Tooling

You can now control web jobs on the Server Explorer WebJob node inside an Azure Website in the following ways:

WebJobs nodes underneath Website nodes in Server Explore.
Start/Stop Continuous WebJobs from Server Explorer.
Run On-demand or Scheduled jobs from Server Explorer.
View WebJob Dashboard from Server Explorer.
You can use View Dashboard context menu to go to the Azure website’s WebJob dash board.

WebJobs SDK

The WebJobs SDK is pre-installed in the Azure WebJob project templates.

ASP.NET runtime updates

Microsoft ASP.NET and Web ASP.NET MVC 5.2.2

Template packages are updated to use ASP.NET MVC 5.2.2. This release does not have any new features or bug fixes in MVC. We made a change in Web Pages for a significant performance improvement, and have subsequently updated all other dependent packages we own to depend on this new version of Web Pages.

ASP.NET Web API 5.2.2

In this release we have made a dependency change for Json.Net 6.0.4. For more information on what is new in this release of Json.NET, see   Json.NET 6.0 Release 4 - JSON Merge, Dependency Injection. This release does not have any other new features or bug fixes in Web API. We have subsequently updated all other dependent packages we own to depend on this new version of Web API.

ASP.NET Web API OData 5.3.1 beta

See What's New in ASP.NET Web API OData 5.3 for the Web API OData 5.3 and 5.3.1 beta.

SignalR 2.1.2

Template packages are updated to use SignalR 2.1.2. See the SignalR release note on GitHub.

Microsoft Owin 3.0 package

Template packages are updated to use Microsoft Owin 3.0 NuGet packages. See this Katana 3.0 release note.

NuGet 2.8.3

Support for DevExtreme project and BizTalkProject are added to 2.8.3. Check the NuGet 2.8.3 release notes for detailed information.

TypeScript

Visual Studio 2015 Preview also includes TypeScript 1.3 - the latest release of the TypeScript tools. This release adds protected member access and tuple types, allowing for more natural object-oriented patterns and more precise array types. TypeScript now uses the .NET Compiler Platform ("Roslyn"), the powerful language service behind C# and VB. With Roslyn come many new editing features including Peek, improved colorization, more accurate rename, and better support for functional programming. Learn more about the TypeScript tools.

Unit Tests

With Visual Studio 2015 preview, we have introduced Smart Unit Tests. Explore your .NET code to generate test data and a suite of unit tests. For every statement in the code, a test input is generated that will execute that statement. A case analysis is performed for every conditional branch in the code. For example, if statements, assertions, and all operations that can throw exceptions are analyzed. This analysis is used to generate test data for a parameterized unit test for each of your methods, creating unit tests with maximum code coverage. Then you bring your domain knowledge to improve these unit tests.

Learn more about Smart Unit Tests.

Application Insights

Visual Studio makes it easy to add Application Insights to your project. With Visual Studio 2015, Application Insights Tools for Visual Studio has more performance improvements and bug fixes. It is fully compatible with projects that had Application Insights added with Visual Studio 2013.3 and 2013.4. This update includes:

Seamless integration with the workflow to publish to an Azure website
Improved solution integration and project detection. (For example, Application Insights is no longer included in unsupported projects like Python.)
Full integration with the new Visual Studio's user account manager, where a user can be signed in to multiple accounts simultaneously.

To learn more about changes to Application Insights data in the Azure Preview Portal, go here.

Release Management

Improve the process of managing the release of your app. Deploy your app to a specific environment for each separate stage. Manage the steps in the process with approvals for each step. Get started with Release Management.

There is no new Release Management server or client for Visual Studio 2015 Preview. Use the Visual Studio 2013 Update 4 Release Management server and client. Learn more about Update 4 features.

Use the Release Management service for Visual Studio Online

Now you can setup a release pipeline from check-in through to deployment without having to install and maintain an on-premises Release Management server. Use the Release Management service for Visual Studio Online to set up your release. (This service is in preview.)

From your Release Management client, connect to your Visual Studio Online account. Create a release definition for your app from the Release Management Visual Studio 2013 Update 4 client. When you release your app to each stage, the Release Management service is used.

Release to Azure from Visual Studio

You can now create a release definition directly from within the Visual Studio IDE using Release Management as a service with a Visual Studio Online account. You must use an Azure subscription to deploy to your Azure VMs with this release definition. Learn more about this here.

Git version control

It is easier to work with branches and see how the changes in your history diverged.

Branches

You can organize your branches hierarchically by specifying a prefix:

Local branches and remote branches (including those you have not created locally) are shown separately in a tree view.

Detailed history

You can now see how commits diverged in the history. For example, here's the history from a pull request.

In the graph, merge commits are gray and non-merge commits are a brighter color. You can switch back and forth between the simple view and the detailed view. If the graph is truncated, you can resize it.

CodeLens

Find out more about your code, while staying focused on your work in the editor. Find code references, changes to your code, related TFS items, and unit tests – all without looking away from the code. Learn more about CodeLens.

Look for patterns in changes to the code, so you can assess the impact. CodeLens now shows change history as a chart for code in Git.

Architecture, Design, and Modeling

Code maps and dependency graphs

Read less code when you use these diagrams to learn more about your code’s design. You can now:

Skip rebuilding your solution for better performance when creating and editing diagrams
Create diagrams from the Class View and Object Browser
Filter relationships to make diagrams easier to read

You can no longer use Architecture Explorer to create these diagrams. But you can still use Solution Explorer.

Layer diagrams

Update these diagrams using the Class View and Object Browser. To meet software design requirements, use layer diagrams to describe the desired dependencies for your software. Keep code consistent with this design by finding code that doesn’t meet these constraints and validating future code with this baseline.

UML diagrams

You can no longer create UML class diagrams and sequence diagrams from code. But you still create these diagrams using new UML elements.

Other Changes: Bug Fixes & Known Issues

For a complete description of technology improvements, bug fixes and known issues in this release see the KB articleDescription of Visual Studio 2015 Preview.

Related Releases

Azure SDK 2.5

This release provides new and enhanced tooling for Azure development with Visual Studio 2013 Update 4 and Visual Studio 2015 Preview, including Azure Resource Manager Tools, HDInsight Tools, and the ability to manage Azure WebJobs from Server Explorer. Learn more about this release from the Azure SDK 2.5 release notes.

Download the Azure SDK 2.5 now.

Team Explorer Everywhere 2015 Preview

TEE 2013 Update 2 improves how TEE stores credentials which makes signing in to Visual Studio Online much easier. This release also adds the capability to browse Git repositories within TEE. Read more about this here.

Download TEE 2013 Update 2 now.

Visual Studio Tools for Unity (VSTU)

VSTU is Microsoft’s free Visual Studio add-on that enables a rich programming and debugging experience for working with theUnity gaming tools and platform. VSTU 2.0 Preview adds support for VS 2015 Preview. Better visualization for objects in watch and local windows has been added too.

Recent releases

2.0 Preview - find out the details for this release here.

To get started with the latest version of VSTU, download the tools from the Visual Studio Gallery: VSTU for Visual Studio 2015 Preview.

Kinect for Windows 2.0 SDK

Here are the details for this release:

Kinect for Windows software development kit 2.0 features over 200 improvements and updates to the preview version of the SDK. The SDK is a free download, and there are no fees for runtime licenses of commercial applications developed with the SDK.
Ability to develop Kinect apps for the Windows Store. With commercial availability of SDK 2.0, you can develop and deploy Kinect v2 apps in the Windows Store for the first time. Access to the Windows Store enables you to reach millions of potential customers for your business and consumer solutions.
Availability of the US$49.99 Kinect Adapter for Windows that enables you to connect a Kinect for Xbox One sensor to Windows 8.0 and 8.1 PCs and tablets. Now developers can use their existing Kinect for Xbox One sensor to create Kinect v2 solutions, and consumers can experience Kinect v2 apps on their computer by using the Kinect for Xbox One sensor they already own. The adapter is available in over two dozen markets—rolling out later today—and will be available in a total of 41 markets in the coming weeks.

For more details, go here.

Download the Kinect for Windows software development kit now.

C++ Extract Function for Visual Studio 2015 Preview

In addition to the Visual Studio 2015 Preview refactoring tools, you’ll be able to try out and give feedback on some of our early work on other refactorings provided as Visual Studio extensions. The Extract function refactor operation will allow you to factor out a piece of code from a function into its own function to be reused elsewhere. Learn more about this function, or download from here.

Azure Cloud Code Analysis Pack

Analyzes your code and identifies areas that may cause issues for cloud apps running at scale. It recommends patterns to improve the code.

Download the Azure Cloud Code Analysis Pack now.

Monday, November 17, 2014