我應該使用VS 2008重構支持還是購買ReSharper？

Question

我應該使用VS 2008重構支持還是購買ReSharper？

使用ReSharper可以使用VS 2008重構支持無法完成的一些非常好的事情是什麼？

Answer 1

爲什麼不是download a 30 day free trial並找出您是否喜歡它？我相當肯定，一旦你習慣了安裝R＃，你不會想回去。

只要文檔右邊的綠色/橙色/紅色錯誤欄就足夠了，但重構要快得多，還有一些其他非常有用的功能，如代碼清理（CTRL + E + F）根據您的樣式首選項重新格式化文檔。

Answer 2

肯定至少要試試ReSharper。它比VS2008默認的重構方式更多，並且能夠很好地跟蹤你的單元測試。

由於有免費試用版，所以不妨嘗試一下。

我已經使用了一段時間，現在我不得不承認我從來沒有回去只是普通的香草的Visual Studio ...

Answer 3

BTW：還有Refactor! Pro。我在短時間內使用了試用版並喜歡它（尚未購買）。

與ReSharper一樣，它提供了更多的重構，並且比Visual Studio重構工具更快。

Answer 4

使用resharper。我用了很多年。一旦你瞭解了快捷方式，就像你僱用另一個人爲你工作:)

請注意，它可以設置爲使用相同的鍵作爲IntelliJ Idea，所以如果你需要做一些Java，你將已經知道如何使用（非常好的）java IDE。

而且，閱讀本 - 31 days of resharper

Answer 5

一個我喜歡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 6

我喜歡關於Resharper的一件事是，您可以使用Ctrl-Shift-Alt-Up或Down將文件中的方法/字段/屬性等向上或向下移動（直接在方法/字段/屬性的上方或下方與其相鄰），或者您可以使用文件結構瀏覽器通過拖放查看和重新排列文件結構。

Answer 7

我試了30天的試用版，現在我迷上了R＃