Announcing ReSharper Upgrade Survey Prize Winners

In November, we conducted a survey for our ReSharper users. We wanted to learn more about your upgrade patterns and your motivations for upgrading to ReSharper 8 or skipping this major release. We appreciate the time that many of you took to complete our survey and having shared your opinions with us.

As promised we are now ready to announce the lucky winners of some great prizes! Our 30 winners were chosen at random from the complete list of participants who completed the survey and choose in advance the prize category they were interested in.

Without further delay here are the winners:

10 Winners of the $50 Amazon.com Certificates:

  • Soulman, Radek, Brad, Casey, Brian Maula, Steve, Rhys Corke, Mason Ryles, Tim, Brad

10 Winners of Free ReSharper Personal License Upgrades:

  • James Carroll, Athu, Soenke, Thiago Bessa, Mujtahid, ANUJ, Benjamin, Andy, Tommy, Mads

10 Winners of a Free ReSharper Personal License:

  • Adam, Denny, Del, MRink, Jennifer, Hilmarv, orzech, Michael, Jason, Bergsten

If your name is on the list, please check your inbox your prize should already be there.

Thanks again for taking part in our survey and helping us to better serve you.

Posted in News and Events, Other | Tagged , , , | 9 Comments

dotMemory 4.0 EAP: .NET Memory Profiler Resuscitation

Do you know that JetBrains provides a .NET memory profiler? You have a good excuse for not knowing this, as the profiler hasn’t seen a single update since 2010.

That is, until today.

Today we’re excited (and by this we mean really excited) to announce the availability of dotMemory 4.0 EAP, providing a brand new .NET memory profiling experience. Download early builds of dotMemory 4.0 and try ‘em out!

dotMemory? Why not dotTrace Memory?

There’s a product currently available that is called dotTrace Memory 3.5, and also a performance profiler called dotTrace Performance, with the names being artifacts of splitting a formerly integrated profiler into separate memory and performance profilers several years ago.

The two profilers have since diverged. In addition, the word “dotTrace” is very loosely related to memory profiling. So we felt it was appropriate to rename the profilers. The new version of the memory profiler is going to be called dotMemory (as opposed to dotTrace Memory), while further versions of the performance profiler will be referred to as simply dotTrace (as opposed to dotTrace Performance). Until dotMemory 4.0 is released to market, both names (“dotMemory” and “dotTrace Memory”) can be used interchangeably.

Enough talking, what’s inside the profiler?

Inspired by many popular television series, we wanted dotMemory 4.0 to feel like a tool that can help with .NET memory crime scene investigations. It lets us collect data (using one or more snapshots), choose a number of suspects (that are potentially causing the issue) and follow clues until we find who’s guilty.

After deciding on being the good cop or the bad cop, we can use dotMemory to provide answers to questions like:

  • Why is a specific object still in memory? What causes the memory leak?
  • What is taking so much memory?
  • How does garbage collection affect the performance of my application (e.g. high memory traffic)?

Let’s have a quick look at dotMemory 4.0 EAP. Do note it’s still EAP so things may change!

Starting memory profiling

After starting dotMemory, we can choose to profile a wide variety of .NET applications. There is support for standalone .NET applications, Windows Store applications, Silverlight, web applications and much more. Note that a profiling session can also be started from within Visual Studio on the project(s) that are currently open.

Exploring memory usage

After taking one or several snapshots of the application, we get to see a number of things. We can see memory usage on the different memory heaps available in .NET.

We can see the various snapshots taken during execution, and drill down into one of them or compare different snapshots. Once we open a snapshot we get a visual representation of our application’s memory usage; then we can dive into our code based on the amount of memory a given type used, based on memory fragmentation or based on dominators, objects that keep other objects in memory. We also get some common leaks shown, such as event handlers that are not being cleaned in our code.

dotMemory lets us explore further and look at objects that are being held in memory and view their dominators, instances, heap generation information and so on. With every investigative step, the left-hand navigation bar shows us exactly what we were looking at before and allows us to navigate back and forth between steps.

Give it a try!

Download dotMemory 4.0 EAP builds and don’t forget to let us know about any issues you might experience via the dotMemory issue tracker or through the comments below.

By the way, we already have some documentation available for you, including an overview of .NET memory management:

Posted in dotTrace Tips&Tricks, News and Events | Tagged , , , | 20 Comments

Beta Updates to ReSharper 8 and .NET Tools

We’ve been publishing ReSharper 8.1 and dotCover 2.6 EAP builds for a while, and although dotTrace Performance hasn’t revealed any early builds recently, it has also been updated to match the state of its peer products. Now, in an effort to simultaneously update all major .NET developer tools and make them work seamlessly with each other, we’re presenting 3 Beta releases at the same time:

  • Download ReSharper 8.1 Beta with support for TypeScript development; integration into Visual Studio 2013 RTM including its two leading features, Peek Definition and Enhanced Scroll Bar; improvements to Project Dependency View, Find Usages and Inspection Results; plus enhanced JavaScript and XAML support; as well as new code inspections. Beta updates to ReSharper SDK and ReSharper Command Line Tools are available as well.
  • Download dotCover 2.6 Beta which integrates with ReSharper 8.1 Beta, works in Visual Studio 2013 and features an Extension Manager previously introduced in ReSharper 8.0.
  • Download dotTrace Performance 5.5.3 which enables profiling unit tests with ReSharper 8.1 Beta.

We’re looking to provide RTM builds of all of these tools in a week or two from now. If you experience any critical issues while using the Betas, please let us know here in comments or post bug reports to issue trackers for ReSharper, dotTrace and dotCover.

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

Find Us at NDC London, December 2nd – 6th

NDC has been running in Oslo annually since 2008 and is making its debut in London on December 2nd – 6th, 2013. While the early years of the conference were focused on .NET and agile, the conference has expanded to include topics such as mobile, web, architecture and open source, front-end and more.

At the inaugural NDC London Conference, JetBrains will be represented by Matt Ellis and Maarten Balliauw who will be staffing our booth. Be sure to stop by for a conversation with these friendly guys, get your hands on some cool gifts and enter our license raffle.

We also invite you to join a session with Matt on Friday, December 6th from 16:20 – 17:20.

Demystifying the Reactive Extensions

Matt EllisReactive programming marks a major shift in the way we build asynchronous and event driven applications, replacing imperative control flow constructs with declarative data flow. Knowing what’s going on under-the-covers can remove some of the mystique, and leave you better able to reason about the data flow in your own Reactive applications. Learn how Microsoft’s Reactive Extensions work by joining us as we re-implement the core functionality from scratch.

Posted in News and Events | Tagged , , | 1 Comment

What’s New in Documentation and Support

As JetBrains .NET tools grow and evolve, their documentation and support teams have to keep the pace. Over the last several months, noticeable changes and improvements were made in these areas, and I’d like to expand on them in this post.

JetBrains .NET Tools Library

In our attempt to have a single entry point for all documentation of JetBrains .NET tools, we came up with JetBrains .NET Tools Library. Along with bringing together a great deal of existing documents, the library presents a number of new articles and tutorials that highlight specific use cases. New documents include:

These and other guides will help you take a quick start with the tools or learn specific use cases.
JetBrains .NET Tools Library

New support site

Customer support for all .NET tools has moved to new Zendesk-based portals which feature expanded FAQs for ReSharper, dotTrace, dotCover and dotPeek, as well as improved search for common problems and workarounds. Note that there are two support portals, one for ReSharper support and a separate one for dotTrace, dotCover and dotPeek support. ReSharper FAQ

Keyboard shortcuts in documentation

Ever since ReSharper online help was first published, we’ve been receiving quite a lot of complaints regarding keyboard shortcuts. Throughout the documentation, all shortcuts used to be specified using ReSharper 2.x/IntelliJ IDEA keyboard scheme, and users who preferred the Visual Studio scheme had to look up their shortcuts in a reference help topic or refer to a PDF keymap. The problem is no longer there now: if a help topic contains references to keyboard shortcuts that differ between the two schemes, a selector appears in the top right corner that allows you to display shortcuts for the chosen scheme. Shortcut scheme selector
By the way, starting from version 1.1, dotPeek also has a fully-fledged online help and the shortcut scheme selector works there too.
Another common problem was finding the right ReSharper command in Visual Studio options (Tools | Options | Environment | Keyboard) to assign custom shortcut keys to it. Now it is much easier: you can find all command aliases right in the list of keyboard shortcuts: Command aliases in help

Feature matrix

ReSharper can handle a dozen of different languages and technologies, especially with its recently added support for TypeScript. However, some of ReSharper features work everywhere, some are language-specific or supported in a subset of languages. To let you quickly check where a feature woks, and where it doesn’t, we have added a ReSharper feature matrix to ReSharper online help. It lists all major ReSharper features and specifies languages and/or technologies for which these features are supported.

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

Free JetBrains .NET Tools Evening in Prague, December 18th

Join Dmitri Nesteruk, Wednesday, December 18th for an informative and exciting evening of JetBrains Tools for .NET Developers in Prague!

The FREE event takes place 16:00 – 20:00 at Konferenční Centrum City in Prague 4, and includes light snacks and beverages. Anybody may join but registration is required and space is limited.

Here’s the Agenda:

What’s New in ReSharper 8.1
In this talk, we’ll take a look at the new features of ReSharper 8.1. We’ll discuss the support for new technologies, new tools, refactorings, inspections and other goodies that 8.1 gives to developers.

How ReSharper Improves Visual Studio 2013
With the release of Visual Studio 2013, some of you might be left wondering: is there anything that ReSharper has that VS2013 does not? Answering with a resounding yes, this session is all about the ways ReSharper enhances almost every aspect of Visual Studio as well as bringing entirely new features to the table.

Beyond ReSharper
It’s not just ReSharper that we’ve got in the .NET space! Whether you’re after code coverage, profiling or super-powered decompilation facilities, this talk will show you the tools we make to help you succeed in all these tasks.

Learn more and reserve your spot at this great event.

 

Posted in News and Events, ReSharper Tips&Tricks | Tagged , , | Leave a comment

ReSharper Workshops at YOW! 2013 in Melbourne and Sydney

YOW! Australia is holding a series of 1 and 2 day Workshops in Brisbane, Sydney and Melbourne to coincide with the YOW! Developer Conferences in each city. These Workshops present an opportunity to get hands-on training from internationally recognized experts in a small group format. The workshops are divided into four subject areas: Agile Practices; Security, Performance & The Cloud; Languages; and Software Architecture & Design.

Hadi Hariri will conduct a Software Architecture & Design workshop in Melbourne (December 3rd) and Sydney (December 11th)In each full-day workshop, you will refresh your knowledge about the mainstream ReSharper functionality and learn about many of the overlooked features of ReSharper. Here are the full details:

ReSharper Inside Out: Effective Refactoring of C# and JavaScript

You will learn how to effectively navigate legacy codebases using advanced navigation features, inspections, usage search, and value/call tracking. You will learn about using some of the less known yet very useful automatic refactorings that ReSharper offers.

You will dive deeply into code inspections and learn not only how to configure them but extend them using Structural Search and Replace, create and extend all the different types of templates ReSharper offers, as well as learn how to do effective TDD/BDD. You will also dig into the configuration features ReSharper offers and see how to effectively configure ReSharper for yourself, your team and your company.

After getting a firm grip of everything ReSharper offers, you will explore extending ReSharper. After an overview of ReSharper’s architecture, you will see how we can extend it using the ReSharper SDK, learning about the different types of extensibility points that ReSharper offers. And if all that isn’t enough, you’ll also learn some of ReSharper’s best kept secrets!

This workshop is intended .NET Developers who are using ReSharper in their development environment. This workshop is not for the ReSharper newbie.

For more information, please visit the workshop page. To register now, click on the conference and workshop city that you are interested in: Melbourne (December 3rd) or Sydney (December 11th).

Posted in News and Events, ReSharper Tips&Tricks | Tagged , , , | Leave a comment

ReSharper 8.1 EAP Guidance for Extensions

Now that we’ve released the ReSharper 8.1 EAP, and you’ve got the new SDK as a NuGet package, I want to provide some guidance for plugin and extension authors on how to update their extensions to be compatible with 8.1.

Traditionally, ReSharper plugins are not compatible across major and minor version releases (although they are for maintenance releases, such as 8.0.1 and 8.0.2). Plugins can access the full API that ReSharper has access to, rather than a limited subset “plugin API.” When we evolve the product and introduce new features, that API, by necessity, changes, requiring updates to plugins.

With 8.0, we introduced NuGet based extensions, and one of the goals of using this format was to make it easy to support multiple versions of ReSharper. The main way this is implemented is to realize that a NuGet package is essentially a zip file – we can easily put multiple copies of a plugin, each targeting different versions of ReSharper, into the same package. Also, ReSharper extensions are installed to a location that is shared between ReSharper versions, so ReSharper 8.1 will attempt to load any extensions that were installed for 8.0. If the extension doesn’t yet support 8.1, ReSharper will continue to check for updates for it, and will notify the user when one is available, allowing for a smooth migration of extensions from 8.0 to 8.1.

There are three steps to properly support extensions that can handle both 8.0 and 8.1:

  • Follow the appropriate file layout
  • Mark as pre-release
  • Check NuGet dependencies

File layout

The file layout is very important, and key to supporting ReSharper 8.0 and 8.1 with a single extension package. When looking for files to load, ReSharper will look in a variety of locations within the package. It uses the following paths:

  • ReSharper$resharper_version$$vs_version$$file_type$
  • ReSharper$resharper_version$$file_type$
  • ReSharpervAny$file_type$

Where $file_type$ is the type of file to be loaded (“plugins”, “settings” or “annotations”), $vs_version$ is the version of the current Visual Studio instance and $resharper_version$ is the current version of ReSharper. For example, ReSharper 8.0 running in Visual Studio 2012 will look in the following locations for plugins:

  • ReSharperv8.0vs11.0plugins
  • ReSharperv8.0plugins
  • ReSharpervAnyplugins

It first looks at the most specific location, allowing for content that is both ReSharper and Visual Studio specific. This allows for a plugin that requires specific Visual Studio versions, by e.g. putting a Visual Studio 2012 build of the plugin in ReSharperv8.0vs11.0plugins and at the same time, a Visual Studio 2013 build of the plugin in ReSharperv8.0vs12.0plugins. By having both plugins in the same package, one extension can support both Visual Studio 2012 and Visual Studio 2013 with one install. This idea extends to support ReSharper 8.0 and 8.1 in the same package.

ReSharper 8.1 will look here:

  • ReSharperv8.1vs11.0plugins
  • ReSharperv8.1plugins
  • ReSharpervAnyplugins

As you can see, the first two locations are different to where ReSharper 8.0 looks. If you want to support a plugin that has a build for 8.0 and a build for 8.1, the recommended locations are ReSharperv8.0plugins and ReSharperv8.1plugins, respectively. Only put your plugins in a Visual Studio specific folder if it actually requires a specific version of Visual Studio. The “vAny” location is shared between 8.0 and 8.1, and shouldn’t be used for plugins.

Settings and annotations files can be put in the ReSharper version specific or vAny folders – the file formats are common between ReSharper versions.

It is recommended that when adding support for 8.1, you continue to support 8.0. Do not remove your 8.0 content from the package, otherwise users of ReSharper 8.0 will lose functionality when they upgrade to the new version of your extension. Note that you aren’t required to rebuild or otherwise maintain your 8.0 content, you can simply include the content used in the previous package and redistribute it.

You can see the locations that ReSharper is searching, and what files it finds (or doesn’t find!) in the diagnostic dialog that is available from the “Additional Information” link in the Extension Manager when an extension is selected.

Extension Manager additional information dialog

Mark as pre-release

Because 8.1 is still an EAP, and not stable, you should mark any extension packages that include 8.1 content as pre-release. This way, any updates to your existing package do not disturb users of the stable package for 8.0 – they won’t see updates that they aren’t interested in. As long as you continue to also ship the existing 8.0 content, then an 8.0 user can still update to your pre-release extension with no negative impact.

Once the EAP is over and 8.1 is released, you should make a new build of your extension that supports the final version and release it, removing the pre-release version identifier. Both 8.0 and 8.1 users will be prompted to install the new version, and it will simply work with either version of ReSharper.

Check your dependencies

You should also check the dependencies in your .nuspec file. All extensions require a dependency on a package called “ReSharper”. If this dependency isn’t included, or isn’t valid, ReSharper will not install or load the extension. This help us solve both a versioning issue, and a suitability issue – ReSharper won’t install or update to an extension that doesn’t declare support, and it won’t try to install the jQuery package from nuget.org! The “ReSharper” package isn’t real – it doesn’t exist on the gallery, and isn’t installed. The Extension Manager adds a hidden “fake” package with the file version of the currently running version of ReSharper – 8.0.14.856 for 8.0, 8.0.1000.2286 for 8.0.1, 8.0.2000.2660 for 8.0.2 and 8.1.8.449 for the EAP build released on November 3rd (this will of course, change as more builds are released).

You can take advantage of this in your .nuspec file, using standard NuGet versioning rules. The simplest dependency is “8.0”, which means at least ReSharper 8.0.0.0 – note that NuGet treats missing version parts as zeroes. This will match ReSharper 8.0 and above, including 8.1. You can of course be more specific than that, e.g. “[8.0.1000,8.1)”, meaning 8.0.1 and above, up to, but not including 8.1. Or “8.1”, meaning 8.1 and above, not including 8.0.

It is recommended that you keep the version specification simple, unless you have specific requirements otherwise. Use “8.0” if you support 8.0 and above, “8.1” if you don’t have any support for 8.0. Alternatively, you can be more specific while still handling maintenance releases, with “[8.0,8.1)” or “[8.0,8.2)”. Since all packages are installed to a single location, ReSharper will check for updates to unsupported packages, so if a user updates and you’re extension isn’t ready with a supported version, the user will be notified when it is available.

Update: It’s important to note that ReSharper uses the full file version of ReSharper in the dependency check, rather than the product version. Using “[8.0,8.1]” will not match the 8.1 EAP. NuGet adds missing version parts as zeroes, and treats this version specifier as (≥ 8.0.0.0 && ≤ 8.1.0.0) and this will NOT match ReSharper 8.1.8.449, so the package won’t be installed or loaded. This specifier should be used to target 8.0 only. To target just 8.0 and 8.1 and no higher, use “[8.0,8.2)”, which is the same as saying (≥ 8.0.0.0 && < 8.2.0.0) – note the closing parenthesis, meaning less than, rather than less than or equal to.

Finally, it is worth pointing out that the gallery URL has changed for 8.1. The ReSharper gallery uses “curated feeds” to provide supported feeds for the current version of ReSharper. It uses the ReSharper_v8.0 feed for 8.0, and the ReSharper_v8.1 feed for 8.1. It uses the “ReSharper” dependency to see if a package should be included in each feed. If the dependency is satisfied by ReSharper 8.0, it gets added to the ReSharper_v8.0 feed, if satisfied by ReSharper 8.1, it gets added to the ReSharper_v8.1 feed. A package can be in more than one feed at a time. There is nothing you need to do to use or support this, but it can be useful to know that if your package doesn’t appear in the Extension Manager gallery, you should check the “ReSharper” dependency is correct.

Update: Since a picture is worth a thousand words, here’s a look at how the xunitcontrib package is laid out to support both 8.0 and 8.1, using the very useful NuGet Package Explorer. You can see that the plugins are in 8.0 and 8.1 specific folders, while the external annotations file and the settings files are shared in the vAny folder.

The xunitcontrib package viewed in NuGet Package Explorer

As ever, more information can be found at the plugin development guide. Here’s the page for packaging, and we’ll be updating the migration guide shortly. We’re looking forward to seeing more extensions supported in 8.1 EAP soon!

Posted in ReSharper Tips&Tricks | Tagged , , , , , | Leave a comment

ReSharper SDK Now Available on NuGet

With the recent announcement of the ReSharper 8.1 EAP, we’ve made steps to address one of the common requests of plugin authors – to ship the ReSharper SDK as a NuGet package. Previously, we’ve shipped the SDK as an MSI installer that would install Visual Studio templates, MSBuild targets, tools and reference assemblies, or as a standalone zip file, containing the same files.

While this works just fine for developing on your own machine, it doesn’t play nicely when building on a Continuous Integration server such as TeamCity. You have to manually install the SDK on each build agent, or check the assemblies into your source control, which is undesirable, due to the size of the SDK and because source control is optimised to text files, not binaries.

So, what’s changed?

Firstly, the MSI install still exists, but it no longer installs the tools, targets or reference assemblies. Instead, it only contains the Visual Studio project and item templates and the samples. The project templates will create plugin and plugin test projects, with the NuGet packages already referenced. To prevent having to download the NuGet packages every time you create a new project, the project templates contain a snapshot copy of the packages, which are installed to the Visual Studio install folder, under the Common7IDEExtensionsJetBrainsReSharper SDKv8.1Packages folder.

Visual Studio project templates

The JetBrains.ReSharper.SDK package is the core NuGet package to reference in your plugin project. It includes the reference assemblies, xml documentation files, target files and tools required to build a plugin. Adding a reference to this package from a blank class library project is all you need to do to create a new plugin. However, you might want to still use the Visual Studio project template to create a project. The template will automatically add the NuGet reference, and it will also setup the debug command line , as well as add plugin metadata attributes and provide example action handlers to get you going.

PM> Install-Package JetBrains.ReSharper.SDK -Version 8.0.1243

Currently, the stable package on nuget.org is the 8.0 SDK. The 8.1 EAP SDK package is a pre-release package that we’re shipping as part of the on-going EAP process, which means you’ll need to select the “Include pre-release” option in the NuGet dialog, or use the “-pre” option for the Install-Package command. We’re also shipping the JetBrains.ReSharper.SDK.Tests package to add to your test project to enable writing tests for your plugin.

PM> Install-Package JetBrains.ReSharper.SDK -Pre

We’ve put together the following guidelines for using the NuGet packages:

  • Don’t commit the NuGet packages folder to your source control repository. You should use NuGet’s package restore feature to automatically download and add back the package. This happens automatically in Visual Studio, you can use the nuget restore from the command line, or as part of your CI build process. TeamCity provides a NuGet installer build step to make this easy.
  • You can use a custom, local package source to prevent multiple downloads, or if your CI server doesn’t have Internet access.
  • Remember that you can pin a package reference to a particular version. For example, you could edit your packages.config file to pin your project to the current 8.0 SDK by setting the version to: version="[8.0.1243]". This will always use the 8.0 version of the SDK, even with package restore, while also allowing another project to use the latest version for the 8.1 EAP. And since the packages folder uses version numbers in the folder name, you can include multiple different versions of the SDK in your solution, to support e.g. 8.0 and 8.1 EAP.
  • You can update your existing 8.0 projects to use the NuGet package by removing the import of Plugin.Targets and the ReSharperSdkTargets property from the bottom of the file. Then simply add a reference to the JetBrains.ReSharper.SDK package.
  • The packages require NuGet 2.7, due to the improvements in handling package restore and importing target files.

Please let us know how you get on with the NuGet package – you can report issues on our YouTrack instance, and next time, we’ll take a look at adding 8.1 EAP support to your ReSharper extension.

Posted in ReSharper Tips&Tricks | Tagged , , , , , , , | 5 Comments

Visual Studio 2013 Support in ReSharper 8.1

This year we’ve seen something unprecedented: the release cycle for Visual Studio has shrunk to just one year, and Visual Studio 2013 came out with some pretty serious improvements across the board. ReSharper, as you can imagine, always tries to provide a seamless development experience, so in ReSharper 8.1 we’ve added support for two VS2013-specific features: peek definition and the enhanced scroll bar.

Peek Definition

Just in case you haven’t seen it, the Peek Definition feature of VS2013 allows you to peek into the source code of a referenced entity right in the current editor window, without opening new tabs, simply by having the cursor on the piece of code you want to investigate and pressing Alt+F12:

ReSharper Peek Definition

ReSharper treats this ‘inset’ editor window as it would any other, so that navigation facilities (including the ability to show and navigate decompiled code) function just as they do in an ordinary editor window, with the exception that any code navigated to is also shown in the editor rather than in a separate tab:

ReSharper Peek Definition Navigation Options

ReSharper also uses the Peek Definition API for large result sets obtained from features such as Find Usages. These are shown on the right hand side of the peek definition window:

ReSharper Peek Definition Results

Finally, to make it even more convenient, we’ve added additional Ctrl-click shortcuts for more convenient navigation. Peek Definition can now be invoked by clicking while pressing Ctrl+Shift, and Go to Implementation can now be invoked by clicking with Ctrl+Alt.

Enhanced Scroll Bar

Visual Studio 2013 comes with an enhanced scroll bar — the vertical scroll bar area is now used not just to indicate position within the document, but also to indicate locations of code elements, Peek Definition windows, and so on.

ReSharper 8.1 integrates its own marker bar (previosly shown as a separate vertical area right next to the scroll bar) to show its errors on this new enhanced scroll bar. Here’s what it looks like:

ReSharper Enhanced Scroll Bar Integration

ReSharper now uses the scrollbar to indicate errors, warnings, hints and suggestions. The horizontal markers are, as always, clickable (a click takes you to the offending line of code) and have tooltips describing the issue at hand.

If, for some reason, you want the old marker bar back, we give you this option, too. Simply open up ReSharper’s Options dialog and go to Environment | Editor | Editor Appearance and at the very bottom of the screen you should see the following settings:

The options here are fairly self-explanatory:

  • Do not show error stripe hides the error stripe completely.
  • Show error stripe bar shows the pre-VS2013 implementation of the marker bar as a separate bar. Choose this if you prefer the way things were in ReSharper 8.0 and earlier.
  • Show marks over enhanced scroll bar is the option for integrating with the VS2013 scroll bar. If you choose this, you can also decide how big you want the error marks on this scroll bar to appear: we give you three settings to choose from.

So with that in mind, we hope you enjoy having ReSharper 8.1 work in tandem with Visual Studio 2013. While we’re getting the final release version ready, check out ReSharper 8.1 EAP builds and let us know what you think!

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