ReSharper Horizons

ReSharper 5 -- Less Shifting Means More Speed

2009-10-29T11:10:00.006+03:00

JetBrains .NET blog and web site are talking about major features in ReSharper 5, like showing metadata for library classes, downloading source code for .NET Framework, code inspections, ASP.NET MVC support and other great things. But there are many more improvements in ReSharper 5 which deserve attention and I thought I should blog about them.

When ReSharper first introduced CamelHumps to .NET world (and then other tools and Visual Studio 2010 followed), it worked only in Go To Type and similar features. It is very convenient to type just "TMV" and see "TreeModelView" in the list. In previous version of ReSharper we added CamelHumps matching to intellisense and that increased productivity once again. In ReSharper-enabled teams one can often hear people talking abbreviations.

But original style of typing abbreviations has one issue - to much Shift use. Now, with ReSharper 5, it is no longer needed:

ReSharper can recognize CamelHumps and match them to lower case letters. This of course works in completion too:

That tiny feature alone can increase code crafting speed and make you more productive, especially when you have longer descriptive type names.

ReSharper 5 early builds are currently available throught Early Access Program. ReSharper 4.5 purchases made on or after October 15, 2009, qualify for a FREE upgrade to ReSharper 5.0

Migrating Source -- Switching Unit Testing Framework

2009-07-08T12:07:00.003+04:00

I noticed several people are migrating their source code base from NUnit to MSTest and vice versa. I thought I could share a useful technique to automate this process with ReSharper, and it appears to be large enough topic to not fit my my twitter feed. Obviously, it applies not just to Unit Testing Framework switching, but to almost any library migrations.

If I were faced with the task to migrate NUnit to MSTest I wouldn't use search-and-replace, but instead migrate it via temporary stubs. It would require me do several pretty easy steps:

Remove references to nuint.framework.dll. I will get lots of red code, but we'll fix it in a minute.

Add nunit.framework.dll source code to solution (if permitted by license), or write stubs for what I use, like TestFixture, Test, Setup and TearDown attributes and assertion classes. When I'm done with that, all code should be green again, which you can instantly verify with Solution Wide Analysis.

Move all those types to MSTest namespaces.

Rename types to match MSTest types.

For assertions, implement missing members using existing API and use Inline Method refactoring to get rid of them.

Remove stubs and add references to MSTest assemblies.

Enjoy MSTest runner in ReSharper 4.5 to run your beloved tests.

Using this technique, or variation of it, you can easily migrate your source code to different API, library or technology, even if you don't have source code for it.

Develop with pleasure!

ReSharper 4.5 Released

2009-04-08T16:18:00.005+04:00

We just released ReSharper 4.5, minor version aimed at performance, stability, compatibility and less memory usage. All the same great features plus some nice additions, free for owners of ReSharper 4.x licenses. You can read more about what we were doing to improve quality of our product for your pleasure.

Download ReSharper 4.5 and enjoy your productivity boost!

From now on, we are going to focus on ReSharper 5 with the main goal to support Visual Studio 2010 and C# 4. But that is not the whole story about next major version! I will be blogging about ReSharper 5 cool new features during our way to the next release.

Develop with pleasure!

Mortal Kode -- Quite Simple Generics

2009-04-06T12:48:00.018+04:00

It is very important for a tool to understand correctly what is written in the code. You just can't underestimate the importance of this ability. If the code is not correctly parsed, resolved, analyzed and understood by the tool's core, any other feature of the tool can easily fail. Nobody wants Rename refactoring to miss changes, code completion to insert unavailable symbols and code navigation to put the caret in a wrong position. Actually, the most annoying thing would be wrong code analysis, when code is incorrectly flagged with error, when in fact it compiles just fine. This all can easily happen if underlying code model is wrong.

That's why here at JetBrains, we put a lot of effort into our code model, language understanding and work hard to handle even most complex cases -- after all, they can easily be found in real applications.

Today we will look at complexity of code involving generics in C#. Consider the following example (thanks to Vladimir for this one):

  abstract class A<T>

    public abstract void Foo(T x);

    public abstract class B<S> : A<B<S>>

      public class C<U> : B<C<U>>

I think not too many people out there can easily say what would be the correct signature for the implementation of method Foo in the nested class C<U>. As for me, I can't. Doing it manually is simply too much.

First, we try Visual Studio "override" helper and we get the following:

  public override void Foo(A<B<S>>.B<C<U>> x)

    throw new NotImplementedException();

Complex enough, and not quite correct:

error CS0115: 'A<T>.B<S>.C<U>.Foo(A<A<A<A<T>.B<S>>.B<A<T>.B<S>.C<U>>>.B<S>>.B<A<A<T>.B<S>>.B<A<T>.B<S>.C<U>>.C<U>>)': no suitable method found to override 
error CS0534: 'A<T>.B<S>.C<U>' does not implement inherited abstract member 'A<A<A<T>.B<S>>.B<A<T>.B<S>.C<U>>>.Foo(A<A<T>.B<S>>.B<A<T>.B<S>.C<U>>)'

Let's see what ReSharper 4.5 inserts when developer uses "Implement missing members" action from the "Generate" menu:

  public override void Foo(A<A<T>.B<S>>.B<A<T>.B<S>.C<U>> x)

You can see that parameter type is exactly the same as expected by compiler. Needless to say the signature is correct, and you don't have to compile it first.

Does your tool understand non-trivial code?

Next time, we'll take a look at some lambda fun.

ReSharper 4.5 -- From Beta to Release

2009-03-20T10:50:00.005+03:00

It's been a while since we released ReSharper 4.5 Beta and it went pretty cool. Those who like fresh bits posted some feedback about Beta already, and they like it!

Of course, Beta is not Release and it has its own problems, which we are working on all days long. Nightly Builds are published and quality constantly improves. You can see community-based build rating improving from "Works" to "Stable", and we aim at five stars "No problems at all" for final version!

There is only one issue with achieving best quality for everyone:

Every combination of
project, environment and developer
is unique

We thoroughly test lots of cases: various packages and extensions installed into Visual Studio, operating system versions, types and sizes of projects, configurations of the environment. But there are thousands other unique combinations of those things, and of course your unique way of working with code.

In our course from ReSharper 4.5 beta to release, we welcome you to participate in the process of making ReSharper best productivity tool for you. Please, do not hide in shadows waiting for release. Tell us anything and everything you feel wrong about latests builds. Don't wait for someone else to report the problem, it can very well happen there is no someone else. Write in comments, post to Twitter, submit requests to our issue tracker, or send email to support at JetBrains. We are in hunger for your feedback! And we promise to do our best to improve your experience with ReSharper.

Thank you for your participation in the Early Access Program!

PS: Try Scott's Nightly Builds Updater, it will help you run the most recent bits of ReSharper.

ReSharper 4.5 -- What Were We Doing?

2009-03-12T18:00:00.013+03:00

Recently we looked at ReSharper's past. You probably noticed that we often have x.5 releases, aimed at performance and stabilization. After the big marathon run for C# 3.0 and VS2008, we finally got some time to perform housekeeping, clean out and sweeping tasks. Not just for beautiful code, but for improvements in speed and memory that require architecture changes.

Since ReSharper 4.1 release in September, we spent lots of time with dotTrace, running hundreds of use cases and analyzing results. We identified several major bottlenecks that hindered performance, and hundreds of smaller problems. We also analyzed managed and unmanaged memory usage in many types of solutions of different sizes. For many issues, small changes here and there just weren’t enough. We had to change data structures, algorithms, dependencies, ownership of objects, and sometimes even basic principles of our code.

Tough decision, but we decided that performance, memory usage and building a foundation for further improvements were of a higher priority than API compatibility. Without that massive code cleanup we would have been spending more and more resources to make our product better for you, and without much success. Please accept our apologies, plug-in developers! We really had to do that to gain 30% speed improvement overall, up to 60% in many cases if you use multicore processor. We‘re hoping to extend parallel processing capabilities in ReSharper 5 and improve speed even more, but we had to lay a foundation for this.

Another big part of our work was dedicated to Visual Studio integration. It is too early to speak about Visual Studio 2010 integration at the moment, but even earlier versions required substantial efforts. We improved integration with various packages, provided fixes or workarounds for a good deal of problems. We spent lots of time doing low level debugging in mixed (managed/unmanaged) environment and I must admit -- it was fun but also very hard. Microsoft Development Tools Division did a great job helping us solve issues and answering our questions (which were far from being trivial, as you might guess). In fact, during the past year we got much more assistance from Microsoft than ever! Thank you guys, I hope you don't have my picture attached to your dartboards :)

Developing new features and improving existing ones was the last, but not the least piece of our work. We reworked ReSharper naming system and, finally, you can configure a style for virtually any identifier . We added more functionality to Solution Wide Analysis -- it is now able to highlight globally unused symbols for you, redundant virtual keyword, parameters that are not used in any overrides, and much more. My favorite global inspection detects potential problems in cross-casts, like when you cast a variable of type IFoo to IBar, but there is no class in solution that implements both interfaces! New Go to Implementation feature allows you to jump straight to the code that might run, skipping all interfaces and abstract classes. Find Referenced Code can now run on any selection in Solution Explorer, quickly showing you dependencies of a particular part of your solution. MSTest is now built into ReSharper, Visual Basic .NET support has been greatly improved, and many reworked refactorings are now particularly rock solid.

These days we are preparing to publish ReSharper 4.5 Beta. As more and more people download ReSharper 4.5 nightly builds, we get invaluable feedback to make this release really shiny. It is currently very stable, with several known glitches that we are fixing. Each new build is better than previous ones.

Don’t hesitate to download it, try it yourself and tell us how it works for you!
We mean it: we really, really need to know how it behaves in your unique environment with your unique solution, and it’s only you who can let us know about it!

ReSharper 4.5 -- Looking in the Past

2009-03-12T13:37:00.008+03:00

I didn't post anything for 4 months and I want to fix that. Where is my light bulb I wonder? Not that I had nothing to say, more like I was wearing developer's hat. Anyway, I thought I could explain what's been going on and what we've been doing for the upcoming release, ReSharper 4.5.

But before I start talking about the new release, I'd like to look back at ReSharper history.

2004, July: ReSharper 1.0
First release of JetBrains ReSharper, productivity add-in for Visual Studio 2003 and C# 1.1. Code analysis, quick fixes and context actions, refactorings and templates, all in JetBrains' intelligent style.


   System.Console.Out.WriteLine("Hello .NET world");

2005, March: ReSharper 1.5
Added 8 new refactorings. Performance was significantly improved.

2006, May: ReSharper 2.0
With this new release, ReSharper makes a step up from a simple add-in to a real development environment. Support for Visual Studio 2005 and C# 2.0, more refactorings, ASP.NET support, Unit Testing, build script support, additional navigation commands and more.

2006, December: ReSharper 2.5
Focus on the performance improvements and usability to improve developers' experience. Of course we couldn't resist a few new features as well: null-reference analysis, Navigate from Here and Go to File Member.

2007, June: ReSharper 3.0
Major feature-loaded release, bringing many productivity enhancements to the table. Many of them are now perceived as if they've been there forever. Go to Symbol, find referenced and dependent code, automatic member reordering, rearranging statements and members, to-do browser. Code analysis got suggestions, VB got many of the features previously available only for C#, and XAML made it to the list of supported technologies.

2008, June: ReSharper 4.0
This release introduced support for Visual Studio 2008 and C# 3.0 with vars, extension methods, lambdas, LINQ, object & collection initializers, anonymous types, and partial methods. This alone would be sufficient for a new major release. However, we did more: Solution-Wide Analysis, Code Cleanup, Complete Statement, more refactorings, improved IntelliSense, recent edits and other tools to simplify everyday development tasks.

That is how ReSharper have been evolving in the past. What's next?

2009, March-April: ReSharper 4.5

To be continued...

Microsoft Tech·Ed EMEA 2008 / Developers

2008-11-07T16:57:00.004+03:00

We'll be there, at Microsoft Tech·Ed EMEA 2008 Developers, Barcelona, booth E3. If you are going to be there come visit us and let's talk! Whether you like to learn about ReSharper or TeamCity or dotTrace, grab some tips and tricks, learn what we are going to do in future versions, or just talk about how wonderful the world is - you're welcome at our booth. See you!

Wild World of Visual Studio -- Proxies confront Hooks

2008-11-01T15:00:00.000+03:00

How can Internet Explorer settings interfere with productivity add-in to Visual Studio, such as ReSharper? And even lead to Visual Studio crash when doing some seemingly unrelated operations, like checking out source code from Team Foundation Server?

Story 3 -- Proxies confront Hooks

We've got a number of reports about Visual Studio crash when doing repository operations using TFS. Of course, when ReSharper is disabled, no crashes occurs, which make users think ReSharper is guilty. We couldn't reproduce the problem in the labs, and we again tried to assert/log/verify everything we can think about. We even got some dumps with the crash, but could not find anything really useful there, besides evidence that there are numerous SecurityExceptions instances in the managed heap waiting to be collected. We needed reproducible case with WinDbg attached. Thanks to Vasily, we got one.

It is funny how we were debugging this crash. Since we were not able to reproduce the problem in the labs, we needed access to the faulty computer. However, due to corporate rules on the user's side, we were not able to arrange real remote session. But we had WinDbg with command line interface, and we had instant messaging. So I was sending WinDbg commands, he copied them into WinDbg, executed, and then copied back the result. We laughed about it and were kidding about extension to WinDbg which would be Jabber client :)

After several days being in this copy-paste process, we finally found the problem. Three components playing together made it explosive:

Connecting to web site with HTTP when automatic proxy configuration script is enabled (It is basically JScript function which gives proxy address for given host)
Managed hooks installed (here is ReSharper's role in the problem, but could be any other plugin)
Pumping messages during JScript code execution

Remove one, and all is fine again. So, what is happening in our case? Now, watch my hands.

TeamFoundation client is going to communicate to server.
It initiates connection to web service.
HttpWebRequest is asking for proxy information.
WebProxy detects that automatic proxy configuration script is enabled.
AutoWebProxyScriptEngine downloads script and uses JScript engine to execute it
JScript engine restricts code permissions to execute only.
Exception happens while executing JScript and dialog is going to be shown with error information. This is who pumps messages.
Our managed hook is executed and attempts to use CallNextHookEx to pass data to other hooks.
Code Access Security system demands UnmanagedCode permission.
Due to restricted mode in which JScript executes, demand fails and SecurityException is rised.
Exception causes corruption of some internal Visual Studio COM objects, which instantly leads to Access Violation.

Well, actually, this one was our fault. I added SecurityPermissionAttribute asserting UnmanagedCode permission to the hook procedure and ReSharper is shining like a diamond again.

Case closed, lessons learned.

Wild World of Visual Studio -- Mysterious Component

2008-10-31T09:00:00.000+03:00

This one was bugging us for a long time, until we got message from Jay (thanks!) who had similar problem and was willing to help.

Story 2 -- Mysterious Component

The problem itself is mysterious. From time to time it happens that Visual Studio stops loading any add-ins. ReSharper is installed, but its menus are suddenly all gray and it is not listed in the "Tools \ Add-in manager" dialog. It happens after installing various products, it could be service pack, SQL server tools, Visual Studio components - anything! Some users install them and all works fine. Some users loose their favorite productivity tool.

Logging, debugging, trying to reproduce for may be several years(!) led to no result. ReSharper was simply not loaded into the process, though all registration information appears to be in the right place. We checked encodings, verified files are not corrupted, verified registry access rights - all we can think of. As you can guess now, the reason was not anywhere near.

After lots of email exchanges with Jay, including mini-dumps, Process Monitor traces, registry excerpts, configuration files and such we suddenly found ourselves staring at the right thing. It was msxml6.dll. Actually, it was the fact that there were no msxml6.dll in the call stack. Instead, there was msxml3.dll.

We use .addin files to register our add-in in Visual Studio. It is XML file describing add-in, containing information about primary assembly, descriptions, load options and Visual Studio version compatibility information. The latter was that msxml3 was not able to process and thus Visual Studio refused add-in as non-compatible. In fact, msxml6 was there in System32, but it somehow happened to be not registered as COM object. Using regsvr32 on msxml6.dll repaired the system, resurrected ReSharper and enabled customers to enjoy our productivity add-in again.

Case closed.

Wild World of Visual Studio -- Unfriendly Package

2008-10-30T13:52:00.015+03:00

While developing "The Most Intelligent Add-In To Visual Studio" we often face issues that originates from the outside of our code. Being that Visual Studio itself, other packages and add-ins installed, OS components or other things added to the mix - it is always extremely hard to reproduce, debug and understand. Usually we have to perform post-mortem debugging, when all we have is mini-dump from the user experiencing the crash. And we are very happy when we have mini-dump! Often we have to resort to psychic debugging, speculating about what could have happened, trying this and that until we find the cause and issue the fix.

I though I could share some stories of pure insanity we happened to participate in recently. May be another add-in developer is scratching his head in an attempt to understand the source of strange sounds from beneath the ground, and these stories will help. Or it may be just interesting reading for you. Or not :)

The first one is the most recent one and is pretty simple.

Story 1 -- Unfriendly Package

Our customers were complaining about Visual Studio crashing on start with ReSharper installed when running non-admin. Disabling ReSharper allows Visual Studio to load normally. When you see such behavior, you are absolutely sure ReSharper is guilty, aren't you?

We've learned to be cautious in such cases. So I asked user (thanks Jon!) to capture mini-dump and send it to me for investigation. While downloading it, I was preparing myself to long hours of WinDbg magic, but !ClrStack revealed it in a second. SnippetDesigner was not able to access its files, since it placed it in privileged folder. It did so in the background thread and didn't catch exceptions. The result is CLR termination, which get Visual Studio to nowhere with itself.

But wait! Why disabling ReSharper helped to avoid crash? Well, actually crash happens during SnippetDesigner package loading. Normally, it occurs when its window is opened (and it indeed crashes VS at this point without ReSharper). However, ReSharper uses Visual Studio API to get some configuration information, which can be extended with packages. So, by calling this API ReSharper caused those packages to load, essentially triggering the bug in SnippetDesigner on startup.

Case closed, opened another one.

ReSharper Combos - Hiding Details

2008-10-06T15:59:00.007+04:00

Today my day started with the question from Oleg Stepanov, Project Manager of ReSharper. He asked about avoiding huge amount of manual code changes, and after short discussion we got it done with ReSharper. I was very excited! We were able to solve refactoring task in seconds, invent new refactoring combo, and ReSharper was so smart to handle it absolutely right. No manual code changes outside of the type being refactored. Here is simplified version of what we had, what we were to accomplish and how we did it.

  public class Person

    public string Name { get; set; }

    public int Age { get; set; }

  public class PersonInformation

    private readonly Person myPerson;

    public PersonInformation(Person person)

      myPerson = person;

    public Person Person

      get { return myPerson; }

  internal class Processor

    private readonly PersonInformation myPersonInformation;

    public Processor(PersonInformation personInformation)

      myPersonInformation = personInformation;

    public int Process()

      switch (myPersonInformation.Person.Name)

        case "Mike":

          return 1;

        case "Sally":

          return myPersonInformation.Person.Age > 30 ? 2 : 3;

      return myPersonInformation.Person.Age < 20 ? 0 : 1;

Consider PersonInformation class above. We wanted to decouple it from Person class and make it store Name and Age itself. However, we had a lot of usages like in Processor.Process, where Person property was being used to access Name and Age. How would we do it?

First, we use Generate (Alt-Ins) and select Delegating Members to generate Name and Age properties in PersonInformation class:

    public string Name

      get { return myPerson.Name; }

      set { myPerson.Name = value; }

    public int Age

      get { return myPerson.Age; }

      set { myPerson.Age = value; }

Then we change Person Property to return PersonInformation instead. Since there are all required properties already, usages are not broken. They are now routed through delegating members and use Name and Age properties of PersonInformation:

    public PersonInformation Person

      get { return this; }

And here magic happens, we use Inline Property refactoring to get rid of the property!

  public class Person

    public string Name { get; set; }

    public int Age { get; set; }

  public class PersonInformation

    private readonly Person myPerson;

    public PersonInformation(Person person)

      myPerson = person;

    public string Name

      get { return myPerson.Name; }

      set { myPerson.Name = value; }

    public int Age

      get { return myPerson.Age; }

      set { myPerson.Age = value; }

  internal class Processor

    private readonly PersonInformation myPersonInformation;

    public Processor(PersonInformation personInformation)

      myPersonInformation = personInformation;

    public int Process()

      switch (myPersonInformation.Name)

        case "Mike":

          return 1;

        case "Sally":

          return myPersonInformation.Age > 30 ? 2 : 3;

      return myPersonInformation.Age < 20 ? 0 : 1;

Look how Processor now uses Name and Age directly on PersonInformation class and has no idea about Person class used inside! Now the fact that PersonInformation uses Person is implementation detail and we can change it any way we like.

Refactor With Pleasure!

ReSharper Guidelines -- First Time Users

2008-10-03T10:55:00.011+04:00

Harry L. wrote in review of ReSharper on Visual Studio Gallery:

... I have found that I used the features of Resharper almost without knowing it. What amazed me was how many features I use without going up a long learning curve...

Indeed, most important ReSharper features can be instantly learned right from the code editor without reading any documentation. However, I thought that having some guidelines about where to look and how to improve own productivity would be nice anyway. So I'm going to write several posts about how to use ReSharper in a form of guidelines.

Shortcuts are given for Visual Studio keyboard scheme, but you can easily find shortcuts for your configuration in ReSharper menu.

First Time Users guidelines:

DO open your real project in Visual Studio with ReSharper enabled. Playing with the productivity tool in a sandbox doesn't really give you understanding about its effect. It can take some time for ReSharper to analyze your solution for the first time, but it will be much faster during subsequent runs.
DO NOT run away from your Visual Studio when you first open your source code with ReSharper :) You will see colored identifiers, a lot of squiggles indicating warnings and suggestions, redundant code painted in gray -- your code most likely will be overhighlighted. You will clean it up pretty fast with ReSharper. You can switch Color Identifiers off if you wish (ReSharper / Options / Code Inspection / Settings).
DO configure your naming (ReSharper / Options / Languages / Common / Naming Style) and formatting preferences (ReSharper / Options / Languages / C# / Formatting Style). ReSharper uses these settings when guessing on identifiers, while updating the code and doing other automatic code generation and transformation for you.
DO learn 4 keyboard shortcuts to use in code editor:
- Alt-Enter - opens code transformation menu with Quick Fixes and Context Actions. Try it whenever you see light bulb to the left of your code, and see what you can do with it.
- Alt-` (Navigate from Here) to open menu with actions to navigate from currently selected symbol, like "Go to base", "Go to derived" and "Go to usages"
- Alt-Ins (Generate) -- generates type members, like properties, constructors, overrides and implementations, Equals, GetHashCode and ToString methods.
- Ctrl-Shift-R (Refactor This) -- opens menu with all refactorings available at current caret position (or current selection in any ReSharper tool window).
DO NOT use Solution Explorer to find code, use "Go to Type" (Ctrl-T), "Go to File" (Ctrl-Shift-T), "Recent Files" (Ctrl-,) and other commands from ReSharper / Go To menu. This will help you navigate much faster.

After you familiarize yourself with these basic actions, download and print key map and start exploring other commands.

ReSharper Combos -- Refactoring To Components

2008-08-13T17:56:00.000+04:00

ReSharper has a number of features which are powerful by themselves, but reveal even more coolness when combined with other features. It's like Kung-Fu, when master can outperform enemies by wisely combining basic movements and strikes.

Let's take for example a task of converting existing system, where all types are instantiated explicitly, to some component container system. Without ReSharper, this task is SCARY! Just imagine, going through hundreds or even thousands of files, checking where particular component is used, where instance is created and how passed to clients and manually updating all that code. Days or weeks to complete? No, we aren't going to do this...

With ReSharper the task is still not simple one, but it can be achieved in a reasonable amount of time. Here is simple example:

  public class TheManager

    public void Manage(string text) {  }

  public class TheProcessor

    private readonly TheManager myManager;

    public TheProcessor(TheManager manager)

      myManager = manager;

    public void Process(IEnumerable<string> texts)

      foreach (var text in texts)

        myManager.Manage(text);

  internal class Program

    public static void Main(string[] args)

      var processor = new TheProcessor(new TheManager());

      processor.Process(args);

Now let's make it utilize some fictional ComponentContainer:

1. Create temporary static class ComponentFactory to put factory methods in
2. Execute Replace constructor with factory method refactoring against component constructor, specify ComponentFactory as containing type.
3. Use Extract Interface refactoring from the component implementation.
4. Utilize Use base type where possible refactoring, select extracted interface. This should update all usages from specific class to interface.
5. Find Usages of component and verify you don't have any references to the class except instantiation inside ComponentFactory. Having other references mean interface was not complete, or there are dependencies on component implementation. Refactor as needed.

Now you should have something like this:

  public static class ComponentFactory

    public static ITheManager CreateTheManager()

      return new TheManager();

  public interface ITheManager

    void Manage(string text);

  public class TheManager : ITheManager

    public void Manage(string text) { }

  public class TheProcessor

    private readonly ITheManager myManager;

    public TheProcessor(ITheManager manager)

      myManager = manager;

    public void Process(IEnumerable<string> texts)

      foreach (var text in texts)

        myManager.Manage(text);

  internal class Program

    public static void Main(string[] args)

      var processor = new TheProcessor(ComponentFactory.CreateTheManager());

      processor.Process(args);

Note, how TheProcessor now uses ITheManager interface instead of specific implementation.

What you do next depends on what framework for components you are going to use. If you plan to use one of the Dependency Injection frameworks out there, you will continue with other components (TheProcessor in our example) and let framework inject ITheManager dependency into constructor. If you are going to use component querying system, you will update component constructor to use factory method instead of parameters, and use Safe Delete on parameters to remove them and update usages.

After you finish with refactoring all component access to ComponentFactory static class, you can change the implementation of factory methods to query your component framework of choice.

Finally, you are ready for the last strike to finish it off: use Inline Method refactoring to get rid of temporary factory methods and finish conversion of your code.

What's Next? -- Life After Release

2008-07-29T20:34:00.007+04:00

We released ReSharper 4 in June and I didn't post since then. First, I was on vacation and it was great. Then, our team left the city to spend 4 full days discussing ReSharper future, inventing new features, building plans and coordinating efforts. Awesome experience, I must say. After that, we focused on preparing maintenance release 4.0.1 which will be out as soon as we verify it against recently released Visual Studio 2008 SP1. Now we are starting to work towards 4.5 release, which is tentatively planned to be released by the end of the year, or may be at the beginning of year 2009. So, what are we going to do?

Please note, that it is preliminary plan only and is subject to change at any time.

1. More performance
2. Less memory usage

Yes, we are going to spend about four months tackling performance and memory issues, optimizing various parts of our product and improving architecture to prepare for the next major step forward.

In addition to the overall product quality improvement, we are going to improve some existing features, based on your feedback, and add some new.

3. New refactorings are being developed, which will allow you to perform more intelligent solution-wide code transformation. We didn't finalize the list yet, but most likely they will be from "Inline" family.

4. Enhanced setup for naming conventions which will be supported by all ReSharper features. We are not going to implement all functionality of the AgentSmith plugin, but we want to stop naming issues experienced by some of ReSharper users once and for all.

5. Visual Build - new feature to display build process inside Visual Studio in a better way. Think "Unit Test Session" style, but for building your solution. This feature will also lay the foundation for future features, like optimizing build procedure.

6. Visual Basic 9 support. Our cross-language refactorings and editing experience enhancements will fully support VB9 constructs, like anonymous functions and XML literals.

As usual, once we perform all potentially dangerous changes to our code base and stabilize the build, we will start publishing nightly builds for your Early Access Pleasure.

PS: If you didn't express your opinion about ReSharper 4 on Visual Studio Gallery, you can let other people know what do you think via rating and review functionality recently added to this site.

ReSharper 4.0 Gone Diamond

2008-06-09T20:18:00.006+04:00

Here it is, ReSharper 4.0. After faceting our diamond, we are finally ready to release it!

In this new release, C# 3.0 is supported in all its power -- lambdas, extension methods, language integrated queries (aka LINQ), object and collection initializers, anonymous types, automatic properties and partial methods. Ah, of course implicitly typed locals ("vars") are there to argue for or against using them. I already wrote about some of the features, and you can find more information on the New Features page. Here is small final touch about how deeeeep we dived into the language: try introducing parameter from expression which uses local variables and play with checkboxes for local variables.

Except for new language support, we also improved our product in many other ways:

We added new powerful refactorings and greatly improved existing.

We extended typing helpers with CamelCase completion and Complete Statement. Now you can achieve more in less time.

We analysed many .NET Framework assemblies for you, and maked them up for you with CanBeNull/NotNull attributes. And ReSharper's value analysis raised to the next level.

We tested it with numerious other addons, plugins, SDKs and packages. And improved ReSharper's integration into Visual Studio ecosystem by a wonderful degree.

Of course we fixed a lot of problems and eliminated many performance bottlenecks.

I can't really enumerate all the improvements in ReSharper 4.0 made during last year. It would take too much space on this blog. Try it yourself! Feel the difference!

develop.With(pleasure => pleasure * 4.0);

ReSharper 4.0 Release Candidate

2008-06-03T16:32:00.003+04:00

After extensive testing and fixing problems in Beta we are ready to publish Release Candidate build. Some critical fixes can still happen in this branch, but otherwise we are almost ready to release.

If you are using any nightly build or beta, please upgrade to Release Candidate. If by chance you find a problem that prevents ReSharper 4 from being used on a regular basis, please tell us! You can submit request into our issue tracking system, and we will try hard to fix any critical problem, if we can reproduce it. So please, please, please, include as much information about your environment, projects and source files as you can.

Thank you very much for participating in our Early Access Program!

Functional Style -- Highlight Mutable Variables

2008-05-26T22:01:00.003+04:00

Once you go for lambdas, lazy computations and other functional techniques in programming, you may want your code to be mostly immutable. With ReSharper 4 we didn't do much about data analysis, like do not detect immutable objects or methods. However, one analysis is already available to you: highlight mutable local variables. Open Tools menu, select Options, browse for Fonts and Colors under Environment group. In the Display items find ReSharper Mutable Local Variable and change the appearance as you like. I use Bold font. ReSharper will now highlight every variable that changes its value after the value has been already used.

Try it, and tell us what do you think!

ReSharper 4 Beta

2008-05-21T16:34:00.010+04:00

Did you use one of the nightly builds we publish for several months already? If you thought it is dangerous for you to run early development bits, today we present you ReSharper 4 Beta, which we optimized, stabilized and verified to be of better quality than ordinary nightlies. It is not complete product yet, we have some more work to do in various areas of product, but otherwise this build is pretty stable and usable.

C# 3.0
This major language update was not an easy thing to support. It was tough to make it right, when tool knows the code inside out and understands every detail of what is written. There are many little things that you probably will not even notice, but which were well thought out and implemented to provide flawless code editing, navigating and refactoring experience.

I'd like to highlight some features: global completion for extension methods, which inserts required namespace imports; optional parameter info in form of lambda, like "IEnumerable<string> => string" instead of Func<IEnumerable<string>,string>; refactorings specific to new language features, like creating named type from anonymous one or converting static method to extension method and updating usages.

.NET Framework Annotations
Since version 2.5 we have "Null Reference Analysis", which is capable to warn developer about potential NullReferenceException in the code. To aid this analysis, developers can annotate methods with NotNull or CanBeNull attributes, which ReSharper then uses to initialize variable states. That's cool enough by itself, but there are thousands of methods you can't annotate in source: the .NET Framework assemblies. We took up a challenge and implemented the way to annotate libraries with external annotations. And we made second step, too. We annotated most of .NET Framework (56 assemblies!), so that you can get potential NullReferenceException warning on the code like (SomeStruct)Marshal.PtrToStructure(...);

Completion-on-steroids
That's something I like most. No, wait, I love new refactorings, recent edits window, to-do browser understanding of NotImplementedException, and all other features mentioned on the official site.

Two things: "CamelHumps Completion" and "Complete Statement" bring my coding speed to a new level. I don't know what it would be called in Jedi hierarchy, but it seems to me that I can create code with ~~lightning~~ teleportation speed.

if(CVM.I.SV(SCV.FU <Ctrl-Shift-Enter>

When I hit keys like above, it is completed into:

if (CodeViewManager.Instance.SupportsView(StandardCodeViews.FindUsages))
{
}

And caret is inside braces for me to type in the body of the "if" statement.

ASP.NET speed-up
The last, but not least thing I'd like to mention is our raid against ASP.NET problems. It is something that had speed and memory problems through all versions of ReSharper, and we finally managed to identify them, and fix. Now, if you develop ASP.NET web sites, go try ReSharper 4 Beta.

Download
In this release we bring you the single installer for both Visual Studio 2005 and 2008, as well as all editions we have. Download, install, select "Free Evaluation", choose edition - and you are ready to be productive.

Extending the Extension -- ReSharper Plug-Ins

2008-04-08T13:53:00.004+04:00

ReSharper, the ultimate productivity tool for Visual Studio, is not just pre-packaged set of features. ReSharper provides rich platform for intelligent extensions, which can read and modify code and provide even more productivity features to you. I thought I would compile list of known public plugins.

ReSharper PowerToys - cyclomatic complexity analysis, explore type interface, find text, generate ToString, csUnit support. Open Source.

RGreatEx - resource refactoring and string manipulation. Commercial.

MbUnit - support for MbUnit tests in ReSharper Unit Testing subsystem. Open Source

xUnit - support for xUnit tests in ReSharper Unit Testing subsystem. Open Source

NSpecify - support for NSpecify in ReSharper Unit Testing subsystem. Open Source

Agent Smith - naming convention validation, spell checking, xml-comments validation, smart paste. Open Source

Agent Johnson - documents exceptions, batch-annotate with NotNull/CanBeNull, favorite files. Open Source

ARP - log4net and NHibernate support. Open Source

Stefan Lieser’s NHibernate plugin - NHibernate support. Free

Scout - navigate to .NET Framework Reference Source. Open Source

If you know any other public plugins to ReSharper, let us know!

We Read You, Anonymous

2008-04-02T16:06:00.002+04:00

9 minutes ago I've received the following from anonymous user of our uninstall feedback form:

I am uninstalling ReSharper because my licencse is only for C# :)
Reinstall is waiting for me, so i can't lose my time typing some unuseful text that won't be read anyway.

Have a good time, JetBrains Server!

Thank you, Anonymous, I will pass this to our administrators so they can decide which server to route information to :)

MbUnit for ReSharper 4

2008-03-24T16:26:00.003+03:00

Albert Weinert ported MbUnit plugin to ReSharper 4 API, so you can try it with latest ReSharper 4 nightly builds. Read more and download Beta 7.

Varification -- Using Implicitly Typed Locals

2008-03-04T12:58:00.009+03:00

With the ReSharper 4 nightly builds available, some people are complaining about numerious suggestions to convert explicit type to "var" keyword. Of course, you can hide this suggestion by using Options / Code Inspection / Inspection Severity, or by using Alt-Enter and selecting "Change severity" option. But what's the deal with implicitly typed locals, anyway? Using var keyword can significantly improve your code, not just save you some typing. However, it may require discipline to apply good practices when using implicitly typed variables. Here is my list:

It is required to express variables of anonymous type. This is pretty obvious - you cannot declare local variable of anonymous type without using var.

It induces better naming for local variables. When you read local variable declaration with explicit type, you have more information at that moment and something like "IUnitTestElement current" makes sense. However, when this local variable is used later, you read "current" which takes some time to figure out the meaning. Using "var currentElement" makes it easier to read at any place.

It induces better API. When you let compiler deduce type from method return type or property type, you have to have good types in the first place. When you don't have explicit type in the initialization expression, you have to have best names for members.

It induces variable initialization. It is generally a good practice to initialize variable in the declaration, and compiler needs initializer to infer type for local variable declared with "var" keyword.

It removes code noise. There are a lot of cases, when implicitly typed local will reduce amount of text developer needs to read, or rather skip. Declaring local variable from new object expression or cast expression requires specifying type twice, if we don't use "var". With generics it can lead to a lot of otherwise redundant code. Another example would be iteration variable in foreach over Dictionary<TKey,TValue>.

It doesn't require using directive. With var, you don't have explicit reference to type, as compiler infers type for you, so you don't need to import namespace when you need a temporary variable.

To summarize the list above, by actively using var keyword and refactoring your code as needed you improve the way your code speaks for itself.

PS: Visit ReSharper at Visual Studio Gallery!

Visual Studio 2005 and ReSharper 4 Nightly Builds

2008-02-20T21:00:00.002+03:00

ReSharper 4 should work with Visual Studio 2005, and it will support C# 2.0 language features. If you happen to participate in our early access program, and you are using Visual Studio 2005, please note that you have to have .NET Framework 3.5 installed.

Also, we would be happy if you were reporting any features that belong to C# 3.0 but appear in Visual Studio 2005, like suggestions for lambdas or var. Please read information about our issue tracker beforehand.

Thank you.

Better Development Tools -- Building Together

2008-02-18T18:49:00.004+03:00

Dear early adopters!

We thank you kindly for your participation in ReSharper 4 early access program. It is going to be wonderful release for everyone, because of you. This time we receive the best response ever, and we are so excited about it!

Many brave developers, who are trying ReSharper 4 early builds with Visual Studio 2008, registered in our issue tracker and provided us with detailed, specific and very important information. This is really great, because we were able to reproduce many issues that were lurking around our code base for some time now. It is very important that you registered and provide us with non-anonymous feedback: bidirectional communication is at least 16 times more effective than one way exception submitting. One sample solution which manifests the problem is 256 times better than 1024 exceptions without a comment. And it is invaluable when you submit instructions to reproduce the problem (well, at least var value = int.MaxValue).

Thank you very much, we really appreciate your effort! With that kind of feedback we receive today, I believe we can build the best release of ReSharper, ever. Everybody wants better tools, right? ;)

Sincerely Yours, Ilya.

ReSharper 4 Nightly Builds - Are You Geek Enough?

2008-02-14T14:52:00.009+03:00

-- When ReSharper 4 will be ready?
-- It is ready when it is ready!

We in ReSharper team want to make sure that C# 3.0 language is fully supported by the product. We spend a lot of time on features and look deep into details of every language quirk. You know, compilers and language standards may have very strange relationships, sometimes very weird. Still, we want to ensure maximum pleasure developing in C# 3.0 when ReSharper is ready. And it is not ready yet.

However, due to the popular demand amongst professional developers using ReSharper and C# 3.0, we are going to open nightly builds to the public. That is, not fully fledged tool, but rather our current development bits. Which could be very well broken, buggy, hanging, slow and useless at times. We will not take any responsibility if the tool wipes out all your source code! But you have a version control system in place, don't you?

So, are you geek enough to take the pill and try ReSharper 4 early builds? Read the ReSharper 4 EAP notes before you decide!

If you feel you can survive pre-release build, you can go to ReSharper 4 Nightly Builds and download your copy of ReSharper development bits.

Good luck!

Compiler Optimizations May Be Dangerous

2008-02-04T21:25:00.001+03:00

Consider the following code:


static class Test
{
  public static IEnumerable<int> Select<T>(this IEnumerable<T> list, Func<int, int> f)
  {
    foreach (var item in list)
      yield return f(item.GetHashCode());
  }

  public static IEnumerable<bool> Where<T>(this IEnumerable<T> list, Func<int, bool> f)
  {
    foreach (var item in list)
      yield return f(item.GetHashCode());
  }

  static void Foo(IList<string> list, IList<string> list2)
  {
    var lengths = from hashCode in list
                   where hashCode * 2 > 10
                   select hashCode;
  }
}

This code doesn't use System.Linq extensions methods to do LINQ, and instead declares own Select and Where methods, which are rather crazy. This code compiles, but what is the type of "lengths" variable? It should be IEnumerable<int>, because that is what Select method returns. But if you look at actual compilation output, it turns out that compiler decided "select hashCode" to be very simple (actually, transforms into identity lambda hashCode => hashCode). And it removes the call to Select() method. And breaks my code. One can have some hard time understanding why their code doesn't work, or even doesn't compile.

I can force compiler to call my Select() method by surrounding hashCode in select clause with parenthesis:


    var lengths = from hashCode in list
                   where hashCode * 2 > 10
                   select (hashCode);

It is not trivial to compiler anymore, and thus it emits correct code.

UPDATE: This behaviour is by design. See 7.15.2.5 Select clauses:

A query expression of the form
from x in e select v
is translated into
( e ) . Select ( x => v )
except when v is the identifier x, the translation is simply
( e )

I still find this very error prone...

ReSharper 4 EAP Will Start in Two Weeks

2008-01-31T19:53:00.000+03:00

ReSharper 4 Early Access Program will start within next two weeks, before Feb 15.

The delay is caused mostly by the complexity of lambda implementation, which we really want to do right so that the power of C# 3.0 and ReSharper can be utilized at a full rate. Now, when we have lambdas working, we will finish with LINQ processing, polish the code a bit and start nightly builds.

I'm going to post some feature highlights here during that period. This will cover C# 3.0 new features support, new features like Complete Statement and Recent Edits, improvements in intellisense like CamelHumps completion and other.

Stay tuned.

One Line - Navigation in Parameter Information

2008-01-25T13:19:00.000+03:00

When ReSharper's parameter information is displayed for a method, TAB and SHIFT-TAB will navigate caret through arguments you are passing.

One Line - Find Usages Advanced

2008-01-14T12:58:00.000+03:00

When you want to search for all overloads of a method, or search for type and its members usages, or search in referenced libaries in addition to source code - use Find Usages Advanced command (ReSharper | Search | Find Usages Advanced...).

ReSharper 3.1 is Released!

2007-12-20T23:31:00.000+03:00

We are proud to announce the release of ReSharper 3.1. The new version not only brings many bugfixes, improved stability and new features, but also provides the opportunity of free upgrade to v4.0 for new purchases.

This minor - but extremely upgrade-worthy - release extends support for various technologies and languages including ASP.NET, VB.NET and XAML, and introduces the amazingly powerful Solution-Wide Analysis. The new feature lets you instantly find compilation errors in your whole solution - not just in the currently opened file.

Download it now and review release notes.

One Line - Filtering Popup Lists

2007-12-18T19:47:00.001+03:00

When recent files list is open, you can start typing and list will get filtered to show only items which contains entered text. This feature also works in all "Go to" popup lists, like Go To Usage or Go To Inheritors.

One Line - Moving Code Around

2007-12-17T18:22:00.001+03:00

Holding Ctrl-Alt-Shift and pressing arrow keys moves code around. It can move members up and down, reorder parameters in place, move statement within a block, move statement out of block or into block, and move XML tags around. Note, that it is just textual editing, it doesn't check if such move would be valid or fix any references.

One Line - Naming Style

2007-12-16T15:55:00.000+03:00

If you configure your field naming preferences in options (Options / Languages / Common / Naming Style), ReSharper will derive better names for properties and other entities when generating code.

One Line - Create File From Template

2007-12-12T01:49:00.000+03:00

You can use Alt-Ins in Solution Explorer to create file from one of your File Templates in the current folder.

Feature of ReSharper 3

ReSharper and Visual Studio crash on x64

2007-12-11T16:44:00.001+03:00

For those who experience problems running ReSharper on x64 machines, here is the bug description on Microsoft Connect.

It turns out that this crash is the result of a bug in the Wow64 layer of Windows x64 (XP/2003 – it has been fixed in Vista x64) and only manifests itself when another app globally hooks all Windows messages.
We are currently working with the Windows servicing folks to get a hotfix produced.

Updated 13 Feb:
Deep in the comments to the aforementioned request there is information about how to obtain hotfix:

If you are experiencing this issue you will need to contact Microsoft Customer
Service & Support (http://support.microsoft.com) and ask for the Windows
Hotfix with ID 947841. If you have any difficulty in obtaining the patch
ask the CSS representative to contact me (Sean Laberee).

I am also pleased to announce that we have created a workaround in VS 2008 SP1 which eliminates this problem and the need for the patch. That workaround is queued for checkin to our build process and will be available in the Beta of the service pack.

And also:

A quick update on the windows patch. I've confirmed with our support team that if you call in for this hotfix you will not be charged. They will set up a "Hot Fix" case for you. I've also received a report that there was some confusion as to whether this fix is for Win2003 or XP. I've confirmed that this fix does in fact apply to both releases.

ReSharper Club - Are You In?

2007-11-28T17:44:00.000+03:00

Well, not really a club, but we thought you may wish to have cute ReSharper banner on the side bar of your blog, or project site, or may be print it and put on the wind-screen of your Porsche :) I have one right here, in my blog! Ah, well, I mean banner, not Porsche...

Want it? Go to The Banner Builder page and assemble it as you like. Don't forget to put the result on your website!

ReSharper and Visual Studio 2008

2007-11-22T18:19:00.000+03:00

Since there is a lot of buzz about Visual Studio 2008 release, I thought I would stand and say about ReSharper in relation to this fact.

Released version

ReSharper 3 can be installed with Visual Studio 2008 and works fine, unless you are using C# 3.0 new features, like lambdas, LINQ, extension methods and such. This constructs are not parsed by ReSharper 3, which was developed to support C# 2.0 only. It is not only highlighting which doesn't support C# 3.0, it is all the core and code intelligence. For example, rename refactoring will not find usages of extension methods and will not update them.
There also could be some glitches, even if you don't use new C# 3.0 constructs. This is due to the fact that C# 3.0 compiler is always used in Visual Studio 2008 C# projects, regardless of target framework. It it is not widely discussed, but changes in language are wider than just several new features. There are differences in type inference in generics and candidates lookup for binding, to name few. If you happen to hit this special cases, ReSharper could behave incorrectly.

If you are really-really going to immediately jump C# 3.0 wagon, you can disable highlighting (Options / Code Inspection / Settings) and switch to Visual Studio native intellisense (Options / Environment / IntelliSense / General). This will help a bit, but still you cannot trust find usages results, refactorings and many other features.

There was also reported weird problem with Visual Studio 2008 and ReSharper installed on x64 computers - opening Visual Studio's Find dialog crashes. We are currently trying to reproduce this problem. If you experience this problem, please tell us!

Some people tend to ask for quick-and-dirty hack for ReSharper 3 so that it just parses the code and don't do anything intelligent with C# 3.0 code. It is not possible. Details are not important here and are pure technical.

Next version
ReSharper 4 is in very active development. Its main purpose is to support C# 3.0 in all of its beauty. This means not only parsing and code intelligence, but also new analysis, refactorings, context actions and quick fixes. We are concentrated on making your development experience with C# 3.0 as smooth and pleasant as possible.

Currently, we have support for implicity typed variables and arrays, extension methods, object and collection initializers and automatic properties. As soon as we complete support for lambdas, queries and anonymous types, we will open Early Access Program. We plan to achieve this goal in January, 2008.
From this point you will be able to download EAP or even nightly builds and try full power of ReSharper 4 with your new C# 3.0 code.

In regards of upgrade policy, we are currently in the process of deciding upgrade cost, who qualifies for free upgrade, or if we want to do something special about this release. I will post about it as soon as I can.

As for release plans, we are aiming at 2008'Q1, hopefully sometime soon after Visual Studio 2008 launch event in February. ReSharper 4 will be available to general public via Early Access Program at least for 2 months before release.

If you have any questions, do not hesitate to ask in comments.

C# 3.0 Automatic Properties - Incomplete Feature?

2007-10-16T19:56:00.000+04:00

Well, C# 3.0 is nice language. However, digging into details of every new language feature while developing ReSharper support make me wonder about little things that look like incompleteness. Today I'm going to wonder about automatic properties.

public string Name { get; set; }

This code is correct in C# 3.0, there are no missing "abstract" or get/set bodies. It simply means that compiler will create field and accessors code for you:

private string __someGeneratedFieldName;

public string Name

  get { return __someGeneratedFieldName; }

  set { __someGeneratedFieldName = value; }

What is cool about automatic properties? Obviously, ReSharper users don't benefit much from shorter code - who types properties by hand these days? However there is one very important thing:

Less complexity to manage.

If you want to know how this property gets its value, you no longer need to search for both field and property usages. You don't need to synchronize field and property types, once you decide to change it. Also, access to the class attribute (in OOP sense) is fully controlled right at the place of the declaration. You can limit it as you wish:

public string Name { get; private set; }

This way you declare that "Name" can be modified only within the class itself, but can be read from outside.

So, what is missing from this language feature?

Initializer.
I may wish to initilize property to some non-default value. Like this:

public List<Person> Persons { get; private set; } = new List<Person>();

Read-only automatic property
In the example above, I don't actually need setter.

public List<Person> Persons { get; } = new List<Person>();

Obviously, you don't need read-only automatic property without initializer. Also note, that such property can never change its value, even in constructor, unlike readonly fields.

Attributes on generated fields
If you use simple event form and compiler generates field for storing delegate, you can apply attribute to the generated field by using attribute target:

[field: NonSerialized]

public event EventHandler Closed;

I wish I could do the same with automatic properties:

[field: NonSerialized]

public List<Person> Persons { get; } = new List<Person>();

Conclusion
Few simple improvements over existing implementation could make automatic properties much more useful in everyday professional .NET development. Unfortunately, language designers decided:

they would work in the "common case" which among other things means no attributes on the generated field. The idea behind that is keeping them simple and not slowly mutating them into full properties.

I'd prefer the advanced version, if I had a chance to choose.

ReSharper 3.0.3 EAP and Solution-wide Error Analysis

2007-09-07T17:45:00.001+04:00

The ReSharper team is actively working on next version with C# 3.0 support, but we are still fixing things for ReSharper 3.0 and even add new features!

Among with various bug-fixes, ReSharper 3.0.3 features "Global Error Analysis" feature that finds compilation errors in your solution on-the-fly. It was available in early ReSharper 3.0 EAP builds, but then we decided that it is not mature enough to put it into release. Now, we've improved it and are going to include it in ReSharper 3.0.3 update.

You can get ReSharper 3.0.3 EAP build at download page. Take a look at post about Early Access Program, if you want to learn more about participating.

To enable analysis of all errors in solution, double-click a red crossing lines symbol at the very right of the status bar and check the "Analyze errors in whole solution" checkbox. Note, that it is per-solution setting. It may take quite a while to analyze your solution for the first time (you can continue your work), but once the solution has been analyzed only those files that may be affected by the changes made are reanalyzed. Tool window with all errors in your solution can be opened using ReSharper | Windows | Errors in Solution menu command. Also, next/previous error command walks through all solution errors, if solution-wide error analysis is enabled.

We would like to hear from you about this feature! Do you like it or not? Does it work fine for you? Do you have any problems? You can leave comments to this post, or drop a message in our EAP newsgroup. Thanks in advance!

C# 3.0 Collection Initializers - Incomplete Feature?

2007-09-06T18:02:00.000+04:00

I was really confused when I learned that "collection initializer" is so limited. I thought it was so natural to support extension methods for "Add" method, but it doesn't.

In short, collection initializer is the following syntax:

var list = new List<int> { 1, 2, 3 };
var dic = new Dictionary<int,string> { { 1, "a" }, { 2, "b" }, { 3, "c" } };

Each item in the braces is simply transformed to the call of Add method with appropriate signature.


var list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
var dic = new Dictionary<int,string>();
dic.Add(1,"a");
dic.Add(2,"b");
dic.Add(3,"c");

It's a bit more complex in reality, but it doesn't matter here.
So, when I first saw description of the feature I thought: How cool! I can specify extension method "Add" for "StringBuilder" and get the following:


var sb = new StringBuilder { "Text = ", Text, ";", "Value = ", Value };

But, restrictions are too strong - type being constructed should implement IEnumerable and have instance method "Add". IEnumerable is not of a big deal, but inability to use extension methods for Add is deal breaker.

How about this?


XmlDocument doc = new XmlDocument
{
  new Node("person") { Attributes = { { "name", "John" }, { "age", "42" } },
    Nodes =
    {
      new Node("phones") { Nodes =
      {
        new Node("number") { Value = "123 45 678" },
        new Node("number") { Value = "777 77 777" },
        new Node("number") { Value = "987 65 432" }
      }
    }
}

No way. You can't use collection initializer for XmlDocument, because it doesn't have Add methods. It is IEnumerable, though.

May be this?


var set = new PermissionSet( new ZoneIdentityPermission(...), new PrincipalPermission(...) };

No way. PermissionSet is IEnumerable too, but does have AddPermission instead of Add method.

If it only were searching for candidates as follows:

If type implements "IEnumerable", look for instance Add method with appropriate parameters,
If not found, if type implements "IEnumerable", look for extension method Add with appropriate parameters,
If not found, look for extension method AddToSequence with appropriate parameters.

This change, or something similar, would turn the otherwise very limited collection initializers into really powerfull object initialization feature.

Visualize Right Margin in Visual Studio

2007-09-04T14:14:00.000+04:00

ReSharper has formatting option to keep your source code lines below certain limit.
In Options, go to Languages / C# / Formatting Style / Line Breaks and Wrapping, find "Wrap long lines" below "Line Wrapping" group and enable it, then set "Right margin (columns)" to the desired value. That's pretty cool, but how can one see which lines will be wrapped?

Meet Visual Studio secret feature: Guides!

As described in this blog post, you can play a bit with registry and make Visual Studio display nice dotted vertical lines at specific column:

Open "HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\Text Editor" key

Create new string value "Guides"

Set its value to something like "RGB(192,192,192) 119" (columns in registry are zero-based)

Restart Visual Studio

Now you will be able to see when your lines are too long, and probably make manual formatting before ReSharper will split lines at next reformat.

ReSharper vs C# 3.0 - Implicitly Typed Locals

2007-08-30T12:22:00.001+04:00

Last month I was on vacation, living in the country, with no access to Internet, doing no programming, reading non-technical books, walking, swimming and otherwise enjoying my life, my family and the nature. It was really-really cool! However, I admit I was thinking a bit about ReSharper features for C# 3.0 and one of the things that puzzled me was

To var or not to var?

Obviously, developer have to use var keyword in case of anonymous types, and can't use var if local variable's type cannot be inferred at the declaration point. But most locals are suitable for both forms - explicit type and var keyword. Context action to switch from explicit type to var and back is okay, but we would like to analyse the code and suggest using var in cases where it will improve the code.

Some cases where it seems just fine to suggest var are:

New object creation expression: var dictionary = new Dictionary<int, string>();

Cast expression: var element = (IElement)obj;

Safe Cast expression: var element = obj as IElement;

Generic method call with explicit type arguments, when return type is generic: var manager = serviceProvider.GetService<IManager>()

Generic static method call or property with explicit type arguments, when return type is generic: var manager = Singleton<Manager>.Instance;

However, various code styles may need to suggest in other cases. For example, programming in functional style with small methods can benefit from suggesting every suitable local variable to be converted to var style. Or may be your project has IElement root interface and you just know that every variable with "element" name is IElement and you don't want explicit types for this case. Probably, any method with the name GetTreeNode() always return ITreeNode and you want vars for all such local variable.

Currently, we have two suggestions: one that suggests every suitable explicitly typed local to be converted to implicityly typed var, and another that suggests according to rules above. They work fine within the team. I hope EAP will give us some feedback about how it works, but Early Access Program for ReSharper 4.0 will be opened later this year.

Meanwhile, do you have any ideas, suggestions or examples where you'd like to see suggestion to convert explicitly typed local variable to the var form?

ReSharper vs C# 3.0 - Extension Methods

2007-07-25T20:19:00.000+04:00

I'm going to do several posts about how are we going to support C# 3.0 in ReSharper. I will not dig into much technical details, instead I will discuss end-user experience and product decisions we have to make. These posts are not meant to be description of features, they are rather invitation to discussion - what do you want to see in ReSharper for C# 3.0.

Today I'm going to discuss Extension Methods.

Note: Information, features and ideas contained in this post are preliminary and subject to change in the release version of ReSharper with C# 3.0 support.

In short, extension methods feature provides ability to pseudo-extend some type's public interface via static member. Compiler looks for static methods marked with System.Runtime.CompilerServices.ExtensionAttribute in the static class with the same attribute. It then converts obj.ExtensionMethod(params) into ExtensionClass.ExtensionMethod(obj, params) while compiling. There is also syntactic sugar to mark methods as extensions - you prefix first parameter of ExtensionMethod with "this" keyword:

  public static class ListExtensions

    public static void Process(this List<int> list, int p) {}

As soon as you have instance of List, namespace of ExtensionClass imported into current file and System.Core assembly referenced you can use it as follows:

    void Foo(List<int> list)

      list.Process(1);

What does it mean for ReSharper? Well, besides parsing and resolving, it mostly means updating many features to support extension methods, like parameter information, navigation and search.

There will be a number of context actions, analyses and quick fixes to help with extension methods. For example, you already added "this" to the first parameter of the static member, but still using it in the form of a static method in your code, like this: ListExtensions.Process(list,1). In this case suggestion could be issued to convert to the pseudo-instance form: list.Process(1);

There are also some things that should be done specifically for Extension Methods feature. It would be very handy to have completion feature which lists non-imported extensions and insert using directives when you select one, much like Type Name Completion. Most likely we will extend existing feature to work after "dot" and rename it as "Import Name Completion".

It would be nice to have a refactoring to convert existing static member in a static class into extension method and update all usages to the pseudo-instance form.

When implementing interfaces, ReSharper could also look for extension methods that match interface members and current type, and suggest to use them as default implementation instead of throwing NotImplementedException.

If you have any other ideas about supporting Extension Methods in ReSharper, you are welcome to comment on this post.

ReSharper 3.0 Screencast Contest

2007-07-23T18:39:00.000+04:00

Are you experienced ReSharper user and want to demonstrate the productivity boost you gain with ReSharper?
Do you like it, but cannot afford to pay the cost?
May be you think you are the BEST in using Visual Studio with ReSharper?
Probably, you are evaluating ReSharper 3.0 and have some time to share your experience?

Even if you don't want to compete for free personal license for ReSharper 3.0 Full Edition, you can help us make the most intelligent add-in for Visual Studio even better, smarter and handy. Participate in video contest - show us your coding session!

P.S. If you already spent your 30 days evaluation time, you can download latests ReSharper 3.0.2 EAP builds, which has renewed evaluation period.

ReSharper 3.0.2 Early Access Program

2007-07-12T15:59:00.000+04:00

We opened ReSharper 3.0.2 Early Access Program and now you can download nightly builds of the next bugfix update for ReSharper 3.0.

What is EAP and why do you want to participate?
There are two major benefits in using early builds and participating in the program:

You get the cutting edge technologies, new features, productivity improvements and bug fixes as soon as they are implemented. You don't have to wait for release, you can start working more effective immediately.

You can influence product development and make sure it works right for you, in your environment, for your development style.

Of course, participating in early access program has its disadvantages, mainly no guarantee that particular nightly or EAP build will work for your project (is there any software currently on the market which does guarantee anything?). However, we install nightly builds every day and rarely have fatal problems preventing us from using Visual Studio and ReSharper.

Why do we need EAP?
We need EAPers for the one simple reason - we can't setup that many test environments people have around the world. Various technologies, libraries, plugins, regional and cultural differences, operation systems and more and more. We can't cover it all. We also can't learn all that styles people do development in. With EAP we can listen to you, and listen early.

How to get most from EAP?

Be proactive. If you see something you don't like - tell us. If you feel something works slow - tell us. If you miss a feature, if you think ReSharper should be smarter in particular case, if you find a typo - file a request in our JIRA database.

Communicate. It doesn't work in a "fire and forget" style. Don't be anonymous, answer the questions team may ask. Explain why the feature is important and how it should work, give code examples to reproduce a bug, make screenshot when you think you see something wrong.

Update and share. I know, it takes some time to download and install new build. I wouldn't suggest to update daily, but if you are interested in taking most from EAP you'd update at least weekly. Tell us and other EAPers how the build is going. Discuss improvements and degradations. Share your experience.

Do you want to join today?

Subscribe to newsgroup or bookmark forums. They are synchronized, so you can use whatever you like most.

Read about creating requests in our JIRA database. Register in JIRA.

Download and install ReSharper 3.0.2 nightly build.

Start EAPing with pleasure! :)

News of the Weekend

2007-07-08T23:42:00.000+04:00

Albert Weinert releases alpha version of the MbUnit plugin for ReSharper 3.0

Dmitry Lomov, ReSharper tech lead, starts blogging about development adventures in the ReSharper project. I'm sure I will learn a lot myself.

I've discovered "draft.blogger.com" and now you can see the poll at the right side of this blog. Would you like to answer?

Of Tools and Languages

2007-07-02T13:51:00.000+04:00

People often discuss tools for languages, often discuss languages, but rarely discuss languages for tools. If you haven't checked the NBL - The Next Big Language - go read it. Until, of course, you don't care about new languages. Here is small quotation:

Most programmers don't realize how often they need to deal with code that processes code. It's an important case that comes up in many, many everyday situations, but we don't have particularly good tools for dealing with it, because the syntax itself prevents it from being easy.

Being tool developer myself, I must say that it is often extremely hard to make desired feature. Not that it is hard to implement the feature, but rather understand how it should work in a particular language and how to "fix" the language. Few examples to illustrate the problem:

Braces in C#
C# block delimiters are braces, symbols "{" and "}", and they are used everywhere, and thus has context-dependent semantics. For a class body they surround methods and properties; for a method they designate start and end of implementation code; inside method they are used for conditional and loop blocks. The problem is that they can easily become unmatched, and thus closing braces change their meaning. The one which was at the method end suddenly becomes closing brace for the loop, method borrows its closing brace from class and all the code looks broken. ReSharper's code analysis goes crazy and highlights the rest of the file in red.

Note, that we don't have such problem in Visual Basic .NET, because we have different "braces" for different constructs and we can detect unmatched "brace" early. However, VB.NET has own problems...

Name suggesting in VB.NET
ReSharper always had name suggesting feature for C# - when you have name of the type in the editor plus space and hit Control+Space you're presented with generated names for local variable or field:

Those names are generated from type name to the left. Note the order - type name first, than declaring symbol name. In VB.NET the order is the opposite. You first give name to the declaring symbol and then specify what type is it.

ReSharper can't help you find the type for the specified name, it would be too slow. We have to invert the order, and we do so by providing "dim" Live Template:

We have similar problem in C# with interface implementation, actually.

So what?
No modern software development process can exist without tools. Continous integration and version control, refactoring and code editing, error detection and code analysis - all these require tools. If the language doesn't support tools, tools cannot support language very well. It requires significant effort to develop tools for unfriendly language and thus less tools appear on the market. At times tool vendors attempt to "fix" language editing expirience with techniques that are not natural to the language itself, because at some moment they need information not typed in yet. In order to get maximum information about developer's intention, we create special features for each intention (like "surround with") instead of understanding what is being typed; just because language forces us to do so.

That said, if you are creating your own language, or even the Next Big Language, be sure to consider tools as a major thing influencing language design.

ReSharper Critical Update 3.0.1 is Out

2007-06-29T18:45:00.000+04:00

As you've probably noticed, we had some nasty bugs which prevented some people from enjoying great new features of ReSharper 3.0. We addressed most of the critical issues in about a week and here is the result: ReSharper 3.0.1 which you can get on the official download page.

If you had problems with ASP.NET user controls, To-do Explorer, Unit Testing or any of these bugs -- you may want to give another try with ReSharper 3.0.1

ReSharper Curious Facts - Unit Testing

2007-06-25T14:35:00.000+04:00

ReSharper 3.0 was released after passing 8518 tests. It took the total of 1 hour 46 minutes to compile, run all tests, prepare help, build installation packages for all three editions, package sources and binaries for archiving -- all without user interaction, automatically by TeamCity.

ReSharper 3.0 Live!

2007-06-21T17:24:00.000+04:00

ReSharper 3.0 is released!

ReSharper Curious Facts - Ancient Request

2007-06-21T15:43:00.000+04:00

Oldest request fixed in ReSharper 3.0 is number 2235, the one about intellisense in app.config files, originally filed on May 06, 2004. Interesting, it was me who submitted it when I was not working at JetBrains but already loved ReSharper and used it in my daily work.

ReSharper 3.0 for C# Developer

2007-06-19T23:08:00.001+04:00

While I have a few spare minutes before reviewing another document being built for web site, marketing and such, I'd like to share brief list of new features in ReSharper 3.0 that will help C# developers to be even more productive. This list is not complete and doesn't go into details about ASP.NET support or XML and XAML features. Instead, these are core C# language productivity boosters that can be used immediately in any C# project.

Go to Symbol -- navigate to any type, field, method, property or event by its name. Of course, camels are here with their humps ready to save you some typing.

Go to next or previous error -- skip warnings and suggestions and put caret immediately on the red code.

Automatic type member layout -- sort and group fields, constructors, properties, inner types, members implementing interface and other members when your reformat code. You can specify custom code layouting patterns in options dialog.

Smart Completion -- smart-complete type arguments and type parameters, infer types and suggest applicable symbols. Also, a nice little helper to give the name to unnamed exception in catch block when smart-completing in place where Exception is expected.

Advanced type choosing -- in refactorings and other places where you have to enter type name ReSharper now provides experience similar to Go to Type.

Find symbols referenced in type or method -- useful for getting big picture about what is using inside a type or method, and drill-down to details in familiar Find Usages style.

Find dependent code -- an advanced version of former Find Module Usages command, which is capable of searching code depending on specific project throughout the solution. If you need to find how particular assembly reference is used (or not used), invoke it on reference in Solution Explorer.

Filter found usages of attributes -- attributes has two distinct categories of places where they are used. One is where they are applied to an entity and the other is where they are analysed via GetCustomAttributes() methods. If you work with attributes a lot, you will find new filter in Find Usages saving you a lot of browsing time.

Highlight usages of expression -- select expression and see where the same expression is used in a method or in a file.

Improved Type Hiearchy -- member preview pane for selected type and two new view modes for deep hierarchies. One mode shows instantiatable types of the hierarchy as roots and their bases as subnodes. The other shows leaf interfaces - those that have only classes as derived types.

Moving things around -- no need to copy/paste code in order to move statement few lines below, move out of "if" statement or push into "for" loop. Much like manual member reordering, which of course still works. Can reorder enum members, though it is not always safe - know what you are doing. Reorders parameters though not changing call sites - thus not a refactoring. Works in XML to reorder nodes too.

Generating equality -- when generating Equals & GetHashCode, you can now optionally generate equality and inequality operators, implement strongly typed IEquatable interface.

Improved Stack Trace Explorer -- now highlights types, methods and source code paths, deals better with broken stacktraces, works for localized stacktraces. Also doesn't show "paste" dialog - less one key to hit.

Generate from Solution Explorer -- hit Alt-Ins while you are on the folder, file or project in solution explorer and bring instant New File From Template menu. Combine with new Locate in Solution Explorer action to find your currently open file in Solution.

Unit Test Explorer -- browse all unit tests in solution, form arbitrary set of tests, multiple sessions with different sets (with simultaneous run!), better output presentation, and the foundation for more features in future versions.

To-do Explorer -- keeps an up-to-date list of comments matching specified patterns for the whole solution, like "TODO:", "BUG:" , "To John:", "Don't forget to remove it before release!" and so on. Processes comments in C#, VB.NET, XML, XAML and ASP.NET pages (both HTML and code).

XML support -- enables almost all editor enhancement in XML files, like expand/shrink selection, highlight and navigate to matching tag, move tags, split and join, replace tags and attributes. Provides type completion and can automatically insert assembly qualification to avoid annoying typing in files like app.config.

Custom string.Format methods -- tell ReSharper about your own format-like methods and get full featured analysis, context actions and quick fixes for them.

New code inspections -- more checks for redundancy, useful suggestions and warnings. Supports #pragma directives and project settings to suppress warnings.

New quick fixes and context actions -- less manual typing, more focus on your primary task. New quick fixes provide alternative ways to fix errors, remove redundancies and deal with type parameters and constaints. New context actions give you more power for ad-hoc code transformations.

So, these are highlights. Complete list will be available short after ReSharper 3.0 is released - either on official site or here, in my blog. There are many subtle changes and nice little additions that make up the product. I don't know some of them myself! But I strongly feel that ReSharper 3.0 is another step up to the ideal development environment.

Develop with pleasure!

ReSharper 3.0 Release Candidate 2

2007-06-19T21:57:00.000+04:00

I'd like to give our big THANKS to those brave people who tried out Beta, Beta2 or Release Candidate, provided invaluable feedback and revealed blocking problems in the upcoming ReSharper 3.0. We really appreciate your effort and doing our best to fix bugs and problems breaking your productivity and flow.

We have a new RC2 build published for you. I ask you to download and try the build.

ReSharper 3.0 Release Candidate

2007-06-17T17:58:00.000+04:00

We are getting really close to ReSharper 3.0 release so we have a Release Candidate build published for you. It has LOTS of improvements over Beta2 particularly in language-specific editions. I recommend everyone to download the build. This might well be your last chance before relase to make sure it works perfectly for you.

Consequently, I will have more time for blogging next week, so if you have some particular topic in mind you would like me to write about -- drop me a comment.

ReSharper 3.0 - Coming Soon

2007-06-16T15:03:00.000+04:00

It's been quite a while since I wrote about ReSharper features, but there was a reason -- we are building final bits of ReSharper 3.0. We passed not-so-good Beta milestone, a much better Beta2 update and currently working on last changes for Release Candidate. If you didn't yet try ReSharper 3.0 pre-release builds -- download almost-release-quality Nightly Builds now and tell us what do you think!

Note: ReSharper 3.0 Visual Basic .NET edition has known problems with ASP.NET.

Jedi Way - Coding in Reverse

2007-05-23T12:46:00.000+04:00

It looks like "ReSharper Jedi" term is beginning to spread! So here is ReSharper Jedi Code, converted from original Jedi Code:

ReSharper Jedi are the guardians of quality and productivity in the .NET world.
ReSharper Jedi use their powers to improve and advance source code, never to degrade.
ReSharper Jedi respect all developers, in any language, with any tools.
ReSharper Jedi serve others rather than ruling over them, for the good of the .NET world.
ReSharper Jedi seek to improve themselves through knowledge and training.

So what would be the major skill ReSharper Jedi should master? I think it is Coding in Reverse. This technique is widely used in test-driven development, I believe. However, it is so effective that every developer should master this skill regardless of programming style. Main principle could be described as follows:

Use Before Declare.

1. Learn to like red code.
2. Always begin with expressing your goal.
3. Deredify your code.

There is one thing to dislike, though. Automatic completion as you type doesn't work well when there are undefined symbols. However it seems to be more about lack of support in tools than fundamental limitation of the technique.

Let's see how does it work.

Code in red indicates unresolved symbols which are just not there yet. At this point I can easily continue writing code for Main method and change my mind any time.

I've expressed my goal pretty well. See how I changed CommandLineParameter to ICommandLineParameter, when I decided that interface would be better. Also, I was able to use "foreach" Live Template to iterate over collection of undefined type.

Okay, now I have to deredify my code and create some methods and types. Where is my light ~~saber~~ bulb and powerful quick-fixes?

Now we need to fill methods with real code, and I will show how to use the Force by implementing ParseCommandLine. We again begin with typing our goal:

Several keystrokes, quick fixes, live templates, some typing and we get to another point:

I use the Force and create class which not only contains required constructor, but also implements interface!

I leave it as an exercise to finish the sample code for anyone who want to practice this technique. Implement ProcessParameter by using some ICommandLineParameter members before declaring them, then quick-fix your way into declaring them, then use Jedi skills and implement members on the SimpleParameter.

Have fun and may the Force be with you!

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Coding Session with ReSharper

2007-05-22T16:01:00.000+04:00

ReSharper team is approaching Feature Freeze milestone for version 3.0, so I didn't have time to write thoughtful posts. However, I needed to write primitive utility for doing some batch operations on the file system structure recursively, and I decided to record a small screen cast for part of the real coding session. It is about 8 minutes long and shows many things I use daily during development. I hope you will enjoy the movie :)

Download "Jedi Coding" from ReSharper Demo page.

Quality is not very good to keep size small. Music in background is "Voodoo People" by Prodigy from "Music For The Jilted Generation" album, I only repeated ending so it fit movie time.

Note: Some or all of the features seen in this movie may be available only in latest EAP versions of ReSharper.

Code Completion with ReSharper

2007-05-08T15:23:00.000+04:00

Completion with ReSharper is very different from what you have in Visual Studio. Some people refer to it as "broken". Indeed, when you start using ReSharper's intellisense, you may feel that something is "wrong". But it's just a little different and much better. I will describe completion features in ReSharper and you'll see how superior they are to what Visual Studio offers.

Look
Visually, completion list is not that different with default ReSharper settings. Here is original Visual Studio completion for type System.String, without any prefix:

Here is what ReSharper displays:

First evident difference is usage of bold font face. It emphasizes immediate members of type, those declared exactly in type for which completion was called. Note how GetType() is not bold, because it was inherited from System.Object. In large hierarchies, like windows controls, it is huge timesaver to be able to spot members specific to current type.

Another obvious difference is ability to show all overloads for a member in a signature popup, not just some random one with cryptic message (+2 overload(s)). You can instantly see that you can test end of line against string in a case-insensitive way and that it would be second boolean parameter.

You can also see, that ReSharper can suggest indexer (and correctly remove dot when inserting brackets). We also have some custom icons for parameters and local variables to distinguish them from fields.

If you wish, you can set completion font to match font in Editor and thus align completion items with what you type. You can tweak it on ReSharper/Options/IntelliSense/Code Completion page.

Narrow Down
More differences become visible when you start typing while completion list is open.

As you can see, list has become smaller and contains only items with the specified prefix, which is highlighted. For a large completion list, such as when you have windows control, it helps you quickly find what you need. It is even more important for type completion, but later about it.

Replace and Insert
The most confusing part and most difficult thing to adopt in ReSharper completion behavior is choosing between replacing and inserting. When you write new code, it doesn't matter, but if you are using completion inside existing expression it makes big difference. Consider the following example: we have method that replaces all spaces with underscores. Imagine that you need to modify the body to remove leading and trailing spaces before doing replacement.

        public string QuoteSpaces(string text)

            return text.Replace(' ', '_');

You position caret right after "text." and hit Ctrl-Space, then type few letters to locate Trim method.

Now, if you hit "Tab" key to complete the identifier it will remove "Replace" and insert "Trim", then put caret into parenthesis. Very useful when you need to change existing identifier to another one. Note the light red highlighting which denotes text to be removed, if you hit Tab. If you hit "Enter" key, it will just insert "Trim()" and let you specify parameters, if needed.

Name Suggestion
One more thing that ReSharper does for you is suggesting variable names when typing declaration.

It works for fields, parameters, variables, members and alike. Saves a lot of typing, I have to say. Name suggestion completion takes naming conventions into account, so be sure to set them in ReSharper/Options/Code Style/ C# or Visual Basic / Naming Convention.

Type Completion
Whenever you need a type at the caret position and you only have basic completion at hands, you have to type full type name and then import type via some sort of fix, e.g. Visual Studio smart-tag action. You also have to match case, and can you remember which one is right - DESCryptoServiceProvider or DesCryptoServiceProvider?

ReSharper comes to rescue with Type Completion, which shows all types matching prefix regardless of (un-)imported namespaces and inserts required using directives when you select a type.

Default shortcut is Ctrl-Alt-Space. Start using it now!

Smart Completion
ReSharper has deep knowledge about your code. Really! When you see variable declaration in gray, it is ReSharper who analysed execution flow and figured out that particular variable is not used. Some of this knowledge is available to you in completion. When it is known what type is expected at specific point, you may get filtered list of available symbols by invoking Smart Complete (default shortcut Ctrl-Shift-Space):

You can see that ReSharper suggested some static members of System.String and parameter "text". Well, you were going to return something of string type, so here you are!

Smart Completion is also smart enough to suggest anonymous and regular method creation:

Or even local variable creation in place of out parameter:

Conclusion
When you type code, completion is your best friend. Master all three completion kinds, practice for second-nature and you can achieve marvellous code generation speed.

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Format Strings -- Episode Two

2007-04-30T17:18:00.000+04:00

Last time I wrote about using string.Format as you type. What if you already have some code and want to transform it to string.Format?

    public override string ToString()

      return "Folder: '" + myPath + "'";

When you position caret inside such string expression, ReSharper displays light bulb and suggests few context actions (caret was on myPath in this case):

It is not surprizing that the first item in menu does what we want:

    public override string ToString()

      return string.Format("Folder: '{0}'", myPath);

If there is known method overload that fits format style, it will be used instead of creating extra string.Format call:

    public void Write(StreamWriter writer)

      writer.Write("Folder: '" + myPath + "'");

ReSharper converts it to:

    public void Write(StreamWriter writer)

      writer.Write("Folder: '{0}'", myPath);

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Transforming Conditionals

2007-04-27T21:12:00.000+04:00

Testing conditions is at least 50% of code in a typical program. When developer writes code, he not always knows in advance how method will look like at the end. Let's look at some typical cases.

This one is pretty simple method, which takes care of null object:

    public string ConvertToString(object obj)

      if (obj != null)

        return obj.ToString();

      return null;

Then I decided to add special handling for IConvertible:

    public string ConvertToString(object obj)

      if (obj != null)

        IConvertible convertible = obj as IConvertible;

        if (convertible != null)

          return Convert.ToString(convertible);

        return obj.ToString();

      return null;

Now it seems that it would have been better idea to check and return null immediately instead of placing all the code in the block. How can we fix this? I put caret on an "if" keyword and hit Alt-Enter.

After context action is executed I get what I need:

    public string ConvertToString(object obj)

      if (obj == null)

        return null;

      IConvertible convertible = obj as IConvertible;

      if (convertible != null)

        return Convert.ToString(convertible);

      return obj.ToString();

If you like shorter methods, you can further transform the code:

Accepting convertion to conditional makes it even smaller:

    public string ConvertToString(object obj)

      if (obj == null)

        return null;

      IConvertible convertible = obj as IConvertible;

      return convertible != null ? Convert.ToString(convertible) : obj.ToString();

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Highlight Usages Of What?

2007-04-27T18:18:00.000+04:00

Many people know about Find Usages (default shortcut Alt-F7), which find usages of element under caret. Some people known about Highlight Usages (default shortcut Ctrl-Shift-F7), which places highlighting markers in current file on element usages. However, ReSharper can highlight usages of different things as well.

Usages of Namespaces
Position caret on "using" directive (Imports in Visual Basic) and invoke Highlight Usages command. ReSharper will highlight all symbols which depend on namespace in question.

Usages of Expressions
Select expression in code and invoke Highlight Usages command. ReSharper will highlight same expressions in other places in code.

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Jedi Way -- Implementing Members

2007-04-24T21:02:00.000+04:00

Object-oriented program is easy to read, if written properly. At every point you deal with appropriate level of abstractness and you don't have to deal with implementation specific details most of the time. However, when you have large type hierarchies and you are going to modify some aspect of a top level interface -- you may be in trouble. You have to thoroughly investigate all implementing types and provide method body for each one. ReSharper can help, of course.

Jedi Trick Level 1
Invoke Type Hierarchy and select Derived Types in the toolbar. You will see hierarchy of types derived from the interface. Use "Go To Next/Previous Occurence" command (Ctrl-Alt-Down/Up) to navigate between types. As soon as you have type which requires implementation in the code editor, Code Analysis will show red squiggly. Invoke Quick Fix to implement member and type in method body.

Jedi Trick Level 2
Use Context Action's power to implement members. Position caret on the newely created member, IsAvailable in this case. You will see the light ~~saber~~ bulb which is activated with Alt-Enter. Select "Implement member" and you will be prompted with the list of types. You can select "All above types" and get method body throwing NotImplementedException for every type.

Jedi Trick Level 3
Use Quick Fix power to implement members. Type in method body right in the interface, as if it were implementation. Code Analysis will show red squiggly, because interface member cannot have body. But you will also get two Quick Fixes via red light bulb - remove method body or use body for implementations. As soon as you select second one, body will be copied to appropriate implementations and removed from interface.

Jedi Trick Level 4

Available to Yoda only.

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Format Strings -- Episode One

2007-04-24T18:23:00.000+04:00

Are you going to override ToString? You do this from time to time, definitely.

You begin typing format string and immediately see ReSharper coming to rescue in an absolutely non-invasive way. First the light bulb will appear.

Second, you hit Alt-Enter to see the list of available context actions. Only one is available here, but it is exactly the one we need.

Accept it with Enter and you can start typing arguments.

Note: Some or all of the features mentioned in this article may be available only in latest EAP versions of ReSharper.

Customizing ReSharper Colors

2007-04-24T14:36:00.000+04:00

Sometimes people complain that they don't like ReSharper's colors, or default colors do not math their personal scheme, or identifier highlighting gets too much in the way. Luckily, you can configure colors.
Color configuration for ReSharper items can be changed in the Visual Studio Options (Tools Options menu), in the Fonts and Colors section. Select "Text Editor" in the settings combobox and scroll down to "Resharper" items. You will see color and font settings for identifiers of different kinds, error and warning highlighting, navigation targets, read/write usages and much more.

The Horizon Comes Closer

2007-04-20T17:13:00.000+04:00

It's been a while since I last wrote about ReSharper future. That's because we are actively working on ReSharper 3.0, the upcoming new version of our intelligent Visual Studio add-in. Besides numerous bug fixes, improvements and greater performance, we are adding more functionality to our product. In the upcoming posts I'm going to reveal what is going to be included in ReSharper 3.0 in more detail. Now I'll just list the most important things we are planning for this release:

Visual Basic .NET
C# developers already know how fast one can work with source code when ReSharper is installed. Now we bring the same pleasure to VB.NET developers. Editor improvements, such as expand/collapse selection, navigate next/prev member, duplicate line, comment/uncomment block/line and other small features, make code editing more enjoyable. Completion brings Smart Completion and Type Completion flavors to VB.NET along with automatic Imports inserting and all other bells and whistles. Code generation with Alt-Ins provides a quick means for generating properties, constructors, overriding and implementing members and works with the same level of cleverness as it does in C#. Live Templates now understand VB.NET and have smart iteration and cast templates, such as For Each or TryCast. Of course, we have Refactoring support for VB.NET in this version, which includes the most important refactorings like Rename, Move and Copy Type, Change Signature, Introduct and Inline Variable, and many others.

If you are a VB.NET developer and if you've ever seen how fast ReSharper-powered C# developers work, you owe yourself to try our EAP versions of ReSharper 3.0.

XML support
We are adding a number of useful editor improvements to Visual Studio XML support. They include expand selection, navigate to next/previous tag, replace tags, and some others. Live Templates are now supported in XML files and have some useful macros. Type completion works in XML, so that you can write configuration files easier. You can also navigate to type from XML.

XAML support
Being a language for user interface definition, it is still a compilation unit and it defines types and fields which are visible from other code. ReSharper is now capable of parsing XAML files, navigating, searching, and otherwise providing data for code exploration tools. We also plan to support smart completion and type completion in specific places, like event handlers, namespace aliases and tags/attributes where a control type is expected. Refactoring support in XAML will be limited in this version, but will allow renaming and moving types between namespaces without breaking code.

Tools
Besides all the languages support listed above, we are adding a number of useful tools and upgrading some existing tools. We've included To-do Explorer, which hunts for comments according to specified patterns and displays them in a dedicated tool window for quick access. We've improved Type Hierarchy to show members of selected type, either all or just polymorphic, and added some new hierarchy browsing capabilities. Unit Testing system is undergoing a major update to support multiple sessions, better support for various testing frameworks like mbUnit, VSTS and NSpecify, improved debugging usability and allow browsing solution for tests in dedicated Unit Test Explorer tool window. The "Go to by name" family of features, which already includes Go To Type, File or File member, is supplemented with Go To Symbol - your best friend when you remember a method's name, but not that util class it was seen in.

Improvements and bug fixes
I'm not going to give you a list of hundreds of bugs and exceptions fixed since previous release. I can't even remember all those small improvements here and there, which makes development with ReSharper even smoother and helps support development flow. Numerous context actions help craft code faster in many new use cases. New code analysis helps keep code clean and spot various problems as soon as you create them (accidentaly, of course). New quick fixes provide yet more automatic code corrections.

What next?
I'm going to blog in details about some of the new features in ReSharper 3.0 and show you some screen casts. I will probably break announced rules of this blog and start publishing tips and tricks, combos and advanced techniques in code generation, analysis and refactoring.

Stay tuned!

ReSharper 2.5 Released

2006-12-11T23:39:00.000+03:00

We are proud to announce ReSharper 2.5 release! You can read about what's new in this version in my recent post Near Future, and on official New Features page.

Current users of ReSharper 2.0 can use new version for free - just download and install it. If you didn't yet try ReSharper - you owe yourself to download a 30-day evaluation of ReSharper, obtain a free evaluation license and increase you productivity with C# and VB.NET projects.

Develop with pleasure!

Near future - ReSharper 2.5

2006-11-29T18:48:00.000+03:00

We at ReSharper team are building version 2.5, which is superior to 2.0.* series in quite few things. These things are so important, that I want to outline them here.

First, we did a tremendous amount of work to reduce Visual Studio slowdown caused by ReSharper. I don't have specific numbers at hand, but I believe that it is at least ten times smoother, than previous versions. Notable areas that were sped up include typing, code completion, parameter information, Visual Studio startup and solution loading, debugger stepping, Live Templates and code formatting.

Second, we did many UI and usability improvements including fonts, colors, tree views handling, forms and popups. Here is how new Find Results looks like with code preview:

Next picture shows both new popup window's style and new feature "Navigate from Here", which shows various navigation options for selected code.

Third, we've added a lot of new context actions and quickfixes. They include various code generations and transformations, which increases code building speed even more! Look for complete list of quickfixes and context actions when ReSharper 2.5 releases.

Fourth, we extended the power of code analysis to provide more erorrs, warnings and insights into potential problems. One of the most powerful new features is null reference analysis, which detects possibility of NullReferenceException in your code and alerts you with appropriate warning. Indeed, we eliminated many potential problems in ReSharper itself using this analysis.

Last, but not least, we supported subset of ReSharper features for VB.NET. In this version this subset is limited to code navigation and search features (go to declaration, base, inheritor(s); find usages; go to type/file; etc.). Some other features like expand selection and quick-doc is also included. Modification actions, like quick fixes, refactorings, automatic namespace import and so on will be supported in subsequent release.

In addition, ReSharper 2.5 will support XAML-generated files to some degree, though full XAML support is planned for next version. ReSharper's handling of new technologies like Windows Communication Foundation is being tested these days and we believe it will work fine by the release date.

Complete roadmap is published on our EAP site, feel free to participate in EAP program and tell us how it goes. Currently we are in the final stage of pre-release product stabilization and clean up.

PS: ReSharper 2.5 does not work with Visual Studio 2003, nor it is planned to build any new major release for this version of Visual Studio. There will be bugfix updates for ReSharper 2.0.* for both VS2005 and VS2003 though.

30 Nov: post updated based on feedback.

Code Metrics

2006-11-10T16:06:00.000+03:00

Many people ask, if we are going to implement code metrics in ReSharper. Most people talk here about cyclomatic complexity, some mention maintainability index or even Halstead complexity measures. In fact, there are two major cases when people need code metrics.

One case is part of global measurement process in software development company. That is, when company measures and tracks requirements, design and architecture, implementation, tests, deployment, support and operations, etc. Obviously, this is out of ReSharper scope. It won't track history of measurements (as it doesn't track history of errors found in source code), it doesn't integrate with corporate database, it doesn't provide any help in fixing these measures. Someday this case will be covered by TeamCity, I think.

Another case is helping developer spot "code smells". This would suit ReSharper's nature perfectly, but why then just talk about code metrics? Why people want just "have a warning about too complex method", and not about "method belongs to different class"? Many of such "code smells" can be automated, and can aid developer in building Good Code. The problem with such warnings is that they often can give false positive. False positives are very frustrating, people will think something like this: "Well, I know, this code is complex. It should be. It was optimized for speed, implements complex algorithm and maintained by experienced Senior Developer. I DON"T want this warning here!". Thus, system that issues such warnings should have "ignore specific warning in specific place" mechanism, otherwise these warnings will be switched off globally most of the time.

I believe ReSharper team most likely will introduce suggestion system sooner or later, and then implement "code smells", including code metrics, and other useful suggestions that will help you write better code.

Introduction

2006-11-08T16:40:00.000+03:00

I'm not sure if this blog will be regular, but I have many ideas, thoughts and just random talks about ReSharper. ReSharper is undoubtedly the most intelligent add-in to Visual Studio .NET 2005. I joined the team in 2006 and I'm doing my best to make this product not only smarter, but also be more usable, have better look and feel and improve interaction experience. And, as I look at the code and features, I undestand that a lot more should be done to make developer's life even easier and pleasurable.

This blog is not for supporting ReSharper users, visit Support Page if you need help. It's not about past days of ReSharper, nor about bugs or incomplete features. It is all about future, ideas, horizons and trends for productivity boosting tools in general and, of course, with ReSharper in focus.