What Is Visual Studio?

Visual Studio 2022 is one of the most powerful and popular IDEs (Integrated Development Environments) among .Net and C++ developers. It can be used for the development of various types of software, including websites, web services, mobile, desktop, web apps, games, and so on.

Visual Studio provides many features that speed up and simplify the process of writing and testing code, including a code editor with IntelliSense and code refactoring, an integrated debugger that can work as a source-level and machine-level debugger, tools for creating the user interface, a code profiler, etc.

You can download the Visual Studio installer from the official website.

How To Use Visual Studio For C++?

C++ is a popular low-level, high-performance programming language that can be used to create many different types of applications. Visual Studio has all the tools you need to easily write C++ applications.

Visual Studio supports various versions of the standard for the C++ programming language and allows you to use all its modern features. With Visual Studio C++, you can perform classic Microsoft Windows desktop development or universal Windows applications for HoloLens, Surface Hub, PC, and Xbox development.

In addition, you can use Microsoft Visual C++ for Linux development, mobile, and game development.

What Are The Most Common Visual Studio C++ Pain Points?

Although Visual Studio offers many useful tools and is a great solution for C++ development, there are pain points that developers who use it occasionally run into.

Poor performance

While it is designed for C++, these projects can sometimes be extra complex and Visual Studio may struggle performance-wise. It would require more resources such as disk space and operating system memory. This is especially noticeable when working with large projects.

Long build time and slow compilation

The process of building projects takes a lot of time. The compilation is slow, which greatly complicates and slows down the process of finding and correcting bugs in the source code.

Stutters and freezes during coding

Sometimes there are cases where the machine freezes during coding, which leads to the need to reboot it. In this case, the programmers need to start over the unfinished work should they be unlucky enough to have forgotten to save.

Chaotic file organization

When working with C++ files in Visual Studio, you need to first create folders and files on the computer disk. Then you need to create a project in Visual Studio and add the already created files and folders to it. The project only lists the names and paths of files and folders that should already exist on your drive. This is different from how Visual Studio works with other programming languages and is awkward and confusing, especially on collaborative projects or complex solutions.

Understanding Complex C++ Language

C++ is a complex programming language that supports higher-order types, a standard library for CPU cache line sizing, dimensional analysis, and other functional paradigms. Even experienced C++ developers have to learn hidden features and discover new ways to optimize their development.

So, it’s time to solve the most common Visual Studio pain points.

What Are The Visual Studio Extensions Available In The Market?

Visual Studio Marketplace [1] provides a wide range of extensions to enhance the capabilities of Visual Studio. GitHub Extension for Visual Studio, CodeMaid, and Visual Assist are very popular among the developer community.

By making it simple to connect to and collaborate with your repositories on GitHub and GitHub Enterprise, GitHub Extension improves Visual Studio 2015 and Visual Studio 2017. It creates new repositories or clones existing ones to get working together.

Our C#, C++, F#, VB, PHP, PowerShell, R, JSON, XAML, XML, ASP, HTML, CSS, LESS, SCSS, JavaScript, and TypeScript coding may be cleaned up and made simpler with the help of the open source CodeMaid Visual Studio extension.

More extensions are available in the marketplace to enhance the capabilities of Visual Studio and improve productivity. However, Visual Assist provides solutions for most Visual Studio C++ pain points mentioned earlier. The following section will discuss it in detail.

The Pain Killer You Need – Visual Assist

Visual Assist is a productivity extension for Visual Studio that has many features for refactoring, quick navigation, code generation, and much more. It provides tools for the automatic detection and correction of errors in the code, automatic understanding, and completion of the code, syntax highlighting, and improved debugging functions. Using Visual Assist greatly simplifies the process of coding in Visual Studio C++ and increases development productivity.

Advantages of Using Whole Tomato –  Visual Assist

Let’s list the main benefits of using Whole Tomato Visual Assist.

Increase Your Productivity

Visual Assist offers advanced navigation features that let you quickly go to any file, method, reference, or code symbol in your projects or solutions. You can also automate code refactoring activities. Advanced features of automatic code generation make the process of writing code as fast as possible, which significantly increases development productivity.

Fast & Responsive Tooling

All Visual Assist commands and tools are responsive and work quickly, which allows you to use them even when working with large and complex projects.

Helps Optimize Workflows

With Visual Assist tools that make code generation and debugging easier, you can optimize and streamline your project workflows.

Adds Support (Fills Gaps)

If you have any problems with Visual Assist, you can use our knowledge base or search for a solution to your problem in the forum. In addition, there is technical support where you can get answers to all questions about working with the Visual Assist extension.

Everything Becomes Customizable

You can fully customize Visual Assist to your liking. This includes customizing colors and shortcuts.

Final Verdict

Visual Assist is the best extension for Visual Studio C++ development, which has numerous advantages and makes the coding process quick and easy. Give Whole Tomato a spin. Sign up for free.

FAQ

Which Visual Studio is Best for C++?

Visual Studio is a widely used IDE that is excellent for development in C++ and supports various standards of this programming language. Another popular Microsoft product used for C++ coding is Visual Studio Code. It is an open-source, cross-platform code editor that offers “Microsoft C/C++” extensions for C++ programming.

How do I Find Build Errors in Visual Studio?

To find build errors in Visual Studio you should choose View -> Error list or use the shortcut Ctrl+\, E. In addition to errors, you can also view a list of warnings and other messages.

How do I Resolve to Build Errors in Visual Studio?

Select the error message in Visual Studio and press F1. Visual Studio will open the documentation page for this error, where you can find workarounds.

[1] https://marketplace.visualstudio.com/

The post Solving The Most Common Visual Studio C++ Pain Points first appeared on Tomato Soup.

Visual Assist is a native plugin, so compiled for either 32-bit or 64-bit Intel depending on which version of Visual Studio you’re using. If you run the normal version of Visual Studio, this is exactly what you need. But if you run the ARM version, you would need an ARM build of Visual Assist, and we haven’t yet shipped one. That is, right now you can’t use Visual Assist using the ARM build of Visual Studio.

We have a history of supporting new versions of Visual Studio very close to release. When Visual Studio 2022 was announced, we spent many months moving Visual Assist to 64bit, including blogging about our progress and which preview builds of Visual Studio we suggested using our beta version with. So you might expect us to release an ARM build within a few days… but we are not.

First, we will support ARM. It’s coming. It’s important to us to be on all platforms where Visual Studio is.

Second, we’re not prioritizing as urgently as we did for Visual Studio 2022 support, for the simple reason that very few of our customers are expressing interest in it, including requiring it – ie moving to ARM for development and thus being unable to use Visual Assist. What we’ve seen is interest along the lines of,

• ‘Do you have any plans in your roadmap?’
• ‘Will there be support for ARM sometime in the future?’
• ‘I’d like to use Apple Silicon.’

Those are close to verbatim quotes from the inquiries we’ve got, and we have only a handful. None of the feedback we’ve been sent indicates an urgent need for it, just interest. And that’s why we’re working on it, but not as urgently.

Currently, and with the caveat nothing is promised until it’s GA-ed / shipped, that means first half 2023.

We want to check: is this the right decision for you?

Do you need ARM? Do you need it now? What’s your use case: why are you using ARM?

Please send us an email at support@wholetomato.com. We will read with interest!

– David Millington, Visual Assist Product Manager

The post Visual Assist and ARM first appeared on Tomato Soup.

If you haven’t updated yet, download the latest release here.

Parser changes

One of the highlights of this release is improvements to Visual Assist’s parser. The parser is core to how Visual Assist understands (and therefore suggests) code.

Numerous upgrades and fixes have been undertaken to make the parser smarter. This makes it recognize modern C++ code standards and practices, thereby minimizing unwanted behavior as well. Here are some of them:

• Now distinguishes between std::get and std::tuple.
• Now understands parameters declared with “out int” in C#
• Fixed parser getting confused with case’1′ inside switch statement.

Expect a steady stream of updates to parser behavior. If you encounter any bugs or errors submit a bug report on our community forums.

Support for C++17’s structured bindings

With the parser changes, VA 2022.4 also includes added support for C++17’s structured bindings. Structured bindings enable users to declare multiple variables initialized from a tuple or struct, simplifying and improving code readability.

VA’s improved parser recognizes structured bindings introduced in C++17, adding support for VA features such as code suggestion and navigation.

With this change, variables that are contained within the binding are now recognized. For example, typing a dot will now be properly colored and displayed on the navigation bar. You can also rename, search, and perform all the other actions you would expect from VA.

Continued HLSL improvement

The recently-added High Level Shading Language (HLSL) support has been augmented with coloring support for a variety of file types. This includes matrix types double4x2 and fixed3x4, and some base types such as min10float3. Because HLSL typically lacks corresponding header files, a more sophisticated understanding of code was required.

For those who are unaware, official HLSL support shipped with the previous release. HLSL and Unreal’s USF and USH files now integrate with VA’s core features.

Respecting VSCode excludes config files

Visual Assist now includes an option to consider configuration instructions similar to those used in VSCode settings .json files. This comes at the request of those who wish to skip unnecessary parsing when building solutions. 

This means that you can open a file without needing to parse an entire project or a solution, saving precious time. This is a way to essentially tell Visual Studio and Visual Assist to “open a file but do not parse anything else apart from a specific part.”

Enable the option to detect and honor exclude settings via ticking a checkbox in Visual Assist options. Here is an example of a configuration file with exclude settings:

An example configuration that VA will now recognize. Note: The actual JSON files are often configured in VS Code itself through a UI.

A new code inspection

This release also adds an inspection for bugprone-string-integer-assignment—a check based on LLVM/Clang-Tidy. It checks for easy-to-miss instances of assigning an integer to  std::basic_string<CharT> (std::string, std::wstring, etc.).

Access other code inspections by accessing the following:
(If you are not seeing options, please remember to enable code inspections!)

• Quick Actions and Refactorings menu ( Shift + Alt + Q ) 
• VAssistX ->> Code Inspection (beta) ->> VA Code Inspection Results

Minor bug fixes

• Fixed comments getting duplicated in tooltips.
• Fixed issue where VA’s tooltips would not appear if IntelliSense was disabled
• Fixed issue where VA Outline tooltip spreads across two monitors with different DPI settings could cause the system to freeze.
• Fixed issue where tomato icon may become black on hover in VS 2022
• Fixed issue where class method name that begins with “using” is missing from MIF.

For more information about the changes in this release, head on over to the documentation. We hope you find these changes useful. Happy coding!

The post Visual Assist 2022.4 now available first appeared on Tomato Soup.

Visual Assist HLSL support

High-level shader language (HLSL), while vaguely similar to C in syntax, is a distinct language and thus most native Visual Studio features may behave differently.

This may bring some frustration, and that’s what VA intends to fix! We’ve had some manual registry edits to let VA work with shaders, but that hasn’t been well-known and we’ve also wanted to improve our internal support before officially supporting the language.

Which is why we’re excited to announce that Visual Assist ‘s features will now work for HLSL, USH and USF files—the latter two being the Unreal Engine-specific shader files.  This includes:

• Code navigation features
• Syntax highlighting 
• Context-aware smart suggestions
• Automatic code generation prompts

Basic HLSL syntax highlighted by Visual Assist.

Please note that support is still in early beta – marking ‘beta’ is standard practice for us for key new features – and that some complex features like refactoring may have some issues. We ask that when you work with HLSL and Visual Assist to send feedback our way to improve behavior.

We often focus on Unreal Engine, where VA is widely used, but HLSL files are used across the graphics industry and this feature is useful for all developers writing shaders, no matter the technology or engine you’re using.

Note: Because it’s in beta, shader file support is disabled by default. To enable it, go to Visual Assist Options ->> Game Development ->> Enable support for shader files

Two new code inspection updates

The first check involves flagging constructors with incomplete initialized fields. Constructors don’t always initialize all fields. And some types don’t have initialization that leaves them in a ‘good’ state – one example is a pointer type. This check flags constructors that leave fields of those types uninitialized.

The second checks for a common mistake when using std::string::compare (or other string types like wstring) method to compare strings. To elaborate, the compare method returns three possible values (instead of a simple boolean True or False) because its primary use is for sorting. If your code is using it where an equality or inequality check would work and be more readable or easier to understand, this check recommends it.

Check for std::string::compare

Access Visual Assist’s code inspections by accessing the following:
(If you are not seeing options, please remember to enable code inspections!)

• Quick Actions and Refactorings menu ( Shift + Alt + Q ) 
• VAssistX ->> Code Inspection (beta) ->> VA Code Inspection Results

New Linux-style navigation in Open File in Solution

Open File in Solution will now accept forward slashes to filter certain directories. Adding a forward slash ( / or \ ) before a string will filter all files not contained in a directory starting with the string. This is a productivity feature: on many keyboards / is easier to type than \, and so several customers requested the forward-slash work. A small feature, but one we think shows our dedication to useful details.

And for those who are unaware, Open File in Solution also accepts the following:

• Negative filtering ( – )
• Multiple entries ( , )
• BeginsWith filter ( .string)
• EndsWith filters ( string. )

You can learn more about available options in the documentation.

Even more

There are several quality fixes as well, since every release we aim to make it better. For more information about the changes in this release, head on over to the documentation.

We hope you find the new inspections and shader support useful, and as always, happy coding!

The post Visual Assist 2022.3 now available first appeared on Tomato Soup.

Visual Assist extends Visual Studio to improve the development experience by providing tools for understanding, checking, and writing code. Its benefits include code inspection, fast navigation, refactoring, code assistance, code correction, and more. This article will discuss the top 10 reasons to use Visual Assist for Visual Studio 2022. 

What are the Benefits Provided by Visual Assist for Visual Studio 2022?

Visual Assist has several features to enhance developer productivity. These features virtually improve every Microsoft IDE with great benefits. Visual Assist helps fill gaps in Visual Studio for C/C++ and C# developers. Let’s discuss the reasons why developers need Visual Assist for Visual Studio 2022.

Write Code Faster With Assistance

VAX coding assistance helps write code faster, especially when on a roll. It suggests completions to avoid typing errors and quietly fixes mistakes in your wake.

• Acronyms: Write code faster using acronyms. Visual Assist extends the acronyms into the valid symbols in current content. Continue typing the lowercase letters if uppercase fails to isolate a symbol. 
• Auto-extend Multi-Line Comments: You can quickly expand multi-line comments from anywhere. Divide a line, and VAX opens a new line using an appropriate comment token at the right indent level.
• Enhanced Listboxes: Hover over the list boxes and control the content with a toolbar from VAX. Reorder Listbox content, or you can filter it by type. Find the required member by investigating a class without leaving your position.
• Multiple Clipboard: Quickly paste the copy-before-last using Ctrl+Shift and Enter because VAX always preselects the second clipboard in the menu. 

Reduce Code Complexity

Refactoring helps reduce the code complexity, enhance its readability, and extend it without changing the external behavior. This feature allows refactoring the legacy code, inherited code, or the first version of your work.

• Access to Refactoring Commands: These commands are available in menus accessible by mouse and keyboard, and the menu contents may vary with the context. 
• Extract Method: Move a code segment into a separate method and then replace the segment using a call to the extracting method.
• Introduce Variable: Replace an expression using a variable that explains the purpose of replaced code.
• Move Implementation to Header File: In C/C++, move a method implementation from the source to the class declaration or a header file.

Faster Code Generation

Visual Assist helps you generate code faster than you think, even only using a few features. You can write and update code faster once you become a proficient user.

• Forward Declaration: Add a forward declaration for a referenced symbol. For example, a pointer to a class from the current location.
• Add Member: Quickly add a member variable or method from any class reference without interfering with your normal flow.
• Add Similar Member: Open a refactoring menu from a reference to create a member similar to the existing reference. This top-down programming style doesn’t interrupt your normal flow.
• Add a Directive: In C/C++, add a directive quickly to the current file for making a symbol known. 

Makes Complex Code Easier

Make complex code easier with various tool windows, fields, and browsers, providing information where and when you need it.

• Column Indicator: VAX displays an indicator at the trailing edge of the specified column.
• Context Field: Glance at the Visual Assist navigation bar contact field to determine the definition and scope of the current symbol.
• Definition Field: Glance at the VA navigation bar right portion to determine the definition of the current symbol.
• Highlight Matching Word: It automatically highlights words that match the symbol at the caret as you move through comments and strings.

Fix Errors With Core Correction

Visual Assist quickly corrects mistakes as you make them, particularly errors in pointer notation and symbol case. Type in lower case and let Visual Assist correct the case symbol in your code.

• Highlights Files in Output Window: Add a standout after files built in your solutions with errors. The code correction feature makes it easier to determine what needs to be resolved.
• Repair Case: Type in virtually all lowercase or a mix of lowercase and uppercase. Visual Assist resolves the case symbol errors in the current context. Type definitions and declarations in camelCase.
• Underline Spelling Errors: Recognize the misspelled words in the code and repair them. Misspelled words appear with similar squiggles. VA lets you browse code without distractions of squiggles, as they appear only in modified files.

Code Inspection

Inspect your code for resolving quality issues. Based on LLVM/CLANG, this Visual Assist feature detects and fixes programming errors, such as interface misuse, style violations, and bugs that can be inferred through static analysis.

• Code Inspection Setting: Enable code inspection and quality checks in the Visual Assist options dialog box. The LLVM/CLANG parser executes in a separate process from Visual Studio to avoid degrading performance.
• Code Issues in the Editor: When you enable this feature, it highlights code issues in the Visual Studio text editor. The first few characters of code issues are underlined in a dotted or solid fashion.
• Quick Fixes in a Tool Window: Code issues are also available in a tool window identifying all issues for the current file. Apply fixes to all issues in a batch for a specified level.

Edit Custom Code Snippets

You can extend frequently typed code segments with a powerful version of like-named features. Include symbols from the current content and edit snippets in a custom editor.

• VA Snippers: Insert common code snippets with the powerful and accessible version of the like-named IDE snippet.
• VA Refactoring Snippets: You can edit various Visual Assist snippets bound to code-generation and refactoring commands and force new code adhering to the formatting preferences.
• Smart Suggestions: It defines suggestions to speed typing and optimize accuracy while assigning a value to a user-defined or built-in type and building constructs, such as loop, switch and a class.

Reduce Debugging Time

Use the Virtual Assist memory view and the step filter to reduce the time required to debug native C/C++. 

• Address Resolver: Debug native C/C++ while debugging information reaches in text form. Address Resolver reads DLLs, EXEs, and PDBs, and detects the symbols associated with the text version of visual addresses.
• PDB Explorer: Browse and search for module symbols comprising executable code, whether or not the code is in the running process. Find symbols in DLLs and EXEs as you were detecting symbols in a solution.
• VA Step Filler: Step directly into methods while stepping through native C/C++ without necessarily stepping into an argument list methods.

Efficient Tool Windows

View code from 30,000 feet and rearrange it to make it easier to understand and maintain. Visual Assist tool windows supply entirely new functionality to the IDE and bring together often-used built-in functionality for more efficient tool windows.

• VA Hashtags: Access your VA hashtags in the single tool window. You can view bookmarks and defined tasks in the comments throughout the project. 
• VA Outline: Inspect methods, classes, and file-scope declarations in the active document with VA outline. Modify the active document, and the VA outline stays in sync. 
• VA view: You can browse and navigate code efficiently with the VA view, a window generally kept in the foreground while editing. You can access the best features of various IDE tool windows in the VA view.

Easy Configuration

You can adjust many features in Visual Assist that suit your programming habits and environment. Find your favorite features and use them for maximum productivity.

• Context Menus: Use menus to access context-specific content. You can bind a shortcut to the VA context menu containing all features available for the current symbol, file, or position in the editor.
• Custom File Extensions: Make Visual Assist parse files without extensions as header files and consider files with specific extensions as header files or sources.
• Keyboard shortcuts: Learn the shortcuts assigned during Visual Assist installations, evaluate recommended shortcuts and assign them for the remainder of your favorites. 

Ready to use Visual Assist for Visual Studio 2022?

Visual Studio extensions are efficient tools to enhance developers’ productivity and efficiency. There are various extensions for Visual Studio, but developers find Visual Assist more productive than others. 

Visual Assist for Visual Studio 2022 helps you make coding easier with its unique and productive features. You can make the development environment more comfortable with the right practical measures. 

This article highlighted the most compelling reason showing that you need Visual Assist for Visual Studio. Visual Assist offers plenty of features to let developers code faster and more efficiently. Install Visual Assist to get a reliable extension for Visual Studio to increase code efficiency and speed. 

The post 10 Compelling Reasons Why You Need Visual Assist For Visual Studio 2022 first appeared on Tomato Soup.

This blog could be as short as that sentence, but I’d like to write a bit more about our support and how we got here. Meanwhile I recommend if you’re using VS2022 you download and install 2021.5 now!

Background

Historically it’s been very important to us to release support for new versions of Visual Studio very quickly, and if you’ve read our blog posts this year about VS2022, you’ll have read me say that before. While many customers stay on older versions for some time, we have a lot of people who upgrade immediately, so we’ve always put a lot of emphasis on being able to ship a version of Visual Assist supporting new versions of Visual Studio quickly. While I’ve been product manager here for almost three years, this is the first new major version of Visual Studio during that time, and I and the whole team were keen to continue that speedy-support tradition.

We started work supporting VS2022 early, and we’ve shared our progress over this past nine months about the work we’ve been doing to support VS2022, with beta support for Previews 3, skipping 4 due to a breaking bug, and 5, 6, and 7/RC. We released Visual Assist 2021.4 shortly before Visual Studio 2022 was released, and many of you are using it with VS2022 already.

Visual Studio 2022 was a large change from previous versions. Not only did it change to 64-bit, but there are many new APIs as well, and these APIs change the interaction model from synchronous to asynchronous interaction. This is a pattern Visual Studio has been following for several years (and we encourage it—it really helps the IDE) but as you may know migrating from any sync to async model is rarely trivial. Usually, the majority of the work for each new Visual Studio release is around adapting to API changes, and that was the case here too. In fact, the most major bug we saw using Visual Assist (abbreviated VAX) 2021.4 with VS2022 and which was one of the issues we fixed for today’s official support, an issue where the code suggestions window sometimes did not show in the right place, was related to the move to one specific async API.

Timeline

• We released Visual Assist 2021.4 on October 29.
• Visual Studio 2022 was released on November 8, nine days later.
• VAX 2021.4 overall worked pretty well with the final VS2022 build
  • But both we and some customers found a few more issues, and we’ve spent the past two weeks since VS’s release resolving them
• VAX 2021.5 with official support for Visual Studio 2022 was released on Nov 22!

Official Support for VS2022

Yesterday afternoon US time we posted Visual Assist 2021.5 on our website. We have a rolling release mechanism and in about a week you should see in-IDE notifications about the new release, followed a couple of weeks later with the new version being available in the Visual Studio Marketplace. However you can directly download and install it now.

We’ve been working on VS2022 for something like nine months now and we’re really happy to have Visual Assist publicly available with Visual Studio 2022 support. We hope it is useful to you!

A note of thanks: VS2022 was a large change from previous versions, and Microsoft has been very open and helpful. We’re very grateful to them for their communications with us, the beta program, and their assistance while we’ve added support. Thank you!

I want to note as well that though as PM I get to write these posts, I really do very little, and all the credit for this release and VS2022 support goes to our amazing team. Thank you!

The post Visual Studio 2022 Support! first appeared on Tomato Soup.

VAX 2021.4 is a quality-focused release. Our last release, 2021.3, was mostly focused on supporting the upcoming Visual Studio 2022 Previews. That early work on support for VS2022 means that when the official release of VS2022 is out, we’ll be able to ship official support very fast. (More on this below.)

However, not everyone upgrades to a new Visual Studio release immediately — in fact many people have very good reasons for staying on older versions for quite some time! — and we want to focus on providing what all our customers across many versions need. (We still support VS 2005!) That’s the focus for this version. This release, as a quality release, focuses on fixing bugs and adding changes for everyone.

Our release notes contain full info, but some notable changes include support for the new External Include Directories property in Visual Studio, and updating the Code Inspection engine to LLVM/Clang version 12.0.1. There are a plethora of bug fixes as well. All up we feel this release is a solid update for you no matter which version of Visual Studio, and for all ways that you use Visual Assist.

Visual Studio 2022

Swiftly supporting new versions of Visual Studio is very important to us, because we understand it’s important to many of you, and we hope you’ve enjoyed seeing VAX working in many of the Visual Studio 2022 Previews. We expect VS2022 to be released very soon. In fact, as we were preparing this release, Previews 5, 6 and 7 came out, the pace increasing so fast that our installer only mentions support for Preview 6, but we do in fact support Preview 7 as well. At the same time we’ve seen significant stability improvements with each newer preview.

We don’t want to delay our release schedule to wait until VS2022 is shipped, especially because this release is focused on what customers using other versions need, which is why we’re releasing now. But since VS2022 will be released so soon, and since we are very ready for that to happen, you can expect a swift mini-update from us adding official support.

In other words:

• VAX 2021.4 supports Visual Studio 2022 Previews 5 and 6 (with issues leading to hangs), and 7/RC3 (fully)
• We’re eagerly waiting for VS2022 to be released, and we’ll add official support for it very quickly when it’s out

We recommend you install Visual Assist 2021.4 now, and we look forward to shipping official support for Visual Studio 2022 very soon.

The post Visual Assist 2021.4 is released! (And notes on Visual Studio 2022) first appeared on Tomato Soup.

Visual Studio Preview

Visual Studio (VS) 2022’s main change—and it’s a significant one—is that it will become a 64-bit process. Since Visual Assist (VA or VAX) runs as a plugin, in-process, we needed to build a 64-bit version of our plugin DLL. Those who have upgraded 32-bit code to 64-bit code before know that, even in well-architected code, it takes some work even just to review code to ensure it is correct. In addition, the new version adds and modifies a number of APIs we rely on to interact with the IDE. Adapting to those was the most significant change for us.

We’ve tested fully against VS 2022 Preview 2, and in fact the installer says ‘Preview 2’. There are some known regressions:

• VA Quick Info not appearing when triggered by keyboard in VS 2022 [case: 146063]
• Source Links example plugin does not load in VS 2022 [case: 146012]
• Changing from Cascadia to another font for italicized system symbols requires restart in VS 2022 [case: 145979]
• plus a few others.

Visual Studio 2022 Preview 3 was released two days ago—overlapping timing with our release—and our regression tests are showing some failures. Currently we believe those are because of changed behaviour in a Visual Studio API which we use when verifying in-IDE behaviour (ie not an issue in VAX itself), but it is always possible that once that is resolved further test failures will need to be resolved. However, we believe the current build is well worth trying out on Preview 3 as well.

Performance

Many of our customers strain the Visual Studio IDE, with many plugins and SDKs installed. Both to help them, and because we believe it’s part of being a good member of the Visual Studio ecosystem where our plugin sits alongside others, last November we greatly reduced the in-process memory usage largely through (spoiler: the full blog is worth reading) use of memory-mapped files.

Now that Visual Studio 2022 is a 64-bit process, that work is not necessary for VS2022. For older versions of Visual Studio, those techniques are still used, so if you’re using VS 2019 or even VS 2005 with Visual Assist 2021.3, you’ll still benefit from the lighter memory impact within the IDE.

When we did that work, we also focused on performance to ensure that the changes to memory access had either zero or a positive impact. The blog notes that for heavy usage, we had equal performance; for small projects, VAX actually was a bit faster. Despite no longer needing the memory usage code we added, VS 2022 benefits from that performance work as well, plus some more work we’ve done while adding support. Since it’s a beta build, and Visual Studio itself is in preview, we do not have hard numbers. But a rough guideline is that an operation like Find References that previously may have taken (say) two minutes will now take about one minute twenty seconds, or about two thirds the time.

Overall

It’s historically been very important to us to have swift support for new versions of Visual Studio, and this work is our foundation for quickly officially supporting Visual Studio 2022 when it is officially released. While the main focus of this release was VS 2022 support, there are other changes as well in 2021.3, which we’ll document in the What’s New. We know we have many customers using older versions of Visual Studio, and as well as those improvements today you can look forward to further improvements focusing on other, non-VS areas as we switch back to a more normal focus in our next release.

We’re really happy to be able to ship beta support for the Visual Studio 2022 previews, and providing an even faster Visual Assist is a happy bonus. We’ll continue to work and look forward to shipping full support when Visual Studio publishes its final release.

Visual Assist 2021.3 is available for download on our website now, and will be on the Visual Studio Marketplace in a few days. Enjoy!

The post Visual Assist support for Visual Studio 2022 Previews! first appeared on Tomato Soup.