CodeSMART is tightly integrated with Visual Studio - all its commands and tools are accessible through the main menu (1) and four toolbars (2)
it adds to the environment. Other CodeSMART 2009 tools are hosted or display their results within special tool windows - for example, pictured below are (3) the CodeSMART 'Code Explorer' and (4) the CodeSMART 'Find and Replace' tool windows.
The CodeSMART Code Explorer is a code navigation and management tool that integrates features from both the standard Solution Explorer and the standard Class
View. Its main design goal was to help the developer locate code as quickly as possible. For a solution and its projects it displays a single hierarchical view with
files, folders, classes, methods etc.
The CodeSMART Code Explorer supports filtering, searching and view customization; moreover, it displays other useful code elements like regions, bookmarks, code
flow nodes etc.
XAML files are completely detailed in the Code Explorer window in two distinct node categories, one containing the specific XAML tag hierarchy and
the other the code-behind file content. The XAML tag node appearance can be easily configured to show specific information like: the tag type, the Name and Content (or
similar) attribute values, or other composite information.
A complex set of commands is available for every element type displayed by the Code Explorer through the node associated context menu.
The Navigation Helper Panes (History, Node Search and Workbench) were especially designed to help the user focus on a limited number of components
and code elements.
- The History pane allows the user to keep in sight the last visited Code Explorer nodes or the last edited code elements (persistent between sessions).
- The Node Search pane allows you to quickly search (with partial search strings) for project item or code element nodes through the entire Code Explorer tree.
- The Workbench pane persists shortcuts to various elements (entire components, designer windows, code documents or code elements) on a per-project basis.
The Visual Studio code editor doesn't have tools to assist the developer in navigating inside a method body. When working with fairly simple methods browsing their
code inside the code window is usually enough to grasp a general idea about the code logic, but trying to navigate complex methods with hundreds of code lines, nested conditional
blocks and loops, can be a very tedious job.
The CodeSMART Code Flow Explorer can parse method code and output a tree representation thus offering instant access to the method's internal
structure and logical code blocks.
With the CodeSMART Designer Explorer you can visualize a designer control hierarchy, select a control (which normally is not an easy job controls
when controls overlap, are included in containers or simply are out of the visibility window) and benefit of several additional control-related operations and enhancements.
The CodeSMART Code Library Explorer represents a convenient way to quickly store and retrieve code pieces written in VB, C#, C++, HTML, XML etc, thus providing a valuable
help in reusing, managing and sharing prewritten code. It can be seen as a code repository in which you can store and organize different code items, group them
in logical folders and share them within a team.
The Extended Find and Replace subsystem adds powerful search and replace capabilities to the Visual Studio environment. It can perform code searches and replacements at
any scope (member, document, project, solution) with a set of user-defined filters. The search target can consist of a single code line or of multiple lines
and can contain wildcards or regular expressions. After the operation finishes, a comprehensive result list is displayed and matches are highlighted
in code.
Two Extended Find and Replace panes hold result lists for two different find/replace operations. Results found within strings and comments (if
these were not configured to be skipped) are displayed by using specific colors. Additionally, a history combobox can be used to access previous find/replace operations.
In the process of code writing as well as when analyzing prewritten code, knowing all the points where a certain code element is referenced can be extremely useful.
There may be many purposes for such a task, like planning a refactoring, generally trying to understand a certain functionality, etc. The CodeSMART Find References tool
can start from various code elements and output their list of references (works with both Visual Basic and C# projects).
The CodeSMART Code Analyzer is a valuable tool that can be used to examine Visual Basic and C# code. It can be seen as a control quality tool for
Visual Studio programmers who want to refine the code they write by making it smaller, faster and less error-prone. Code Analyzer features include detecting private dead
code, code complexity issues, potential problems, optimization flaws and coding standards infringements.
The CodeSMART Designer Analyzer can be used to examine Windows Forms components for known problems. It can be seen both as a UI quality
control tool and as a UI standards enforcement tool. Several options are available and grouped by problem categories.
The analysis result set is listed in a comprehensive window.
What can be more embarrassing than delivering an application and realizing you have spelling errors in its user interface? Let's face it, we all felt bad because of this at least
once in our lives. We did it too - so we decided it's the time to have a Spelling Checker feature in CodeSMART.
The Strings Review tool does somehow share part of its goals with the spelling checker. Its exact purpose is to offer a global and complete perspective on all
the string constants used in code, but while the spelling checker focuses on individual words correctness, this new tool was designed to ease the phase of logical word
combination (phrasing) analysis and correction.
Many times during the process of code writing you have probably used identical or similar code blocks, or written the same long code sequence over and over.
In such cases, an auto-text feature like the one found in many professional text editors could have saved you a lot of time. Typing a few letters and then hitting a special
keyboard combination is obviously much more productive than writing the same code piece again and again. This is what the CodeSMART AutoText system was built for; here's
a sample of this system in action:
The CodeSMART SmartComplete brings an Intellisense-like list with specific language keywords, statements and global functions and user-defined items which
are missing from the Visual Studio standard Intellisense list (in VS.NET 2002/2003 works for VB/C#/C++, while in Visual Studio 2005/2008 only works for VB).
Here are two examples on how SmartComplete works:
| Example 1 |
 |
 |
Private |
| Example 2 |
 |
|
WithEvents |
The CodeSMART AutoBrackets feature is a simple yet very useful tool that eases code writing by auto-completing the closing character in standard character pairs (parentheses,
square brackets, braces and quotes).
Here's a sample:
CodeSMART extends the standard Clipboard with 10 additional copy-and-paste persistent buffers. These buffers can be filled with any piece of text and their contents
can be pasted into any Visual Studio code window by using an extremely simple shortcut key system.
These represent a set of wizards for creating basic code constructs like class definitions, methods, properties and indexers.
Advanced Code Builders represent a set of tools which can be used to insert complex code constructs into Visual Basic and C# projects. By using these tools you can
considerably reduce the time and effort that's usually necessary to write certain code like interface implementations, overridden methods, object construction
and destruction, custom exception classes, custom formatter classes, collection classes, etc.
Adopting an appropriate strategy for exception management can help you build successful and flexible applications that can be easily maintained and debugged. However,
implementing a proper and consistent exception handling policy is not a trivial task - this is where the CodeSMART Exception Handling Tools come into play, as by
using these tools you can:
- define your own exception handling templates enriched with CodeSMART standard parameters.
- designate a default template to be used for a specific programming language.
- share the same templates within a development team.
- explicitly mark different methods, properties and classes to use a specific exception handling template
- automatically insert and remove exception handling code at different levels (current selection, method, class, document, project, solution).
As projects become more and more complex, adhering to certain standards usually becomes a necessity. These standards may include specifications and recommendations on how
code should be formatted and documented. CodeSMART has dedicated tools that can help you meet such requirements.
The CodeSMART Code Formatter can be used to reshape Visual Basic and C# code based on certain standards. These standards can be specific to a single programmer or can
be used for an entire programming team.
Occasionally you may consider it necessary to rearrange code in a more logical and intelligible manner. The CodeSMART Sort Procedures tool comes to meet this requirement.
XML documentation (XML comments), are a mix of XML and comments used to document code. CodeSMART not only extends support for XML comments to Visual Basic developers
(VS.NET 2002/2003) but also offers an unified and flexible way to standardize this powerful feature in both Visual Basic and C# through the XML Comment Templates (avalable
in all versions of Visual Studio).
The XML Comments Preview tool provides an easy way to vizualize pre-formatted XML comments when editing or browsing code.
Comments standardization is a must for every company, and adoption of such a standard by a single user is an extremely intelligent decision that will definitely show its benefits
in time. Regular Comment Templates are intended to complement the XML Comment Templates feature described above; also, CodeSMART can ease commenting tasks by automating
the regular comment skeleton insertion process.
No matter if you write simple functions or complex classes, using relevant comments as often as possible is a requirement that every application developer should conform
to. The CodeSMART Code Commenting Analyzer tool can help in getting a global perspective on code commenting at a certain scope by indicating in-method contiguous blocks
of code that exceed a certain maximum length and have no comments, as well as code definitions that either have no comment defined or have an incorrect
one from a standards point of view.
Configuring/reconfiguring tab order on a Windows Forms designer by managing each control's TabIndex property value can be a very tedious task. The CodeSMART Tab
Order Designer tool can help you automate this process - you can either set the order manually by simply sorting the control list or you can let the tool automatically establish
the tab order.
The CodeSMART Hotkey Designer allows you to automatically manage hotkeys on a designer. The tool provides several hotkey generation methods along with the possibility
to preserve (lock) some already defined hotkeys.
The Property Tips lists a preset group of properties and their values in a special window that is displayed as a tooltip whenever the user pauses the mouse
cursor over a designer control.
These tools are intended to ease working with controls while in designer mode. They offer a simple and quick way to identify a control, modify its size and position by
using the keyboard in predefined fine or fast modes.
CodeSMART offers the possibility to automate two mechanisms that can prove indispensable in application development: saving your work and creating backup copies.
The CodeSMART Code Statistics subsystem provides useful information about code at various scopes ranging from component up to the entire solution.
There are times during the coding process when the need to insert similar pieces of code in every method at a certain scope arise. For example, imagine your program generates
a GPF. Probably having the possibility to trace code execution and see which is the last method that gets called before the GPF occurs could help. However, manually inserting tracing
code into each method may take quite a long time. CodeSMART features an Iterative Code inserter/remover subsystem - by using it you will be able to insert and afterwards
remove special code chunks at a certain scope in just a few seconds.
