Should I use VS 2008 refactoring support or buy ReSharper?

Question

Should I use VS 2008 refactoring support or buy ReSharper?

What are some of really good things you can do using ReSharper that cannot be done using VS 2008 refactoring support?

Answer 1

Why not download a 30 day free trial and find out whether you like it? I'm fairly sure once you get used to having R# installed, you won't want to go back.

Just the green/orange/red error bar on the right hand side of the document is enough, but the refactoring is much faster, and there are some other really useful features like code cleanup (CTRL+E+F) which reformats the document according to your style preferences.

Answer 2

Definitely at least try ReSharper. It does way more than the default VS2008 refactorings and also does a good job of keeping track of your Unit Tests.

Since there is a free trial, it shouldn't hurt to try it out.

I've been using it for a while now and I have to admit I could never go back to just plain vanilla Visual Studio...

Answer 3

BTW: there is also Refactor! Pro. I used the trial version for a short time and liked it (didn't buy it yet).

As with ReSharper, it offers a lot more refactorings and is faster than the Visual Studio refactoring tools.

Answer 4

Use Resharper. I used it for years. Once you learn the shortcuts, it's like you hired another guy to do work for you :)

Note that it can be set to use same keys as IntelliJ Idea, so if you need to do some Java, you will already know how to use (a very nice) java IDE.

Also, read this - 31 days of resharper

Answer 5

One of the things I love about Resharper is that you can create a custom Type Members Layout and use it to format all of your files.

This means that you can sort all the fields/properties/methods/constructors/overrides/interface implementations/delegates/enums etc etc etc in whatever mannar you like (including subsorts by name, access modifier, etc) and then even encase them in regions if you choose.

For example here are the guidelines I currently code to:

CONSIDER grouping members into the following sections in the specified order: 
•   All fields
•   All constructors
•   Public and protected properties
•   Public and protected methods
•   Events
•   All explicit interface implementations
•   Internal members
•   Private members
•   All nested types
When more than one access modifier is in a section, the most visible access modifier should come first (e.g. public before protected).
 DO use #region blocks around not publicly callable and explicit interface implementation groups. 
#region internal members
...
#endregion
#region private members
...
#endregion

And here is the template I use to match them:

<?xml version="1.0" encoding="utf-8" ?>

<!--
I. Overall

I.1 Each pattern can have <Match>....</Match> element. For the given type declaration, the pattern with the match, evaluated to 'true' with the largest weight, will be used 
I.2 Each pattern consists of the sequence of <Entry>...</Entry> elements. Type member declarations are distributed between entries
I.3 If pattern has RemoveAllRegions="true" attribute, then all regions will be cleared prior to reordering. Otherwise, only auto-generated regions will be cleared
I.4 The contents of each entry is sorted by given keys (First key is primary,  next key is secondary, etc). Then the declarations are grouped and en-regioned by given property

II. Available match operands

Each operand may have Weight="..." attribute. This weight will be added to the match weight if the operand is evaluated to 'true'.
The default weight is 1

II.1 Boolean functions:
II.1.1 <And>....</And>
II.1.2 <Or>....</Or>
II.1.3 <Not>....</Not>

II.2 Operands
II.2.1 <Kind Is="..."/>. Kinds are: class, struct, interface, enum, delegate, type, constructor, destructor, property, indexer, method, operator, field, constant, event, member
II.2.2 <Name Is="..." [IgnoreCase="true/false"] />. The 'Is' attribute contains regular expression
II.2.3 <HasAttribute CLRName="..." [Inherit="true/false"] />. The 'CLRName' attribute contains regular expression
II.2.4 <Access Is="..."/>. The 'Is' values are: public, protected, internal, protected internal, private
II.2.5 <Static/>
II.2.6 <Abstract/>
II.2.7 <Virtual/>
II.2.8 <Override/>
II.2.9 <Sealed/>
II.2.10 <Readonly/>
II.2.11 <ImplementsInterface CLRName="..."/>. The 'CLRName' attribute contains regular expression
II.2.12 <HandlesEvent />
-->

<Patterns xmlns="urn:shemas-jetbrains-com:member-reordering-patterns">

  <!--Do not reorder COM interfaces-->
  <Pattern>
    <Match>
      <And Weight="100">
        <Kind Is="interface"/>
        <HasAttribute CLRName="System.Runtime.InteropServices.InterfaceTypeAttribute"/>
      </And>
    </Match>
  </Pattern>

  <!--Special formatting of NUnit test fixture-->
  <Pattern RemoveAllRegions="true">
    <Match>
      <And Weight="100">
        <Kind Is="class"/>
        <HasAttribute CLRName="NUnit.Framework.TestFixtureAttribute" Inherit="true"/>
      </And>
    </Match>

    <!--Setup/Teardow-->
    <Entry>
      <Match>
        <And>
          <Kind Is="method"/>
          <Or>
            <HasAttribute CLRName="NUnit.Framework.SetUpAttribute" Inherit="true"/>
            <HasAttribute CLRName="NUnit.Framework.TearDownAttribute" Inherit="true"/>
            <HasAttribute CLRName="NUnit.Framework.FixtureSetUpAttribute" Inherit="true"/>
            <HasAttribute CLRName="NUnit.Framework.FixtureTearDownAttribute" Inherit="true"/>
          </Or>
        </And>
      </Match>
      <Group Region="Setup/Teardown"/>

    </Entry>

    <!--All other members-->
    <Entry/>

    <!--Test methods-->
    <Entry>
      <Match>
        <And Weight="100">
          <Kind Is="method"/>
          <HasAttribute CLRName="NUnit.Framework.TestAttribute" Inherit="false"/>
        </And>
      </Match>
      <Sort>
        <Name/>
      </Sort>
    </Entry>
  </Pattern>

  <!--Default pattern-->
  <Pattern RemoveAllRegions="true">
    <!--public delegate-->
    <Entry>
      <Match>
        <And Weight="100">
          <Access Is="public"/>
          <Kind Is="delegate"/>
        </And>
      </Match>
      <Sort>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!--public enum-->
    <Entry>
      <Match>
        <And Weight="100">
          <Access Is="public"/>
          <Kind Is="enum"/>
        </And>
      </Match>
      <Sort>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!--fields and constants-->
    <Entry>
      <Match>
        <Or>
          <Kind Is="constant"/>
          <Kind Is="field"/>
        </Or>
      </Match>
      <Sort>
        <Kind Order="constant field"/>
        <Static/>
        <Readonly/>
        <Access Order="public"/>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!--Constructors. Place static one first-->
    <Entry>
      <Match>
        <Kind Is="constructor"/>
      </Match>
      <Sort>
        <Static/>
      </Sort>
      <Group/>
    </Entry>

    <!--public and protected properties, indexers-->
    <Entry>
      <Match>
        <And>
            <Or>
              <Kind Is="property"/>
              <Kind Is="indexer"/>
            </Or>
            <Or>
            <Access Is="public"/>
            <Access Is="protected"/>
            </Or>
        </And>
      </Match>
      <Sort>
        <Access Order="public"/>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!-- Methods -->
    <Entry>
      <Match>
        <And>
            <Kind Is="method"/>
            <Or>
                <Access Is="public"/>
                <Access Is="protected"/>
            </Or>
        </And>
      </Match>
      <Sort>
        <Access Order="public"/>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!-- Events-->
    <Entry>
      <Match>
        <Kind Is="event"/>
      </Match>
      <Sort>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

     <!--interface implementations-->
    <Entry>
      <Match>
        <And Weight="100">
          <Kind Is="member"/>
          <ImplementsInterface/>
        </And>
      </Match>
      <Sort>
        <ImplementsInterface Immediate="true"/>
        <Kind Order="property"/>
        <Name/>
      </Sort>
      <Group/>
    </Entry>

    <!--internal properties, indexers, methods-->
    <Entry>
      <Match>
        <And>
            <Or>
              <Kind Is="property"/>
              <Kind Is="indexer"/>
              <Kind Is="method"/>
            </Or>
            <Access Is="internal"/>
        </And>
      </Match>
      <Sort>
        <Access Order="public"/>
        <Kind Order="property"/>
        <Name/>
      </Sort>
      <Group Region="Internal Members"/>
    </Entry>

    <!--private properties, indexers, methods-->
    <Entry>
      <Match>
        <And>
            <Or>
              <Kind Is="property"/>
              <Kind Is="indexer"/>
              <Kind Is="method"/>
            </Or>
            <Access Is="private"/>
        </And>
      </Match>
      <Sort>
        <Access Order="public"/>
        <Kind Order="property"/>
        <Name/>
      </Sort>
      <Group Region="Private Members"/>
    </Entry>

    <!--all other members-->
    <Entry/>

    <!--nested types-->
    <Entry>
      <Match>
        <Kind Is="type"/>
      </Match>
      <Sort>
        <Name/>
      </Sort>
      <Group/>
    </Entry>
  </Pattern>
</Patterns>

This makes formatting your code to meet your companies coding style as easy as a single keyboard shortcut.

Answer 6

One thing I like about Resharper is that you can use Ctrl-Shift-Alt-Up or Down to move a method/field/property etc up or down in the file (directly above or below the method/field/property adjacent to it), or you can use the file structure browser to both view and rearrange the structure of your file through drag and drop.

Answer 7

I tried the 30 day trial and I'm now hooked on R#