visual-studio-2008 - 我应该使用 VS 2008 重构支持还是购买 ReSharper？

Question

我应该使用 VS 2008 重构支持还是购买 ReSharper？

使用 ReSharper 可以做哪些使用 VS 2008 重构支持无法完成的非常好的事情？

Answer 1

为什么不下载 30 天免费试用版，看看您是否喜欢它？我敢肯定，一旦你习惯了安装 R#，你就不想回去了。

仅文档右侧的绿色/橙色/红色错误栏就足够了，但是重构要快得多，并且还有一些其他非常有用的功能，例如代码清理 (CTRL+E+F)，它可以根据重新格式化文档根据您的风格偏好。

Answer 2

我喜欢 Resharper 的一件事是您可以创建自定义类型成员布局并使用它来格式化所有文件。

这意味着您可以按照您喜欢的任何方式（包括按名称、访问修饰符等进行子排序）对所有字段/属性/方法/构造函数/覆盖/接口实现/委托/枚举等进行排序，然后甚至将它们封装在区域中如果你选择。

例如，这是我目前编写的指南：

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

这是我用来匹配它们的模板：

<?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>

这使得格式化您的代码以满足您公司的编码风格就像一个键盘快捷键一样简单。

Answer 3

使用锐器。我用了很多年。一旦你学会了捷径，就好像你雇了另一个人为你工作:)

请注意，它可以设置为使用与 IntelliJ Idea 相同的键，因此如果您需要做一些 Java，您将已经知道如何使用（非常好的）Java IDE。

另外，请阅读此内容 - 31 天的 reshaper

Answer 4

绝对至少尝试 ReSharper。它比默认的 VS2008 重构做得更多，并且在跟踪单元测试方面也做得很好。

由于有免费试用版，因此尝试一下应该不会有什么坏处。

我已经使用了一段时间了，我不得不承认我永远无法回到普通的 Visual Studio ...

Answer 5

顺便说一句：还有重构！临。我用了很短的时间试用版并喜欢它（还没买）。

与 ReSharper 一样，它提供了更多的重构，并且比 Visual Studio 重构工具更快。

Answer 6

我喜欢 Resharper 的一件事是，您可以使用 Ctrl-Shift-Alt-Up 或 Down 在文件中向上或向下移动方法/字段/属性等（直接在与其相邻的方法/字段/属性的上方或下方） ，或者您可以使用文件结构浏览器通过拖放来查看和重新排列文件的结构。

Answer 7

我尝试了 30 天试用，现在我迷上了 R#