ReSharper Changelog

What's new in ReSharper 2024.1 Build 2024.04.08.211826

Apr 9, 2024

C# support:
More conversions to collection expressions:
Now, you will get suggestions to convert more code constructions in your source code to collection expressions from C# 12, such as an empty array or the ImmutableArray declaration and initialization.
Collection was modified analysis:
We’ve added the new Possible 'System.InvalidOperationException: Collection was modified’ inspection, which will warn you when a collection was modified while iterating inside foreach loops, since this modification might lead to an exception in runtime. This analysis is aware of cases when there is an exit from the loop after a collection's modification, and these cases won’t trigger the warning.
The inspection comes with a corresponding quick-fix to help you solve this issue instantly.
Generate | Formatting Members update:
Generate | Formatting Members allows you to generate boilerplate code to override the ToString() method and return a meaningful string for your types. Starting from the 2024.1 version, this feature supports more types, such as ISpanFormattable, IUtf8SpanFormattable, and IFormattable.
Enhanced support for disposable resources in async methods:
[MustDisposeResource] Annotation improvements: C# code analysis now ensures that resources returned by async methods, including those wrapped in Task<IDisposable> and ValueTask<IDisposable>, are disposed of correctly, helping you avoid unintended disposal of the task itself.
Task-like return values: Correct analysis for task-like return values in the 2024.1 version ensures the awaited resource is checked for disposal and also includes resources retrieved via .ConfigureAwait(...), .AsTask(), or .Result.
Updates to the Change Signature refactoring:
Here are some of the improvements we’ve made to the Change Signature refactoring:
The refactoring now supports Deconstruct methods. You can add, remove, rearrange, and rename parameters, and these changes will be reflected in both the method declaration and its usages.
Code completion is now available for type parameters. This means that when you need to specify a type for a List<>, for example, you can use code completion to easily select the desired type, such as int.
Type namespaces are automatically shortened when adding or updating parameters. This helps keep the code clean and simplified after applying the refactoring. For example, if you specify the System.Collections.Generic.List<System.Int16> type in the Change Signature dialog, it will be automatically shortened to List<short> in the resulting code.
The refactoring now supports more features from the last versions of C#, such as in and ref readonly modifiers and record types.
Updates to the Make Static refactoring:
In this release, the Make Static refactoring supports primary constructor parameters. They appear in the Introduce parameters list and have a separate icon to help you distinguish them easily. This refactoring is also available for local functions.
Support for the protobuf-net library:
Code Analysis now provides support for the ProtoContract attribute and ImplicitFields enum from the protobuf-net library. Both of these can be used to mark members that are implicitly used for serialization. As a result, such members are no longer flagged with unused members warnings.
Razor support:
Resolve references for the @addTagHelper and @removeTagHelper directives
Resolve references for @addTagHelper and @removeTagHelper directives
ReSharper now resolves references for assembly names specified within @addTagHelper and @removeTagHelper directives in your Razor views. As a result, you can now benefit from code completion, the ability to find usages, and the ease of code navigation.
ReSharper now considers any unresolved assembly names as errors and highlights them in red to bring them to your attention.
C++ Support:
Notable enhancements in C++ support include:
The reworked implementation of C++20 modules improves performance and provides support for internal module partitions.
Change Signature offers new features, including the ability to change a parameter type between a pointer, a reference, or a value type.
Call Tracking now supports outgoing call chains.
You can now easily customize the style of generated documentation comments. Additionally, grammar inspections are available inside documentation comments.
Support is now available for Unreal Engine’s Slate UI framework.
Performance:
High resource utilization mode in solution-wide analysis:
We are actively refining high resource utilization mode for solution-wide analysis, which will significantly reduce analysis duration by using CPU parallelism more efficiently. We’ve improved the memory allocation profile of code analysis activities to minimize the time spent on garbage collection. While the refinement process is ongoing, we would appreciate it if you would enable this mode and provide feedback on your experience.
Faster Rename refactoring:
Renaming elements in your code is now faster and more efficient. This change also affects other core components of ReSharper, leading to performance improvements across multiple features, including Find Usages.
Faster Move to Another Type refactoring:
The performance of the Move to Another Type refactoring for static members has been significantly improved for dealing with large classes.
Code formatting:
Improved UX/UI for custom naming rules:
The changes should make it easier to work with advanced naming rules and observe any rules that were imported from EditorConfig files.
Remove whitespace on blank lines setting:
This new formatting setting allows you to either leave or remove whitespace in blank lines.
Decompiler:
A new dedicated Assembly Diff tool window:
The 2024.1 update introduces the new Assembly Diff tool window to ReSharper. There are a couple of changes that come with it:
The ability to compare assemblies, NuGet packages, folders, and .zip archives has been moved from the Assembly Explorer to the Assembly Diff tool window.
The Diff mode selector and the Compare and Diff Options buttons have been relocated to the Actions bar of the Assembly Diff tool window.
Support for the WebCIL packaging format:
The decompiler inside ReSharper now supports the WebCIL packaging format for WebAssemblies. The support covers:
Decompilation for WebCIL.
The ability to view .wasm files in the Assembly Explorer.
Metadata subtrees for WASM nodes in the Assembly Explorer, including WASM and WebCIL headers.
MAUI support in dotTrace, dotMemory, and dotCover dotUltimate:
The standalone versions of dotTrace, dotMemory, and dotCover now support MAUI (desktop only) and .NET macOS applications.
Supported target frameworks:
MAUI Windows: net8.0-windows, net7.0-windows
Support for MAUI projects is now also available in dotTrace, dotMemory, and dotCover inside Visual Studio.
Support for the Frozen Object Heap dotUltimate:
Support for Frozen Object Heap (FOH)
The standalone dotMemory profiler tool now offers support for the Frozen Object Heap – a feature first introduced with the .NET 6 SDK as part of the performance improvements for garbage collection.
FOH allocates a dedicated memory area for immutable objects. These objects are not changed after being allocated and are not subject to garbage collection. Support for this technology enables dotMemory to perform a more detailed analysis of memory used by immutable objects in the FOH, thereby boosting the optimization of memory usage.
Miscellaneous:
Out-of-process refactoring:
We've finished an internal refactoring of text controls. In addition to being part of our effort to make ReSharper run out of process, this refactoring is designed to improve typing and related aspects of editor performance for both ReSharper and Rider. You can find the latest status update about our progress on bringing ReSharper out of process here.
Extension manager:
The JetBrains Marketplace plugin feed has adopted a new filtering mechanism that is based on compatibility checks. This means that incompatible plugins are no longer displayed in ReSharper’s extension manager.

New in ReSharper 2024.1 Build 2024.1.0.8 EAP 8 (Mar 7, 2024)

New in ReSharper 2024.1 Build 2024.1.0.5 EAP 5 (Feb 16, 2024)

New in ReSharper 2024.1 Build 2024.1.0.4 EAP 4 (Feb 10, 2024)

New in ReSharper 2024.1 Build 2024.1.0.3 EAP 3 (Feb 2, 2024)

New in ReSharper 2023.3.3 Build 2024.0118.221520 (Jan 23, 2024)

New in ReSharper 2024.1 Build 2024.1.0.1 EAP 1 (Jan 20, 2024)

New in ReSharper 2023.3.2 Build 2023.3.2.65536 (Dec 21, 2023)

New in ReSharper 2023.3.1 Build 2023.3.1.65536 (Dec 13, 2023)

New in ReSharper 2023.3 Build 2023.3.0.8 EAP 8 (Nov 22, 2023)

New in ReSharper 2023.3 Build 2023.3.0.7 EAP 7 (Nov 15, 2023)

New in ReSharper 2023.2.3 Build: 2023.2.3.65536 (Nov 4, 2023)

New in ReSharper 2023.3 Build 2023.3.0.5 EAP 5 (Nov 1, 2023)

New in ReSharper 2023.3 Build 2023.3.0.4 EAP 4 (Oct 23, 2023)

New in ReSharper 2023.3 Build 2023.3.0.3 EAP 3 (Oct 17, 2023)

New in ReSharper 2023.3 Build 2023.3.0.2 EAP 2 (Oct 10, 2023)

New in ReSharper 2023.2.2 Build 2023.2.2.65536 (Sep 27, 2023)

New in ReSharper 2023.2.1 Build 231.9559.61 (Aug 25, 2023)

New in ReSharper 2023.2 Build 2023.2.0.10 EAP 10 (Jul 22, 2023)

New in ReSharper 2023.2 Build 2023.2.0.9 EAP 9 (Jul 14, 2023)

New in ReSharper 2023.2 Build 2023.2.0.8 EAP 8 (Jul 10, 2023)

New in ReSharper 2023.2 Build 2023.2.0.7 EAP 7 (Jul 3, 2023)

New in ReSharper 2023.2 Build 2023.2.0.6 EAP 6 (Jun 26, 2023)

New in ReSharper 2023.1.3 Build 65536 (Jun 25, 2023)

New in ReSharper 2023.2 Build 2023.2.0.5 EAP 5 (Jun 16, 2023)

New in ReSharper 2023.2 Build 2023.2.0.4 EAP 3 (Jun 9, 2023)

New in ReSharper 2023.2 Build 2023.2.0.2 EAP 3 (Jun 6, 2023)

New in ReSharper 2023.2 Build 2023.2.0.1 EAP1 (May 15, 2023)

New in ReSharper 2023.1.1 Build 65536 (Apr 27, 2023)

New in ReSharper 2023.1 Build 2023.1.0.65536 (Apr 5, 2023)

New in ReSharper 2023.1.0.10 EAP 10 (Mar 30, 2023)

New in ReSharper 2022.3.3 Build 65536 (Mar 23, 2023)

New in ReSharper 2023.1.0.8 EAP 8 (Mar 10, 2023)

C# support:
Insert a return type specification for lambdas:
Lambda expressions in C# usually have implicitly-typed parameters and an inferred return type. Sometimes, it can be useful to add explicit types in a signature of a lambda expression to make code clearer or to help C# type inference in some complex scenarios involving overload resolution. A context action to insert parameter types, Insert parameter signature, has been around for a while.
Starting from C# 11, adding a return type specification for lambda expressions is also possible. To accomplish this, we introduced a new context action, Insert return type specification, in version 2023.1. You can apply it to all lambda expressions in scopes like method, class, file, project, or an entire solution.
Syntax style for null checking patterns:
We provided the new “Syntax style” setting to help you enforce one consistent style of not null checks inside patterns. It consists of 2 options: empty recursive pattern syntax { } and negated pattern not null, where the latter is set by default. You can adjust the behavior on the ReSharper | Options | Code Editing | C# | Syntax Style page.
ArgumentNullException.ThrowIfNull style of null checks:
.NET 6.0 SDK introduced a new API for null checking – ArgumentNullException.ThrowIfNull. Our code analysis engine has recognized this checking approach since then, but there was no option to use this API as a default style of null checks produced in ReSharper. In the 2023.1 release, we added an ArgumentNullException.ThrowIfNull pattern to ReSharper | Options | Code Editing | C# | Null checking.
Pattern is redundant inspection:
C# or/and/not patterns can be useful to produce compact value checks without repeating the input value reference (value == 1 || value == 2 vs. value is 1 or 2). However, this syntax is still not as recognizable as good older expressions like ||/&&/!. Pattern priorities are not that clear at first, so it is easy to miss parentheses and introduce hard-to-find bugs.
For example, the expression value is not 0 or -1 compiles without any warnings. When the user’s intention is to check the value for being not equal to both 0 or 1, this check will evaluate to true with the value being equal to -1. The correct pattern to use would be value is not (0 or -1).
Convert to list pattern context action:
We’re continuing to improve our support for C# 11 list patterns. With the new Convert to list pattern context action, you can turn collection length checks into a list pattern syntax. It works in any context where a collection length check can be done.
C++ support:
ReSharper 2023.1 EAP 8 comes with the following updates for C++:
We’ve introduced support for the C++20 __VA_OPT__ macro.
The Rename refactoring now works on named modules and module partitions.
The Introduce using enum and Convert to scoped enum refactorings are now available as context actions via the Alt+Enter menu.
We’ve added 2 new inspections: Template parameter is never used and Function result of type HRESULT/NTSTATUS should be used.

New in ReSharper 2022.3.2 Build 65536 / 2023.1.0.6 EAP 7 (Mar 6, 2023)

New in ReSharper 2023.1.0.6 EAP 6 (Feb 24, 2023)

New in ReSharper 2023.1.0.5 EAP 5 (Feb 17, 2023)

New in ReSharper 2023.1.0.4 EAP 4 (Feb 13, 2023)

New in ReSharper 2023.1.0.3 EAP 3 (Feb 3, 2023)

New in ReSharper 2022.3.2 Build 65536 (Jan 30, 2023)

New in ReSharper 2023.1.0.1 EAP 1 (Jan 19, 2023)

New in ReSharper 2022.3 Build 2022.3.0.9 EAP 9 (Nov 28, 2022)

New in ReSharper 2022.3 Build 2022.3.0.7 EAP 8 (Nov 14, 2022)

New in ReSharper 2022.2.4 Build 2022.2.4.65536 (Nov 9, 2022)

New in ReSharper 2022.3 Build 2022.3.0.4 EAP 4 (Oct 17, 2022)

New in ReSharper 2022.3 Build 2022.3.0.3 EAP 3 (Oct 10, 2022)

New in ReSharper 2022.3 Build 2022.3.0.1 EAP 1 (Sep 27, 2022)

We’ve introduced support for the #pragma pack directive, which modifies the current alignment rule for the members of structures. ReSharper C++ now correctly computes the sizes of packed structures so you can rely on analysis and highlighting for static assertions.
Recently released ReSharper C++ 2022.2 brought a lot of improvements for working with emplace-like and make-like function calls. However, these features were limited to classes and functions from the standard library. Starting with the first EAP build of 2022.3, ReSharper C++ can now show you parameter info and inlay hints for any function or method that implies a constructor call!
To benefit from this update, make sure that the function template is limited using SFINAE or a requires clause with type traits and concepts that restrict T to be constructible from a given arguments pack. This could be std::enable_if with the std::is_constructible type-trait, or requires std::constructible_from<T, Args...>, or any similar construction.
As you may have noticed in the screenshot above, ReSharper C++ now includes the function origin in parameter info and other function tooltips. The updated tooltips now show you when a function is implicitly generated (e.g. constructors or assignment operators), built in (e.g. operator+ for fundamental types), or compiler intrinsic (e.g. functions with the __builtin_ prefix).
We’ve also introduced a useful new context action that replaces && with || and vice versa inside a boolean expression, following De Morgan’s laws.
For better-looking code, we’ve added a number of new formatting options for configuring:
Spaces before and after ellipsis (…) in parameter packs.
The number of blank lines that are acceptable to present in declarations and in the rest of the code.
Whether blank lines are kept or removed after an opening brace ({) and before a closing one in declarations and in the rest of the code.
Blank lines before and after access specifiers.
All the new formatting settings can be found, as usual, on the Code Editing | C++ | Formatting Style page of the ReSharper options.
Finally, we have a small but important update for Unreal Engine projects: ReSharper C++ no longer offers unwanted entities from system headers in auto-import suggestions. By default, system headers are not suggested, but if you want them to be, you can enable them in Options | Code Editing | C++ | Unreal Engine.
Those are all the highlights for today! The full list of issues we’ve addressed is available in our issue tracker.

New in ReSharper 2022.2.2 Build 2022.2.1.65536 (Aug 22, 2022)

New in ReSharper 2022.2.1 Build 2022.2.1.65536 (Aug 11, 2022)

New in ReSharper 2022.2 EAP 9 (Jul 14, 2022)

New in ReSharper 2022.2 EAP 7 (Jul 7, 2022)

New in ReSharper 2022.2 EAP 4 (Jun 10, 2022)

New in ReSharper 2022.1.2 Build 2022.1.2.65536 (Jun 4, 2022)

New in ReSharper 2022.2 EAP 1 (May 20, 2022)

New in ReSharper 2022.1.1 Build 2022.1.1.65536 (Apr 30, 2022)

New in ReSharper 2022.1 (Apr 19, 2022)

Game development with Unreal Engine and Unity:
Rider is already widely used in the Unity development world, and it now comes deeply integrated with Unreal Engine support. This converts Rider into a full-fledged IDE for game development, no matter your game engine of choice.
Remote Development (Beta):
Rider now supports a Beta version of the long-awaited remote development workflow. It allows you to connect to a remote machine running Rider’s backend from anywhere in the world. All the processing happens on that powerful remote machine, and you can work on your project as seamlessly as if it were on your local machine. This functionality can be initiated from Rider’s Welcome screen or from a new application called JetBrains Gateway, which is available in the Toolbox App.
Other highlights:
You can now customize the new toolbar by adding new elements to both the left and right sides of the toolbar, as well as rearrange and remove widgets. Profiling with dotTrace is also available right from the Run/Debug widget’s More menu (the “kebab” icon).
Fast mode has come to Docker and Docker-Compose solutions, which should significantly reduce build times during development.
We’ve added full-text search in Search Everywhere. The new Text tab will show all text occurrences in the solution that match the string while you are typing it.
We continue to improve support for C# 10, particularly global usings. We’ve implemented two new refactorings that are also available as context actions: Extract Global Using to introduce the concept of global usings in your project and Inline Global Using to refactor a global using into a regular using.
We’ve added support for the new [EditorRequired] attribute from .NET 6. The corresponding inspection and quick-fix are also available if you try to use a Blazor component without specifying the required parameters. We’ve also added navigation through inheritance hierarchy to the Razor code.
A new Notifications tool window replaces the Event Log instanсe. With this update, we aim to make notifications more visible and keep them better organized in a dedicated tool window that you can access from the navigation bar.
A new Zoom widget shows you the actual font size of the editor and helps you reset it to the default.
You can now add a web reference to .NET and .NET Core projects.
Version Control: we’ve moved the Preview Diff icon from the Commit toolbar to the menu, which is accessible by clicking on the Cog icon, and renamed it to Show Diff Preview on Single Click.

New in ReSharper 2021.3.4 (Mar 31, 2022)

New in ReSharper 2022.1 EAP1 (Feb 2, 2022)

ReSharper:
We’ve improved C# 11 support: ReSharper is now aware of generic attributes.
We’ve fixed the support for .sqlproj files in localized Visual Studios (RSRP-487192).
We’ve fixed the issue that caused code cleanup to remove all @using declarations from .razor files that contain Blazor components (RSRP-485772).
We’ve fixed the behavior of If To Switch and Invert If context actions for Razor code that contains references to Blazor components.
We’ve added the Metadata tree view, that may already be familiar to dotPeek users, into ReSharper, but only for Visual Studio 2022.
We’ve fixed the problem of event buffer overflow (also known as “massive file system change”) that caused ReSharper to unnecessarily review all files in the solution.
ReSharper C++:
The Quick Documentation pop-up now includes the embedded links to the Unreal Engine documentation.
We’ve supported Unreal Engine 5 built-in preprocessor macros in the .Build.cs and .Target.cs files.
We no longer suggest C# features that are too modern in the .Build.cs and .Target.cs files on Unreal Engine 4.
ReSharper C++ now reads the list of valid reflection specifiers directly from the currently used version of Unreal Engine, so it offers you only applicable items in code completion and shows up-to-date documentation.
We’ve fixed the issues caused by DOREPLIFETIME_WITH_PARAMS_FAST and MARK_PROPERTY_DIRTY_FROM_NAME push model macros – ReSharper C++ now is aware of entities generated by the replication system, such as ENetFields_Private enum.
dotPeek:
dotPeek now shows XML doc comments for platform assemblies, including assemblies whose names differ from the names of the XML documentation files (e.g. System.Private.CoreLib).
The path to XML documentation is now displayed in the decompiled file’s header.
We’ve turned off retargeting of navigation in the Metadata view.
We’ve added decoded / raw blob presentations in the properties for blob nodes.
dotTrace:
We’ve added support for .NET Core NetTrace file format. Collect the nettrace files with dotnet-trace collect command, and dotTrace will convert them to its snapshot format and present them in the Timeline viewer.
dotMemory:
For the command line tool, we’ve improved the visual display of progress when saving the snapshot data. Now the size of already written data is shown during saving.

New in ReSharper 2021.3.3 Build 2022.01.26.131358 (Jan 31, 2022)

New in ReSharper 2021.3.1 (Dec 10, 2021)

New in ReSharper 2021.3 (Dec 8, 2021)

Support for Visual Studio 2022
Re:Sharper now supports the release build of the new Visual Studio 2022. You will have access to the same rich feature set you are already used to having in other Visual Studio versions. But since Visual Studio 2022 is an x64 process, there is no longer a limit to the maximum amount of memory that can be allocated to it. As a result, all ReSharper features work faster.
More C# 10 features:
ReSharper continues to add more C# 10 features. Today, we are happy to add support for file-scoped namespaces, global using directives, the CallerArgumentExpression attribute, the “interpolated string handlers” concept, readonly record structs, and C# 10 lambdas. You can learn more about them in our series about the new C# 10 features or directly on the What’s New page.
Support for nullable reference types:
Let’s say you paste in some code with NRT syntax but you don’t have NRTs enabled in your solution. There is now a quick-fix that gets rid of the NRT syntax for you. There are also several helpful new quick-fixes:
A quick-fix for eliminating nullability mismatches between type arguments and their nullability constraints
A bulk quick-fix for correcting annotations on parameters with nullable default values in a file, project, or whole solution.
A new bulk quick-fix that makes a parameter nullable if it’s checked for null within a method.
General C# code analysis improvements:
The latest version of C# isn’t the only one getting support improvements. This release brings additional inspections and quick-fixes for general C# support, as well:
New quick-fixes for static local and anonymous functions with closures.
Improved support for regular structs.
Quick-fixes that convert classes to records and then transform them into primary constructors.
Additionally, scope quick-fixes and context actions are now executed in parallel and use the results of solution-wide analysis.
Navigation and Find Usages:
We’ve added a few more gutter marks to help you quickly navigate through the inheritance structure of a class, interface, or struct. The new ↑O icon indicates that a code entity inherits a class, while the ↑I icon indicates that the code entity implements an interface. Additionally, ReSharper will add the ↓O icon in the left gutter next to a class member if the class member is overridden in derived classes.
You can now call Find Usages for user-defined implicit conversion operators. This allows you to find out whether user-defined implicit conversion operators are used at all and then navigate to blocks of code with conversions.
Finally, when you invoke Go to Type of Symbol on a variable or parameter of an interface type in debug mode, ReSharper will take you to the exact implementation of it that is used in the current frame, rather than the interface declaration.
Other updates:
You can now mark any of a function’s parameters, fields, or properties with the LanguageInjection annotation attribute. ReSharper will consider a string of a marked code entity as a code fragment in a specified language. The following languages can be injected: CSS, HTML, JavaScript, JSON, or XML.
We’ve redesigned the Copy Code Reference feature. It has a new name, a new UI, and new GitHub options for generating proper links to GitHub repositories and sharing them with anyone right away. Learn more in this blog post.

New in ReSharper 2021.3 EAP 1 (Sep 28, 2021)

.NET 6 SDK Support
Starting from this EAP, Rider officially provides initial support for .NET 6 SDK, including project templates, target frameworks, and creating/running/debugging projects targeted to the new SDK. If you experience any issues, please let us know. Please note that the Hot Reload feature and Blazor Debugging for .NET 6 are not supported yet.
New UI for the Debug tab
A new UI is coming to the Debug tab! We have lots of changes to talk about.
By default, there are three tabs: Threads & Variables, Console, and Debug Output. Other tabs like Memory and Parallel Stacks are hidden, but you can show them via the Options Menu (the nut icon).
We completely removed the left toolbar and moved icons to the top toolbar or the context menu. To keep the top toolbar as short as possible, we reordered the icon set and left only the most important actions visible. The rest of the icons were moved to the More dropdown menu (three vertical dots icon). Hide Frames from Libraries icon and Hide/Show Threads toggle have been moved to the context menu in the Threads view.
The More dropdown menu has a new Settings submenu. Here, you can find a shortlist of the most common settings related to the debugger without having to go to the Settings/Preferences dialog and drill down into the Build, Execution, Deployment | Debugger page.
The Immediate Window has several updates too:
Add Watch has been moved from the Variables view to the toolbar of the Immediate Window.
There are two layouts: maximized and minimized. In the minimized layout, you can see the execution result only in the $result variable in the Variables view. In the maximized layout, in addition to the $result variable, you can see the history of the previously executed lines with the results of the executions. You can toggle between them using the Expand/Collapse icon.
A new option, Stop on Breakpoints, is available. It forces the evaluating process to stop on the breakpoints while evaluating an expression. Disabling the option will allow the evaluating process to ignore the breakpoints.
The Add Watch action now has a shortcut, Ctrl+Shift+Enter.
Debugger Updates
The debugger itself received a couple of long-awaited and highly-requested features.
First of all, there is good news for UWP developers: you can start your UWP project under the debugger right away. You no longer need to run the project first and then manually attach the debugger to the running process.
Secondly, you can now debug both .NET (Core) and .NET Framework apps in local Windows Docker containers. Previously, the debugger could work only with .NET Core apps in Linux Docker containers.
Language Support
C# 10
The C# 10 is around the corner, and Rider continues adding some of the upcoming features. Today, we are happy to add support for file-scoped namespaces and global usings.
Let’s start with file-scoped namespaces. In addition to supporting the new syntax itself, we’ve added a new Syntax style option (Settings/Preferences | Editor | Code Style | C# | Syntax Style | Code body | Namespaces) which helps you select the desired style. When you choose the style, Rider will show you inspections for code that has to be changed to follow the style and suggest the appropriate quick fix for you. You can propagate the fix through the project or even through the whole solution in one click.
If you want to return to the previous Syntax style for the code, there are two context actions: “Convert to file-scoped namespace” and “Convert to block-scoped namespace.”
Now, let’s take a quick look at global usings. Rider code analysis is aware of usings marked with the global keyword and uses these usings to correctly resolve symbols in all the code files in the project. If Solution Wide Error Analysis is ON, Rider will highlight global usings which have no usages in the project as unused with a proper quick-fix suggestion to remove the statement. Rider will also notify you if the global using has been placed in the wrong place in the file.
Code Analysis
It is not unusual for people to copy pieces of code from other resources, like stackoverflow.com. Nowadays, with nullable reference types is available in C#, some of the code samples already include the NRT syntax. But what if you don’t have NRT enabled in your solution? To help you get rid of this syntax after pasting such code to your project, Rider has two new quick-fixes: Replace with JetBrains.Annotations attributes and Remove nullable annotations without ‘#nullable’ context.
We’ve added a couple of new quick-fixes and a context action for static local/anonymous functions with closures:
A quick-fix, Allow closures, to remove static modifiers from a local or an anonymous function if it contains closures.
A quick-fix, Pass closure as a parameter, to lift closures in static local functions to parameters.
A context action, Pass closure as a parameter, to lift closures in non-static local functions to parameters.
There is a new inspection, Simplify string interpolation, with a corresponding quick-fix to replace .PadLeft() and .PadRight() method calls with interpolated string placeholders with an alignment expression.
In addition to adding new quick-fixes, we significantly improved the daemon performance for files with huge methods inside:
Methods with large/nested conditional expressions, tuple expressions, or switch expressions.
Methods with lots of type checks when nullable reference types are disabled.
Methods with a lot of indexer accesses when nullable reference types are enabled.
Methods with a huge number of closures when nullable reference types are enabled.
Now, the code analysis is completed faster for such files.
Better Support For SQL Injections
In this release, we improved the support for SQL injections. We now support a lot of common cases where you write SQL code right inside C# code:
SQL query strings are correctly resolved for string.Format methods, string interpolations, and simple string concatenations.
There are no more errors on an SQLParameter variable for parameters inside SQL query strings when using the Microsoft SQL Server dialect or the Dapper library.
Unity Support
We’ve made a couple of small fixes for Unity support in this EAP, plus we’ve added a nice little feature to display the contents of a serialized field’s [Tooltip] attribute in the editor as a tooltip. There’s also an Alt+Enter context action to convert an XML documentation summary into a [Tooltip] attribute, so you’ll be able to see your XML docs in the Unity Inspector. There’s more to come in future EAPs!
Support for Apple Silicon Chips
Some time ago, we started an early preview for the Rider “Apple Silicon Edition” build, which natively runs on Mac computers with Apple silicon processors. Starting from this EAP, this support is included in the regular Rider and will be delivered as part of our EAP and release pipelines. The first EAP build uses the following runtimes:
The Apple silicon–compatible JBR (JetBrains Runtime) for the frontend.
The .NET6 RC1 for the backend.
Project and Solution Properties
Now, let’s look at what’s new in the Project Settings dialog:
You can specify an application icon in the Resource section on the Application page.
There is a new Build Events page to specify commands to run for before and after build.
The Inspections page gets several project properties related to code analysis: Localizable, Localizable inspector, and Solution-Wide inspections.
You can configure reference paths for a project on the Reference Path page.
The Solution Properties dialog has a new Dependencies column in the table to specify build dependencies for each project.
Run Configurations for Publishing
Starting from the 2021.3 EAP, Rider imports all .pubxml files from Properties/PublishProfiles on project loading and converts them to run configurations. Whenever you add a new .pubxml, a new run configuration is generated automatically. There is no more need to create these run configurations manually!

New in ReSharper 2021.2.1 (Aug 28, 2021)

New in ReSharper 2021.2 (Aug 3, 2021)

Code Analysis:
The new Swap via deconstruction quick-fix is available to swap variable values!
Nullable Reference Types:
ReSharper indicates suppressions (!) that are no longer needed and that can be safely removed.
A new context action lets you search for all nullable warning suppressions in the scope.
We’ve introduced a new refactoring to change nullability that will update nullability annotations and suggest propagating the changes throughout your codebase.
Several new inspections with corresponding quick-fixes are available for when you’re using JetBrains.Annotations attributes and nullable reference types are enabled. Update JetBrains.Annotations attributes to NRT syntax and compiler-supported attributes!
ReSharper adds new inspections and quick-fixes to help you use compiler-supported annotations such as [DisallowNull],[AllowNull], [MaybeNull], and [NotNull].
Source Generator Support:
In ReSharper 2021.2, many of the features available for manually-written code files are available for source-generated files as well.
For generated code, warnings and errors are displayed in the editor and on the marker bar.
Solution Wide Analysis (SWEA) now includes files generated by source generators. If there’s an error in a generated file in your project, you’ll be able to see it immediately and navigate to it.
Refactorings, like Rename or Change Signature, can now be triggered from source-generated files.
HttpClient URI support:
When using HttpClient, code completion will suggest all URIs that can be resolved to actions in controllers annotated with [Route], [Http{Method}], or [AcceptVerbs] attributes.
Other updates:
Navigation:
While debugging, calling Go To Declaration (or Ctrl+Click) on interface references will navigate you directly to the implementations.
The Go To Base/Inheritors list shows hidden overrides.
Code Styling and Formatting:
We’ve changed the default formatting preferences to align with the Visual Studio defaults.
Support for the Pico brace (indenting) style is here.
It’s now possible to specify advanced naming rules for records, extension methods, and catch variables.
Dynamic Program Analysis:
Dynamic Program Analysis (DPA) now stores two values for each issue – the historical max value and the value from the last run.
Assembly Explorer:
The embedded decompiler can now decompile single-file apps. It supports single-file formats for the .NET Core 3.1, .NET 5, and the upcoming .NET 6 SDKs.
Using Assembly Explorer, you can browse through bundled assemblies inside a single-file app, just like you are used to doing.
Razor:
Razor developers working on large views can turn off the CPU-intensive assistance and automatic suggestions if their editor begins to lag.
ReSharper C++:
We’ve introduced the Inline Function refactoring to quickly replace a function call with the body of the function.
ReSharper Command Line Tools:
We introduced a breaking change in the InspectCode tool. Starting from v2021.2, InspectCode automatically restores NuGet packages and builds a solution before starting its analysis. If this behavior is undesired, use the --no-build key to disable restoring NuGet packages and building the solution.

New in ReSharper 2021.2 EAP 4 (Jun 25, 2021)

ReSharper:
Nullable reference types:
We've introduced a new refactoring to change nullability! It is available through a quick-fix on NRT (nullable reference types) warnings, from the Refactor This action in the context menu or the main menu, or through an in-place refactoring when adding or removing the nullable annotation (?).
You can now search for nullable warning suppressions in a file, project, or solution. The new action is available from a suppression expression.
More of ReSharper's features now support source-generated files when the file is opened in an editor:
Now you can navigate from the generated code with Ctrl+Click, search for usages, search for inheritors, and more.
When debugging, ReSharper's own Data Tips are shown.
Errors and warnings are now displayed in the editor and on the marker bar.
Semantic highlighting is enabled so that events, fields, properties, and more are highlighted correctly.
All types of inlay hints are shown.
Refactorings can now be invoked from a source-generated file. For example, you can update the usages of a method before you change how it's generated.
Source generators support:
The files generated by source generators are now supported in Solution Wide Analysis (SWEA). If there's an error in a generated file in your project, you'll be able to spot it immediately in SWEA and navigate to it. We've made this feature customizable because some source generators may produce large files that are frequently modified and require re-analyzing, which might cause slowness. There's a new setting under ReSharper | Options | Code Inspection | Settings | Enable solution-wide analysis to Include source generated files, which is enabled by default.
Microservices support:
We've provided the whole editor functionality for endpoints: completion, navigation, Find Usages, Search Everywhere, and rename refactoring for route segments.
ReSharper C++:
Inline Function refactoring.
New modernizing inspections: std::size can be used and Zero initialization can be used instead of memset.
DotMemory:
DotMemory can now show the stack trace copied to the clipboard from applicable dotMemory views in Rider or in Visual Studio.
We've made improvements in object export:
You can now export objects with a specified traverse depth. The depth can be set manually.
You can now select one or several types and export all objects of these types to a single file. This action is available from the list of types in the Object set and from the Unreachable objects view.
A single object can now be exported from more views: the Outgoing references view for object instances, and the Instances view of the Object set. The latter view also allows you to choose Export all objects to export all objects from that Object set.
DotCover:
We've implemented finer distinction in coverage reports: dotCover can now show coverage details per test method. This may help you, say, match the coverage data from the previous build on a CI build against a changeset you have, and see any risks.
We've implemented a concept of preloaded unit test runners. When you run your unit tests under coverage, an additional test runner process is started. When you run the tests again, this preloaded process will be used, and another one will be started for the future. This helps dotCover reduce the lag between the build and the start of the tests, meaning the test will start faster. The number of allowed processes is controlled by the option Unit Testing | Run up to N test runners in parallel. The whole feature can be turned off by unchecking Preload test runners setting in dotCover's options.
Another option to reduce the waiting time is to run test classes in parallel. dotCover will divide tests within each assembly into several groups and run each group with its own test runner process. Groups are formed in such a way that there's approximately the same number of tests in each, or, if the tests were already run and we're aware of their timing, that the time of a run of each group is approximately the same. This feature has hidden pitfalls, for example, if your tests depend on each other and can not be run in parallel – that's why it's disabled by default. To turn it on, use the Run test classes in parallel option in dotCover's settings.
C# 8.0 default interfaces are now supported – they will be shown in the coverage tree if they have any method implementations.

New in ReSharper 2021.2 EAP 3 (Jun 11, 2021)

New in ReSharper 2021.2 EAP 2 (Jun 4, 2021)

New in ReSharper 2021.2 EAP 1 (May 31, 2021)

Code Analysis:
Do you still use temporary variables to swap variable values? There is a more elegant way! Rider 2021.2 EAP will help you modernize your code with the new Swap via deconstruction quick-fix!
There are two new useful inspections that come with the corresponding quick-fixes:
Replace empty array creation with Array.Empty<T> (or with Type.EmptyTypes in case of new System.Type[0]).
Replace new EventArgs() with EventArgs.Empty.
Rider 2021.2 EAP respects the generated_code property from your .editorconfig file, allowing you to specify which files to ignore in its code analysis.
Code Analysis is getting a couple of performance improvements:
Find similar issues now provides its results faster. This is because Rider no longer runs analyses that are irrelevant for the corresponding highlighting/inspection.
We’ve sped up a code analysis for large and complex switch statements and switch expressions by caching/sharing the data needed for different inspections.
Nullable reference types:
We are improving our support for nullable reference types (NRT) and updating some actions accordingly.
If you use NRT, you may have noticed that an action to use explicit types instead of var always produces a nullable variable. Although that is correct, var being nullable is an implementation detail of the compiler, and using a nullable type might be confusing if developers never store nullable values in it.
Starting from this EAP build, Rider checks whether the variable needs to be nullable, and it will produce a stricter type when possible.
As you adopt nullable reference types, you might use some nullable warning suppressions that are no longer needed, since the suppressed expression is no longer nullable. Rider will help you find such suppressions and remove them.Finally, sometimes we may be too optimistic about some code and suppress an actual problem, thinking it’ll never happen. When this does eventually happen, it’s very hard to backtrack such suppressions, since ! is a very common symbol in source code. If you want to investigate where nullability contracts are violated with suppressions in your solution, you can now enable a new inspection, A suppressed nullable warning might hide an underlying problem, to find every suppression without having to dig through all other usages of the ! symbol. The inspection can be found in the Rider settings. And it will not be triggered by default, since suppressions are a completely valid way to prevent the compiler from nagging you about complex code that it cannot analyze.
Unity support:
Rider now warns you when you are trying to commit changes and Unity has unsaved scenes open.
We’ve also improved our online help in many ways. Importantly, you can now use the F1 (External Documentation) shortcut to navigate to localized documentation, if available locally.
Solution Explorer:
You can now edit File Properties (such as Build Action or Copy to Output Directory) for multiple items selected in the Solution Explorer.
IIS Express support
Rider will warn you when you try to run a 64-bit web application on 32-bit IIS Express (“use64Bit”: false in launchSettings.json) in in-process mode.
Razor:
Razor developers working on large views can turn off the CPU-intensive assistance and automatic suggestions if their editor begins to lag. You can find the settings here: Preferences/Settings | Editor | General | Typing Assistance | Razor | Allow CPU-intensive typing assist.
Navigation:
The Go To Base/Inheritors list shows hidden overrides, as well.
Code Styling and Formatting:
Support for Pico brace (indenting) style is here.
It’s now possible to specify advanced naming rules for records, extension methods, and catch variables.
Dynamic Program Analysis:
The list of issues now supports multi-selection.
On the off chance you’re developing a performance profiler and Dynamic Program Analysis (DPA) is affecting your profiling (i.e. application performance): you can disable DPA when starting a profiling session. To do this, have your profiler set the JETBRAINS_DPA_AGENT_ENABLE environment variable to 0.

New in ReSharper 2021.1.1 (Apr 12, 2021)

New in ReSharper 2021.1 (Apr 8, 2021)

Code Analysis:
We’ve significantly improved support for records: they’re now handled properly by the Extract interface and Extract superclass refactorings, the File Layout feature, Find Usages for the primary constructor, and XML documentation. There are some new inspections and quick-fixes to help you migrate your code to records: Redundant explicit property declaration, To record, and To explicit constructor. Code analysis now also works better with redundant code in records – it suggests replacing the empty record type declaration body with a semicolon.
ASP.NET Core route templates:
Route templates are widely used in MVC applications to configure how HTTP requests are matched to the application’s executable endpoints. In 2021.1, we’re introducing support for route templates for attribute-based routing (with more to come). This support includes code completion, structural navigation, rearranging the code, and something we’ve been missing ourselves ‒ the Rename refactoring for route parameters. As for code analysis, ReSharper can now check route template syntax errors and work with route parameters: it can highlight duplicate parameter declarations and correct missing parameters, incorrect constraints, and constraint violations (including for custom constraints).
Rename in Tuples:
Named tuples have been with us for some time already, but we haven’t had a proper rename refactoring for them. That wrong has been righted in the current release. You can now rename components in named tuples just as you would other entities.
Performance:
The “performance problem” issue type is one of the most important in our tracker. Working with a huge solution ourselves, we understand that performance is crucial. While we’re still dismantling ReSharper and putting it back together for ‘out of process’ mode, we never stop fixing specific performance issues where it’s possible to do so. Here are some highlights:
We’ve sped up typing in Razor files inside large solutions.
We’ve sped up typing in any large files where ReSharper’s analyzers are working.
We’ve improved the performance and responsiveness of debugger data tips.
We’ve optimized how ReSharper deals with shared documents, so it now consumes less memory.
We’ve implemented performance improvements for JavaScript and TypeScript unit testing.
We’ve continued to take steps to address performance issues. We tried using some new performance counters – for now in-house only – but unfortunately nothing really useful came out of it, so we’re now redesigning them.
Formatting, Code Style, and EditorConfig:
We are continually adding new formatting options, this time for target-typed new() parentheses, wrapping before the assignment operator, and outdenting label statements. Apart from that, for custom naming rules we have updated the order in which they are applied: more specific ones now go first.
Unit Testing:
We’ve implemented support for VSTest adapters, the feature that allows you to discover and run tests from a third party framework. Enable it in ReSharper | Options | Tools | Unit Testing | Test Frameworks | VSTest.
Other Updates:
We’ve added an action for copying GitHub links with the ‘Copy FQN’ feature.
You now have a new navigation action – Navigate to Windows Explorer. You’ll find it in the Navigate | Navigate to menu or by pressing Ctrl+Shift+A and typing its name.
The Extend/shrink selection feature now works in regular expressions in strings, be they C#, VB, or JavaScript, including Razor pages.
We’ve added type conversion hints for tuple conversions.
A new “Body” constraint is available for methods in File Layout, allowing you to specify different rules for block-bodied and expression-bodied methods.

New in ReSharper 2020.3.4 (Mar 18, 2021)

New in ReSharper 2020.3.3 (Feb 23, 2021)

New in ReSharper 2020.3.2 (Dec 30, 2020)

New in ReSharper 2020.3.1 (Dec 24, 2020)

New in ReSharper 2020.3 (Dec 14, 2020)

C# 9:
Record types introduced in C# 9 are reference types with value semantics. They go perfectly with init-only properties that can only be set during the initialization of an object. This means you can now achieve immutability, for the whole object or just for the property, and keep using object initializers.
ReSharper is keeping up with these changes, from code style settings to quick-fixes.
For positional records that have a compiler-generated Deconstruct() method, ReSharper offers a deconstructing declaration when appropriate.
Local functions have received new features in C# 9.0: their parameters and type parameters, as well as the local functions themselves, are now allowed to have attributes. ReSharper now has quick-fixes for that.
With top-level programs, entry-point code can be placed right after the using directives – that’s right, no namespace or class is required. There are, however, some rules: only one file per project can contain top-level code, and top-level sentences should indeed be placed on top, meaning they should precede any type or namespace.
ReSharper is here to help if you break any of these rules when moving your code around. Also, the Extract Method and Extract Local Variable refactorings are available in top-level code.
One more thing that’s no longer necessary is the type after the new keyword – if it can be inferred from the context, of course. This is called target-typed new expressions. ReSharper provides syntax style options for the new construct, and the Find Usages feature on the constructor.
What about pattern matching? Well, here we have relational and logical patterns, and all of them can now be used in matching expressions. Again, ReSharper can help you apply the new style.
ReSharper also covers smaller language updates, with static lambdas and lambda discard parameters, target-typed conditional expressions, native integer types, extension GetEnumerator methods in foreach, and function pointer types.
Source Generators:
What can ReSharper do about probably the hottest feature in the new C# compiler? What it does best: let you do your thing and lend a helping hand without getting in your way. Generated files are taken into account in refactorings and code editor features such as completion, and navigation can take you to the generated code.
Inlay hints:
Inlay hints can take one more thing off your mind. But what if you don’t need them all the time? What if you would want only to summon them temporarily, as a magical helper? Well, this is now possible with the new Push-to-Hint visibility mode in Settings. In Push-to-Hint mode, the hints will be shown if you press and hold Ctrl (and hidden as soon as you release it) or press Ctrl twice (in which case they remain visible until you press Ctrl twice again).
You can specify different visibility modes for different hints types and different languages.
Speaking of hints types, we have a new one! Implicit type casts are now marked right in the code. Ctrl+Click on a hint will navigate you right to the implementation of the conversion.
Avalonia:
Support is now available for the Avalonia XAML UI framework. Unleash the whole ReSharper arsenal: code inspections with appropriate quick-fixes for both C# code-behind and .axaml files, including Avalonia-specific inspections, code completion and other editor features, navigation, and refactorings.
Navigation:
Go to Text (or Find Text) now has one more inner tool to help you navigate in your project – fuzzy search, which takes into account possible typos and even missing words. The results are displayed below the results of the regular exact search, both in the popup and in the Find Results view.
In addition to helping find mistyped text, it can help when you’re not sure about the exact wording, or when you need to find where a formatted string is built.
Formatter:
We’re always updating the set of formatting options to help you see your code arranged exactly how you like it. In this release, we’ve added a group of settings for property patterns, which allow you to enable alignment in columns, place a simple pattern on a single line, and specify how to wrap long patterns. Also, blank lines can now be added around property or event accessors.
There have also been some additions in the .editorconfig department. First, ReSharper now supports the Roslyn properties file_header_templates, dotnet_sort_system_directives_first, and dotnet_separate_import_directive_groups. Second, the “Spaces around ‘=’” setting is now exported to .editorconfig. It’s detected automatically in existing files, and it can be set manually for new files. It is set to ‘true’ by default.
Dynamic Program Analysis:
Imagine your code being analyzed for memory usage during the usual cycle of running and debugging. All you would have to do is work on your project, and occasionally get a report about closures and allocations exceeding the specified thresholds (or see a green light and pat yourself on the back).
Introducing Dynamic Program Analysis (DPA)! Silent, configurable, and a perfect companion to the Heap Allocations Viewer plugin. Check out the dedicated blog post to learn more about DPA in ReSharper.
Structural remove
Have you ever selected a piece of code with structural navigation, deleted it, and found yourself left with an extra comma? Things like that can be pretty annoying. ReSharper is now smarter and tries to not only select structurally, but to delete structurally as well. A tiny act of care!
Command Line Tools:
First, a little time-saver: the CleanupCode console tool can now reformat the specified set of files or folders without pointing to the solution file. No need to wait for the whole solution to be scanned after you’ve just added a couple of files. The command line will look like this:
cleanupcode.exe [Path to folder] [Path to file] [Path to another file]
Please note that the tool only formats the code – cleanup isn’t available in this mode.
Second, plugins are back, but only on Windows for now. InspectCode and CleanupCode are now able to automatically download and enable plugins. You’ll need the plugin ID: go to JetBrains Marketplace, open the plugin page, go to the Versions tab, click on any version, and grab the plugin ID. After that, use the -x=[ID] key like that:
cleanupcode.exe -x=[ID] [Path to solution file]
Please note that the plugin has to be compatible with the tool version. Also, plugins are not yet supported if you’re using the .NET Core global tools mechanism to install ReSharper’s CLT.
Decompiler:
Private Source Link is now supported in the integrated decompiler. When navigating to the external sources that require a connection to a private source server, ReSharper will ask for your credentials – unless they have already been entered in Visual Studio’s settings, in which case they will be applied automatically (for GitHub and BitBucket).
We’ve also implemented some less visible but still important internal updates: improved the synchronization between IL Viewer and the source code, and updated the decompiler to understand new C# 9 features.
Other updates:
In Blazor support, we’ve been working on supporting generic type parameters and their type inference from usages, and minimizing performance setbacks.
We’ve added a new quick-fix that helps you transform a sequential pattern check into a complex pattern-matching check.
Nullable annotations are supported on unconstrained generic types (including default constraint).
A modest update for TypeScript support: ReSharper now supports nullish coalescing and optional chaining.
Inside the Change Signature refactoring, we’ve redesigned the ‘Resolve with call tree’ tool.

New in ReSharper 2020.2.4 (Oct 1, 2020)

New in ReSharper 2020.3 EAP 1 (Sep 24, 2020)

For top-level statements, ReSharper not only provides some basics, like code completion and code analysis, but also offers a couple of handy quick-fixes and refactorings.
When copy-pasting pieces of code, we often don’t care about placement. However, C# 9 requires top-level statements to precede any type or namespace declarations. Fortunately, ReSharper can help correct the placement with the Move top-level statements before types and namespaces quick-fix.
Because top-level statements implicitly declare the entry-point of a program, only a single file in the project can contain top-level code. If this requirement is not met, ReSharper allows you to move top-level statements to another file.
Finally, the Extract local variable and Extract method refactorings are available in the top-level context.
Native integer types, nint and nunit, are supported in our code analysis, completion, and code editor features.
C# 9.0 makes conditional expressions target-typed. With this change, the two expressions need not have an implicit conversion from one to the other, as long as they are both implicitly convertible to a target type. Notice how ReSharper doesn’t highlight the following code with error squiggles.
Finally, we’ve added support for the [DynamicallyAccessedMembersAttribute], so that ReSharper does not highlight any entities mentioned in the attribute as unused.
In addition to our efforts to keep up with the new language features, we have a couple of improvements in the feature set.
The results of Find Text now have a new section called Fuzzy. In addition to the traditional substring search that you are probably already familiar with, ReSharper now also performs a broader search that takes possible typos and missing words into account. It displays the results below the standard results, in the Fuzzy section. In addition to helping you deal with typos, this can also be useful if you want to find where a certain formatted string is built in your code.
Unit tests can be now launched in your preferred target framework directly from the editor. This saves time and clicks!

New in ReSharper 2020.2.3 (Sep 18, 2020)

New in ReSharper 2020.2.2 (Sep 10, 2020)

New in ReSharper 2020.2.1 (Aug 21, 2020)

New in ReSharper 2020.2 (Aug 13, 2020)

Code Analysis:
C# 8 support has been improved with a number of new inspections and quick-fixes, most notably for nullable reference types. For instance, code analysis now takes into account JetBrains.Annotations attributes (both NotNull and CanBeNull) for API declared in code where nullable reference types are disabled (#nullable disable).
Also, nullability code analysis is now aware of more cases and can trace incorrect nullability through deconstruction and the foreach cycle. It also provides a corresponding quick-fix.
Code Cleanup on Save:
Finally, you can set up ReSharper to launch Code Cleanup automatically on saving a file! We’ve also added more granular scopes to run Code Cleanup for recently modified or recently opened files.
Revamped Unit Test runner:
We’ve remade our Unit Test runner from scratch for both .NET Framework and .NET Core, which allows us to use the same runner for both runtimes that run out of the Visual Studio process. This has helped us solve quite a lot of problems with discovering, running, and debugging unit tests, and gives us full control over unit test hierarchies for .NET Core tests. What’s more, the new test runner has built-in MSFakes support for the NUnit, xUnit, and MSTest v2 unit test frameworks.
In other news:
We have good news for UWP developers – support for compiled bindings with x:Bind is finally here!
This release comes with improved support for screen readers like JAWS, NVDA, and Microsoft Narrator.
Type and project dependency diagrams have been updated. The yFiles engine, which is used to draw the graph, has been updated to the latest version. This, in addition to our optimizations, means the resulting graph is drawn much faster. Also, you can export the graphs to new file formats, GraphML and XPS.
Navigating to usages of types from external assemblies in the code is now much easier. ReSharper can navigate directly from Go to Type search results to Find Usages.
New Peek actions have been added to show the result of some common ReSharper actions in a Peek Definition view.
We have updated our offline and online installers to cover all products under the dotUltimate license, which includes ReSharper, ReSharper C++, JetBrains Rider, dotCover, dotTrace, dotMemory, and dotPeek.

New in ReSharper 2020.2 EAP 9 (Aug 6, 2020)

New in ReSharper 2020.2 EAP 8 (Jul 24, 2020)

New in ReSharper 2020.2 EAP 7 (Jul 17, 2020)

New in ReSharper 2020.1.4 (Jul 9, 2020)

New in ReSharper 2020.1 (Apr 16, 2020)

The backend runs on .NET Core runtime
Finally, the backend runs on .NET Core runtime by default on macOS and Linux, instead of the Mono runtime. Moving to .NET Core runtime delivers noticeable performance improvements, a lower memory footprint, and multithreaded NuGet restore.
Lin_mac-perf-TotalTime
This is important for developers using Rider on macOS and Linux, but it is also good news for developers on Windows because bringing it to Windows is the next big step we’re going to take.
Now let’s have a look at the other impressive features and improvements in this first major release of the year.
Xamarin hot reload
Now Rider automatically applies changes made in Xamarin Forms XAML to the application under debugging on a device or a simulator, without rebuilding and redeploying the whole application.
Dynamic Program Analysis
Every time you run your project in Rider, Dynamic Program Analysis (DPA) starts collecting memory allocation data. Once you close the application, DPA will show you a list of detected problems: closures, and allocations to large and small object heaps. No need to start any “profiling sessions” and get snapshots – just work as usual and all the data will be collected in the background, with almost zero overhead.
Dpa-blog@2x
Dataflow analysis of integer values
Thanks to ReSharper, this version of Rider comes with a new type of analysis that tracks how the values of all int local variables change, and it verifies the correctness of all common operations on such variables to detect unnecessary or possibly erroneous pieces of code.
Int-dataflow-blog@2x
Deferred asset indexing for Unity projects
We’ve made significant improvements in the memory usage and speed of asset indexing. Rider will now index all of your code before looking at your assets, meaning that all productivity features, such as code completion, highlighting, and inspections, are available for use sooner than before. And this is just one thing from the heap of improvements Rider Unity team has delivered in this release, which we will mention a bit later.
Even more features and improvements
If the above is not enough to call this release feature-rich, perhaps these additional goodies will tip the scales:
C# code analysis reports compilation warnings related to nullable reference types and provides quick-fixes for most of them.
Now the code completion popup displays much faster after you begin typing, especially in large solutions.
We have completely reworked the UI for the Debug tool window to make it as clean and uncluttered as possible. The tabs layout is simplified, as all tabs are now on one single level, and we’ve combined the Threads and Frames views.
The debugger engine now supports detaching from a process initially started under the debugger without terminating the app, supports the .NET Core x86 runtime, and Smart Step Into is enabled by default for the Step Into action.
As already mentioned, there are a lot of other improvements in Unity support: Asset indexing understands usages of your code in Nested and Variant prefabs, unit testing discovery now works better for Unity projects, and code completion no longer suggests Boo.Lang.List or System.Diagnostics.Debug, just to name a few.
If our TFS client is selected in Settings/Preferences, enabling Version Control Integration now works for TFS workspaces locally created with Visual Studio.
For Unit Testing, we’ve tweaked the toolbars on Unit Testing windows and added new advanced Group by functionality, new filtering of unit tests by the target framework, and export/import for Unit Test Sessions.
A new non-modal popup where you can change the editor’s highlighting levels.
Extract Class refactoring.
Coverage Filters for the unit test coverage results.
Two new folders in the Solution Explorer: Implicit references and MSBuild import targets.
Support for WIX (Windows Installer XML Toolset) projects.
Tons of improvements and fixes in F# support to help you in your daily routine: new inspections and quick-fixes, a new “Send project references to F# Interactive” action, the evaluation tooltip on mouseover works for more expressions when you are debugging, and more.
A new Cancel build action.
Keep in mind the list above does not cover all the features, improvements, and smaller tweaks that our team has worked on to bring to you in the last four months. To see everything this release has to offer and find even more interesting things, please refer to What’s New in Rider 2020.1 on our website.
The full list of fixes completed in the 2020.1 release cycle can be found on YouTrack.
Use any of these ways to download this Rider 2020.1:
Download and install from www.jetbrains.com.
Update right inside Rider: select Help | Check for updates.
Use our Toolbox App.
Use this snap package from the SnapCraft store if you are using a compatible Linux distro.

New in ReSharper 2020.1 EAP 7 (Apr 3, 2020)

New in ReSharper 2019.3.4 (Feb 28, 2020)

New in ReSharper 2020.1 EAP 1 (Feb 27, 2020)

New in ReSharper 2019.3.3 (Feb 20, 2020)

New in ReSharper 2019.3 (Dec 11, 2019)

Let’s highlight the most important features in this release:
Outstanding support for T4 templates is here with capabilities such as template execution, debugging, code highlighting, navigation, refactorings, code completion, and much more.
We’ve made a huge step forward in performance profiling, so now you can profile .NET Core applications on Windows, Linux, and macOS right in Rider.
If you are a Unity developer, you should benefit greatly from the cross-platform unit test coverage and continuous testing, which finally supports Unity tests!
Startup performance has been improved, smooth mouse scrolling is here, and a lot of UI freezes have been eliminated. These are just a few of the performance improvements in Rider 2019.3.
Docker-compose support now covers the debugger. Enjoy debugging multi-container Docker applications with the click of a mouse.
In version control support, we’ve started experimenting with the user interface and user experience when working with version control systems like Git. Check out the new live diff preview, a new Commit tool window on the left-hand side of the IDE, and several other improvements.
If none of the above caught your interest, we have more new features for you still:
Edit & Continue can now apply changes to a running (not suspended) application, and the application does not need to be stopped at a breakpoint.
The debugger in general has many improvements. The Exceptions tree in the Breakpoints view is updated and Remote Debugging is enhanced, to mention just a few.
The AWS Toolkit plugin is now compatible with Rider! It supports creating, running, and debugging an AWS Lambda locally and remotely. Cloud Debugging support is also here.
Database support has several updates, with the biggest highlight being early MongoDB support.
C# 8 support becomes even better and includes support for notnull constraints, target-typed switch expressions, early support for default interface methods, and several new inspections and quick-fixes.
For Xamarin developers, we’ve got better discovery of Apple devices and simulators, a list of connected Apple devices on the toolbar, and a “Publish Android APK” action for Xamarin Android projects.
Find dependent code now works for NuGet references and can be run for a whole solution instead of just a project.
The Quick definition overlay tooltip is available for any symbols in the code editor
C# naming settings now support reading from / exporting to EditorConfig.
Support for TypeScript 3.7 is here alongside other improvements in support for JavaScript, TypeScript, Vue.js, and Angular.
Type Name Hints are available for all var occurrences, lambda’s parameters, and more.
Identifier highlighting has been completely reworked with a separate page for C#, separate colors for preprocessor directives, static methods, fields, etc.
There’s one last thing we’d like to mention, which is a small but very handy improvement for today’s .NET Core era. If you’ve ever added a second target framework to your .NET Core app by editing a .csproj file manually, did you forget to change TargetFramework to TargetFrameworks? I would venture a guess that you have, and probably more than once.

New in ReSharper 2019.2.3 (Oct 18, 2019)

New in ReSharper 2019.2.1 (Aug 20, 2019)

New in ReSharper 2019.2 (Aug 8, 2019)

New in ReSharper 2019.2 EAP 4 (Jul 18, 2019)

New in ReSharper 2019.1.3 (Jul 11, 2019)

New in ReSharper 2019.2 EAP 1 (Jul 2, 2019)

ReSharper:
There is initial support for the “Per-Monitor DPI Awareness” mode in Visual Studio 2019. If you disabled Optimize rendering for screens with different pixel densities via Tools | Options | Environment | General because of the rendering issue we had with the ReSharper tool windows, please enable it again and check out how it now looks.
We’ve updated the Performance Guide page. It has a new Windows Defender section and descriptions for all performance tips, which describe what exactly will be done after a suggestion is applied.
You can search in a file right through the Go to File member dialog.
A new filter in the Go To Text results window to filter out comment lines.
The Advanced symbol options dialog under ReSharper | Tools | External Sources now supports relative paths.
The debugger data tips respect the Enable property evaluation and other implicit function calls setting, and can evaluate property values on demand.
A new tooltip with the description of a keyword is available in the IL Viewer.
ReSharper C++:
Improved hints in the code editor. ReSharper C++ adds two new types of hints: hints after preprocessor directives and hints for function arguments passed by a non-const reference. Hints in aggregate initialization expressions now show the names of initialized base classes.
New inspections and quick-fixes:
Several new inspections are available: “Unmatched preprocessor directive”, “Explicitly defaulted special member function is implicitly deleted”, and “Redundant final function specifier in a final class”.
“Use static_cast fix” for the "C-style cast used” inspection can be run in bulk and as a part of Code Cleanup.
Several updates in Navigation:
Go to declaration can navigate to the default constructor called when an object is default-initialized in variable declarations and new expressions..
Find usages finds usages of default constructors in default initialization.
Go to symbol now hides symbols with qualified names (e.g. out-of-class function definitions). When an item is selected, Go to symbol jumps to its definition, similar to how Go to declaration does.
More C++ 20 features are supported: conditional explicit, char8_t, pack expansion in lambda init-capture, default constructible and assignable stateless lambdas, C++20 rules for aggregates, consteval and constinit specifiers, C++20 improvements to structured binding declarations.
Code completion: The summary tooltip in the code completion popup is now colored and shows documentation for the selected item.
Improvements to typing assist in multi-line comments: multi-line comments that use single-line syntax are automatically extended; extending multi-line comments now inserts correct indentation when virtual space is enabled.
Unreal Engine 4 support: The "Rename" and "Change Signature" refactorings handle RPC functions properly.
dotPeek:
an unmanaged (win32) resources subtree in the Assembly Explorer.
a couple of updates for the metadata tree: a description for unmanaged resources directories and entries (type, language) and a description for section’s headers.

New in ReSharper 2019.1.2 (Jun 6, 2019)

New in ReSharper 2019.1.1 (May 5, 2019)

New in ReSharper 2019.1 (Apr 30, 2019)

New in ReSharper 2019.1 EAP 4 (Apr 2, 2019)

New in ReSharper 2019.1 EAP 1 (Mar 15, 2019)

ReSharper 2019.1 EAP comes with the following notable enhancements:
Initial C# 8 support: Ranges and index from end expressions, null-coalescing assignment, switch expressions, tuple expression in a switch statement, static local functions, and nullable reference types are supported.
Parameter name hints work for attribute usages and for StringFormatMethod calls.
Enhanced typing assists for nullability annotations.
Improved support for Visual Studio 2019 RC.
Code formatting: detecting formatting settings works in the background; “export settings to .editorconfig” is possible; and formatting inspections for indenting around child statements are ON by default.
Optimize references works on SDK projects.
Go to Text searches inside all text files in a solution.
The Extract Method refactoring can now rename introduced parameters.
ReSharper C++ 2019.1 EAP – The ReSharper C++ team has started this year putting the pedal to the metal on performance optimizations in Unreal Engine 4 codebases. The changes include initial indexing that runs several times faster, much better memory utilization, and new settings to tweak ReSharper's indexing behavior. ReSharper is also aware of UE4 RPC functions, which means that you can now jump between related function declarations and definitions, generate required definitions, and so on.
Apart from all the UE4 improvements, ReSharper C++ delivers the following:
Lots of general performance improvements to reduce indexing time and improve memory usage.
C++ language support: C++20 familiar template syntax for generic lambdas, C++17’s hexadecimal floating-point literals, and alternative operator representations.
Navigation improvements: Include base members option in Go to file member is supported; and Go to file member, Go to base class, and Go to derived class searches are now available during indexing.
Unit testing: support for TEMPLATE_PRODUCT_TEST_CASE test declarations from Catch 2.7 and GTEST_SKIP() macro in Google Test.
Documentation comments: parameter names get renamed in XML documentation comments, and a typing assist automatically inserts '///' on a new line.
Clang-Tidy: separate Clang-Tidy options page, and a new setting to use a custom clang-tidy binary instead of the built-in one.
dotPeek 2019.1 EAP adds navigation to source from a document token node, and navigation to the XML view of the PDB content in the metadata tree. The Assembly Explorer adds the Dependencies node for NuGet packages and allows navigating to nuspec file by double-clicking the NuGet node. dotMemory 2019.1 EAP provides initial .NET Core 3.0 support and can instantly navigate from dotMemory to the object's type declaration in JetBrains Rider.

New in ReSharper 2018.3.4 (Mar 5, 2019)

New in ReSharper 2018.3.3 (Feb 11, 2019)

New in ReSharper 2018.3 (Dec 19, 2018)

New in ReSharper 2018.3 EAP 8 (Dec 7, 2018)

New in ReSharper 2018.3 EAP 1 (Oct 8, 2018)

We’ve implemented the Introduce parameter refactoring for local functions.
Lots of new inspections, quick-fixes, and context actions have been added to C# code analysis for different cases:
Add an explicit tuple component name.
Split ||-expressions in switch case guard clauses into separate switch cases.
Detect format strings that were incorrectly used as interpolated strings.
Use string interpolation, convert LINQ to XML/JSON, and format items highlighting for the string.Concat method.
Detect format strings which were incorrectly used as interpolated strings.
Initialize members to create and fill the object initializer.
An improved context action "Deconstruct variable" is available on usages and on parameters, and supports deep nested deconstructions.
Show Inspection Help is now available for inspections in the Inspection Results and Error in Solution windows if the inspection has a corresponding WebHelp article.
The Go To Action popup allows looking for Options pages.
You can select which font style ReSharper Editor Adornments should inherit: Visual Studio IntelliSense or Text Editor.
We’ve made ReSharper more FIPS-compliant by stopping the use of the md5 hash algorithm and eliminating all its previous uses in the codebase.
Other tools from ReSharper Ultimate family:
ReSharper C++ introduces predefined naming schemes for common C++ code standards. It also makes several usability improvements to Parameter Info, and adds the Specify template arguments explicitly context action for use with C++17 class template argument deduction. Finally, it includes several fixes that improve performance during solution opening (in particular for projects that use Unreal Engine).
dotTrace gets a new subfilter in the Timeline Viewer, which allows you to analyze how the allocated memory is distributed between the objects of a certain type.
dotMemory gets a new condition on the profiling controller for taking a snapshot: Get a snapshot if total memory usage exceeds X MB. Also, the view showing objects queued for finalization (the result of the Finalizable objects inspection) allows opening these objects and analyzing them in other dotMemory views.
dotPeek supports decompiling local functions and pattern matching and makes it possible to copy the fully qualified name (FQN) of a symbol to the clipboard.

New in ReSharper 2018.2 (Aug 22, 2018)

ReSharpher Ultimate (part of this suite)
228mb
Performance improvements:
Every release, we make a lot of performance improvements and bug-fixes to limit ReSharper’s impact on Visual Studio, increase responsiveness, and eliminate UI freezes. Back in ReSharper 2018.1, we started publishing blog posts about the current situation in terms of performance: where we are now, why we have what we have, what fixes we’ve made in the latest release cycle, and our plans to make things better.
For the 2018.2 release, we’ve made about 30 performance fixes across different parts of ReSharper, from speeding up EditorConfig support to decreasing solution loading times. More detailed information can be found in the new blog post series dedicated to the ReSharper 2018.2 release.
Integrated spell checking with ReSpeller:
This release comes with the ReSpeller extension to provide spell-checking functionality out of the box. Just like with code analysis, ReSpeller scans for spelling mistakes and typos in identifiers, comments, string literals, and more, and provides quick-fixes to resolve each detected problem. By default, ReSpeller is enabled for many of the languages ReSharper supports. A simple way to enable/disable individual inspections and change severity is by searching for “typo” in the settings (you’ll end up in Code Inspection | Inspection Severity).
We can then invoke the Alt+Enter menu where ReSpeller gives us several options to fix our mistake. In the menu, we can either fix the typo or add a new word to ReSpeller’s dictionary.
By default, the spell checker comes with a built-in dictionary for English (United States). It uses a dictionary based on Hunspell, which means you can install additional languages if you like.
To learn more, see Integrated spell checking with ReSpeller in ReSharper and Rider.
C# 7.3 support:
ReSharper now supports all features from the latest C# 7.3:
Declaration expressions in initializers and queries.
Tuple equality.
Ref assignments.
Unmanaged, System.Delegate, and System.Enum constraints.
Stackalloc array initializers.
Pattern-based fixed statement.
Indexing movable fixed buffers.
Besides supporting the syntax, we’ve added new inspections and appropriate quick-fixes to make your code compatible with C# 7.3.
To learn more, see C# 7.3 in Rider and ReSharper
Initial Blazor support:
The experimental project Blazor is a single-page web app framework built on .NET that runs in the browser with WebAssembly. Even though Blazor is declared experimental for now, we’ve added initial support for this promising framework in ReSharper. For instance, code completion includes all the possible directives like page (routing), inject (service injection), and function (component members).
To learn more, see Initial Blazor support in ReSharper and Rider 2018.2.
Navigation improvements:
Several small but handy new features are added in Navigation.
ReSharper introduces a long-awaited feature for Search & Navigation options: you can now specify ignored files by using a mask in Environment | Search & Navigation. You can exclude files from all search and navigation features, based on a file extension or by folder.
The StackTrace Explorer parsing engine has been added to Search Everywhere. With ReSharper 2018.2, we can now copy a function signature from dotTrace’s / Visual Studio’s Call Stack window and navigate directly to the correct method overload in the codebase, by using Search Everywhere.
Last but not least, some ReSharper features like File Structure, Containing Declaration, Next/Previous Members, and others now take local functions into account.
Colored Parameter Info popup and Summary tooltip for IntelliSense:
This release updates the way ReSharper presents parameter information in lookup item popups. For example, when using code completion in C# or VB.NET, ReSharper displays parameter types and method return types in a different color, making it easier to visually identify method overloads.
The formatter engine update:
The formatter engine has several new features:
Comments in a code file to override formatter settings can be generated directly from the Configure Format dialog.
The File Formatting Info tool window explicitly shows the settings affected by StyleCop rules.
The Options dialog can now show a StyleCop rule name if StyleCop rules override a code style/formatting setting.
JSLint, ESLint, and TSLint:
ReSharper extends the built-in code analysis rules with support for three static analysis tools: JSLint, ESLint, and TSLint. All of these linters help ensure that JavaScript and TypeScript code is readable and maintainable. They also allow adding custom rules, which can be included in ReSharper code analysis.
In case a Node.js interpreter is already configured on your machine, you can enable linters in ReSharper settings under Tools | Web Linters.
Refactorings UI update:
In this release, several ReSharper refactorings have been moved to the new presentation framework. Most of the improvements happen under the hood and are not visible in the UI. This move helps us unify the behavior of controls across ReSharper and Rider.
The key visible UI changes include:
Change Signature dialog has a code completion popup for parameter type.
Extract Method has a disambiguate popup which specifies whether a method or a local function should be created as a result.
Other ReSharper 2018.2 updates include:
Fix in scope quick-fixes receive more granular fixing scopes: Fix in method and Fix in class.
The code style for Built-in Type was improved: it gets independent settings for member access expressions and "fields, parameters, variable" declarations.
There’s a new option to execute BeforeBuild and AfterBuild targets for skipped projects in ReSharper Build.
A new inspection to highlight misplaced text in XAML.
In XML/XAML support, when you press Enter before a closing tag on a separate line, typing assist now inserts a blank line before the closing tag and leaves the caret on the blank line (instead of moving it to the closing tag).
Initial C++/CLI support (ULTIMATE):
C++/CLI is a set of C++ language extensions by Microsoft for easy interoperability between managed and native code. With extensive support for both managed languages and C++, it is only natural for ReSharper to offer help with writing code in C++/CLI too.
However, with so many syntactic additions and peculiar changes to the C++ language semantics handling C++/CLI is no easy task. But now the wait is over — ReSharper C++ 2018.2 makes C++/CLI support public, with many major features (including code inspections, typing assistance, formatting, and code completion) updated to support this language dialect.
C++17 and C++20 features (ULTIMATE):
ReSharper С++ 2018.2 deepens its understanding of the modern C++ language. Thanks to the added support for class template argument deduction, user-defined deduction guides, fold expressions, auto non-type template parameters, and more, most of the major C++17 features are now supported by ReSharper C++.
As the C++20 standard is already shaping up, ReSharper C++ 2018.2 learns to understand a number of C++20 features already available in major compilers, specifically coroutines, designated initialization, feature test macros, and others.

New in ReSharper 2018.2 EAP6 (Aug 7, 2018)

New in ReSharper 2018.2 EAP5 (Jul 27, 2018)

New in ReSharper 2018.1.2 (May 31, 2018)

New in ReSharper 2018.1.1 EAP 11 (May 17, 2018)

New in ReSharper 2018.1 (Apr 16, 2018)

ReSharper gets a significant number of bug fixes (based on more than 260 requests) and a bunch of features and improvements as highlighted below:
C# 7.2 support has been finalized by adding the missing pieces to the puzzle: non-trailing named-arguments, private protected access modifier, leading underscores in numeric literals, in parameter, ref readonly returns and locals, readonly struct type, ref struct type, and conditional ref operator. Now, if your code follows the latest language version – there’s no more red code!
Navigation features improved: Go to File Member gets a new grouping for better presentation of multiple classes in a single file; Recent Files shows Go to File underneath its search results; Search Everywhere adds a Unit Test filter; and Find Usages now has a disambiguate dialog with a suggestion to look for default constructor usages.
The code formatting engine was given a huge update – inspections and quick-fixes for formatter-related problems, including indenting, line breaks, spaces, and blank lines, can now be observed and fixed directly in the code editor.
C# 7.x support has been improved by adding more options to code style, inspections, quick-fixes, and context actions for deconstruction and discards.
editorconfig file can now be used to set inspection severities for any scope: for the whole solution, for a project, or even for a specific file. Also, ReSharper now reads code style settings (Code Editing | C# | Code Style) from .editorconfig files and extends its support for Roslyn language conventions. In addition, the inspection severity settings can be read from a project’s DotSettings file.
Value Tracking, the Introduce variable refactoring, and the .foreach/.var postfix template now support C# 7.x features.
In the same way that ReSharper handles Roslyn coding conventions, it will also handle StyleCop rules directly from StyleCop configuration files.
A couple of handy features around code comments have been added.
ReSharper Build engine now supports Pre-/Post-build tasks.
The option Remember last search is now enabled by default.
As far as other ReSharper Ultimate tools are concerned:
ReSharper C++ 2018.1 comes with two new major features: Debug Step Filters which lets you avoid stepping into specific functions during debugging, and Includes Analyzer which helps you investigate the dependencies between the header files that affect compilation time. Other updates include a redesigned Go to File Member dialog, new code inspections, and a command-line tool to perform code cleanup.
dotCover 2018.1 has redesigned two of its vital features: continuous testing mode can be turned on for any unit test session instead of running a separate continuous testing session, and coverage information is now shown in a separate Unit Test Coverage window, instead of a per-session Coverage tab. dotCover console runner gets the ability to cover arbitrary managed processes and services (analyze-everything, analyze-service) and send the get coverage snapshot command to the running instance of the console tool. And last but not least, coverage analysis performance has been improved.
dotMemory 2018.1 comes with many minor user interface improvements. The most significant change is the reworked Analysis Subject panel. Now, it’s much easier to navigate your analysis path.
dotPeek 2018.1 can now decompile the async Main method, dictionary initializers, null-conditional operators, and await inside catch/finally blocks.
dotTrace 2018.1 has received a set of bug fixes and minor performance improvements.

New in ReSharper 2018.1 EAP 6 (Apr 5, 2018)

New in ReSharper 2018.1 EAP 3 (Mar 19, 2018)

New in ReSharper 2018.1 EAP 2 (Mar 7, 2018)

New in ReSharper 2018.1 EAP 1 (Feb 27, 2018)

New in ReSharper 2017.3.2 (Feb 2, 2018)

New in ReSharper 2017.3.2 EAP (Jan 26, 2018)

New in ReSharper 2017.3.1 (Dec 22, 2017)

New in ReSharper 2017.3 (Dec 19, 2017)

Debugger features:
ReSharper brings one of Rider's debugging features to Visual Studio: local variables, current line expressions, and function return values are now displayed in the editor. This provides immediate feedback during debugging sessions without leaving the code editor.
ReSharper also comes with its own debugger DataTips that enable you to search for any value. Just start typing, and get search results right there and then.
Performance Guide:
ReSharper's Performance Guide collects Visual Studio and ReSharper settings that could negatively affect performance, and helps you adjust them in a centralized manner to improve the overall IDE responsiveness.
Performance Guide can be found in ReSharper's options, under Environment | Performance Guide.
The feature is inspired by an extensive ReSharper web help article which collects and prioritizes known performance improvement recipes.
Huge code formatting engine update:
The code formatting engine has been extended with a lot of new settings for more flexible formatting and to cover more use cases:
Option to keep extra space inside (to respect user alignment around existing =)
Options to outdent binary operators, dots and commas
Option "Nested ternary expression style"
Option to insert blank lines before/after statements, depending on their contents
Improve alignment of nested binary expressions and chained method calls
Line Breaks and Wrapping options to place attributes on same line/previous line, specify arrangement of attributes, …
Options to specify single-line/multi-line formatting for expression-bodied members
Options for embedded blocks of code
HTML formatter has new options for linebreaks before multiline elements or even before all elements.
Aligning code in columns:
We have implemented a set of popular feature requests around aligning code. There were requests to align equal operands, to implement outdenting and make code using the ternary operator look nicer, and several other requests to help make code more readable.
Some developers like to have properties in a class aligned in columns, e.g. the { get; set; } starting in the same column. Others like to align assignments in columns. ReSharper 2017.3 now supports all of those flavors!
Enable/disable formatter on selected blocks:
In this release, ReSharper prevents code formatting from running on a block of code surrounded by specific comments. There were many users who wanted to use different formatting styles for different blocks of code, or disable formatting altogether. You can now prevent unwanted changes to your unique hand-made formatting!
Also, there is now a way to override specific settings for a block of code, instead of disabling the whole formatter, by surrounding the block with a comment.
Improved Extract Method refactoring:
A revised Extract Method refactoring levels up its support for C# 6 and C# 7. Specifically, support for local functions has been added, there's now an option to return value tuples instead of out parameters, and the refactoring now works in expression-bodied members.
Create and navigate to breakpoints/tracepoints efficiently:
ReSharper 2017.3 introduces creating breakpoints or tracepoints right from search results in the Find Results window. You can quickly generate breakpoints for all the occurrences of a code entity you would like to debug.
Also, the new release adds a new Breakpoints menu which shows you all the available breakpoints/tracepoints in the solution. The menu supports searching/deleting any of them directly or opening the list in a separate tool window.
The new R# Breakpoints tool window supports a lot of actions with breakpoints/tracepoints:
Grouping in different ways (file/folder/project/type/member).
Removing/disabling/enabling a single item or a group of items.
Searching for them.
Find Usages/Call Tracking update:
Find Results tool window brings more love to multi-line occurrences: the presentation has been changed to show context as a single line in the result tree. Now it is easy to see multiline formatted occurrences in the list of search results.
The updated Call Tracking tool window helps keep focus by allowing to remove calls that you have already reviewed.
Linking to external resources in to-do items:
To-do patterns get a URL field: it creates a link in your code to navigate to external resources by Ctrl+Click on a to-do item or via Alt+Enter. It helps you keep your to-do comments brief and straightforward: no full URLs, only an issue ID.
Links in to-do items support the Peek Preview feature to display the linked issue inline in the editor. Also, you can easily locate the to-do item in the To-do Explorer via Alt+Enter menu.
Finally, a new filter in the To-do Explorer allows you to select multiple patterns.
New C# typing assists:
We have added more typing assists in C# to help you:
Automatically generate */ for a new multiline comment by hitting Enter and inserting * for a new line.
Indent a method in chained method calls after typing a dot.
Surround a code selection by typing a brace or a parenthesis.
In a related change, smart indent on Enter is now on by default.
Tuples in VB.NET:
ReSharper now understands the tuple syntax introduced in VB.NET 15: no more bogus red code when you use them, and IntelliSense does not interfere with your typing.
Enhanced Preview pane in tool windows:
This release has integrated a refreshed Preview pane into most ReSharper windows such as Find Results and Options.
In Find Results, the code in the Preview pane looks more natural: keywords and strings are highlighted, identifier colors are applied, font settings and scaling are inherited from Visual Studio's text editor settings.
On formatter pages in ReSharper Options, the pane always displays whitespaces and tabs to show you everything you need to know about the selected formatting style.
More ReSharper updates:
Other updates to ReSharper include the following
Alt+Enter menu does not wait for the file analysis to finish, it appears immediately
For TypeScript, we've improved the performance of type guards support, changes in npm modules are now tracked, and auto-completion is available for imported paths
Peek Definition is supported in Visual Studio 2015 and 2017
New code generation action is available to create deconstructors from selected fields/properties when you use C# 7.0
inheritdoc/> support comes to VB.NET
Profiling async code (Ultimate):
The downside of asynchronous code is it's extremely difficult to profile it and analyze its performance.
dotTrace 2017.3 dramatically simplifies the analysis of asynchronous code. It marks all async call nodes in the Call Tree and groups the corresponding await time and continuation code under that node. This means that you can quickly find all "parts" of an asynchronous call in one place instead of searching in different call stacks.
ReSharper C++ updates (Ultimate):
ReSharper C++ 2017.3 brings the same debugger features as the mainline ReSharper, improves its language understanding including the C++17 and C++14 specification, integrates Clang-tidy, adds more code inspections, context actions, and formatting options, and supports Catch2 in its unit test runner.

New in ReSharper 2017.3 EAP 9 (Dec 7, 2017)

New in ReSharper 2017.3 EAP 8 (Dec 1, 2017)

New in ReSharper 2017.3 EAP 7 (Nov 24, 2017)

New in ReSharper 2017.3 EAP 5 (Nov 15, 2017)

New in ReSharper 2017.3 EAP 4 (Nov 2, 2017)

New in ReSharper 2017.3 EAP 3 (Nov 1, 2017)

New in ReSharper 2017.2 (Aug 31, 2017)

Highlights of ReSharper 2017.2 include:
Support for .NET Core 2.0 in Visual Studio 2017 15.3. Your favorite code inspections, navigation actions and refactorings are now available in .NET Core 2.0 projects, including the new ASP.NET Core Razor Pages projects. Lots of .NET Core unit testing issues have been resolved along the way, and you can now run xUnit.net, NUnit or MSTest in your .NET Core 2.0 projects.
Improved support for C# 7.0 including pattern matching and out variables, as well as initial
support for C# 7.1: the default literal, tuple projection initializers, async main and pattern matching with generics.
New code inspections around IEnumerable usage and XML documentation inheritance.
Null checking preferences that let you tell ReSharper how you want it to introduce null checks when it generates code.
Multiple navigation improvements, including search in any order, exact search, textual search in Go to Everything, and navigating to nearby files.
TypeScript, JavaScript, JSON and Angular support improvements, including code completion performance, TypeScript 2.3 and 2.4 features, new kinds of language injections and new TypeScript refactorings.
Interactive tutorials to help you get started with ReSharper’s functionality or get up to speed with features in new ReSharper releases.
Other ReSharper Ultimate products have received their share of improvements as well:
ReSharper C++ 2017.2 is mostly focused on better language understanding and supporting features from C++11 and C++17. Other changes include enhancements in code formatter and navigation, improved performance, new code inspections and quick-fixes.
dotCover 2017.2 improves code coverage performance, starts to support MSTest unit tests in .NET Core applications, and introduces a new kind of markers for coverage and test status indication.
dotTrace 2017.2 enables profiling child processes in unit tests, introduces Timeline profiling from the command line, and learns to show navigation paths in the Call Tree view.
dotMemory 2017.2 enables importing raw Windows memory dumps and analyzing them using its full range of features.
dotPeek 2017.2 supports SourceLink and extends its feature set in terms of navigation and search.

New in ReSharper 2017.2 EAP 3 (Jun 15, 2017)

New in ReSharper 2017.2 EAP 2 (Jun 15, 2017)

New in ReSharper 2017.2 EAP 1 (Jun 15, 2017)

New in ReSharper 2017.1 (Apr 5, 2017)

Visual Studio 2017 RTM support:
Full support for Visual Studio 2017 new features is finally here. You can now work with solutions loaded in a lightweight mode. When you use the Open Folder option, ReSharper sees all files in the folder and supports .xml and .js file types. Move to Folder refactoring works in this mode
ReSharper respects the current target framework context. This is set by the drop-down at the top of the editor window, and can change settings such as the assemblies being referenced, as well as symbols defined in the build and pre-processor
C# 7 support:
ReSharper receives a lot of new inspections to comply with the C# 7 compiler. For example, it can detect typos in tuple variable names when overriding a method or implementing an interface.
ReSharper supports local functions with a new quick-fix to Convert a read-only delegate variable into a local function, as well as two new context actions:
Convert lambda expression or anonymous method into a local function
Convert local function into a regular method
The Join null check with assignment quick-fix makes the code more readable by combining the assignment, the null-coalescing operator, and throw. The existing context action Convert to '?:' operator and the .throw postfix template also support C# 7 throw expressions.
Unit testing:
ReSharper’s unit testing works in both project.json- and .csproj-based projects in Visual Studio 2017 RTM. It discovers and runs MSTest and xUnit tests and supports code coverage and profiling as well as targeting multiple frameworks. NUnit tests that target .NET 4x frameworks are supported. There’s also DataRow support for MSTest v2.
Note that ReSharper currently doesn't support continuous testing for .NET Core unit tests. This will be fixed in the next updates.
EditorConfig support:
EditorConfig support is enabled by default. ReSharper understands standard EditorConfig properties, most of Roslyn EditorConfig properties, and provides a rich set of custom EditorConfig properties for much more granular configuration of formatting rules. This means that you can maintain the entire configuration of formatting rules in EditorConfig files.
The File Formatting Info window displays the scopes and properties defined in all active .editorconfig files. This window also shows the source of indentation settings and its value, and the status of indent autodetection.
Code cleanup and formatting improvements:
ReSharper’s Code Cleanup gets usability improvements. Now you can create and configure your custom task-specific profiles right in the Code Cleanup dialog box, simply by pressing Ctrl+E,C.
Contextual configuration of formatting rules is available in ?#, C++, JavaScript and TypeScript. Press Alt+Enter over the selected block of code that you need to reformat, and then choose Format Selection | Configure in the actions list to see all formatting rules that affect the code.
Tabs and indents in all supported languages can now be configured on a corresponding options page and stored in ReSharper’s layered settings.
ReSharper applies its formatting rules to any code you paste. The Reindent option that affects only the indentation settings is set by default and you can change it on the Editor Behavior options page.
When you reformat a part of code in a file, or when code is auto-formatted on editing or pasting, ReSharper can calculate and apply indentation based on the existing indents in that file. This feature comes in handy when you want to contribute to existing projects where indentation differs from your settings.
New C# code style and formatting options:
C# formatting styles were enhanced with several new options:
Code style settings for type members bodies: choose between always using a body block, with braces, or using the expression format.
The new wrapping engine now handles the alignment correctly, and comma-first wrapping style is supported
Set spaces before and inside the parentheses of 'nameof'
Choose preferred wrapping style for chained binary expressions
Add line breaks in a single 'case' statement
Navigation and search:
The Find Results window gets a new option to group search results by kind of usage, new filters to select occurrences of a specific usage, and using quotes to search for exact matches.
ReSharper's Search & Navigation page adds a new option to open files in the preview tab from everywhere. This option is turned off by default.
The Go to Everything and Go to Text popups support inline commands for advanced filtering of search results.
Angular 2 templates syntax:
ReSharper understands the following elements of Angular 2 templates syntax: template expressions, template statements, NgFor directive and template variables. Support is implemented for the template: property in Angular @Component decorator as well as for pure HTML referenced by templateUrl: property in @Component. Only relative paths are supported in templateUrl. For HTML pages, Angular markup is switched off by default and can be enabled in ReSharper Options (Code Editing | HTML | Editor)
Code completion works for Angular attributes and component tags, as well as for [attr., [style. and [class.. Component attributes receive support for the Go to Declaration (F12) command. The Rename refactoring works for component tags and for 'foo' in [class.foo]
Note that Angular 1 is not yet supported. You can use the AngularJS plugin for code completion and live templates, if Support Angular markup in HTML pages is set to 'None' in ReSharper options
TypeScript and JavaScript support:
Full support for TypeScript 2.1: mapped and indexed types, object rest and spread properties, updated logic for literal types, configuration inheritance, untyped imports, combined types normalization, partially annotated signatures, and control flow analysis for implicit any and implicit any arrays
Initial support for TypeScript 2.2: 'object' type, JSX spread syntax and deriving (extends/implements) from signatures/tuples/intersections/mapped types
Inspection and quick-fixes for unused imports in TypeScript ES6-style imports
Postfix Templates in JavaScript and TypeScript
Improved relevance of code completion items in TypeScript and JavaScript
The Generate Code menu gets a new option to generate properties or read-only properties for TypeScript classes. The Generate Overriding Members command now calls 'super' whenever possible
Navigate to Implementing Members in TypeScript
Navigate to Function Exits in TypeScript and JavaScript
The Rename refactoring in TypeScript works faster for local symbols and gets a new option to disable dynamic search for TypeScript
Code analysis:
ReSharper's File Status Indicator (the small icon at the top of the Error Stripe) receives a new context menu. With a right-click on the icon, you can quickly toggle not only ReSharper code analysis but also identifier highlightings and Visual Studio code analysis (lightbulb and squiggles). If there are code issues in the current file, you'll also see commands for navigating between issues of the highest severity level.
Note that for large files ReSharper suspends code analysis automatically. In this case, you'll see a gray Pause icon in the Status Indicator.
ReSharper C++ updates [Ultimate]:
ReSharper C++ 2017.1 finalizes Visual Studio 2017 RTM support and learns to work with the Open Folder mode and CMake projects. Changes also include improved performance, extended set of postfix templates and code cleanup tasks, and updates to control flow inspections.
Command-line profiler [Ultimate]:
dotMemory 2017.1 includes the dotMemory.exe tool that allows you to profile from the command line. The tool is extremely helpful when you need to automate the process of gathering memory snapshots, e.g. if you want to make profiling a part of your continuous integration builds.
Profile running apps with drag and drop [Ultimate]:
You can now attach the profiler to running applications using drag and drop. Simply drop a special icon onto the application window that you want to profile.

New in ReSharper 2016.2.2 (Oct 7, 2016)

ASP.NET Core 1.0 RTM:
ReSharper 2016.2 adds initial support of ASP.NET Core 1.0 RTM. ReSharper should now correctly resolve project references in projects of this type and provide its core set of features, including refactorings, code inspections and navigation.
Tag helper syntax is now also supported in terms of code completion, navigation, search and refactorings.
However, running .NET Core unit tests is not supported so far: this is going to be addressed in the next update.
Structural navigation with Tab:
ReSharper now allows using Tab and Shift+Tab keys to jump between logical pieces of your code, similar to how you navigate in your web browser.
For example, when editing a for statement, Tab will select the initializer statement, then the terminating condition and then the iterator statement. Shift+Tab will make these selections in reverse order.
When the cursor sits before the first non-whitespace character in a line, you can still use Tab for indentation.
Go to Text for textual search:
A new navigation action, Go to Text (Ctrl+T,T,T), lets you quickly find and navigate to any text in source and textual files that are included in your solution. Similar to other navigation commands, if there are too many matching items, you can hit + on the numeric keypad to explore results in the Find Results window.
Advanced ReSharper users may recall an older plugin called Go to Word, and the new navigation action re-implements the functionality of this highly popular plugin right inside the mainline ReSharper.
Warnings in solution-wide analysis:
If you're using solution-wide analysis, you know that normally, its red status bar indicator turns green as soon as the last error in solution is fixed.
Starting from 2016.2, you can make the indicator stay orange as long as your solution contains any unresolved warnings: both actual compiler warnings and ReSharper's inspections with the Warning severity level.
It is still up to you whether to enable the solution-wide analysis and whether to make it show warnings: you can right-click the status bar indicator to configure everything.
More C# typing assistants:
ReSharper 2016.2 introduces a set of new C# typing assistance features that correct subtle mistypes as you enter code.
For example, if you happen to type MethodName(.), this will be automatically replaced with MethodName()., allowing you to keep entering a call chain without having to deal with an invalid syntax error.
Similarly, ReSharper will correct a mistyped @$ prefix to $@ in verbatim string interpolations.
New quick-fixes and context actions:
A ReSharper update without a new set of code inspections, quick-fixes and context actions is next to unthinkable, and ReSharper 2016.2 is no exception.
New Alt+Enter commands help simplify string interpolation inserts, revert the order of iteration in simple for loops, and fix awaiting of a void method by making it return a Task. Along the way, existing quick-fixes that make methods async were also revised to suggest using Task instead of void.
In other news, you can now check all parameters of a method for null (or empty strings) with a single context action. More than that, uncommenting and deleting comments can now also be done with Alt+Enter actions.
ReSharper 2016.2 improves support for the tag in XML documentation comments, which is a good alternative to copying documentation from base types/members to derivatives:
There is now a context action to add an to an inherited type member.
ReSharper can generate missing members and overriding members along with comments if you want it to.
Quick Documentation can now correctly work on members that not only inherit documentation from their base members but refine it with additional or overriding comments.
Safer Optimize References refactoring:
Based on popular demand, ReSharper 2016.2 adds a way to mark references as used at runtime. This is important if you're using dependency injection frameworks.
By marking all references that are implicitly loaded, you can safely run ReSharper's Optimize References and Remove Unused References commands without breaking references that are required at runtime.
Move members between type parts:
A new refactoring, Extract Members to Partial, helps you quickly move type members between different type parts if partial classes are in use in your solution. Based on your input, the refactoring will use existing or create new type parts.
You can even invoke the refactoring over a #region to move all region members into a new file with a name inferred from the region name.
Revised surround templates:
If you need to surround a piece of code with a template, you can now just select the code, and type in the name of a template you need: no extra shortcuts required.
In other news, a single template can now be used for for creating code (as a live template) and for surrounding existing code (as a surround template).
HTML and RegEx injection:
You can now take advantage of HTML code analysis inside string literals in .cs, .js, and .ts files. Just put a comment /*language=html*/ ahead of a string literal that contains HTML, or use the Mark HTML here context action to enjoy syntax highlighting, error detection and other kinds of ReSharper's HTML support right inside the string literal.
Regular expression assistance in string literals can now also be enabled when you put a comment /*language=regexp|jsregexp*/ before a string literal that contains a C# or JavaScript type regular expression.
JSON value helpers and schema catalogs:
JSON value helpers allow you to tell ReSharper to provide code completion or validation for your own JSON files. You can add a helper in the JSON Value Helpers options page, matching based on a filename mask and/or schema match. Custom JSON schema catalogs can also be added in JSON options.
CSS custom properties:
ReSharper's code inspections, quick-fixes, code completion, navigation, search and refactorings are now made available in CSS custom properties (also known as variables).
For example, in terms of code analysis, ReSharper helps you remove unused custom properties, detect undeclared custom properties and replace their usages with fallback values.
In addition, ReSharper 2016.2 introduces a set of fixes for improved CSS spec handling.
TypeScript 2.0 support:
ReSharper 2016.2 completes support of language features available in TypeScript 2.0.0, such as abstract properties, this for functions, control flow-aware type guards, path mappings, optional class members, and the never type.
More JavaScript and TypeScript improvements:
Generating TypeScript code, such as overrides and lambdas, with code completion.
Completion for package versions in bower.json manifest files.
Improved Find Usages and Rename for union and intersection types.
A new quick-fix to implement missing members as abstract.
Go to Declaration and Find Usages work correctly with type aliases.
When renaming JavaScript function parameters, ReSharper learns to update the corresponding JsDoc items.
Assembly dependency diagram:
ReSharper 2016.2 adds the assembly dependency diagram to the family of its dependency analysis tools.
You can invoke the diagram on selected assemblies in the Assembly Explorer and explore connections that are established between the assemblies by virtue of their references.
Process Explorer:
The Process Explorer window, which was previously only available in dotPeek, displays all currently running processes, allows exploring their modules and decompiling those of them that are .NET assemblies.
You can choose to show or hide native processes and modules, or turn on process hierarchy view.
Filter the list to find a module or process that you're looking for, and then add its assemblies to Assembly Explorer for further investigation.
In other news, ReSharper 2016.2:
Makes string interpolation suggestions, quick-fixes and context actions available in VB.NET.
Extends the C# formatter with new options for indenting of parentheses and code inside them; controlling spaces before and after ++ and -- operators, as well as before and inside parenthesis of checked and default expressions.
Helps rearrange code in interpolated string inserts and in expressions with 3 and more operands. "Greedy brace" now works for the opening brace, braces of types and namespace declarations.
Makes IL code displayed in the IL Viewer more readable: types, members, type parameters, and local variables are now highlighted with distinct colors; and loops are better distinguishable with indents and comments.

New in ReSharper 10.0.2 (Mar 18, 2016)

New in ReSharper 9.1.1 (Jun 18, 2015)

New in ReSharper 9.0 (Jun 18, 2015)

Visual Studio 2015 CTP support
C# 6.0 support, including conditional access expression, expression-bodied members, auto-properties with initializer expression, etc.
Support of C++ in the dedicated product ReSharper C++, which is also available as a part of ReSharper Ultimate.
Note that by the time of ReSharper 9.0 release, C++ support stays available in a separate EAP.
Regular expressions assistance including syntax and error highlighting, completion features, quick-fixes and more.
Type dependency diagram - a new visual code analysis tool that complements the existing project dependency diagram.
Major improvements in TypeScript support, including, but not limited to:
Configurable TypeScript language level up to 1.3.
New code inspections including inspections for about 300 compiler errors and inspections dependent on project properties + about 100 new quick-fixes. For more information, see Code Analysis in TypeScript.
Import missing namespace pop-up.
Code generation actions (Generate missing/overriding members, Generate constructor).
Performance improvements and new features in code completion. You can now apply filters to completion suggestions, complete call chains based on existing patterns in your solution, and more.
Code style assistance improvements: a number of new code style preferences that have common configurations for both code inspection and code cleanup. For more information, see Code Style Assistance.
Entering license information using the JetBrains Account.
Ability to suppress some or all code inspections in specific type or method using the SuppressMessage attribute.
The Fix in Scope feature is supported for more quick-fixes. Now the global fixes work for naming rules, code redundancies, and more.
Similarly to 'Fix in scope', some context actions can be now also applied in a wider scope.
The Navigate to Action feature that allows you to find and execute any ReSharper command with a couple of keystrokes.
The Navigate to Exposing APIs action that allows finding all methods returning a specific type.
Recently viewed methods and performance improvements in Go to Everything.
A new visual editor greatly simplifies understanding and editing of file and type layout patterns.
Support of custom HTML harness for JavaScript unit tests.
Search through preferences in the Options dialog.
Ability to toggle support of languages and feature sets on the Environment | Products & Feature options page.
Ability to view and configure code formatting rules that are applied for selected code block (supported in JavaScript, TypeScript, and C++).

New in ReSharper 8.2.0.2160 (Mar 21, 2014)

New in ReSharper 8.1.23.546 (Jan 10, 2014)

New in ReSharper 8.0.10.1252 Beta (Jun 29, 2013)

New in ReSharper 7.1.3 Build 3000.2254 (Apr 13, 2013)

New in ReSharper 7.1.2 Build 2000.1478 (Feb 21, 2013)

New in ReSharper 7.1.1 Build 1000.900 (Dec 18, 2012)

New in ReSharper 7.1 Build 25.234 (Nov 14, 2012)

New in ReSharper 7.0.1 Build 1098.2760 (Aug 29, 2012)

New in ReSharper 7.0 Build 97.60 (Jul 26, 2012)

New in ReSharper 6.0 Build 2202.688 (Dec 20, 2011)

New in ReSharper 5.0 (Dec 20, 2011)

New in ReSharper 4.5 (Dec 20, 2011)

New in ReSharper 4.1 (Dec 20, 2011)

New in ReSharper 4.0 (Dec 20, 2011)

Comprehensive support for Visual Studio 2008 and C# 3.0, including LINQ, implicitly typed locals and arrays, extension methods, automatic properties, lambda expressions, object & collection initializers, anonymous types, expression trees, and partial methods.
Errors, warnings and suggestions are complemented by hints, which are by far the most non-intrusive way to recommend coding improvements.
.NET Framework classes were annotated with custom attributes to make ReSharper analyze your code even better than before - for instance, to let it know where format strings should be passed or where null values can or can not be assigned. You can also use these custom attributes to annotate your own source code, as well as library symbols that you don't have source code for.
Code Cleanup - a powerful successor to Reformat Code. By simply running Code Cleanup, you can instantly apply a dozen of actions, including arranging 'this' qualifiers, removing code redundancies, migrating to auto-properties, optimizing using directives, and many more.
All ReSharper refactorings now support C# 3.0. New members of the refactoring family are available, including Convert Method to Indexer, Convert Indexer to Method, Convert Static to Extension Method, Convert Extension Method to Plain Static, Convert Property to Auto Property, Convert Anonymous to Named Type, and Inline Method. All refactorings that are not C# 3.0-specific are now available for Visual Basic 8.
Complete Statement - a new feature that inserts necessary syntax elements (braces, semicolons etc.) and gets you to the position to start the next statement.
CamelHumps in Code Completion. All three completion features - Symbol Completion, Smart Completion, and Import Symbol Completion - let you complete any symbol by entering only its uppercase characters.
Templates Explorer and Template Editor - a redesigned set of tools to view, manage, and edit the three types of templates that ReSharper provides. From now on, you can manage and classify your templates in a special-purpose window, and edit them right in a Visual Studio code pane.
Recent Edits - a drop-down list similar to existing Go To features that shows files and symbols that you recently modified.
Go to Type / Symbol / File features allow you to display destination types/symbols/files in the Find Results window.
To-do items are now discoverable in identifiers and strings.
File Structure, Go to File Member, and Go to Next/Previous Member all support XML and XAML.
Vast improvements in Quick Documentation, including hyperlinks to related items, back/forward navigation, "read more" links and navigating to source.
Smoother interaction with Visual Studio ecosystem. The quality of interaction with frameworks, add-ins, version control clients and other members of the Visual Studio ecosystem (.NET Compact Framework, BizTalk, and Silverlight included) is brought to a new level.
ASP.NET Speedup. ReSharper 4.0 significantly speeds up analysis and, consequently, editing of ASP.NET pages, to enable more web developers benefit from the great toolset that ReSharper provides.

New in ReSharper 3.1 (Dec 20, 2011)

New in ReSharper 3.0 (Dec 20, 2011)