JetBrains .NET Tools Blog

ReSharper has always had a powerful extensibility story – its Open API allows plugins to use the same APIs that the core product uses. But distribution – discovery, installing and uninstalling – has previously been left to the plugin author, meaning the user is left with an experience ranging from msi installers to zip and batch files. Recently, .NET has seen the success of the NuGet package manager, which makes it very easy to install, uninstall and update libraries in a project. We’d like to bring that ease of use and discovery to ReSharper, which is why we’re very happy to be taking the wraps off our NuGet based Extension Manager.

The latest EAP build of ReSharper 8 adds support for extensions to be distributed as NuGet packages. You get to use a very familiar interface to browse and install extension packages from our new extensions gallery. Of course, you can easily uninstall and update, too, and ReSharper will check for updates for you, and notify you when a new build is available – perfect for keeping up to date with EAP changes.

Speaking of EAP changes – since ReSharper 8 is currently still under development, it is obviously changing and evolving with each EAP release. Which means our packages are marked as “prerelease”. Once 8.0 is released, these will of course become Stable. Until then, please make sure to select “Include Prerelease” when browsing with the Extension Manager, or in the Gallery.

Extensions, Not Plugins

A very important change, though, is that an extension is not just for plugins. An extension can also be used to distribute ReSharper’s settings files and External Annotations, meaning you can now write useful extensions without even having to write any code.

The benefit of distributing .dotSettings files is that these are the files used by ReSharper to store Live Templates, Structural Search and Replace patterns, and other settings. For example, the xUnit.net test runner extension includes a plugin to provide the test runner capabilities, but also includes a .dotSettings file, adding lots of Live Templates to help generate code to write asserts faster.

And the sample patterns catalog extension adds a sample set of Structural Search and Replace patterns. These patterns are a very powerful, declarative way of analysing code and applying the standard warning squiggly underline highlight. What’s more, they can also provide a declarative means for creating a quick-fix for this code – adding an action to the alt+enter quick-fix menu to replace the code. See here for an introduction to SSR, and check out these posts for more information.

Of course, settings files aren’t limited to Live Templates and SSR patterns. While these were the primary motivation for adding support for .dotSettings files, it opens the door for more interesting extensions – defining code formatting standards, code cleanup profiles, extra To-do items, or even a different set of opinionated code inspection defaults (don’t like our default “var” recommendations? Change them!).

Extension packages take advantage of ReSharper’s settings layers. If the extension contains a .dotSettings file, it is added as a read-only layer. The settings in the file are merged with the other layers in your installation (This Computer, Solution and project files – see this post for more information on layers), and naturally appear in the Options dialog or Live Templates Explorer. This means you can edit the templates, patterns or other settings, and any changes are then saved in the This Computer layer.

If you don’t want these extra settings (for example, you want the test runner, but not the included Live Templates) you can easily remove them from the system by disabling the layer in the Manage Options dialog. The settings, templates or patterns are immediately removed.

External Annotations are xml files that contain a map between ReSharper’s annotation attributes, and pre-compiled assemblies. ReSharper’s code analysis uses these annotations to make better decisions about the warnings to show. For example, without annotations, this test code warns about potential null usage, even though the preceding Assert will throw an exception if the value is null – in other words, the value is guaranteed to be not-null when accessed.

The xUnit.net extension adds annotations for the xunit.dll assembly, which tells ReSharper that Assert.Null will throw if the passed parameter is null. Now, ReSharper knows that the second assert will never get hit, and marks it as unreachable.

ReSharper ships with annotations for the BCL, and some annotations for third party assemblies, notably to enable INotifyPropertyChanged support. Extensions can now distribute annotations for other third party assemblies.

Dependencies

Since extensions are NuGet packages, they can have dependencies. Someone could write an extension that exports a Live Template for creating test methods. That template could use a macro from another extension to make sure the method name you type gets converted to a valid name – changing spaces to underscores, for example.

Bundled Extensions

Another exciting benefit we get from the extension manager is the ability to have bundled, or pre-installed, extensions. These are simply extensions that are installed for you as part of the normal installation process. Once installed, they behave just like normal extensions, and we can push updates to the Gallery at any time, allowing us to update these plugins on a separate schedule to ReSharper itself.

In the latest EAP build, we’re bundling our NuGet plugin which uses NuGet to add package references, rather than file references when importing types. We now get the best of both worlds – this really useful functionality is included by default for every ReSharper user, and we have the flexibility to update it at any time, decoupled from ReSharper’s release schedule.

Custom sources

Of course, since this is based on NuGet, we get to take advantage of the existing infrastructure and tooling available in the NuGet community. Our Gallery is based on the NuGet Gallery sources, and is the default, primary location for getting extensions (remember to select “Include Prerelease”!). But you can also use the Extension Manager page in the Options dialog to specify extra sources – local or remote file system or a custom NuGet feed, such as TeamCity or MyGet. This makes it easy to install private, company wide extensions that target your specific needs, or nightly builds of an extension you build, or perhaps create a curated feed of your favourites.

How to Build Your Own Extensions

Building extensions is very straightforward. While we’re based on NuGet, we have a very different purpose to NuGet – extensibility information as opposed to assembly references. So we don’t use the standard libs, tools or content folders. Instead, we have our own folder structure that makes more sense for the data we need to distribute in the package. But that’s really the only difference. We still use the .nuspec file for metadata, and we pack and push the .nupkg file to the ReSharper Gallery in the same way – sign up for an account, get an API key and push away! You can get more information on creating an extension package at the ReSharper 8 devguide site, and if you have more questions, please email us at resharper-plugins@jetbrains.com, or send a message to the new resharper-plugins Google Group.

Please note that the Extension Manager relies on NuGet’s core library to implement a lot of its functionality. Since this is a .NET 4 library, the Extension Manager is limited to Visual Studio 2010 and 2012. We’re looking at ways to improve this as we progress through the EAP.

We hope you enjoy the changes we’ve introduced around extensions. Please try it out and let us know your feedback. We’re still quite early on in the EAP cycle, so expect changes – but if there’s something you want to see changed or updated, let us know! You can report issues at our YouTrack instance.

And remember, you don’t need to write a plugin to release an extension – let’s see some Live Templates and SSR patterns!

Good news everyone — we’ve got another EAP build ready and it should come as no surprise that we’ve got a few new features to talk about. So without further ado, here’s what we’ve got in store for you today.

Extension Manager or how to provide xUnit.net support

We sometimes get requests to provide certain features out of the box, functionality that is currently provided via plugins. xUnit.net support is one of these.

While doing this certainly has its benefits, it also has disadvantages. As such, we decided instead to take the opportunity to address the core problem, which is to simplify the discovery, installation and updating of ReSharper plugins.

We’re very pleased to introduce our NuGet based Extension Manager. It’s now very easy to add extensions and plugins to ReSharper, all from a user interface you’re very familiar with from NuGet. Simply open the Extension Manager from the ReSharper menu, and you’ll be able to browse and search for extensions from the “Online” category - make sure you select “Include Prerelease” in the drop down first - these are still EAP packages!

So to get xUnit.net test support, simply find the xunitcontrib package and hit Install.

That’s all there is to it! ReSharper now has support for running xUnit.net tests, and includes Live Templates and External Annotations to make your test code writing experience better.

We’ll be taking a more in-depth look at this feature very soon, but one important point to make right now is that because NuGet is a .NET4 library, the Extension Manager is only available in Visual Studio 2012 and 2010.

ToString() Format Completion

ReSharper already has a few features related to String.Format() usage, such as for example inspections and fixes related to format arguments being used in the format string. However, in this EAP we’re taking it a bit further by adding code completion for types which have well-known format specifiers (such as DateTime, TimeSpan, Guid, enumerations and many others):

Multi-File Templates

By popular demand, ReSharper’s support for file templates has been expanded to incorporate the possibility of creating several files from a single template. You start, as always, by creating a single file template. But then, ReSharper gives you controls to add additional files: you can either add a new file or a file from an existing template:

Choosing one of these options adds another editor into the template editor window. In this editor, you can specify the placement of the file (either a relative location or an ASP.NET code-behind file), the name of the folder to place the file into, and of course the name of the file. Then, just edit this template as you would any other — you can reuse the parameters you declared for the first template.

You can add as many files as you want and once you come to fire the template, all the necessary files (and folders, if they do not exist) will be automatically created in the right places.

Go To Generic Subsitutions

When you have the usage of a generic type such as List<Foo>, it’s easy enough to find all usages of List<T>, but what if you want to know the exact types that List<T> is being specialized with. To help with this, one of the new navigation options is to look for Generic Substitutions:

Once you fire up this navigation item, ReSharper will search for all the types that are used to substitute the generic parameter T and will show you a summary tree grouped by the type used to substitute the generic parameter. You can drill down into the tree to find out the exact locations where a particular type is used:

Blue Theme Support

Visual Studio 2012 Update 2 has been released with support for a Blue Theme, and we’ve made adjustments to ensure that ReSharper plays nice with it too:

We’ve got a lot more in store, and we’ll be blogging in the coming weeks about new features as well as giving in-depth overviews of the ones we’ve already mentioned. Meanwhile, please feel free to check out the EAP and let us know what you think!

You have probably already guessed that this post is about a new set of features that has appeared in the new build of the ReSharper EAP late last week, so, without further ado, here’s what we’ve got in store for you:

Bulb Menus in Margin

In an attempt to streamline the programmer’s interaction with gutter marks and bulb pop-ups, we have added an option to merge both of these constructs into a single construct that we call an action indicator. Here’s what it looks like:

As you can see, both the gutter mark options from unit tests and the context action on that element have been merged into a single menu. The use of action indicators is an optional feature that can be found in ReSharper’s Options under Environment|Editor|Editor Appearance:

Option #2 in the above list revers to the R#7.1-style mechanism of showing a bulb pop-up. The last option prevents any visual queues that a bulb item is available (save for the indicator itself), and only shows the menu when you explicitly open it with Alt+Enter.

Please note that this feature is available only for Visual Studio 2010 and later.

Decompiler Improvements

We’ve already talked a bit about decompilation (both in ReSharper and dotPeek), but this deserves a mention: we now know how to correctly decompile

• async methods and await expressions, including async lambdas.

• Expression trees — the decompiler will now help you when exporting Linq to SQL or Entity Framework code in query expressions. This means in ReSharper 7 you could only decompile an expression into this:
  
  whereas with ReSharper 8 you can decompile it into this:
  

• Field-like events, taking into account the lock-free nature of C# 4’s add/remove accessors.

Fix in Scope

In-place fixes are great, but what’s even better is when you can apply that fix in a given scope. Take those pesky unused references, for example – now you can get rid of them not only in a file, but also on a project/solution level. All with a single quick-fix:

Now quite a few fixes can be applied to a larger scope than just the code under the cursor — including making a field read-only or removing a redundant cast.

Default Alignment Setting Adjustments

One common complaint about ReSharper’s default settings was that certain constructs we indented, shall we say, aggressively. The two particular cases of note are anonymous lambdas

And another case is indentation when a function call including parameters gets too big and is indented similar to

These and similar cases will now be treated more gently by ReSharper’s default settings.

Code Inspection Performance Improvements

Last, but certainly not least, after another round of performance improvements we’ve managed to once again speed up ReSharper’s code analysis. Specifically, the Find Code Issues command enjoys an over 2× performance improvement.

Now, you know what to do – grab the EAP and check out those features today!

Just so you know, we’re continuously trying to improve the coding experience of everyone who works with XAML. ReSharper 7.0 that we have released a couple of months ago was highly focused on supporting Windows Store application development and quite frankly, didn’t contain many changes targeted at a broader crowd of XAML pros. Come 7.1, it’s time to make everyone happier, even if you’re not very much into Windows Store apps right now.

Code completion

The main challenge that we’ve solved in ReSharper 7.1 was to come up with fast, smooth and smart automatic code completion in XAML markup. Providing code completion lists in XAML is sometimes a non-trivial task: for example, WPF actually exposes hundreds of public types with lots of members like attached properties and events that should be taken into account while building completion lists. By virtue of reviewing our caching strategies in ReSharper 7.1, we ended up with a nice performance boost in code completion and whole XAML support as well.

Automatic completion by design drops many possible types that you can possibly use to qualify properties in XAML markup and includes only types that can bear a meaning in the current context:

If you’re looking for the full list of possible types with attached properties/events, just invoke symbol completion (Ctrl + Space). This behavior differs from that used in other languages where automatic completion works pretty much the same as symbol completion. However, it makes XAML lookups much cleaner and more precise in most cases. If you happen to find this behavior confusing, please vote or leave a comment under this issue.

Property completion in XAML now highlights a type’s own properties with bold, helping identify control-specific properties among thousands of those inherited from framework classes:

When generating completion lists for markup extensions, ReSharper can now filter out properties that you have already set:

An action to generate event handlers is now available with both automatic and symbol code completion:

If invoked inside an empty x:Name attribute, symbol code completion now suggests name options derived from control type name. If you’re providing a prefix for the new name, it still works as expected:

Automatic code completion is getting much more useful when dealing with resources: completion list is filtered based on expected resource type:

Field modifiers in Windows Store applications are now correctly handled and completion list now includes the previously missing protected modifier:

Different icons help identify markup extensions when using object element syntax:

Automatic closing tag code completion in all XML-based languages now only shows tags that are actually not closed:

A plethora of other small improvements has been implemented in code completion for XAML, including fixes in the calculation of expected types and improvements in Windows Workflow Foundation (WF) projects. As expected, XAML code completion in ReSharper reacts to type changes immediately, without requiring to build your project.

Typing assistance

The second important area that has been improved for XAML developers is typing assistance.
ReSharper 7.1 introduces some really nice bits of HTML editing experience to XML-based formats (including XAML, web.config, MSBuild scripts and all other kinds of XML documents) — for example, synchronous tag editing:

A feature called smart slash helps create self-closing tags by automatically removing the closing tag and placing the caret after the new tag for you (and also removing any white space that could have left between the converted pair of tags):

In order to prevent code completion from getting in your way, it should be able to detect when you’re trying to enter characters that had already been completed for you. In the case below, ReSharper auto-completes the closing angle bracket of the opening tag, as well as the entire closing tag. Meanwhile, if you’ve not looking at the screen and proceed to entering the closing angle bracket yourself, ReSharper simply merges the two brackets to prevent duplication:

Binding assistance

One of the greatest benefits of using ReSharper with XAML is static typing of data bindings. When ReSharper knows the binding source type it offers you a lot of opportunities: navigation directly to bound properties, code completion for property paths, refactoring support, error validation, and more. Static typing increases maintainability of your XAML markup, especially in applications with heavy usage of bindings (like MVVM-based apps.)

ReSharper is trying to infer the type of binding source in many ways (like in the screenshot above) but in cases where it’s not possible, there’s an easy way to annotate the data context type with design-level annotations, now using a submenu:

Such annotations are usually only required at the top level of XAML element trees. ReSharper 7.0 is trying to utilize the property name you have already typed and suggest a smart choice:

If the suggested type doesn’t fit, you can trigger import completion or enter a new type that can then be declared from usage.

ReSharper 7.1 offers new ways to infer binding source type. One popular scenario that is now supported involves binding through the DataContext property of another named control element. ReSharper can now share information about data context type between different controls:

ReSharper provides code completion and other features despite <DataContext property being of System.Object type. Similar bindings with RelativeSource mode are also supported.

If you are using custom markup extensions as binding source, ReSharper 7.1 can now calculate data context type from [MarkupExtensionReturnType] annotation in WPF (or implementation of IMarkupExtension<T> interface in Silverlight 5):

Binding type calculation also deals with CollectionViewSource in ReSharper 7.1 with respect to design-level attributes like d:DesignSource. Finally, ReSharper 7.1 introduces support for IValueConverter annotated with [ValueConversion] attribute:

Naming consistency

ReSharper 7.1 now highlights naming consistency issues in XAML markup just like in other supported languages and offers actions to fix naming. Naming rules are configurable for XAML fields, resources and namespace aliases.

Create from usage

ReSharper’s Create from usage family of quick-fixes can be very useful during development of custom controls or building custom object structures in XAML markup. ReSharper 7.1 knows a lot about all the types that you are using inside markup and improves actions like Create type and Create property with calculation of expected types — similar to how it does in C# and VB.NET:

You can specify a resource for a non-existing property, use nested object element like in the example above or even bind the property to something — ReSharper 7.1 will suggest the correct type for the new property when it creates it from your usage:

Custom bindings and resource dictionaries

ReSharper 7.1 introduces basic support for custom resource dictionaries and binding extensions. Custom structures are currently detected via naming conventions. Inheritors of ResourceDictionary type should be named using “ResourceDictionary” suffix in order to be correctly handled by ReSharper in XAML markup and participate in resource resolution:

There’s a similar story with custom bindings: you should use “Binding” suffix to enable ReSharper support for your custom markup extensions that complement XAML binding capabilities:

In future versions, we’ll be looking to provide adequate tooling without enforcing any particular naming conventions.

Other fixes

We’ve also implemented a number of miscellaneous XAML support fixes including (but not limited to) the following:

• Suppressing inspections with comment now works everywhere in XML documents (including XAML, web.config.)
• Color boxes in code completion and color usage highlightings are back in Silverlight and WinRT projects (both in XAML markup and code-behind files.)
• Unused XAML resources are no longer highlighted with gray in their entirety: only resource keys are highlighted.
• Support for markup extensions has been rewritten to solve a bunch of issues and provide improved code completion.

Here’s the full list of XAML-related fixes implemented for ReSharper 7.1 this far, and we still have quite a bit on our XAML support improvement agenda.

As usual, any feedback on your experience with ReSharper XAML support is highly appreciated! To test drive the recent changes, make sure to download a fresh ReSharper 7.1 EAP build.

Say hello to ReSharper 7.1 EAP! Starting today, you can download early builds of the new ReSharper update.

In this release, we’re trying to focus on little things: removing minor but irritating flaws as well as introducing small improvements that go a long way towards better usability. The everlasting battle for smooth performance and light memory usage is also in full force. Anyway, read on to learn what we have in store as of EAP launch.

Code formatter revitalized

We know that code formatting is a very sensitive set of IDE functionality — to the extent of donating kingdoms in return for fixing formatting issues. Seeing a set of these issues that have accumulated over the years, we decided it was time for action.

Specifically, following enormous demand, ReSharper now provides versatile settings to format chained method calls. For example, you can chop chained calls while giving preference to wrap after delimiter dots:

In conjunction with a new option to align chained method calls, this gives you the following formatting setup:

Second, facing the region controversy, Code Cleanup doesn’t introduce regions by default anymore. Too many people consider regions a code smell, and we had to do something about it.

In other formatting news, code formatter now indents with tabs only if using spaces is not allowed in a specific coding standard; there’s now a new options page which actually makes formatting XML doc comments a feasible task; and if you’re an ASP.NET developer, look for a new option to always use Kernighan & Ritchie style brace layout in markup pages regardless of whatever style you’re using in code-behind. There are even more formatting and cleanup fixes — here’s the full list in case you’re interested.

Fewer annoyances all around

If fixing some of the weirdness in code formatting behavior wasn’t enough, we handled quite a bit of other annoying bugs. For instance, configured JavaScript abbreviations are now respected by JavaScript naming inspections; moving types or files no longer changes their encoding; and importing types for pasted code doesn’t bring up an ugly dotted box.

Easy sharing of ReSharper inspection results

Following insightful feedback from John Papa and other long-time users, we’ve revised the experience of working with Inspection Results and Errors in Solution tool windows, primarily in order to streamline sharing ReSharper inspections with non-ReSharper users (amazing but there are some) as well as creating work items based on inspection results.

Specifically, you can now copy individual entries or custom selections of entries from both Inspection Results and Errors in Solution:

This is handy if you’re working in a team environment and assigning work items based on ReSharper inspections to different developers: copy an issue or a group of issues, submit the copy to an issue tracker, and there you go into the wonderful world of delegation!

However, copying an entry or a selection gives you a plain text copy of the issues that ReSharper has detected. If you’re a fan of HTML- or XML-based issue reports, be informed that entries can now be exported from Errors in Solution (this was previously only available from Inspection Results):

Speaking of XML reports, that was the only export format that included line numbers in previous ReSharper versions. In 7.1, we’ve put an end to this inexplicable injustice: HTML and plain text exports now include line numbers, too:

INotifyPropertyChanged tooling now supports Caller Info

ReSharper 7.1 takes advantage of Caller Info attributes when it implements INotifyPropertyChanged in .NET Framework 4.5 projects. Needless to say, if your project is targeting .NET Framework 4.0 or below, ReSharper still uses the traditional syntax.

The new version also facilitates migration to CallerMemberName-based implementations by highlighting redundant arguments. If you happen to have, say, an OnPropertyChanged implementation that includes a parameter annotated with CallerMemberName, any calls passing explicit arguments will be marked as redundant:

There’s more in store regarding INPC support in ReSharper 7.1, so stay tuned for a separate blog post.

A different treatment of the Preview tab

We’ve received complaints stating that we were taking advantage of the Preview tab in Visual Studio 2012 in more cases than it made sense.

In 7.1, all contextual (such as Go to Declaration or Go to Implementation) and context-insensitive (Go to File or Go to Symbol) navigation actions are reverted to open files in standard text editor tabs. The Preview tab is still used to open files that you’re selecting via Enter from tool windows such as Find Results.

Do you think this is a better way to use the Preview tab? Please let us know!

Refactoring coverage and quality assault

Many refactorings have received a level or two up in terms of stability and functionality. For example, Extract Class is now working with VB.NET in addition to C# code, plus the C# implementation has received a substantial share of bug fixes. (You’ve watched the video on using Extract Class, haven’t you?)

Change Signature now works correctly with default parameter values and handles usages of named arguments just fine. Other fixes cover Extract/Inline Method, Rename, Extract Superclass, Introduce Variable, Pull Members Up and quite a few more refactorings — here’s the full list of fixes.

Entity Framework 5-specific fixes

A couple of code analysis false positives are now gone, and extension methods should now be resolved without extra manipulations with ReSharper caches.

Various improvements in VB.NET support

For example, VB.NET quick-fixes for WinRT have been added to pair those available for C#; VB.NET inspections can finally be suppressed with comments; IntelliSense has been fixed for enums and LINQ-to-SQL joins. On top of that, as mentioned above, Extract Class refactoring is now functional in VB.NET code.

ASP.NET and ASP.NET MVC refined

ReSharper now consents with the exotic case of wrapping asp:placeholders with styles in ASP.NET markup files. ASP.NET MVC developers should be happier as ReSharper 7.1 handles cases where file names of views are not derived from action names and resolves relative view paths much better. For details on more web dev fixes, see this list.

Performance and memory consumption improvements

These traditionally cover all kinds of technologies but most importantly SharePoint, ASP.NET MVC and resource files. On another note, if you’re a fan of typing in web.config files, this should now be a much smoother task.

Unit testing: JavaScript and usability

First off, nested references are now supported for JavaScript testing frameworks (both QUnit and Jasmine).

Another improvement is relevant to a broader scope of unit testing practitioners however. If you have a great load of unit tests in your session, there’s now an easy way to filter the session to specific tests — just use quick search that is now available in Unit Test Sessions:

In other news

• More fixes to Optimize References related to removing necessary references in projects referencing WCF services and Castle Windsor.
• ReSharper has grown friendlier to SVN-indexed PDBs: from now on, when you’re using ReSharper navigation during debugging, ReSharper will fetch SVN-indexed PDBs correctly.
• Exception reporting doesn’t any longer expose paths from reporters’ machines. This was previously a valid privacy concern which is now removed.
• Quick Documentation is now available for JavaScript.
• You can now disable more ReSharper inspections with comments. First of all, as mentioned above, this action now works in VB.NET code. In addition, it also works in HTML and XML code, and a specific case of suppressing “Convert to auto-property with private setter” is now functional, too.

If you’ve read through to this point, you just owe it to yourself to download a ReSharper 7.1 EAP build.

Questions? Bug reports or improvement requests? We’re all listening.

Tonight in London Hadi Hariri and Sergey Coox have unveiled the early bits of the upcoming ReSharper 6 in front of DevCon London and JetBrains Community Night attendees.

While you can be sure that more exciting announcements on the new ReSharper functionality is ahead, one thing is crystal clear: ReSharper 6 will provide first-class support for JavaScript and CSS.

While there are currently no public builds available incorporating JavaScript support, you can expect ReSharper 6 Early Access Program to open in November, and November is very soon!

Meanwhile, please bombard ReSharper issue tracker with your feature requests detailing how you would like the most intelligent Visual Studio extension to support JavaScript and CSS!

Cheers!

UPDATE. For more details on ReSharper 6, watch the ReSharper 6 tag here on the .NET tools blog.

A couple of weeks ago we posted a blog entry on known issues in ReSharper 5.0 and workarounds, and today we’re taking the next logical step by opening a new Early Access Program for ReSharper 5.1 to fix them. If you’ve having issues with ReSharper 5.0, please start downloading ReSharper 5.1 nightly builds: it should feel much better.

Here’s a quick list of fixes that the Early Access Program presumably brings:

• Typing latency in ASP.NET Web Forms and MVC is considerably reduced.
• Code-behind files in ASP.NET projects don’t disappear when saving files anymore.
• Splitting Visual Studio text editor tabs does not result in ReSharper features disappearing from one or both tabs.
• Silverlight 4 support is fixed: no more error highlighting when referencing Silverlight 4 code from a regular .NET assembly.
• Encoding issues when working with XAML files are resolved.

If something goes wrong, please report issues to our YouTrack project.

As announced a week ago, we’re launching Early Access Program for the new JetBrains .NET tool, dotCover! If you missed the news, check out the initial dotCover announcement and Hadi Hariri’s introductory blog post about code coverage for .NET and using dotCover.

Download early dotCover builds from jetbrains.net, use them and vote for them. Report bugs and request features using dotCover issue tracker. If you have product-related questions (we bet you do), ask them in dotCover community or on Twitter.

Enjoy!

The first half of 2010 turns out to be pretty fruitful for .NET developers who use JetBrains tools. In addition to upcoming major releases of ReSharper and dotTrace, we’re extending our .NET toolset with dotCover — a code coverage tool.

Many of our customers consider unit tests a vital part of their development workflow. It doesn’t come as a surprise that we want to let them easily see how successful they are in covering their applications with tests. To bring an extremely comfortable code coverage experience to developers, the initial version of dotCover will introduce the following features:

• Integration with Visual Studio 2005, 2008 and 2010.
• .NET projects coverage in Visual Studio.
• Test coverage through tight integration with unit test running engine in ReSharper 5.0.
• Navigation to source code from coverage report.
• Highlighting for covered and uncovered code in Visual Studio code editor.
• Navigation from source code to unit tests that cover it.

We’re thrilled to announce that some of these features will be available via Early Access Program that we’re launching next week. Stay tuned for an additional launch announcement here on the .NET Tools Blog and follow us on Twitter.

We’re happy to finally provide public access to early bits of the renewed ReSharper!

Starting today, you can download nightly ReSharper builds, and the first one is already there for you.

Note that this is only pre-release software. Nightly builds are assembled automatically every night without proper alpha testing, and we can’t guarantee that they will even run on your machine. However, we hope that by participating in this Early Access Program, you can help us gradually improve product quality up to a level that is proper for final release.

Some additional notes on this EAP:

• At this time, we’re only publishing ReSharper builds for VS 2008. We’ll start publishing VS 2010-compatible builds as soon as we verify that ReSharper works decently with VS 2010 Beta 2.
• The UI for many new and improved ReSharper features is not yet finalized. Shortcuts and titles may change as well.

Once you have downloaded, installed, and used a nightly build for a while, please vote for it in the nightly builds page so that other users are able to judge on its quality. If you’re willing to report a bug or feature request, please do so using our bug tracker (here’s how it works).

To further comment on the quality of individual nightly builds please use jetbrains.resharper.eap newsgroup or its web mirror in our development community.

To get an idea of improvements and new features that we’re starting to reveal during this EAP, take a look at the recently published ReSharper 5 Overview.

Happy early accessing!