Few weeks ago The product Team has presented What’s new in VS2015 CTP6 , so here are big part of the changes
UI debugging tools for XAML
Are added two new tools—the Live Visual Tree and the Live Property Explorer—that you can use to inspect the visual tree of your running WPF application, as well as the properties on any element in the tree. In short, these tools will allow you to select any element in your running app and show the final, computed and rendered properties. Here’s more:
- Live Visual Tree. Now, you can view the full visual tree of a running application during a debug session. The Live Visual Tree is available when you press F5 in Visual Studio or attach to a running application. You can use the Live Visual Tree to select elements in a running application for inspection in the Live Property Explorer. Descendant count is displayed, and if the source information is available, you can instantly find the file and location of the element’s definition.
- Live Property Explorer. Use this new tool to inspect the properties set on any element in a running application, grouped by the scope in which they are set. You can modify these properties during a debugging session and immediately see their changes in the running application.
Picking apart how properties override each other and figuring out winning behavior can prove difficult at design time. Now, by using our new UI debugging tools for XAML, you can perform these inspections at runtime, when you can take everything into account.
(Support for Windows Store apps will be released in a future update.)
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.
Learn more about Code Lens.
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.
Learn more about Code Maps.
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
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.
- Task List support. You can use the Task List feature to review task comments, such as
In Visual Studio 2015 preview, we introduced Smart Unit Tests, which explores your .NET code to generate test data and a suite of unit tests. In CTP 6,are added the following functionality:
- Parameterized Unit Tests. Smart Unit Tests enables support for an API that you can use to guide test data generation, specify correctness properties of the code under test, and direct the exploration of the code under test. This API is available in the Microsoft.Pex.Framework namespace and can be used in the test methods (parameterized unit tests, factory methods) generated by Smart Unit Tests. Consequently, the “Smart Unit Tests” context menu command is now available from the generated test methods as well.
- Test stubs creation. “Create Unit Tests” is now available on the context menu as a command that provides the ability to create and configure a test project, a test class, and a test stub.
Learn more about Smart Unit Tests.
Visual Studio Emulator for Android
In CTP 6, the Visual Studio Emulator for Android now supports the following:
- OpenGL ES
- Android Version 5.0 (Lollipop, API Level 21)
- Camera interaction using image files or your webcam
- Multi-touch input
Visual Studio Tools for Apache Cordova
Over the last few releases, we listened to your feedback and broadened the number of devices you can debug to, as follows:
- Android 4.4, Android 4.3 and earlier with jsHybugger
- iOS 6, 7, and 8
- Windows Store 8.1
With CTP6, we are broadening our debugging support further. You can now debug your Apache Cordova apps that target Windows Phone 8.1
You can set breakpoints, inspect variables, use the console, and perform other debugging tasks on your Windows Phone 8.1 emulator or attached device.
Learn more about the Visual Studio Tools for Apache Cordova.
Visual Studio C++ for Cross-Platform Mobile Development
You can use Visual Studio to share, reuse, build, deploy, and debug your cross-platform mobile code, all within a single solution. And in CTP 6, also added or updated the following:
- Support for Android API Level 21 (Lollipop).
- Improvements to Android Logcat. (Logcat is a diagnostic tool and essential for a good edit->build->debug experience.)
Use Logcat to do the following:
- Search for specific log messages by using search bar.
- Use Toggle Autoscroll to view upcoming log messages easily.
- Clear previous log output messages.
- Choose between various log levels.
- A new template that is based on make file support for Android, which allows using an external build system (including NDK-BUILD).
- Precompiled headers in all templates (including Dynamic Shared Library, Static Library, and Cross-platform mobile templates).
In this CTP 6 release, are 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.
Learn more about ASP.NET 5 updates in Visual Studio 2015 CTP 6.
Are added the following new features to Visual C++ in CTP 6:
- Control Flow Guard (CFG). With this new security feature, simply add a new option to your project, and the Visual C++ compiler will now inject extra security checks into your binaries to help detect attempts to hijack your code. When the check fires, it will stop execution of your code before a hijacker can do damage to your data or PC. Learn more about Control Flow Guard.
Note: We have updated the command options. Instead of using the
/d2guard4 switch as you did in CTP 5, you should now use
/guard:cf in CTP 6.
- Typename keyword. Users can now write
typename instead of
class in a template template parameter. Learn more about typename.
For additional features of Visual Studio 2015, see our Preview release notes.
XAML Language Service
The XAML language service is rebuild on top of .NET Compiler Platform (“Roslyn”) so that we can provide you with a fast, reliable, and modern XAML editing experience that includes IntelliSense.
This makes the XAML authoring experience equal to other first-class languages in Visual Studio. We’ll also be able to deliver powerful feature sets around cross-language refactoring to you at a much faster cadence.
Our new Timeline tool in CTP 5 provides you with a scenario-centric view of the resources that your applications consume, which you can use to inspect, diagnose, and improve the performance of your WPF and Windows Store 8.1 applications.
The Timeline tool, which is in the Performance and Diagnostics hub, shows you how much time your application spends in preparing UI frames and in servicing networks and disk requests, and it does so in the context of scenarios such as Application Load and Page Load.
Learn more about the new Timeline Tool in Visual Studio 2015. (The new Timeline tool replaces the XAML UI Responsiveness tool.)
Are added a new Diagnostic Tools window in CTP 5 that appears when you start debugging (press F5). The Diagnostics Tools window contains the following features:
- Debugger Events (with IntelliTrace)
Debugger Events (with IntelliTrace) gives you access to all Break, Output, and IntelliTrace events collected during your debugging session. The data is presented both as a timeline and as a tabular view. The two views are synchronized and can interact with each other.
Learn more about IntelliTrace in Visual Studio 2015.
- Memory Usage
The Memory Usage tool allows you to monitor the memory usage of your app while you are debugging. You can also take and compare detailed snapshots of native and managed memory to analyze the cause of memory growth and memory leaks.
- CPU Usage
The CPU Usage tool allows you to monitor the CPU usage of your application while you are debugging.
(This tool replaces the CPU time PerfTip that was available in the Preview release of Visual Studio 2015.)
The Diagnostics Tools window supports the following project types and debugging configurations:
- Managed WPF, WinForms, and Console projects
- Native Win32, Console, and MFC projects
- ASP.NET 4 using IIS express only
(ASP.NET 5 and IIS are not supported at this time)
- Managed or Native 32-bit Windows Store projects running locally
Learn more about the Diagnostics Tools window in Visual Studio 2015.
In this CTP 5 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 improved our support of client-side task runners (such as Grunt and Gulp) that run alongside the Task Runner Explorer.
- For ASP.NET 5 projects, you can select the browser you want while running or debugging a project.
- You can define custom commands in project.json file, which you can launch by using the ASP.NET 5 command-line tools. And now, you can also run and debug your custom commands directly in Visual Studio 2015.
- Are updated our ASP.NET 5 templates to include a project.json file that uses the latest packages, and fixed some bugs in the template content.
Learn more about ASP.NET updates in Visual Studio 2015.
In CTP 5, added the following new features to Visual C++ to bring the compiler closer to conformance with the standards set in Visual Studio 2012 and Visual Studio 2013.
- Digit separators: Now, you can intersperse numerical literals with single quotes to make them more readable. For example,int x = 1’000’000;
- Universal character names in literals: You can now write basic characters, like ‘A’ and the line feed character, as code points in literals. For example, const char *s = “\u0041\u000A”;