Shulou(Shulou.com)05/31 Report--

­Visual Studio 2017 version 15.8 has been officially released, and you can now choose to download all installation files before starting the installation. To use this new option, select the download all before installing option in the installer. This option is recommended if the Internet connection is slow. The default option is install on download, which can be downloaded and installed in parallel.

­performance

­this release includes the following performance improvements:

­since there is no need to reload the solution, branch switching of the C#, VB and C++ projects can be performed more quickly for large solutions.

­reduce the time it takes to unload and reload a small group of C# and VB projects in a large solution-from minutes to seconds.

­an option has been added to prevent reopening documents that were opened in the previous session, because reopening some types of files or designers delays solution loading.

­Toggle this option through tools > options > projects > Solutions > General.

­Test performance

­significantly improves performance during running a large solution with multiple test projects. In our lab, the speed of performing individual tests for more than 10000 MSTest solutions has increased by 82%!

­Visual Basic performance improvement

­Visual Basic now significantly improves performance when converting non-integer types to integers using the CInt (Fix (number)) mode.

­performance analysis

­this release enhances performance analysis in the following areas:

­added "start but pause analysis" feature:

­the CPU usage tool in the performance Profiler (ALT-F2) can now start but pause the analysis. This feature is useful if the CPU usage survey does not provide valuable results until some time later. By starting with CPU usage collection disabled, performance Profiler will not collect any CPU usage sample stack data until such data is specifically enabled. As a result, the amount of data collected and analyzed is significantly reduced, making performance surveys more efficient.

­to start a session with CPU usage sample collection disabled, click the Settings (Gear) icon next to the CPU usage tool on the performance Profiler startup page to display the CPU usage property page, and then uncheck the check box labeled enable CPU Analysis (sampling). Finally, press OK to save these settings.

­\ * after starting the target application (press the start button on the performance Profiler launch page), you will see a monitoring screen showing the CPU utilization graph, through which you can control CPU analysis * *. To enable the CPU usage sample stack data collection, press the enable CPU Analysis link in the middle of the view, or click the record CPU profile button below the CPU usage graph. You can click the record CPU profile button to enable / disable sample data collection as many times as needed. The color of the CPU usage graph changes accordingly, indicating whether sample collection is enabled / disabled at that point in time.

­added .NET object allocation tracking tool:

­the family of tools provided to the performance Profiler adds the .NET object allocation tracking tool. If you call this tool for a performance Profiler session, a collection stack trace is assigned to each .NET object that occurs in the target application. This stack data is analyzed along with object type and size information to show details of the application's memory activity. You can quickly identify allocation patterns in your code and identify exceptions. In addition, for garbage collection (GC) events, users can easily determine which objects have been collected and retained, thus quickly determining the types of objects that take up most of the application's memory.

­this is particularly useful for API writers and helps minimize allocation. Many applications exceed the buffer limits involved in diagnostic data collection, but they can still diagnose small test applications that perform key API scenarios. During the execution of the test application, the performance Profiler displays a monitoring view that contains a line chart of real-time objects (counts) and a bar chart of object increments (percentage changes).

­to use the .NET object allocation tracking tool, bring up the performance Profiler startup page, select the target you want to analyze (the default target is the startup project in the solution), check .NET object allocation tracking from the list of available tools, and then press the start button.

­performance analysis (CPU usage)

­this release makes the following improvements to the CPU usage tool for performance Profiler (available through ALT-F2):

­by default, the call Tree view now displays asynchronous execution according to the logical call stack. You can turn off this behavior by unchecking the flattening Asynchronous Code option in the filter drop-down list in the main view of CPU usage.

­added the Module / function view, which displays performance information by module (dll) and functions within the module. When you select a function in the CPU usage main view, you can display the Module / function view from the context menu or the Module / function view from the View drop-down list in the call Tree or caller / callee view.

­in the main view of the CPU usage tool, add "instance indication" to the CPU usage diagram. Double-click any function listed in the CPU usage view to view the instance while the function is executing, such as on the stack.

­productivity

­this release increases productivity in the following areas:

­you can use format documents (Ctrl + K, D or Ctrl + E, D) to perform other code cleanup for C # development. Configure cleanup as follows: go to tools > options > text Editor > C# > Code Styles > format > General.

­added more use of Ctrl +. Or Alt + Enter refactoring and fast operation:

­dotnet_style_prefer_conditional_expression_over_assignment

­dotnet_style_prefer_conditional_expression_over_return

­dotnet_style_parentheses_in_arithmetic_binary_operators

­dotnet_style_parentheses_in_relational_binary_operators

­dotnet_style_parentheses_in_other_binary_operators

­dotnet_style_parentheses_in_other_operators

­reverse If reverses the logic in the if-else statement. Place the cursor over the if keyword to trigger this refactoring.

­by adding parameters from the method call site, you can add parameters to the method call site and trigger Quick Action and ReFactor to add parameters to the method.

­deleting unnecessary parentheses also removes the parentheses on both sides of binary operators that are not important to compilation. You can configure this style rule from tools > options > text Editor > C# > Code Styles > General or the following .editorconfig:

­in addition, use ternary conditions in allocation and return statements can be configured as style rules through tools > options > or the following .editorconfig:

­New commands and improvements have been added to the go to all window:

­you can quickly navigate to the beginning of a closed code block by "go to a closed block" (Ctrl + Alt + up arrow).

­by going to the next / previous question (Alt + PgUp/PgDn), you can skip to the next / previous question (error, waveform curve, and light bulb).

­"go to member" (Ctrl + T, M) now defaults to files. You can change the default value back to the solution by switching the scope to the current document (Ctrl + Alt + C).

­with support for multiple insertion points, you can now create insertion points and select content anywhere in the file. In this way, you can add, edit, or delete text in multiple locations at the same time.

­through the "Ctrl + Alt + left mouse button" insertion point.

­use Shift + Alt + Ins to add the selection and insertion point at the next location that matches the current selection.

­for a complete list of operations, see "Edit" > "multiple insertion points".

­use Alt + `to access the context navigation menu.

­keep the key binding consistent with the two new keyboard profiles Visual Studio Code and ReSharper (Visual Studio):. You can visit tools > options > General > Keyboard, and then use the drop-down menu at the top to find these scenarios.

­debugging

­this release enhances debugging in the following areas:

­if you have more than one instance of Visual Studio 2017 installed, you can now select the instance to which you want to deploy the extension when debugging. In this way, when debugging in the preview channel, you can develop in channels such as the Visual Studio version.

­\ * you can now attach Snapshot Debugger__ directly from the publication summary page.

­tools for general Windows platform development

­in the target platform version of Windows 10 Fall Creators Update (build 16299) or later, we have made a number of significant improvements to the XAML designer of the project for the generic Windows platform.

­you can now edit the collection in the property inspector.

­the designer now allows editing of templates and styles, including when the definitions of these entities are defined in other documents.

Properties of the ­type IconElement (such as the icon in AppBarButton) now have a custom editor in the property inspector to make it easier to set these properties.

­designers, editors, and Edit and continue should now apply to x:DefaultBindMode.

The visual state manager experience in ­Blend now supports AdaptiveTrigger.

­F# 4.5 and F# tools for Visual Studio

­We have introduced F# language version 4.5 in this version. This is also consistent with the new FSharp.Core 4.5.x series (F# core library). You can read a description of each change in the F# RFC repository. There are also many improvements to the F# tool for Visual Studio in this release.

­F# 4.5

­here are some highlights of F# language version 4.5:

­Span support

­We have implemented Span and related functions, so API can be effectively used and generated in F# through constructs such as Span, Memory, and ref. Features include:

­New voidptr type.

New NativePtr.ofVoidPtr and NativePtr.toVoidPtr functions in ­FSharp.Core.

­the new types inref and outref are read-only byref and write-only byref, respectively. This value corresponds to in ref and out ref in C#.

­able to generate ByRefLike structures (such as Span and ReadOnlySpan).

­can generate IsReadOnly structure.

­implicitly dereferencing the byref return value and the inref return value in the method.

­you can generate extension members on byref/inref/outref.

­this feature set fixes a bug of the original design of byref return values in F# 4.1-functions, methods, and properties that return byref are not implicitly dereferenced. We made this change to make this feature consistent with the way C# handles the ref return value. Error messages are used when type annotations indicate that implicit dereferencing of ref return values is now used.

­in addition, this feature set fixes a bug in the F# compiler-that is, a "bad structure replacement" can be made, that is, when a method on an F# structure is called, another structure can be used to replace the actual structure being called. Now think of the this parameter on the structure as inref, which contains an error: if you want to modify the structure, the error suggests adding variable fields.

­you can learn more about constructs such as span and ref in the RFC of this feature set.

­evaluate Match in an expression!

­F # 4.5 introduces matchphrase, a new keyword used in evaluation expressions (provided independently by John Wostenberg). This syntax sugar is equivalent to let in the result! Followed by match. But in match! For more information in the RFC of

­relaxes the upconversion requirements in sequence, list, and array expressions when using yield

­F# 4.5 now relaxes some restrictions: upconversion is required to convert subtypes to supertypes when using yield. Since F# 3. 1, there is no such limitation in these expressions if you do not use yield, so this improvement makes it more consistent with existing behavior. More information can be found in the RFC for this feature.

­indentation is allowed on list and array parentheses

­F# 4.5 now relaxes the indentation rules for list and array parentheses, which need to be indented forward if they are on their own lines. This requirement has always been very confusing, especially for F# beginners. In addition, F# sequence expressions are not required. Now, array expressions and list expressions, like sequence expressions, are no longer subject to this requirement. More information can be found in the RFC for this feature.

­enumeration use cases are issued in public form

­F# 4.5 now issues enumerated use cases in a common form in all cases, consistent with the way C# emits enumerated use cases. This also makes it easier for the analysis tool to analyze logs from the F# code, where the value is emitted instead of the label name. More information can be found in the RFC for this feature.

­F# compiler improvement

­F# 4.5 includes not only the previously mentioned language improvements, but also improvements to the F# compiler. These methods include:

­We removed up to 2.2% of the allocation in the F# compiler (in various cases) to improve compiler performance.

­fixed using yield for structure-based enumerable objects! The bug generated in the AccessViolatioNException when.

­you can inherit from FSharpFunc again.

­tail calls are disabled by default for debug versions of F# for .NET Core. They are enabled in the release and therefore match the desktop version of the F# compiler.

­fixed F# reference normalization that allows you to control transitive assembly references written to the output file. You can then perform the equivalent of assembly redirection on the .NET Core.

­fixed the following bug: ignored error messages used when trying to use dynamic calls on inline functions. The error message will now be sent.

­F# now respects the WarningsNotAsErrors flag that you can set in the project file.

­Isaac Abraham updates the error message that occurs when the pattern matching branch does not return the same type to make it more friendly.

­Steffen Forkmann fixed an internal error when compiling interface implementations that lacked overloaded method implementations.

­Gauthier Segay removes some unnecessary array copies in the compiler grammar phase.

Incomplete pattern matches on the ­F# enumeration now generate detailed warnings, giving examples of uncovered use cases (provided by John Wostenberg).

­`# nowarn "2003" is now respected (provided by Matthias Diitrich).

­Steffen Forkmann fixed a bug where using the C# extension method in F# overload parsing may fail.

­Steffen Forkmann fixed the internal QueueList data structure bug.

­Steffen Forkmann, Eugene Auduchinok, and ncave also provide a variety of minor optimizations and code cleanup.

­F# Core Library 4.5.x

­the following additions to the F# core library are now available:

­A lot of work has been done to improve the stack trace of async {} evaluation expressions. You should now be able to view the user code and user line number in the stack trace. More information can be found in the RFC for this feature.

­provide FuncConvert.FromFunc and FuncConvert.FromAction API with types of System.Func and System.Action overloads to facilitate interoperability in C #. More information can be found in the RFC for this feature.

­provides a new type of ValueOption, the first in a series of future features designed to bring better performance to the active mode. More information can be found in the RFC for this feature.

­TryGetValue is now a new member on the F# Map type. More information can be found in the RFC for this feature.

­We have solved the problem of high CPU utilization when MailboxProcessor.TryReceive is called for the first time.

­bool comparison now uses fast generic comparisons (provided by Vasily Kirichenko).

The summary text of ­Array.allPairs has been updated to be correct (provided by Patrick McDonald)

­F# tool improvement

­significant improvements to the F# tool are available in this release, such as performance improvements and some new editor features. As always, the F# open source community has provided a lot of content and made a great contribution. Here are some highlights:

­We have improved the IntelliSense performance of all forms of .NET SDK style projects, including those that use multiple goals.

­Vasily KirichenkoSteffen Forkmann and Gauthier Segay have done community-driven work to analyze and improve the IntelliSense performance of very large files. IntelliSense in very large files (more than 10k lines of code) is now about twice as fast.

­warnings for obsolete FSharp.Core (although packages are installed) no longer appear in .NET SDK style projects.

­IntelliSense. The tooltip for displaying the description of the XML document to the member is no longer timed out after 10 seconds.

­fixed bug where breakpoints could not be set in object constructor parameters.

­fixed bug that will be copied when renaming symbols are generic parameters.

­. The template for the .NET Framework (the classic F# template) now uses FSharp.Core from the NuGet package to be consistent with the .NET SDK F# template.

­now provides automatic transactional brace completion for (), [], {}, [| |] and [] curly braces pairs. We finished the work together with Gibran Rosa.

­you can now go to the definition by holding down Ctrl and clicking the F# symbol. The setting of this gesture is also respected in the tools > options window.

­modified IntelliSense performance UI to allow outdated typecheck information to be configured for various IDE features. A description of each option is now displayed in the tooltip for the settings.

­curly braces match highlight now correctly highlight curly braces (done in collaboration with Vasily Kirichenko).

­now "go to definition" correct navigation (provided by Vasily Kirichenko) when the type is defined recursively.

­Vasily Kirichenko fixed a bug that did not open the automatic import namespace when the top of the file was empty.

­Vasily Kirichenko fixed the bug that incorrectly colored the printf specifier that contains points.

­Vasily Kirichenko fixed a bug that treats all open items in a recursive module as unused.

­Vasily Kirichenko greatly improves the performance of Unused Opens parsers.

­property autocompletion is now recommended only for options that are indeed properties (provided by Vasily Kirichenko).

­now generate signature help tooltips (provided by Vasily Kirichenko) for the static parameters of the type provider on the constructor call site.

­Vasily Kirichenko fixed the bug that shaded the value type used as the unit of measure as the reference type.

­Vasily Kirichenko fixed a bug where the semantic coloring of some files might disappear when scrolling.

­an experimental CodeLens implementation (provided by Victor Peter Rouven M ü ller) is now available. You can open it in options > text Editor > F# > Code Lens.

­Sebastian Urban fixed a bug where the F# compiler service mistakenly omitted the spelling of module names in XML documents.

­the code for using Dictionary with ContainsKey and subsequent Item calls has been changed to use TryGetValue (provided by Eugene Auduchinok).

­Jakob Majoka is also involved in the creation of other API using tooltips.

­Infrastructure, packaging, and open source improvements

­We have made the following improvements to the infrastructure, packaging, and open source feed experience:

­the F# compiler distributed with Visual Studio is no longer installed as a single instance in the F# compiler SDK location. It is now completely parallel to Visual Studio, which means that installing Visual Studio in parallel will eventually lead to a true parallel F# tool and language experience.

­sign the FSharp.Core NuGet package now.

­ETW logging has been added to the F# tool and compiler.

The very large control.fs/contro.fsi files in ­FSharp.Core are now split into async.fs/async.fsi, event.fs/event.fsi, eventmodule.fs/eventmodule.fsi, mailbox.fs/mailbox.fsi, and observable.fs/observable.fsi.

­We have added a .NET SDK style version of the project performance stress test project.

­Newtonsoft.Json has been removed from the base code, and now you will download one less package for OSS participants.

­We are now using the latest versions of System.Collections.Immutable and System.Reflection.Metadata.

­C++ compliance and toolset improvement

­this release includes the following C++ compliance and toolset improvements:

­A new experimental token-based preprocessor that complies with 11 C++ standards (including C99 preprocessor functions) and is enabled with the / experimental:preprocessor switch. Use the macro _ MSVC_TRADITIONAL to control it, defined as 1 when using a traditional preprocessor and 0 when using a new experimental preprocessor that meets the standard.

­Visual Studio developer command prompts support enabling Visual C++ Spectre variant 1 mitigation runtime (- vcvars_spectre_libs = spectre). For more information about Spectre mitigation, see the Visual C++ team blog.

­two new additions to the SSA optimizer focus on new C++ code generation: redundant storage clearance and redundant branch folding.

­optimized memory maps the Istroke O performance in the linker to reduce link time.

­C++ cross-platform development

­in this version, we improved the cross-platform development of C++ and added the following:

­added the add > New item template to generate .clang format files that follow the coding convention specified for ClangFormat in tools > options. If you select the Visual Studio convention, the resulting file attempts to match the user's current Visual Studio formatting configuration in tools > options.

­update the shipped format.exe version to 6.0.0.

­templates used to simplify adding configurations to CppProperties.json.

­templates have been added to simplify adding configuration to CMakeSettings.json.

­C++ productivity

­the following are enhancements and improvements to C++ productivity:

­C++ quick message tooltips about macros now show their extended functionality, not just their definition. This is especially useful if complex macros refer to other macros when they clarify what the preprocessor uses instead of macro identifiers.

­added a new quick fix light bulb to convert basic macros to constexpr as a new tool to make the code new.

­IntelliSense for templates provides detailed information about template parameters to make full use of IntelliSense in the body of the template.

­We are trying to revolutionize the code analysis experience. You can now enable new in-progress features under tools > options > text Editor > C++ > experiments > Code Analysis. When you open or save a file, the code analysis can be run in the background, and the results are displayed in the error list and as green waveform curves in the editor.

­C++ debugging improvement

­We have made the following debugging improvements:

­my-only code functionality now allows you to step through code in the system or third-party C++ libraries, as well as to collapse those calls in the call stack window. This behavior can be controlled for any C++ library when the code is compiled with / JMC and a non-user library path is specified in the .natjmc file. If the system library invokes the user code when you enter, the debugger skips all system code and stops on the first line of the user code callback.

­data breakpoints can now be set in the Monitor, Quick Monitor, automatic, and Local variables windows so that they can be cut off with just a few short clicks when the value stored in memory changes.

­Source links allow information about the original source code of an executable or library to be embedded in PDB during compilation.

­when debugging, if the program terminates execution, the console window will now remain open by default (similar to running the program without a debugger). You can switch this behavior back to the automatic shutdown console in tools > options > Debug > General.

­Visual Studio Web tool

­Library Manager is a new feature included in Visual Studio 2017. Helps manage client libraries in Web projects.

­Container tool

­added a new single project Docker container experience for the ASP.NET Core Web project. This complements existing Docker Compose-based container tools and provides a simpler and easier way to create, debug, and generate Docker containers directly from Visual Studio.

­when creating a project, you can add Docker support.

­alternatively, you can enable Docker support for existing projects through the context menu of the project in solution Explorer. Once you do this, Visual Studio creates a single Dockerfile in the project. You can choose Windows or Linux.

­Visual Studio also adds a debugger startup configuration file for Docker so that the project can be debugged when it runs within the container.

­if you have a solution with multiple Docker projects, by default, only one container runs when you choose to start the solution. If you want to run multiple containers at the same time, right-click the project in solution Explorer and select set Startup Project, multiple Startup projects. Then set the actions drop-down list to start or start (do not debug) for all projects you want to run.

­after the containerized project is running the way you want, if you are ready to push the project to the Azure container registry or DockerHub, you can right-click the project and select generate Docker Image to generate the image locally.

­in addition, you can add existing Docker Compose-based functionality to ASP.NET Core Web projects through the new Container Business process Coordinator support option. Right-click the ASP.NET Core Web project in solution Explorer, select add > Container Business process Coordinator support, and then select Docker Compose from the drop-down list menu.

­release improvements

­this release includes the following release improvements:

­when you publish a Docker container to the container registry, you can now customize the markup of the image. You can add tags manually (the default is up-to-date), or use automatically generated tags to ensure that each tag is unique.

­when you create a new Azure application service, you can also configure Application Insights to automatically collect telemetry data. If the selected area also has Application Insights, it is enabled by default. If the selected area does not already contain Application Insights, you can manually specify a different zone for the Application Insights resource from the drop-down list.

­when publishing an Azure Functions project, you can choose to publish using the new Run-From-Zip feature.

­Visual Studio Tools for Xamarin

­this release includes the following Xamarin updates:

­added support for Xcode 9.4.

­when you create a new Xamarin.Forms project, the default code sharing option is now .NET Standard. The shared project option is still available.

­added improvements to Android incremental generation. Xamarin.Android uses files generated in the intermediate output directory to achieve incremental generation faster than full generation. Previously, if you changed the target framework of the project, it would invalidate the file and achieve a full build the next time you run. In this version, the files in each frame folder are kept so that you can switch between different target frames, and you can still use incremental generation. By cleaning up the project, you can recycle the disk space occupied by the reserved files.

­We have added minimum support for Xamarin.Mac binding projects in Visual Studio 2017. In this way, Visual Studio can load the Xamarin.Mac binding project and recognize it as "supported". In addition, Xamarin.Mac binding projects can be generated, but the build process is performed locally instead of using the native Mac toolchain, so the generated IL assemblies cannot be used when running or debugging in the application.

­Hyper-V Android Emulator support

­this version now supports the use of Hyper-V-compatible Google Android Emulator at run time on the April 2018 update of Windows 10. In this way, you can use Google Android Emulator in parallel with other Hyper-V-based technologies such as Hyper-V virtual machines, Docker tools, and Hololens emulators. A fast-running Android simulator is now available for mobile application developers using Hyper-V, which always supports the latest Android API, can be used with existing Google Play Services, and supports Android Emulator features such as camera, geolocation, and quick launch.

­Xamarin.Android designer

­significantly improved the designer experience of Xamarin.Android. Highlights include:

­introduced the split View Editor, which can be used to create, edit, and preview layouts at the same time.

­improves the Intellisense experience while improving the reliability of custom controls.

­support the use of sample data for values provided by the system.

­Xamarin.Forms previewer

­when using Xamarin.Forms version 3.1.0.583944 or later, the Xamarin.Forms previewer now provides toolkit support. Xamarin.Forms controls will be displayed in the toolbox, making it easier for beginners to find them. You can also drag and drop controls into the XAML code editor to add controls to the page.

­Python

­this release adds the following improvements for Python developers:

­Python IntelliSense now uses typeshed definitions to provide richer results for libraries that cannot be inferred automatically from static analysis.

­the experimental debugger, first introduced in preview version 15.7, is now the default debugging engine used by Python, providing faster and more reliable debugging for Python code.

­added support for Python 3.7with patches to enable calls to additional functions, analysis capabilities, and mixed mode (cross-language) invocation functions.

­to learn more about the above features, be sure to check out the Python blog posts in Visual Studio 15.8.

­migrate local Azure function settings

­the managed Application Settings dialog box provided on the publish summary page now displays values in local.settings.json files and allows you to migrate these values to remote Azure function applications hosted in Azure.

­connected servic

­for solutions for Azure function projects, continuous delivery of Azure Functions can now be configured directly through Visual Studio 2017.

­Test improvements in resource manager

­when a grouping in the hierarchy view is selected, Test Explorer now displays a more detailed test status summary pane (the lower pane of Test Explorer). The window now shows the number of failed, passed, or unrun tests in the group.

­New extensible functional language server protocol

­Visual Studio now provides native support for language server protocols. Extension authors can create extensions to communicate with existing language servers to add additional language support to Visual Studio. Extension users can install these extensions to start using a language they are familiar with (such as Rust) in Visual Studio.

­AsyncPackage template

­extension authors can now optimize the performance of their extensions by creating AsyncPackage through item templates. To learn more about how to use AsyncPackage, refer to this document.

­expansion pack

­with the expansion pack, you can easily share your preferred set of extensions or set up a new Visual Studio installation with all the extensions. With expansion packs, you can create a list of extensions, package them in extensions, and use the list to quickly install these extensions in bulk.

­Command Line extension release

­publish the extension to Visual Studio Marketplace using the command line.

­.NET Core SDK 2.1.400

­Visual Studio 15.8 comes with .NET Core SDK 2.1.400. New SDK features include:

­added NUnit template

­added support for signed global tools

­improved help text to make it clearer

­32 issues on the .NET Core CLI have been resolved. 20 problems on .NET Core SDK have been solved.

­Source code control

­for .NET Core projects, files added directly to the project through File Explorer can now display the correct Git and TFS tracking icons in solution Explorer without reloading the solution.

­.NET test adapter extension: disruptive changes and deprecation

­.net test adapters have the following disruptive changes and deprecations:

­disruptive changes: all test projects must include their own .NET test adapter NuGet references in their csproj. If not, when you start the discovery of the test adapter extension after the build or when the user tries to run the selected test, the following test output is displayed in the project:

­the test project {} does not reference any .NET NuGet adapters. Test discovery or execution may not apply to this project. It is recommended that the NuGet test adapter be referenced in each test project of the solution.

­. Net Test Framework has released its adapter in the NuGet package and has moved out of the Visual Studio extension. The .NET test adapter support provided through extensions has been deprecated (although it is still supported). This means that two new options are available through tools > options > Test.

­with the first option, Visual Studio can only use the test adapter it found in the test assembly folder (populated by the test adapter NuGet reference) or specified in the runsettings file.

­with the second option, Visual Studio can "fall back" to the previous behavior and search for test adapter extensions for projects that do not have a test adapter NuGet reference. These two options are checked by default, so the default behavior remains the same in this version.

­Please note that this change does not affect non-.NET test adapters.

­ASP.NET .NET Framework password support

­for ASP.NET .NET Framework projects for .NET Framework 4.7.1 or later, you can now open unwanted passwords in the source code and store them in usersecrets.xml by right-clicking the project and selecting managed user password.

­.NET Framework 4.7.2

­Visual Studio 2017 version 15.8 now provides .NET Framework 4.7.2 (including 4.7.2 runtime) for all supported platforms. The .NET Framework 4.7.2 provides a number of new and improved features, as well as a number of patches for reliability, stability, security, and performance.

­for more details on .NET Framework 4.7.2, refer to the following article:

­.NET Framework 4.7.2 RTM blog

­.NET framework 4.7.2 release not

­known issues in .NET Framework 4.7.2

­Application compatibility in .NET Framework 4.7.2

­API Chan

­delayed loading software packages that are automatically loaded asynchronously

­Visual Studio now delays loading asynchronous packages that are configured to load automatically until Visual Studio IDE is fully started and the solution is loaded. This change does not affect packages that are automatically loaded synchronously. Users can view the Task status Center in the lower left corner of the status bar to monitor progress. The extension author who created the asyncpackage should test its extension. For more information, see Improving the responsiveness of critical scenarios by updating auto load behavior for extensions (improving the responsiveness of key scenarios by updating the extended autoload behavior).

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.