ReSharper Ultimate 2016.2 EAP kicks off

Welcome to ReSharper Ultimate 2016.2 Early Access Program!

Here’s a quick summary of what is available in the initial EAP build:

  • Initial support of ASP.NET Core 1.0 RC2, including support for tag helpers in terms of code completion, navigation, search and refactorings. At this point, ASP.NET Core web applications are supported if they’re targeting .NET Framework but are not supported if they’re targeting .NET Core. We’re looking to improve this in subsequent builds.
  • Assorted TypeScript support improvements such as generative code completion; improved Find Usages and Rename for union and intersection types; more TypeScript 2.0 features (this types for functions, control flow-aware type guards, path mappings, optional class members, the never type); important bug fixes for Angular and Sugar users.
  • Multiple bug fixes and better spec handling in CSS support, which is expected to improve code validation and completion.
  • A new refactoring to move members to another part of a class. You can even use the refactoring over a region to move all region members into a new file with a name inferred from the region name.
    Make partial class refactoring
  • New quick-fixes and context actions, helping simplify string interpolation inserts, revert the order of iteration in simple for loops, or fix awaiting of a void method by making it return Task. In addition, existing quick-fixes that make methods async now suggest to use Task instead of void.
  • Optimize References and Remove Unused References now allow marking references as used at runtime, which finally makes both features useful in solutions that are using IoC.
  • New subtle C# typing assistance features, such as auto-replacing MethodName(.) with MethodName(). as you type:

  • A revised indenting engine in the C# formatter, particularly new options for indenting parenthesis.
  • Rearrange code improvements. For example, it is now available in interpolated string inserts, and in expressions with 3 and more operands.

Changes are currently limited to the mainline ReSharper. Other tools such as dotTrace and ReSharper C++ will be merging their changes as the EAP goes forward.

Download ReSharper Ultimate 2016.2 EAP!

Posted in News and Events | Tagged , , | 4 Comments

Open sourcing ReSharper’s external annotations

We recently open sourced the external annotations that ReSharper uses to improve analysis and provide extra features over third party code, and we’ve also opened up to contributions from the community. You can now add other assemblies, fix issues with the existing annotations, or simply make use of the information in the files.

But wait, what are external annotations?

ReSharper can use attributes defined in the JetBrains.Annotations nuget package to improve its own analyses and inspections – this blog post has more details. They can give ReSharper extra context to allow for more accurate inspections.

For example, if a parameter or return value can never return null, ReSharper can tell you that your null checks are irrelevant, and provide quick-fixes to remove them. Or perhaps you have a custom attribute that indicates that the method it’s applied to is only called by reflection – ReSharper will normally mark the method as unused, unless the custom attribute is itself marked with the [MeansImplicitUse], in which case ReSharper will mark it as in use.

ReSharper marking null analysis as redundant

Annotations are not just limited to improving inspections. For example, the [StringFormatMethod] attribute marks a method as having semantics similar to string.Format. When ReSharper sees this, it will treat the specified argument as a format pattern, and ensure that the right number of parameters are specified in the rest of the method call, and highlight the appropriate argument when the text caret is on the corresponding {0} format specifier.

Similarly, the [RegexPattern] attribute will mark a parameter as being a regular expression, and any string literal passed in will be syntax highlighted, have auto completion and Alt+Enter quick-fixes to test the regex.

String highlighted as regular expression

There are many more annotation attributes, and you can find out more details in the ReSharper web help, along with a reference for the available attributes.

These attributes are great for adding to your own source code (and they don’t even add any binary references!) – but what about pre-compiled assemblies? How to add these attributes when the code is already compiled? Well, that’s exactly what external annotations do.

An external annotations file is an XML file that ReSharper reads to effectively “add” attributes to existing compiled code. Each file describes types and type members in an assembly, and provides the fully qualified name for attributes to apply, as well as arguments for the attribute constructor (remember, when compiled, attribute constructor arguments are simply constants, serialised into the assembly).

When ReSharper reads the annotations file, it merges these “fake” attributes from the XML file with the real attributes from the assembly itself. As far as ReSharper is concerned, it’s as though the assembly was compiled with these attributes all along! This allows us to add [NotNull] and [CanBeNull] or [RegexPattern] attributes to a compiled assembly, and improve ReSharper’s analysis and feature set for existing code.

The external annotations that ship with ReSharper cover the entire BCL of the .NET framework, and more. We have performed null analysis on the whole BCL, and the results are applied to assemblies, types and type members. On top of that, we have added extra annotations for extra functionality – string format methods, regular expressions, ASP.NET Views, Actions and Controllers, and so on.

For the most part, the annotations are for BCL and related Microsoft assemblies, such as ASP.NET MVC, but certain third party assemblies are also annotated. Primarily, these are commonly used assemblies that benefit from a piece of functionality that the annotations can add. For example, various community MVVM frameworks are annotated with the [NotifyPropertyChangedInvocator] attribute to provide improved INotifyPropertyChanged support. Similarly, NUnit and are marked to contain assert methods, which ReSharper can use to help control flow analysis (e.g. if an assert is always going to cause an exception, we can mark the rest of the method as dead code).

And now, these annotations are open source. They’re available on GitHub, with an MIT license. We use this repo to build the annotations that ship with each version of ReSharper, and we’re opening it up to contributions from the community (we’ve already accepted a pull request to add support for FakeItEasy). If you see a mistake with ReSharper’s null analysis, or missing string.Format highlighting, raise an issue, or file a pull request. If you’d like to add a new third party assembly, fork the repo and add it!

And the best bit? Since version 10, ReSharper will automatically keep the annotations up to date. ReSharper 9 shipped them as a bundled plugin, and will prompt you to update them. This allows us to update some functionality without waiting for a full ReSharper release (as an example, an ASP.NET MVC update caused ReSharper’s navigation between views and controllers to stop working. The fix was to update the annotations to support the new version of the assembly).

But what this means now is that if a fix or new assembly is contributed, we can push the new version of the annotations to ReSharper 9, 10 and 2016.1.

Previously, external annotations could be shipped either side-by-side with an assembly (as a file called MyAssembly.ExternalAnnotations.xml) or as part of an extension. This still works, and if you have an existing ReSharper extension that adds features via a plugin .dll, it’s still a good idea to ship the annotations with the extension. But if the extension is just annotations, then it can be added to the standard annotations package, and we can make sure that all ReSharper users get it.

Check out this web help page for more details on how external annotations work, and what the file format looks like. This page lists all the annotations that are available. And finally, here’s the GitHub repo.

Posted in How-To's, ReSharper Tips&Tricks | Tagged , , | 1 Comment

dotMemory Unit update: version 2.3

Following a recent ReSharper Ultimate bug fix release, we are now releasing an update to dotMemory Unit, the .NET unit testing framework to check your code for memory issues.

As a reminder, dotMemory Unit lets you extend NUnit, MSTest, or another .NET unit testing framework with the functionality of a memory profiler. It’s integrated with Visual Studio, works with standalone unit test runners, can be used in Continuous Integration, and is free of charge.

Highlights of dotMemory Unit 2.3

Most changes in dotMemory Unit 2.3 relate to how dotMemory Unit works with unit testing frameworks that are not supported out-of-the-box. For example, new arguments are now supported in DotMemoryUnitController‘s methods:

  • The TestStart() method now accepts an instance of the MethodBase type: TestStart(MethodBase testMethod). You can use it to remove ambiguity and clearly specify a certain method as a test. For an example of using this method, see Working with unsupported unit testing frameworks.
  • The TestFailed method now accepts a bool parameter: TestFailed(bool onMemoryAssert). Use it to indicate whether a test failed on “memory” assertion or due to a different reason.

In addition, dotMemory Unit 2.3 improves how you check memory traffic in tests. You can now place any number of AssertTraffic attributes before the test and filter traffic by any set of conditions. For example, to ensure traffic doesn’t exceed 1000 bytes and there are no objects of the Foo type, simply add two attributes before the test:

For the detailed list of improvements in this dotMemory Unit update, please see dotMemory Unit 2.3 Release Notes.

Start using dotMemory Unit

You can download dotMemory Unit and start playing with it right away, or you can read the blog post that explains the basics, then take a look at some usage examples, or refer to online help for more detail.

Posted in How-To's | Tagged , | 2 Comments

ReSharper Ultimate 2016.1.2 is here

We have just released a fresh bug fix update to our tools and welcome you to download ReSharper Ultimate 2016.1.2.

Major highlights

dotCover, dotTrace, dotMemory and dotPeek 2016.1.2 are updated solely for compatibility reasons and don’t include significant changes.

In case you were affected by the issues mentioned above, we recommend that you download and install ReSharper Ultimate 2016.1.2.

Posted in How-To's | Tagged , , , , , , , | 10 Comments

ReSharper Ultimate 2016.1.1 is released

You can now download ReSharper Ultimate 2016.1.1, which includes a set of bug fixes and improvements to ReSharper and ReSharper C++.

Highlights of this update

Note that dotCover, dotTrace, dotMemory and dotPeek 2016.1.1 are basically all compatibility updates that have not received any considerable changes by themselves.

If you are interested in the improvements described above, please download and install ReSharper Ultimate 2016.1.1.

Posted in How-To's | Tagged , , , , , , , | 33 Comments

JavaScript support improvements in recent ReSharper releases

There are quite a few things in ReSharper 2016.1 designed to advance your JavaScript experience.

This update improves support for JSX, enhances regular expression features, supports more complex type annotations and constructs in JsDoc, provides full-featured JSON and JSON schema support, and supports a lot of experimental ECMAScript features.

Also worth noting is official support for NodeJS, meaning that all your NPM package dependencies and node modules are now handled nicely.

Advanced JSX experience

JSX is a very popular ECMAScript extension that allows you to use XML-like syntax for JavaScript expressions. JSX is primarily used with the ReactJS framework, though not necessarily limited to it.

Earlier in ReSharper 10 we introduced initial support for JSX by providing all the features you usually expect from HTML in JSX tags.

JSX support in ReSharper

Because JSX markup can embed JavaScript code, expect to have usual assistance for JavaScript inside JSX, too.

JavaScript inside JSX

Starting with ReSharper 2016.1, if you use plain JS files in Visual Studio or use Visual Studio versions earlier than 2015, ReSharper now provides its own syntax highlighting for JSX constructs, so that you won’t even notice that your Visual Studio version is not the most bleeding-edge one. (You will however need to disable Visual Studio’s own syntax errors to have the best possible experience in this case.)

Improved support for JS regular expressions

Earlier in ReSharper 10, we extended our support for regular expressions in JavaScript by automatically injecting them into RegExp constructor and regex-related String methods (search and match). You can complete regex flags in RegExp constructor as well.

JavaScript regular expressions

Also, you can enjoy having a context action for injecting regular expression facilities into any JavaScript string.

Injecting regular expressions into JavaScript strings

Enhanced JSDoc support

JSDoc is supported for documentation purposes since ReSharper 9.1.

ReSharper 10 offered extended JSDoc support by using types specified in JSDoc for improving our existing features, such as code completion. Most of the types defined by JSDoc 3 were supported, including primitive types, union types, signatures, record types, type definitions, and callback definitions.

ReSharper support for types defined in JSDoc 3

ReSharper 2016.1 goes further as it supports templates (generics) and type inference for them, improves rendering for JSDoc that uses HTML tags, and supports structured parameter and property syntax.

ReSharper supports JSDoc generics

Also note that now all the JSDoc keywords are supplied with a short description of their meaning.

JSDoc tooltips

JSON and JSON schemas

Starting with ReSharper 2016.1, JSON is an officially supported language. That means that you get the usual ReSharper features in JSON files like typing assistance, formatting, rearrange code, and code analysis with quick-fixes.

ReSharper quick-fix in JSON

If your JSON file is supplied with a JSON schema, then you’ll be provided with code completion based on schema, and your JSON will be validated against the schema, providing fixes for validation issues.

JSON schema-aware code completion

Invalid JSON and a quick-fix

For several known JSON schemas, you get enhanced features such as regular expressions support, JSON Path references, file and folder references and completion for them, and code completion for packages (NPM, Bower and NuGet).

Code completion for known JSON schemas

As a special bonus, completion for open source license names in SPDX format is provided for NPM and DNX package descriptions.

Completion for Open Source license names

Note that all provided features are available for all supported Visual Studio versions.

ECMAScript Experimental

ReSharper 2016.1 provides initial support for most of the currently known ECMAScript experimental constructs (some of which are going to become part of the ECMAScript 2016 specification while others are still in proposal).

Now you can easily code with ReSharper while using transpilers such as Babel or when using ReactJS with ES2016 elements. Support is provided for: async functions and await, comprehensions, exponentiation operator, rest in object destructuring and spread in object literals, bind operator, class properties, decorators, new export statements, and call-constructors.

Experimental ECMAScript support in ReSharper

Node.JS support

ReSharper 2016.1 now fully supports working with Node.JS modules and NPM packages. This results in enhanced code assistance, in particular, better code completion and inspections when you use Node.JS modules.

Get ReSharper Ultimate 2016.1

We hope you enjoy these features when working with JavaScript. Do let us know about your experience with that by leaving a comment below.

Posted in How-To's | Tagged , , , | 8 Comments

JetBrains joins the .NET Foundation

Recently at BUILD, Microsoft announced that JetBrains has joined the .NET Foundation, which you can read more about on the .NET Foundation Blog. What we’d like to comment on in this post is the reason behind this decision.

Why join?

It’s no surprise that we have invested a lot in .NET as a platform, and thanks to a wide recognition by our customers, ReSharper and the ReSharper Ultimate suite have enjoyed tremendous success for over a decade.

With the recent announcement of JetBrains Project Rider, our cross-platform .NET IDE, we have increased our commitment to the the platform and are striving to provide a truly cross-platform experience for .NET developers that brings the functionality of ReSharper to all, whether working on Windows inside Visual Studio, outside of Visual Studio, on Linux or on OSX.

Given this investment, for us, the future of .NET as a platform is important and our participation in the Technical Steering Group is to this effect. In essence, we’ll have a voice (technically with three seats we have three voices!) in decisions that impact key projects of the .NET Foundation such as the CoreCLR, Mono, C#, ASP.NET et al.

Our commitment to ourselves and our customers is that we will strive for the best interests of .NET, which are to be a truly open, versatile and cross-platform ecosystem.

Posted in How-To's | 15 Comments

ReSharper Ultimate 2016.1 is released

We’ve just finalized an update to ReSharper Ultimate and welcome you to download Resharper Ultimate 2016.1 RTM!

Watch the following video for a summary of what is new in ReSharper Ultimate 2016.1, or read on for the main highlights of this release:


Along with 950+ fixes, major highlights of ReSharper 2016.1 are the following:

  • A variety of new context actions: ReSharper 2016.1 brings a set of new Alt+Enter actions to check method input parameters, manipulate strings, convert strings to objects, comment and uncomment code selections, and many more!
  • A new Invert Boolean Member refactoring. The refactoring can be invoked on a method, property, local variable or a parameter to invert the boolean value it returns and update other members that receive values from it.
    Invert Boolean Member refactoring
  • Smart Paste feature that ensures the right escaping in string literals that you copy/paste around your code. It works in C#, VB.NET, JavaScript, XML, XAML and HTML files. Smart Paste
    Two new context actions, “Convert XML string to a LINQ to XML object” and “Convert JSON string to a Newtonsoft JSON.NET object”, complete the workflow of transferring existing XML or JSON into C# code.
  • Asynchronous Find Code Issues. Starting with version 2016.1, Find Code Issues works in the background both in ReSharper and ReSharper C++. This lets you keep editing or navigating your code while ReSharper runs its analysis.
  • New WCF-specific code inspections, quick-fixes and context actions.
  • Initial support for Node.js. All ReSharper goodies you are well familiar with, like completion, code inspections, quick-fixes, and navigation features are now available for Node.js.
    Node.js support
  • ReSharper 2016.1 is way better at understanding VB.NET 14, introducing support for string interpolation, multi-line strings, null-conditional operators, partial modules and interfaces, year-first date literals and XML documentation comments.
  • Out-of-the-box support. ReSharper 2016.1 provides built-in support for and doesn’t require a separate extension to be installed anymore. This means ReSharper will discover your tests and allow you to run and debug them right from the editor.
  • Support for JSON files and schemas includes the File Structure view, a “Convert JSON string to a Newtonsoft JSON.NET object” context action, JSON schema-aware code completion, inspections and quick-fixes.
    JSON file structure
  • JavaScript and TypeScript support enhancements include a reworked Rename refactoring (which can now rename files corresponding to TypeScript types), granular formatter settings, and full support for TypeScript 1.8. In addition, ReSharper starts to properly handle some bits of TypeScript 2.0: readonly properties, implicit indexers, private and protected constructors, abstract properties, and nullable types. Please expect a separate blog post describing TypeScript and JavaScript support in ReSharper 2016.1 shortly.
  • JSDoc improvements. ReSharper can now parse generics, HTML markup, and parameters with properties in your JSDoc comments. Everything that ReSharper infers from JSDoc becomes immediately available in code completion suggestions.
  • Code style features keep improving. Code styles can now be applied with a single command, ReSharper | Edit | Apply Code Style (Ctrl+Alt+S). Reformat Code, Apply Code Style and Run Code Cleanup commands are now accessible from Alt+Enter menu when you make a selection in the editor. In addition, a dedicated action for reformatting code is back, and it can be invoked from the main menu (ReSharper | Edit | Reformat Code) to reformat code depending on the context. Another improvement covers the use of braces, which ReSharper now helps you make consistent across your code base. Preferences for each kind of code block can be configured separately in a code style options page, and ReSharper makes sure to respect these preferences:
    Quick-fix to add missing braces
  • Intermediate Language viewer is now built into ReSharper. The IL Viewer, which first appeared in dotPeek 10, is now available for drilling down library code right in Visual Studio. To check how it works, navigate to any library symbol (which can be as easy as Ctrl-clicking it), and then choose ReSharper | Windows | IL Viewer in the menu.
  • Optimize References learns to handle NuGet references, and Remove Unused References starts to support NuGet references as well.
    Analyze NuGet references

ReSharper C++

ReSharper C++ 2016.1 comes with 270+ fixes and a set of larger improvements:

  • To-do Explorer: ReSharper C++ 2016.1 introduces the long-awaited navigation view, which lets you view, group and filter comments that contain one of the 3 default to-do patterns (Bug, Todo and Not Implemented) and any custom patterns that you might want to set up.
    To-do explorer in ReSharper C++ 2016.1
  • New context actions and quick-fixes. ReSharper C++ 2016.1 comes with quick-fixes to change variable type, function return type, type of unmatched out of class definition or declaration. Another new quick-fix lets you create a field from constructor parameter.
    Quick-fix to create field from constructor parameter
    We also added a set of new context actions and quick-fixes for working with #include directives; quick-fixes to change type of unmatched out-of-class function definition; to make a data member mutable or a member function non-const; to make a base class or a function non-final; to move all function definitions inside a selection.
  • The list of supported C++ language features is extended with generalized lambda captures, exception specifications, user defined literals and delegating constructors.
  • ReSharper C++ 2016.1 enhances Rename refactoring, which can now automatically rename corresponding files (both source and header) along with code symbols, and to update usages in include directives.
  • ReSharper C++ 2016.1 adds support for the Boost.Test framework to its Unit Test Runner. Please note that only Boost version 1.60 is supported.
    Boost.Test support in ReSharper C++
  • Code generation improvements. The Generate stream operations action available via Alt+Ins can now generate stubs for Boost.Serialization functions: save(), load() and serialize(). In addition, formatting options are now taken into account when generating code.
  • All ReSharper C++ actions are now banned from changing library headers.

Other tools within the ReSharper Ultimate family have received their shares of improvement as well.


  • Test execution in Continuous Testing for MSTest and xUnit test becomes faster with dotCover 2016.1 thanks to pre-loading test runners.
  • Coverage filters are now supported in Continuous Testing.
  • Quick search results are now highlighted in the coverage tree.
  • We added a button to explore the stack trace of the selected test in Stack Trace Explorer:
    Improved Continuous Testing tool window
  • Another improvement applies to the relationship between dotCover console runner and TeamCity. TeamCity is now tuned to understand the output of the console runner and can highlight its errors and warnings in the build log.


  • dotTrace 2016.1 adds its Threads diagram into Visual Studio. Now, the integrated Timeline Viewer gets exactly the same diagram, which you can use to select threads, time range, and of course, view thread activity and filtered time intervals.
  • Moreover, the Threads diagram in both standalone and Visual Studio viewers gets smart tooltips. Hold the mouse over a specific time point on the timeline and a tooltip containing current thread state, executed method, and other info will appear. Tooltips are context-sensitive. This means that if some filter is applied, the tooltip will contain additional data on the filtered event. For example, when the File I/O filter is selected, the tooltip additionally shows info about file operation, file name, and data size.
    Threads diagram in Visual Studio with smart tooltips


dotMemory 2016.1 adds browser-style Back and Forward buttons to navigate across different views in profiling results.
Back and Forward navigation in dotMemory

dotMemory Unit

dotMemory Unit 2.2 gets a number of improvements:

  • Object selection queries now support open generic types, which is useful if you want to get all substitutions of your generic type.
  • The GetNewObjects, GetSurvivedObjects, and GetDeadObjects methods get overloads that accept query as a parameter. This allows to avoid one more GetObjects call and simplify assertions.
  • You can select objects by wildcards using the Like and NotLike queries on types, interfaces, and namespaces.
  • You can use three constants when specifying a directory for saving workspaces in the DotMemoryUnit attribute. The constants are written in angle brackets: <User>, <LocalAppData>, <CommonAppData> and stand for, correspondingly, %USERPROFILE%, %APPDATA%, and %LOCALAPPDATA% directories.
  • Improved performance of key queries: Type.Is, Interface.Is and Namespace.Like.
  • Tests that execute queries from child processes are now handled correctly.

Improvements in dotMemory Unit 2.2


  • dotPeek 2016.1 learns to handle extension methods as instance methods and automatically highlights usages of the symbol under the caret.
  • With dotPeek 2016.1 you can load NuGet packages and their dependencies from any online package source, or load packages listed in a packages.config file in your Visual Studio project.


If you have an active license to ReSharper, ReSharper C++ or ReSharper Ultimate, we encourage you to start using 2016.1 straight away.

As we have just recently switched to subscription licensing, some of you may still use older, pre-subscription licenses. If you are not sure whether your licenses are eligible to use with 2016.1, or if you need a formal quote or any other assistance, please get in touch with JetBrains sales anytime.

Get ReSharper Ultimate 2016.1

Posted in News and Events | Tagged , , , , , , , | 43 Comments

ReSharper Ultimate 2016.1: What’s new in recent EAP builds

The release of ReSharper Ultimate 2016.1 is just around the corner, and today we sum up what has changed in its recent pre-release builds (EAP 7 to EAP 10).

We have fixed hundreds of bugs and exceptions, and added some new features. Some of these features are described below.

The feature set as of EAP 10 is likely to be final for the upcoming release. If you’re curious, you’re welcome to download the current EAP build and check out what ReSharper Ultimate 2016.1 will look like.

VB.NET 14 support

Some parts of VB.NET 14 support were implemented in ReSharper 10.0.2:

  • NameOf Operator
  • Read-only Auto Properties
  • TypeOf [expression] IsNot [type] operator
  • Null-conditional operators (only parser)

And now, just in time for the release of 2016.1, we are happy to announce that the following previously missing parts are now supported as well:

  • String Interpolation
  • Multi-Line String
  • Null-conditional operators (semantics)
  • Partial Modules and Interfaces
  • Year-first Date literals
  • XML documentation comment improvements

Intermediate Language viewer in ReSharper

The IL Viewer, which first appeared in dotPeek 10, is now available for drilling down library code right in Visual Studio. To check how it works, navigate to any library symbol (which can be as easy as Ctrl-clicking it), and then choose ReSharper | Windows | IL Viewer in the menu.

Intermediate Language viewer in ReSharper

Find Code Issues goes async

Previously, when you used ReSharper’s Find Code Issues command in any given scope, you had to stop and wait until the code analysis was over.

Starting with 2016.1, Find Code Issues works in the background, in a manner similar to Find Usages. This lets you keep editing or navigating your code while ReSharper runs its analysis and populates the Inspection Results tool window in the background.

Find Code Issues runs in the background

Easier ways to apply your code style preferences

The growing set of configurable code styles can now be applied with a single command: ReSharper | Edit | Apply Code Style (Ctrl+Alt+S).

This command (which only works in C# for now) will enforce your preferences for explicit types vs ‘var’s, CLR type names vs type keywords, and other styles configurable under ReSharper | Options | Code Editing | C# | Code Style.

If you feel your code is messy, you can use commands in the ReSharper | Edit menu to clean it up to a level you’re comfortable with. Specifically:

  • Reformat Code will prettify your code by only adding or removing spaces, tabs, and new lines;
  • Apply Code Style will change identifiers according to your code style, without changing application logic;
  • Finally, Cleanup Code will do both, and additionally it will rearrange type members and remove redundant code.

All these commands are also available when you make a selection in the editor and press Alt+Enter:

Code style commands for a code selection

Further improvements in TypeScript support

Good news for those trying to keep pace with the evolving TypeScript spec. The latest 2016.1 EAP build of ReSharper can properly handle some bits of TypeScript 2.0: readonly properties, implicit indexers, private and protected constructors, abstract properties, and nullable types.

Download ReSharper Ultimate 2016.1 EAP

If you feel that the highlights above are enticing enough, please download the latest ReSharper Ultimate 2016.1 EAP build.

If you spot any problems with this build, please do report them to issue trackers of affected products: ReSharper, ReSharper C++, dotTrace, dotCover, dotMemory, dotPeek.

Posted in News and Events | Tagged , , , , , | 22 Comments

Rider Session Recordings from Munich

On March 25th we held an evening event at our office focused on Rider in cooperation with .NET Developers Group Munich. We experienced technical issues with one recording, however the good news is that we were able to capture and now share with you two sessions. Watch the recordings in their entirety below.

Connecting Two Worlds
Rider combines two technologies that work on two different platforms: .NET and JVM. How can we make these two different worlds talk to each other efficiently? Good inter-process communication is difficult and we knew this when we set out on this venture. But we also knew that combining the best of the IntelliJ Platform and ReSharper, could give us a lot of potential.

In this talk we dive deep into the architecture of Rider and see how it works under the covers. We look at the application model, threading, data serialization, safe asynchronous execution, data consistency and other things that we had to deal with. See how following a few simple principles, namely keeping things dry, having less and keeping it async helps us with the challenges we face.

Teaser: Next Level Testing
Finally you’ve got your ultimate IDE; how about some awesome testing too? TestFx allows developers to invent new test frameworks in C# more rapidly, without worrying about a solid foundation for a pleasant testing experience, like ReSharper integration, TeamCity support or a console runner. Built on top of TestFx, SpecK is a proof of concept that enables you to write reliable BDD-styled tests using an extensible fluent interface and a well-designed base class that eliminates vast amounts of boiler-plate code.

We experienced issues with the recording of our session with Hadi Hariri, Getting Started with Rider. We suggest to have a look at Project Rider Survival Guide and Video Tutorials.

Posted in How-To's | Tagged , , , | 2 Comments