What's new in Microsoft Visual Studio Ultimate 2013 12.0.40418.0 Update 5 RC

Apr 30, 2015
  • Current iteration query token:
  • You now can run queries in Visual Studio with the @currentIteration token that you create by using Visual Studio Online or Visual Studio Team Foundation Server 2015.

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

  • Technology improvements - debugger:
  • Capturing depth buffers on version 9.3 hardware is now supported. This enables support for graphics debugging Unity-based applications that run on Windows Phone.
  • Fixed bugs:
  • Visual Studio IDE:
  • After you install Microsoft Visual Studio 2013 Update 4, a critical notification in the Notification Hub indicates that you must obtain or renew a developer license. If you dismiss this notice, and then you open another project, the critical notification appears again.
  • Assume that you have installed Microsoft Visual Studio 2013 Update 4 on your computer. When you build a Windows Store application that requires WinRT registrations, you may receive the System.TypeLoadException exception at runtime.
  • Team Foundation Server:
  • Assume that you have a SharePoint document whose name contains too many Unicode characters. When you try to open the document from Team Explorer, the document opens incorrectly.
  • Git:
  • When you download changes in a remote repository, your configuration file is replaced by a specially crafted file. Your configuration file resides outside the repository. By replacing this file with a bad file, the Git commands can be remapped in order to execute arbitrary commands that run under your credentials. In this situation, a bad file is introduced into the Git repository.

New in Microsoft Visual Studio Ultimate 2015 14.0.22609.0 CTP 6 (Feb 24, 2015)

  • UI DEBUGGING TOOLS FOR XAML:
  • We've added two new tools—the Live Visual Tree and the Live Property Explorer—that you can use to inspect the visual tree of your running WPF application, as well as the properties on any element in the tree. In short, these tools will allow you to select any element in your running app and show the final, computed and rendered properties.
  • Live Visual Tree. Now, you can view the full visual tree of a running application during a debug session. The Live Visual Tree is available when you press F5 in Visual Studio or attach to a running application. You can use the Live Visual Tree to select elements in a running application for inspection in the Live Property Explorer. Descendant count is displayed, and if the source information is available, you can instantly find the file and location of the element's definition.
  • Live Property Explorer. Use this new tool to inspect the properties set on any element in a running application, grouped by the scope in which they are set. You can modify these properties during a debugging session and immediately see their changes in the running application.
  • Picking apart how properties override each other and figuring out winning behavior can prove difficult at design time. Now, by using our new UI debugging tools for XAML, you can perform these inspections at runtime, when you can take everything into account. (Support for Windows Store apps will be released in a future update.)
  • SINGLE SIGN-IN:
  • You, like many other developers today, take advantage of multiple cloud services when developing your applications. For example, you've probably added a cloud backend to your applications to store data, stored your source code in the cloud, or published an application to a store.
  • In the past, each of these services required a separate sign-in process, and each service managed the signed-in user state separately.
  • With this release, we are reducing the authentication prompts required to access many integrated cloud services in Visual Studio. Now, when you authenticate to the first cloud service in Visual Studio, we will automatically sign you in, or reduce the authentication prompts for other integrated cloud services.
  • CODELENS:
  • With CodeLens, you can find out more about your code while staying focused on your work in the editor. In CTP 6, you can now see the history of your C++, SQL, or JavaScript files versioned in Git repositories by using CodeLens file-level indicators. When working with source control in Git and work items in TFS, you can also can get information about the work items associated with C++, SQL, or JavaScript files by using CodeLens file-level work items indicators.
  • CODE MAPS:
  • When you want to understand specific dependencies in your code, visualize them by creating Code Maps. You can then navigate these relationships by using the map, which appears next to your code. This helps you track your place in the code while you work.
  • Performance improvements. With this release, now you can get reactive Code Maps more quickly: drag and drop operations produce an immediate result, and the links between nodes are created much more quickly, without affecting subsequent user-initiated operations such as expanding a node or requesting more nodes. When you create Code Maps without building the solution, all the corner cases—such as when assemblies are not built—are now processed.
  • Code Map filtering. Now you can quickly unclutter your Code Maps by filtering for nodes and groups. You can show or hide code elements on a map based on their category, as well as group code elements by solution folders, assemblies, namespaces, project folders, and types.
  • Dependency links. Dependency links no longer represent the inheritance from System.Object, System.ValueType, System.Enum, and System.Delegate, which makes it easier to see external dependencies in your code map.
  • Improved top-down diagrams. For a medium to large Visual Studio solutions, you can now use a simplified Architecture menu to get a more useful Code Map for your solution. The assemblies of your solution are grouped alongside the solution folders, so you can see them in context and leverage the effort you've put in structuring the solution. you'll immediately see project and assembly references, and then the link types appear. Also, the assemblies external to your solution are grouped in a more compact way.
  • Improved link filtering. Link filtering now applies to cross group links, which makes working with the filter window less intrusive than it was in previous releases.
  • DIAGNOSTICS TOOLS:
  • In CTP 6, the Diagnostic Tools debugger window has the following improvements:
  • Supports 64-bit Windows Store apps
  • The timeline zooms as necessary so the most recent break event is always visible
  • EXCEPTION SETTINGS:
  • You can configure debugger exception settings by using the Exception Settings tool window. The new window is non-modal and includes improved performance, search, and filter capabilities.
  • JAVASCRIPT EDITOR:
  • Task List support. You can use the Task List feature to review task comments, such as // TODO, in your JavaScript code.
  • Object literal IntelliSense. The JavaScript editor now provides you with IntelliSense suggestions when passing an object literal to functions documented using JSDoc.
  • UNIT TESTS:
  • In Visual Studio 2015 preview, we introduced Smart Unit Tests, which explores your .NET code to generate test data and a suite of unit tests. In CTP 6, we've added the following functionality:
  • Parameterized Unit Tests. Smart Unit Tests enables support for an API that you can use to guide test data generation, specify correctness properties of the code under test, and direct the exploration of the code under test. This API is available in the Microsoft.Pex.Framework namespace and can be used in the test methods (parameterized unit tests, factory methods) generated by Smart Unit Tests. Consequently, the "Smart Unit Tests" context menu command is now available from the generated test methods as well.
  • Test stubs creation. "Create Unit Tests" is now available on the context menu as a command that provides the ability to create and configure a test project, a test class, and a test stub.
  • VISUAL STUDIO EMULATOR FOR ANDROID:
  • In CTP 6, the Visual Studio Emulator for Android now supports the following:
  • OpenGL ES
  • Android Version 5.0 (Lollipop, API Level 21)
  • Camera interaction using image files or your webcam
  • Multi-touch input
  • VISUAL STUDIO TOOLS FOR APACHE CORDOVA:
  • Over the last few releases, we listened to your feedback and broadened the number of devices you can debug to, as follows: Android 4.4, Android 4.3 and earlier with jsHybugger, iOS 6, 7, and 8, Windows Store 8.1. With CTP6, we are broadening our debugging support further. You can now debug your Apache Cordova apps that target Windows Phone 8.1. You can set breakpoints, inspect variables, use the console, and perform other debugging tasks on your Windows Phone 8.1 emulator or attached device.
  • VISUAL STUDIO C++ FOR CROSS-PLATFORM MOBILE DEVELOPMENT:
  • You can use Visual Studio to share, reuse, build, deploy, and debug your cross-platform mobile code, all within a single solution. And in CTP 6, we've added or updated the following:
  • Support for Android API Level 21 (Lollipop).
  • Improvements to Android Logcat. (Logcat is a diagnostic tool and essential for a good edit->build->debug experience.)
  • Use Logcat to do the following:
  • Search for specific log messages by using search bar.
  • Use Toggle Autoscroll to view upcoming log messages easily.
  • Clear previous log output messages.
  • Choose between various log levels.
  • A new template that is based on make file support for Android, which allows using an external build system (including NDK-BUILD).
  • Precompiled headers in all templates (including Dynamic Shared Library, Static Library, and Cross-platform mobile templates).
  • ASP.NET:
  • In this CTP 6 release, we’ve added the following new features and performance improvements:
  • Run and debug settings are now stored in debugSetting.json, which can be customized to configure how the project is started.
  • Add reference to a system assembly.
  • Improved IntelliSense while editing project.json.
  • New Web API template.
  • Improvements to call out ASP.NET 4.6/ASP.NET 5 on the New ASP.NET Project (One ASP.NET) dialog.
  • Ability to use a Windows PowerShell script which can be customized for the web publish experience for ASP.NET 5.
  • You can use Lambda expressions in the debugger watch windows for ASP.NET 5 applications when running on the Desktop CLR.
  • VISUAL C++:
  • We've added the following new features to Visual C++ in CTP 6:
  • Control Flow Guard (CFG). With this new security feature, simply add a new option to your project, and the Visual C++ compiler will now inject extra security checks into your binaries to help detect attempts to hijack your code. When the check fires, it will stop execution of your code before a hijacker can do damage to your data or PC.
  • Note: We have updated the command options. Instead of using the /d2guard4 switch as you did in CTP 5, you should now use /guard:cf in CTP 6.
  • Typename keyword. Users can now write typename instead of class in a template template parameter.

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

  • Includes adding support for graphics debugging of Unity-based applications on Windows Phone, and making fixes in the IDE, Team Foundation Server, and Git support.

New in Microsoft Visual Studio Ultimate 2015 14.0.22512.0 CTP (Jan 17, 2015)

  • XAML LANGUAGE SERVICE:
  • Fast, reliable, and modern:
  • In this release, we’ve rebuilt the XAML language service on top of .NET Compiler Platform ("Roslyn") so that we can provide you with a fast and reliable XAML editing experience that includes IntelliSense
  • This makes the XAML authoring experience equal to other first-class languages in Visual Studio. We'll also be able to deliver powerful feature sets around cross-language refactoring to you at a much faster cadence.
  • TIMELINE TOOL:
  • Inspect and diagnose performance issues in your WPF and Windows 8.1 applications:
  • Our new Timeline tool provides you with a scenario-centric view of the resources that your applications consume, which you can use to improve the performance of your WPF and Windows Store 8.1 applications.
  • The Timeline tool, which is in the Performance and Diagnostics hub, shows you how much time your application spends in preparing UI frames and in servicing networks and disk requests, and it does so in the context of scenarios such as Application Load and Page Load.
  • DIAGNOSTICS TOOLS:
  • Use the Diagnostic Tools window while debugging:
  • We've added a new Diagnostic Tools window that appears when you start debugging (press F5). The Diagnostics Tools window contains the following features:
  • Debugger Events (with IntelliTrace):
  • Debugger Events (with IntelliTrace) gives you access to all Break, Output, and IntelliTrace events collected during your debugging session. The data is presented both as a timeline and as a tabular view. The two views are synchronized and can interact with each other.
  • Memory Usage:
  • The Memory Usage tool allows you to monitor the memory usage of your app while you are debugging. You can also take and compare detailed snapshots of native and managed memory to analyze the cause of memory growth and memory leaks.
  • CPU Usage:
  • The CPU Usage tool allows you to monitor the CPU usage of your application while you are debugging.
  • This tool replaces the CPU time PerfTip that was available in the Preview release of Visual Studio 2015.)
  • The Diagnostics Tools window supports the following project types and debugging configurations:
  • Managed WPF, WinForms, and Console projects
  • Native Win32, Console, and MFC projects
  • ASP.NET 4 using IIS express only
  • ASP.NET 5 and IIS are not supported at this time)
  • Managed or Native 32-bit Windows Store projects running locally
  • Windows Store projects that are 64-bit, using JavaScript, running on a remote device, or running on a phone are not supported at this time)
  • ASP.NET:
  • In this release, we’ve added some new features to the ASP.NET 5 experience, as well as improved its performance.
  • Now, you can add a reference to a standard C# project.
  • In previous releases, the Add Reference dialog only supported referencing other ASP.NET 5 projects.)
  • We’ve added IntelliSense and validation to our HTML, CSS, and JavaScript editors.
  • We’ve improved our support of client-side task runners (such as Grunt and Gulp) that run alongside the Task Runner Explorer.
  • For ASP.NET 5 projects, you can select the browser you want while running or debugging a project.
  • You can define custom commands in project.json file, which you can launch by using the ASP.NET 5 command-line tools. And now, you can also run and debug your custom commands directly in Visual Studio 2015.
  • We've updated our ASP.NET 5 templates to include a project.json file that uses the latest packages, and we've fixed some bugs in the template content.

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

  • TECHNOLOGY IMPROVEMENTS:
  • Debugger - Capturing depth buffers on version 9.3 hardware is now supported. This enables support for graphics debugging Unity-based applications that run on Windows Phone.
  • FIXED ISSUES:
  • Visual Studio IDE - After you install Microsoft Visual Studio 2013 Update 4, a critical notification in the Notification Hub indicates that you must obtain or renew a developer license. If you dismiss this notice, and then you open another project, the critical notification appears again.

New in Microsoft Visual Studio Ultimate 2015 14.0.22310.1 Preview (Nov 14, 2014)

  • 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. 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.
  • 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 through Microsoft 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
  • chrono> 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • ASP.NET:
  • SP.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
  • ASP.NET Web API 5.2.2
  • ASP.NET Web API OData 5.3.1 beta
  • SignalR 2.1.2
  • Microsoft Owin 3.0 package
  • NuGet 2.8.3
  • 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.
  • 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.
  • 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.
  • 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. 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.
  • GIT VERSION CONTROL:
  • 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.
  • 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.
  • FIXED BUGS:
  • Debugger - Assume that you set a breakpoint in an auto-implemented properties in a C# application. When you run the application, you receive the following error message: A breakpoint could not be set at this location.
  • BREAKING CHANGES:
  • Visual C++:
  • You can no longer use char16_t or char32_t as aliases in a typedef, because these types are now treated as built-in. It was common for users and library authors to define char16_t and char32_t as aliases of uint16_t and uint32_t respectively. For example:
  • typedef uint16_t char16_t; //C2371
  • typedef uint32_t char32_t; //C2371
  • uint16_t x = 1; uint32_t y = 2;
  • char16_t a = x; //C2440
  • char32_t b = y; //C2440

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

  • CODELENS:
  • With CodeLens indicators you can learn about your code while staying focused on your work. You can find code references, changes to your code, related TFS items, and unit tests – all without looking away from the code.
  • Reduced data storage requirements for CodeLens with TFVC:
  • The size of CodeLens data stored in the TFS database has been reduced. The data has been reformatted and duplicated information removed.
  • By default, CodeLens now only processes changes from the last 12 months to calculate team indicators. You can change this duration by using the TFSConfig CodeIndex command.
  • C++ DIAGNOSTICS:
  • GPU Usage:
  • A new GPU Usage tool in the Performance and Diagnostics hub helps you determine whether the CPU or the GPU is the performance bottleneck. This tool lets you collect and analyze GPU usage data for DirectX applications.
  • You can use this tool for both Windows Desktop and Windows Store apps; support for Windows Phone and remote diagnostics will ship in a later release. You can also inspect the timing of each individual GPU event if a supported graphics card is present and latest drivers are installed.
  • Faster browsing:
  • Visual Studio now scans or rescans large solutions and updates the symbol database more quickly. Browsing should be more responsive, and operations such as Go To Definition should not be blocked, even if the database has not been completely updated. A non-blocking message will warn you that your results may be inaccurate.
  • JAVASCRIPT INTELLISENSE:
  • You can now get IntelliSense in JavaScript modules loaded with RequireJS.
  • MICROSOFT ASP.NET AND WEB TOOLS:
  • JSON Editor Improvements:
  • We made a few improvements in the JSON editor, including loading the JSON schema asynchronously, caching child schemas, and improving IntelliSense. We also have the following new features:
  • JSON Schema validation. We added a JSON schema validation feature, based on the schema selected in the drop-down list.
  • Un-minify the context menu button. You can right-click the JSON editor and select Un-minify context menu button to un-minify any long arrays in the JSON file.
  • The Reload Schemas context menu button. Visual Studio caches the schema downloaded from internet, and will use the cache even after you restart Visual Studio. If you know the schema has changed, you can use the context menu to download the changed schema in the active JSON document and use it immediately.
  • HTML Editor Improvements:
  • We improved the HTML editor with some bug fixes, 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 {{…}}, so we don’t flag the content as invalid HTML or try to format it as HTML. This is great for Angular, Handlebars, Mustache and other double-curly template syntaxes.
  • Support for custom elements, polymer-elements and attributes.
  • We no longer validate unknown attributes for custom elements, because there can be many custom-made tags in different frameworks. There will no longer be squiggles under the unknown elements.
  • HTML element tooltips. We now supply tooltips for HTML elements in the editor.
  • #region support. The HTML editor now supports region folding. You can use a surrounding snippet to surround the current selection as well.
  • viewport fix for the LESS editor. In the LESS editor, @viewport no longer shows verification warnings.
  • Many more snippets. We now provide more snippets to make your developing experience easier.
  • CSS auto-sync. Saving the CSS file or changing it externally (for example, with a LESS/SASS compiler) causes the whole CSS file to reload in the browser. If the file couldn’t auto-sync, Ctrl+S causes an automatic reload without needing to refresh the linked browsers(Ctrl+Alt+Enter). This feature can be disabled in the toolbar.
  • Azure WebJobs:
  • In Visual Studio 2013 Update 4 we’re releasing some new features that will make it easier than ever to build, deploy, and debug Azure WebJobs, and to add background processing to Azure Websites. WebJobs are now represented as nodes in the Visual Studio Server Explorer, so you can link directly to the WebJobs dashboards to see how your WebJobs are running. You can also use the Server Explorer to start and stop continuous jobs and run on-demand or scheduled jobs. We’ve also enabled one-click remote debugging of continuous WebJobs, so if you need to see how your continuous WebJob is processing incoming queues or blob messages, you can step through your code as it’s running live in the cloud.
  • WebJobs SDK:
  • The WebJobs SDK is pre-installed in the Azure WebJob project templates. As before, you can create a new WebJob project using the Azure WebJob project template.
  • ASP.NET MVC 5.2.2:
  • Template packages are updated to use ASP.NET MVC 5.2.2. This release doesn’t have any new features or bug fixes in MVC. We made a change in Web Pages for a significant performance improvement, and have 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. Get more details about what's new in this release of Json.NET 6.0 Release 4. This release doesn’t 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
  • SignalR 2.1.2:
  • Template packages are updated to use SignalR 2.1.2.
  • Microsoft Owin 3.0 package:
  • Template packages are updated to use Microsoft Owin 3.0 NuGet packages.
  • APPLICATION INSIGHTS:
  • With Update 4, 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. 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.)
  • DEVELOPER LICENSE RENEWAL:
  • When your developer license is within 15 days of expiring, you will start to see a new notification in the notification hub. Click the notification when you’re ready to renew your license, and then click I Agree on the renewal window. You must have an internet connection to renew your license. After your license expires, you won’t be able to debug or deploy your Windows Store apps, or open the XAML or HTML designers.
  • 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.
  • You can create release templates that use deployment agents to deploy your app, or you can create release templates that use Windows PowerShell, Windows PowerShell Desired State Configuration (DSC), or Chef. To help you know which type of release you are setting up, terms have been added to the UI to make your choices clearer: agent-based or vNext (without agents). This simply helps you identify that you are using the correct environments and components for your release templates and release paths.
  • 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.
  • Use tags when you deploy to an environment:
  • Now you can use tags with the servers in your Azure or standard environments when you deploy without agents. For example, if you have multiple web servers in your environment then you can tag them all with WebServer. Set up your deployment actions for your tags. When a stage is deployed, these actions are performed on any server with this tag. So you only have to create the set of actions once for multiple servers.
  • With tags you can also switch the deployment order from parallel to sequence.
  • Access to system variables for your deployment sequences or scripts:
  • By popular user demand, you can now access system variables just like other configuration variables and use them in your release template if you deploy without agents. You don't have to hardcode these any more.
  • Supported variables:
  • Build directory
  • Build number (for component in the release)
  • Build definition (for component)
  • TFS URL (for component)
  • Team project (for component)
  • Tag (for server which is running the action)
  • Application path (destination path where component is copied)
  • Environment (for stage)
  • Stage
  • Release id
  • Release name
  • Reduce the need for configuration files to deploy your builds:
  • If you deploy without using agents, you can now set up configuration variables for your release at the following levels: global, server, component, action. This extra flexibility means you might no longer need to maintain configuration files with your build. If variables have the same name, the value is determined based on this order of precedence: action, component, server, global. (Action has the highest precedence to override the other values).
  • Manual intervention for a release path:
  • Now you can add manual steps to a stage in any release path, even if you deploy without agents. Add a manual intervention activity into your deployment sequence. When the notification is triggered in that sequence, the deployment pauses and you can run some manual steps before continuing with the rest of the automation for the release path.
  • Build drops stored on TFS servers:
  • If you have set up your build definition to copy the build output to the server and not a UNC path, you can now use these builds that are stored on the server if you deploy your app without agents.
  • Deploy from a build drop using a shared UNC path:
  • You can now use Release Management to deploy to servers using build drops located on a shared UNC path. You can deploy only if both the target server and the Release Management server have access to the shared UNC path, and you deploy your app without deployment agents.
  • Usability improvements:
  • You can now select servers and components from the drop-down list in the action for all types of release templates. You can also give actions friendly names to make it easier to identify them.
  • Mix and match Azure and standard environments:
  • Previously for a release path that deployed to servers without agents, each stage in the path could only use either all Azure environments or all standard environments. Now you can mix and match your environments. For example, your test stage might deploy to an Azure environment, but your production stage deploys to on-premises production servers using standard environments.
  • Find out quickly if a test case belongs to other test suites:
  • As test cases can belong to more than one test suite, it's good to check if there are any other associated test suites before you make changes to a test case. Now you can quickly view all the test suites associated with a test case.
  • View recent test results for a test case:
  • Quickly see the test result history for a test case to see if it has passed or failed recently. Just select the test case, view the details pane, and choose test results.
  • Real-time lightweight charts to show testing status:
  • Now you can create snapshot and trend charts for test cases from the Charts tab in the test hub. You can also create snapshot charts for test results. Pin these charts to your home page so that all the team can see the test status.
  • Filter by tags in the test hub:
  • Tag test cases in a suite with any tag that is important to you. For example, tag all the tests related to login so that you can rerun these tests if a bug is fixed for the login page. Then you can filter on that tag from the test hub. You can add and edit tags when you edit a test case, or bulk edit tags in the grid view.
  • VERSION CONTROL:
  • Review and merge code with Git pull requests:
  • Pull requests are a critical component of the developer workflow in Git. Now developers can use pull requests to help review and merge their code. Pull requests enable developers working in branches to get feedback on their changes from other developers before adding their code into the mainline. Any developer participating in the review can see the code changes, leave comments in the code, and give a “thumbs up” approval.
  • Plan and track work:
  • The many small improvements to Team Foundation Server (TFS) with Update 4 help make it easier for you to use our tools to get your work done faster.
  • Visualize trends and aggregate field values:
  • Query-based chart authoring now includes trend charts: Stacked Area, Area, and Line. You can visualize trends across a one-week, two-week, or four-week time range. Also, in addition to field counts, you can now sum a field value across work items returned in a flat-list query. These new chart types can be pinned to your home pages too. Learn more about how to view the status of your progress.
  • Quickly reorder backlog items:
  • If you had a large backlog, it was hard to drag and drop items to a different position. The context menu for backlog items now contains options to move an item directly to the top or to a specific position in the backlog. Be aware that with this change, we removed the field that tracks backlog priority from the work item forms in the default TFS process templates.
  • Full screen mode support for backlog views, boards, queries:
  • If you’re running a daily standup or viewing large backlogs, it's useful to be able to maximize the screen space and see as many items at once. Now you can hide all the chrome in the UI and have full-screen views of the backlog and boards. The toggle to enter full screen mode works for all the pages under the Backlogs and Queries tabs in the Work hub. Press ESC to return to the full work item view.
  • Full screen mode support for all HTML/rich-text fields:
  • You can now enter full screen mode for rich-text fields to help improve the readability and usability. For example, the Steps to Reproduce field can be maximized as shown below. The button toggles the text area between full screen mode and the work item view. Press ESC to return to the full work item view.
  • Better triage experience:
  • To improve the triage experience when you review query results, you can go back to the query by pressing Alt+Q. This keeps your position in the query
  • Assign backlog items to iterations within hierarchical views:
  • From hierarchical views, you can now assign product backlog items to iterations with drag and drop
  • In-line search for area and iteration fields from the work item form:
  • Often when triaging or assigning work items it’s necessary to change the area and/or the iteration path. Finding the path you want in large, deeply nested trees can be difficult. With inline search, values that match what you type are instantly highlighted. For example, type Team to highlight all path entries that contain the work Team in their name
  • Open hyperlinks quickly:
  • If you have a hyperlinks defined within an HTML field, press the CTRL key and click the link. Previously it was a two step process to click the link, and then click the “navigate to…” command at the top of the text area.
  • Teams choose whether or not to track bugs on their backlog:
  • Teams now have greater flexibility in how they track bugs. While team projects created with the Scrum process template include bug tracking on the backlog, other process templates don't. Each team can now choose to view the bugs with the product backlog or turn off including them.
  • Work item form enhancements:
  • Track work and share information more easily using some of the new features listed below and highlighted in the work item form pictured.
  • Send a nicely formatted email directly from the work item form using the new email icon.
  • Return directly to the query result you navigated from. If you like to use the keyboard, press ALT+Q. Or you can use the browser back button to do the same thing. This keeps your position in the query.
  • Enter full screen mode from all queries and all work items. Just click the command in the toolbar to remove all the chrome and maximize your screen real estate.
  • Open a work item in a new browser tab with the context menu command for query results.
  • Copy and paste of query results now formats the results much better for pasting into email or a document.
  • More items in your Kanban board:
  • There is no longer a hard limit on the number of items in the first and last columns of the Kanban board. Now you can configure this limit to have up to 999 items.
  • Easier way to link work items:
  • In Visual Studio, there has always been a dialog box to find a work item that you want to link to, but with Team Web Access you could only type the work item ID to find it. With Update 4, you get a similar dialog box to find the work item you want to link to. You can run an existing query or find the work item based by searching for its title.
  • ACCESS LEVEL NAME CHANGES AND FEATURE ACCESS:
  • With Update 4, all access levels have been renamed. The new names correspond to the same names used for Visual Studio Online licensing.
  • Stakeholder (previously was Limited)
  • Basic (previously was Standard)
  • Advanced (previously was Full)
  • With this change, the feature set support for the Stakeholder access has been enhanced. Stakeholders have access to the project home page and most of the “work” related functionality. This includes the ability to view the backlog, add and edit items, run work item queries and more.
  • Any number of users can be assigned a stakeholder license at no charge.
  • MICROSOFT SQL SERVER DATABASE TOOLING FOR VISUAL STUDIO:
  • These are the added features for Update 4:
  • SQL Server 2014 is now supported.
  • Schema compare supports MSBuild with text and XML output.
  • Token-based authentication for Azure SQL Database node in Server Explorer is supported - for Microsoft accounts and organizational accounts.
  • From the Azure Preview Portal for Microsoft Azure SQL databases, you can now open the database schema directly in Visual Studio.
  • Extensibility for Static Code Analysis.
  • Filtering for the editable data grid.
  • Save your data compare settings to a file (.dcmp).
  • Additional actions are available when you connect to the TSQL editor.
  • PDW tools are now part of Visual Studio Express 2013 for Windows Desktop

New in Microsoft Visual Studio Ultimate 2012 11.0.50727.1 (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.