Code Quality Analysis
Continuous Code Quality Analysis
ReSharper applies over 1700 code inspections to your code at design time so you can instantly see whether your current file or even your whole solution contains any errors or problems.
ReSharper highlights detected errors and problems right in the Visual Studio editor, and additionally visualizes them using the Marker Bar on the right.
The Status Indicator at the top of the Marker Bar changes its color and icon if the file contains errors or problems.
Detecting Errors and Code Smells
ReSharper instantly detects and highlights errors as you code, right in the editor.
Errors are highlighted with either red font or curly underline. If you roll the mouse pointer over an error, its description is displayed in a tooltip.
ReSharper is capable of detecting errors not only in plain C# or VB.NET code, but in ASP.NET code-behind files, references in markup files, and ASP.NET MVC calls.
For XAML, ReSharper checks XML syntax and expertly validates XAML semantics, including references between XAML entities.
In build scripts (NAnt and MSBuild), ReSharper analyses and highlights unknown properties, targets, tasks, and attributes.
In addition to compiler errors and warnings, ReSharper displays its own warnings that don't prevent your code from compiling but may nevertheless represent serious coding inefficiencies. For example, ReSharper informs you about redundant casts, incorrect format strings, declared but never used local variables, etc. Constructs that have associated warnings are emphasized with either grayed text or a blue curly underline.
A deeper level of code analysis is available with code suggestions. Suggestions provide insights into code structure, drawing your attention to things that aren't necessarily bad or wrong, but probably useful to know. Suggestions are highlighted by green curly underline.
For instance, you may be interested to know that a certain parameter can be declared with base type, meaning that your method only uses members of the parameter's base type. ReSharper can also suggest to create an auto-property from a property with backing field, convert a static method invocation to extension method call, or use 'var' keyword when possible.
The final and less intrusive level of code highlighting severity is hint. Unlike errors, warnings and suggestions, hints are not taken into account when you navigate to next/previous highlights, not shown in the Marker Bar and therefore do not influence the color of the Status Indicator.
A hint simply brings your attention to a particular code detail and recommends a way of improvement. Code items that have associated hints are highlighted with a solid green underline (in Visual Studio 2005 and 2008), or a dashed green underline in later versions of Visual Studio.
ReSharper 4.5 introduced solution-wide warnings and suggestions to detect unused non-private members on the fly. These inspections only work when you let ReSharper analyze your whole solution. Look for the inspections in your code and on the Marker Bar. Specifically, you can discover:
- Unused non-private declarations.
- Unused return values of non-private methods.
- Unaccessed non-private fields.
- Unused parameters in non-private members.
- Abstract or virtual events that are never invoked.
- Unassigned fields.
- Members and types that can be made internal instead of public.
In addition, code annotations are available that you can use to mark certain non-private types and members if they are left unused intentionally, to prevent ReSharper from fussing about them.
Disabling and Configuring Code Inspection Items
At any time, you can change severity of different analysis items — for example, make ReSharper display a
particular inspection/notification as error, warning, code suggestion, or hint, according to your individual
coding style or corporate requirements.
Even more, sometimes you know better that a particular piece of code is just fine and no warnings are necessary, so you can simply disable a certain warning.
To disable or configure code inspection items, use the Inspection Severity page of ReSharper options. You can also configure a particular warning, suggestion, or hint using the Options for inspection menu in the action list.
ReSharper provides quick-fixes for most detected code issues, helping you solve them instantly. Quick-fixes are represented by the red (for errors) or yellow (for warnings, suggestions and hints) light bulb that appears to the left of a highlighted code line, when you set the caret on the highlight. You can see the list of available quick-fixes for a given error either by clicking the light bulb or by pressing Alt+Enter. Then simply select an appropriate quick-fix from the list, and the problem will be resolved in the most convenient way.
Some quick-fixes (e.g. Remove unused directives, Make field read-only, Remove redundant cast, etc.) can automatically find and fix issues in a larger scope - in the current file, in the current project or in the whole solution.
ReSharper also provides context actions that are displayed in the drop-down lists along with quick-fixes.
Navigating Between Highlighted Code Items
Each error, warning, or suggestion is represented by an individual stripe on the Marker Bar. Clicking the stripe navigates you directly to the line of code that contains the error or causes the warning/suggestion.
You can navigate between errors, warnings and suggestions by pressing F12 (forward) and Shift+F12 (backward). You can also navigate between just errors (skipping any warnings and suggestions) by pressing Alt+F12 (to next error) and Shift+Alt+F12 (to previous error). A message describing the current error, warning, or suggestion displayed in the status bar:
Starting from version 5, ReSharper provides an alternative way of navigating between highlighted code items — you can find all code issues in a certain scope, and explore them from a dedicated tool window.
Not only is ReSharper capable of analyzing a specific code file for errors, but it can extend its analysis skills to cover your whole solution.
Suppose that you changed the visibility of a member from public to internal, assuming that it was only used inside the current assembly. At this stage, ReSharper finds no errors in the current file. Then, you switch on Solution-Wide Analysis and ReSharper discovers that something went wrong. You jump to the next error in solution and you find out that someone used this member from outside of the current assembly.
All you have to do is explicitly switch Solution-Wide Analysis on, and then, after it analyzes the code of your solution, view the list of errors in a dedicated window:
Even without opening that window, you can still easily navigate through errors in your solution with Go to Next Error in Solution (Alt+F12) and Go to Previous Error in Solution (Shift+Alt+F12) commands.
Your Custom Code Inspections
ReSharper provides Structural Search and Replace to find custom code constructs and replace them with other code constructs. What's even more exciting is that it's able to continuously monitor your solution for your search patterns, highlight code that matches them, and provide quick-fixes to replace the code according to your replace patterns.
That essentially means that you can extend ReSharper's own 1300+ code inspections with your custom inspections. For example, if you're migrating to a newer version of a framework, you can create search patterns to find usages of its older API and replace patterns to introduce an updated API.
Find Code Issues
ReSharper 5 and higher lets you view all ReSharper code highlights — code quality issues, redundancies, language usage opportunities, and code improvement suggestions — from a single tool window called Inspection Results. That's much easier than navigating through your code files one by one to find and remove issues.
To display this tool window, choose Inspect | Code Issues in Solution or Inspect | Code Issues in Current Project on the ReSharper menu. Alternatively, select a node in the Solution Explorer, right-click it, and choose Find Code Issues.
In the past, attempting to track call sequences in code could end up with lots of Find Results windows and lost context. To streamline this task, ReSharper 5 and higher visualizes an entire call sequence in a single tool window. This is called Call Tracking, and it enables you to view and navigate through call chains in your code.
Thanks to support for events, interfaces, and closures, ReSharper Call Tracking is a substantial improvement over Visual Studio's own Call Hierarchy.
To visualize a call sequence, choose Inspect | Outgoing Calls or Inspect | Incoming Calls on the ReSharper menu, or use the Inspect This shortcut feature.
Value Tracking gives you important information about data flow in your program. At any point in your source code, you can point to a variable, parameter, field or property and ask ReSharper to inspect it. You will then see how its value flows through your program, back to its sources or straight to consumers.
Value Tracking helps you determine how a certain incorrect value might have passed to a given point in your program, and where it might be passed next. This helps you investigate possible NullReferenceExceptions, inappropriate behavior and reasons why you get incorrect values.
To visualize data flow that a certain value takes part in, choose Inspect | Value Origin or Inspect | Value Destination on the ReSharper menu, or use the Inspect This shortcut feature.
Starting from version 5, ReSharper provides Inspect This — a shortcut to several ReSharper features that combine code analysis and navigation, including Call Tracking, Value Tracking, and Type Hierarchy.
To display the list of inspection options, press Ctrl+Shift+Alt+A.
We have analyzed a great share of .NET Framework Class Library, as well as NUnit Framework, and annotated it through external XML files, using a set of custom attributes from the JetBrains.Annotations namespace, specifically:
- StringFormatMethodAttribute (for methods that take format strings as parameters)
- InvokerParameterNameAttribute (for methods with string literal arguments that should match one of caller parameters)
- AssertionMethodAttribute (for assertion methods)
- AssertionConditionAttribute (for condition parameters of assertion methods)
- TerminatesProgramAttribute (for methods that terminate control flow)
- CanBeNullAttribute (for values that can be null)
- NotNullAttribute (for values that can not be null)
- UsedImplicitlyAttribute (for entities that should not be marked as unused)
- MeansImplicitUseAttribute (for extending semantics of any other attribute to mean that the corresponding entity should not be marked as unused)
Annotations for members of the standard class library increase the efficiency of code analysis that ReSharper carries out. For example, StringFormatMethodAttribute is used to annotate String.Format-like methods the way that ReSharper checks the number of provided arguments against the structure of format string and warns the user if a necessary argument is missing.
You can also use the code annotation attributes to annotate your own code for better code analysis. To do that, put a reference to JetBrains.Annotations.dll in ReSharper's installation directory, or, alternatively, choose ReSharper | Options | Code Inspection | Code Annotations and copy the default implementation of the code annotation attributes into your solution:
All keyboard shortcuts provided in the "Features" section are taken from ReSharper 2.x / IDEA keyboard scheme. For details on ReSharper's two default keymaps, see Documentation and Demos.