If you know your way around Microsoft Visual Studio, especially if you know its boundaries, you’ll find Visual Assist to have features you wish were standard in the IDE. This extension makes the IDE phenomenal.
If you're already a fast coder, a wee bit set in your ways, and skeptical of plug-ins and extensions, you'll really appreciate the understated interfaces of Visual Assist. This product doesn't get in your way.
If you cringe at the thought of another parser running as you edit, you'll be impressed with the speed of Visual Assist. This plug-in doesn't consume resources just to tell you you've violated a formatting standard.
They're all really great.
Improve virtually every Microsoft IDE you have with the multitude of features that comprise Visual Assist.
Navigation
Move about your code with newfound ease—to any file, method, symbol, or reference in your projects and solutions. Get anywhere from anywhere. Let Visual Assist remember where everything is.
Open a list of all files in a solution, and optionally include all open files and windows. Shrink the list with path filters, multiple match strings, and negative filters. Click a column heading to sort. Shift+Click and Ctrl+Click to open multiple files.
Open a list of all symbols in your solution, and optionally include all symbols in 3rd party libraries. Shrink the list with prefixes, multiple match strings, and negative filters. Select a symbol, and find its references or jump to its implementation.
Open a context menu in the dialog to set advanced options.
Open a list of references to the current symbol, or to a symbol in any tool window of Visual Assist. Read and write access are differentiated in the results using light blue and pink by default.
Clone the results to find references to other symbols without losing your original set.
Open the context menu in the results window to filter results and set advanced options.
Jump where you need to be using the default shortcut (Alt+G) or Go button, from within comments, into frameworks that support code-behind, and into source files outside your projects.
Jump to more places using the default shortcut for Goto Related (Shift+Alt+G). Locations vary with type of symbol, but may include definition of a type, base classes, base methods, derived classes, constructors, and overridden methods.
Browse members of a class, or "members" of other data structures, such as enums, namespaces, and structs. Browse via a dialog that supports filtering.
Use the Down Arrow in the VA Navigation Bar, or the default shortcut Alt+M, to see a list of all classes and methods in the current file. Filter the list using multiple match strings, and jump where you need to be.
Use the tiny arrows in the VA Naviation Bar to move to the next, and previous, methods and scopes in the active document. Assign shortcuts for faster access.
Find the next reference of any symbol, skipping like-named symbols found with F3. Use buttons in the Visual Assist toolbar, or assign shortcuts for faster access.
Open quickly the file that is most related to the active document. In C/C++, that typically means the corresponding header or cpp file. In C#, the designer and code-behind files, or aspx and source. Use a toolbar button, or the default shortcut Alt+O.
Hashtags in comments act as named bookmarks that are shared, move with code, and can be accessed in all solutions. VA Hashtags can also define tasks for all developers of a solution. (No configuration required.) Navigate to hashtag references using a tool window or the Goto Related (Shift+Alt+G) command.
Glance at the VA Navigation Bar to determine your current scope, to a degree more detailed than that of the IDE navigation bar. Visual Assist is specific to the class, method, and language construct. For language constructs such for(), if() and while(), the right portion of the VA Navigation Bar includes the condition of the statement.
Navigate back and forward in your code much like you do with an Internet browser, to and from more places than the navigation commands in the IDE. Visual Assist extends navigation among files. If you navigate into file B, return quickly to your location in file A.
Highlight using background color, or thin frame that does not obscure text and special characters.
Refactoring
Reduce the complexity of your code, improve its readability, and make it extensible without changing its external behavior. Refactor legacy code, code you inherit, or the first version of your own work.
Refactoring commands are available in menus accessible by keyboard and mouse, and contents of the refactoring menus vary with context. Refactoring is available in the tool windows of Visual Assist, and in the text editor on symbols, selections, and whitespace.
Open a context-aware refactoring menu for the current symbol with the default shortcut Shift+Alt+Q.
Obtain a complete list of refactoring commands in the context menu of the text editor.
Hover over a symbol and Visual Assist displays an icon when refactoring is available. Click the icon to open a context-aware menu.
This often-used refactoring renames the definition and declaration of a symbol, all references to it, and optionally, occurrences in comments and strings. A preview of all targets to be renamed is always shown so you are confident the rename does what you expect. Deselect any references you want untouched, and undo the entire operation if you make a mistake.
Rename is available for:
Select Rename from any of the refactoring menus, specify a new name, and set your options. The preview of changes differentiates read-only and writeable occurrences.
Update the signature of a method or function in a simple dialog, and Visual Assist infers the differences between the original and new signatures. Reorder, rename, add, and delete parameters with this powerful refactoring that also updates all references to your method. When renaming a parameter, references to it within the method are also renamed.
Change any or all of the following parts of a signature:
Similar to the rename refactoring, set the scope of the change and preview the set of references that will be refactored.
Restrict actions on a member field with the Encapsulate Field refactoring. Accessors are created and named automatically, and your original field is untouched in the event you need legacy code to compile as you update references. If you encapsulate a new field, immediately make the field private to restrict future access.
In C/C++, accessor methods are created adjacent to a declaration in a header, and can remain in the header for inline execution.
If you prefer implementations in a source file, follow Encapsulate Field with another refactoring to move the implementations to a corresponding source file.
Make long methods easier to read and share common blocks of code with the Extract Method refactoring. Extract multiple lines, or a segment of one. The return value and parameters of the extracted method are determined for you.
In C/C++, the refactoring creates an inline method in a header, or extracts the implementation directly to source.
Introduce Variable defines a temporary variable in the innermost scope of the selection, initializes the temporary variable with the replaced code, and replaces one or multiple occurrences of the expression with the temporary variable.
Rename the active document and its corresponding files easily, without interrupting your flow or breaking the build. Visual Assist automatically updates files, projects, and solutions, and then propagates the rename through source control systems that integrate with Microsoft Visual Studio.
In C/C++, headers and source files are renamed in pairs, and the rename of a header automatically updates all directives that #include the header. In C#, design and code-behind files are renamed simultaneously.
The refactoring creates the new file in the same directory as the active document. Define the format of the new file with a VA Snippet. In C/C++, Visual Assist can replace the selection in the active document with an #include if the selection is moved to a header.
This refactoring is often initiated after other refactorings that place implementations in header files for inline execution, e.g. Encapsulate Field. The refactoring creates a declaration in the header, and moves the implementation near those of other methods in the same class. Define the format of the implementation with a VA Snippet.
To complement to the refactoring command that moves a single implementation, this plural version moves all methods from a header to a class. Invoke the command from the name of a class, not from one of its members. A dialog appears in which you can select the implementations to move.
Generate code faster than you think possible, even if you use just a handful of the features in Visual Assist. As soon as you're a proficient user, share with us ways to improve Visual Assist so you're even faster.
Type the name of an undefined symbol, and open a refactoring menu to introduce the symbol without leaving your current position. This top-down style of development works for many targets, including enums, variables, functions, and methods.
Tell Visual Assist what target to create in the dialog that opens.
Add a method or member variable to a class from any reference to the class, without interrupting your normal flow.
Specify the signature of the new method or member variable in the dialog that opens.
Open a refactoring menu from any reference to create a member in a class similar to the existing reference. This style of top-down programming doesn't interrupt your flow.
Specify the name of the new member, and modify its signature if necessary.
Implement methods from a single inherited interface or class by opening the refactoring menu when the text caret is on an inherited object. Implement methods from all inherited objects by opening the refactoring menu from the name of the current class.
Select the methods to implement in the dialog that opens.
Visual Assist creates empty stubs for definitions.
In C/C++, Visual Assist also creates declarations.
Add a comment block prior to a method, using a format defined by a VA Snippet. Reserved strings in the VA Snippet automatically expand for parameters and return value, so the components are commented on separate lines.
Create a file in the same directory as the active document, and have the file automatically added to its project. Define the initial content of new files with a VA Snippet. In C/C++, invoke the command a second time to automatically create a header, and have it included in a new source file.
Add a #include directive for any symbol known in the project, solution, system, or 3rd party libraries. Visual Assist inserts the appropriate directive, adjacent to other directives near the top of the active document, without moving your position.
In C#, reference a common .NET type, and Visual Assist suggests adding the appropriate Using directive. Unlike with the like-named IDE feature, the directive appears as a suggestion; there is no need to expand a smart tag.
Easily expand a switch statement to consider all values of an enum.
Quickly add braces to convert a simple statement to a compound statement, or remove braces from a one-line compound statement to make it a simple statement. Assign a shortcut to toggle braces.
Create the implementation of a symbol that has only an declaration, and Visual Assist automatically places the implementation in the corresponding source file, near the implementations of neighboring symbols. Types, return values, and parameters are consistent between header and source file.
Declare a class, then in a single step, create implementations of all of its methods. Declarations and implementations are consistent between headers and source files. Existing implementations are not overwritten or recreated.