Welche ReSharper 4.0-Vorlagen für C # verwenden Sie?

Lassen Sie uns diese im folgenden Format teilen:

[Titel]

Optionale Beschreibung

Verknüpfung: Verknüpfung
Verfügbar in: [AvailabilitySetting]

// Resharper template code snippet
// comes here

Makroeigenschaften (falls vorhanden):

• Macro1 - Value - EditableOccurence
• Macro2 - Value - EditableOccurence

• Ein Makro pro Antwort bitte!
• Hier sind einige Beispiele für das NUnit-Testgerät und den Standalone-NUnit-Testfall , die Live-Vorlagen im vorgeschlagenen Format beschreiben.

Einfaches Lambda

So einfach, so nützlich - ein kleines Lambda:

Verknüpfung : x

Verfügbar : C #, wobei Ausdruck zulässig ist.

x => x.$END$

Makros: keine.

Implementieren Sie die Methode 'Dispose (bool)'

Implementieren Sie das Entsorgungsmuster von Joe Duffy

Verknüpfung: entsorgen

Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration von Typmitgliedern zulässig ist

public void Dispose()
{
    Dispose(true);
    System.GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    if (!disposed)
    {
        if (disposing)
        {
            if ($MEMBER$ != null)
            {
                $MEMBER$.Dispose();
                $MEMBER$ = null;
            }
        }

        disposed = true;
    }
}

~$CLASS$()
{
    Dispose(false);
}

private bool disposed;

Makroeigenschaften :

• MITGLIED - Variable von System.IDisposable vorschlagen - Bearbeitbares Vorkommen # 1
• KLASSE - Enthält den Typnamen

Erstellen Sie eine neue Einheitentestvorrichtung für einen Typ

Verknüpfung: ntf
Verfügbar in: C # 2.0+ -Dateien, in denen eine Typmitgliedsdeklaration oder eine Namespacedeklaration zulässig ist

[NUnit.Framework.TestFixtureAttribute]
public sealed class $TypeToTest$Tests
{
    [NUnit.Framework.TestAttribute]
    public void $Test$()
    {
        var t = new $TypeToTest$()
        $END$
    }
}

Makros:

• TypeToTest - keine - # 2
• Test - keine - V.

Überprüfen Sie, ob eine Zeichenfolge null oder leer ist.

Wenn Sie .Net 4 verwenden, bevorzugen Sie möglicherweise string.IsNullOrWhiteSpace ().

Abkürzung : sne

Verfügbar in : C # 2.0+, wo Ausdruck erlaubt ist.

string.IsNullOrEmpty($VAR$)

Makroeigenschaften :

• VAR - schlägt eine Variable vom Typ string vor. Editible = true.

Erstellen Sie einen neuen eigenständigen Unit-Testfall

Verknüpfung: ntc
Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration eines Typmitglieds zulässig ist

[NUnit.Framework.TestAttribute]
public void $Test$()
{
    $END$
}

Makros:

• Test - keine - V.

Deklarieren Sie einen log4net-Logger für den aktuellen Typ.

Verknüpfung: Protokoll

Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration von Typmitgliedern zulässig ist

private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof($TYPE$));

Makroeigenschaften :

• TYPE - Enthält den Typnamen

MS Test Unit Test

Neuer MS Test Unit-Test unter Verwendung der AAA-Syntax und der Namenskonvention in Art Of Unit Testing

Abkürzung: Testen (oder tst oder was auch immer Sie wollen)
Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration von Typmitgliedern zulässig ist

[TestMethod]
public void $MethodName$_$StateUnderTest$_$ExpectedBehavior$()
{
    // Arrange
    $END$

    // Act


    // Assert

}

Makroeigenschaften (falls vorhanden):

• Methodenname - Der Name der zu testenden Methode
• StateUnderTest - Der Status, den Sie testen möchten
• ExpectedBehavior - Was Sie erwarten

Überprüfen Sie, ob die Variable null ist

Verknüpfung: ifn
Verfügbar in: C # 2.0+ -Dateien

if (null == $var$)
{
    $END$
}

Überprüfen Sie, ob die Variable nicht null ist

Verknüpfung: ifnn
Verfügbar in: C # 2.0+ -Dateien

if (null != $var$)
{
    $END$
}

Schreiben Sie eine StyleCop-kompatible Zusammenfassung für den Klassenkonstruktor

(Wenn Sie es satt haben, ständig eine lange Standardzusammenfassung für jeden Konstruktor einzugeben, damit diese der StyleCop-Regel SA1642 entspricht)

Abkürzung : csum

Verfügbar in: C # 2.0+

Initializes a new instance of the <see cref="$classname$"/> class.$END$

Makros:

• Klassenname - Enthält den Typnamen - V.

Assert.AreEqual

Einfache Vorlage zum Hinzufügen von Asserts zu einem Komponententest

Verknüpfung : ae
Verfügbar in : in C # 2.0+ -Dateien, in denen Anweisungen zulässig sind

Assert.AreEqual($expected$, $actual$);$END$

Fließende Version:

Assert.That($expected$, Is.EqualTo($actual$));$END$

Viele Lambdas

Erstellen Sie einen Lambda-Ausdruck mit einer anderen Variablendeklaration, um das Verschachteln zu vereinfachen.

Abkürzung: la, lb, lc

Verfügbar in: C # 3.0+ -Dateien, in denen Ausdrucks- oder Abfrageklauseln zulässig sind

la ist definiert als:

x => x.$END$

lb ist definiert als:

y => y.$END$

lc ist definiert als:

z => z.$END$

Dies ähnelt Sean Kearon oben, außer dass ich mehrere Lambda-Live-Vorlagen für das einfache Verschachteln von Lambdas definiere. " la " wird am häufigsten verwendet, aber andere sind nützlich, wenn Sie mit Ausdrücken wie diesen umgehen:

items.ForEach(x => x.Children.ForEach(y => Console.WriteLine(y.Name)));

Warte darauf...

Pause für Benutzereingaben vor dem Ende einer Konsolenanwendung.

Verknüpfung: Pause

Verfügbar in: C # 2.0+ -Dateien, in denen Anweisungen zulässig sind

System.Console.WriteLine("Press <ENTER> to exit...");
System.Console.ReadLine();$END$

Generierung von Abhängigkeitseigenschaften

Erzeugt eine Abhängigkeitseigenschaft

Verknüpfung: dp
Verfügbar in: C # 3.0, wo die Mitgliederdeklaration zulässig ist

public static readonly System.Windows.DependencyProperty $PropertyName$Property =
        System.Windows.DependencyProperty.Register("$PropertyName$",
                                                   typeof ($PropertyType$),
                                                   typeof ($OwnerType$));

    public $PropertyType$ $PropertyName$
    {
        get { return ($PropertyType$) GetValue($PropertyName$Property); }
        set { SetValue($PropertyName$Property, value); }
    }

$END$

Makroeigenschaften (falls vorhanden):

PropertyName - Kein Makro - # 3
PropertyType - Zu diesem Zeitpunkt erwarteter Vermutungstyp - # 2
OwnerType - Enthält den Typnamen - kein bearbeitbares Vorkommen

Benachrichtigen Sie die geänderte Eigenschaft

Dies ist mein Favorit, weil ich es oft benutze und es viel Arbeit für mich erledigt.

Verknüpfung : npc

Verfügbar in : C # 2.0+, wo Ausdruck erlaubt ist.

if (value != _$LOWEREDMEMBER$)
{
  _$LOWEREDMEMBER$ = value;
  NotifyPropertyChanged("$MEMBER$");
}

Makros :

• MITGLIED - Enthält den Namen des Mitgliedstyps. Nicht bearbeitbar. Hinweis: Stellen Sie sicher, dass dieser zuerst in der Liste steht.
• LOWEREDMEMBER - Wert von MEMBER mit dem ersten Zeichen in Kleinbuchstaben. Nicht bearbeitbar.

Verwendung : In einem Property Setter wie folgt:

private string _dateOfBirth;
public string DateOfBirth
{
   get { return _dateOfBirth; }
   set
   {
      npc<--tab from here
   }
}

Es wird davon ausgegangen, dass Ihre Hintergrundvariable mit einem "_" beginnt. Ersetzen Sie dies durch alles, was Sie verwenden. Es wird auch davon ausgegangen, dass Sie eine Eigenschaftsänderungsmethode wie die folgende haben:

private void NotifyPropertyChanged(String info)
{
   if (PropertyChanged != null)
   {
      PropertyChanged(this, new PropertyChangedEventArgs(info));
   }
}

In Wirklichkeit basiert die Version, die ich benutze, auf Lambda (weil ich meine Lambdas liebe!) Und produziert das Folgende. Die Prinzipien sind die gleichen wie oben.

public decimal CircuitConductorLive
{
   get { return _circuitConductorLive; }
   set { Set(x => x.CircuitConductorLive, ref _circuitConductorLive, value); }
}

Dann verwende ich nicht das äußerst elegante und nützliche PostSharp, um die gesamte INotifyPropertyChanged-Sache ohne Anstrengung auszuführen .

Quick ExpectedException Shortcut

Nur eine kurze Verknüpfung zum Hinzufügen zu meinen Unit-Test-Attributen.

Abkürzung : ee

Verfügbar in : Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration von Typmitgliedern zulässig ist

[ExpectedException(typeof($TYPE$))]

AutoMapper-Eigenschaftszuordnung

Abkürzung: fm

Verfügbar in: C # 2.0+ -Dateien, in denen Anweisungen zulässig sind

.ForMember(d => d$property$, o => o.MapFrom(s => s$src_property$))
$END$

Makros:

• Eigentum - bearbeitbares Vorkommen
• src_property - bearbeitbares Vorkommen

Hinweis:

Ich lasse den Lambda "Punkt" weg, damit ich schlagen kann. sofort und Eigentum Intellisense bekommen. Benötigt AutoMapper ( http://automapper.codeplex.com/ ).

Erstellen Sie einen Testfall-Stub für NUnit

Dieser kann als Erinnerung (an die zu implementierende oder zu testende Funktionalität) dienen, die im Unit-Test-Runner angezeigt wird (wie jeder andere ignorierte Test).

Verknüpfung: nts
Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration von Typmitgliedern zulässig ist

[Test, Ignore]
public void $TestName$()
{
    throw new NotImplementedException();
}
$END$

Bei Bedarf aufrufen

Nützlich bei der Entwicklung von WinForms-Anwendungen, bei denen eine Methode von Nicht-UI-Threads aufgerufen werden kann und diese Methode dann den Aufruf an den UI-Thread weiterleitet.

Verknüpfung : inv

Verfügbar in : Die Anweisung C # 3.0+ files ist zulässig

if (InvokeRequired)
{
    Invoke((System.Action)delegate { $METHOD_NAME$($END$); });
    return;
}

Makros

• METHOD_NAME - Enthält den Namen des Typmitglieds

Normalerweise verwenden Sie diese Vorlage als erste Anweisung in einer bestimmten Methode. Das Ergebnis ähnelt:

void DoSomething(Type1 arg1)
{
    if (InvokeRequired)
    {
        Invoke((Action)delegate { DoSomething(arg1); });
        return;
    }

    // Rest of method will only execute on the correct thread
    // ...
}

Neue C # Guid

Generiert eine neue System.Guid-Instanz, die mit einem neu generierten Guid-Wert initialisiert wurde

Verknüpfung: csguid Verfügbar in: in C # 2.0+ -Dateien

new System.Guid("$GUID$")

Makroeigenschaften :

• GUID - Neue GUID - Falsch

MSTest-Testmethode

Das ist ein bisschen lahm, aber es ist nützlich. Hoffentlich wird jemand einen Nutzen daraus ziehen.

Verknüpfung: testMethod

Verfügbar in: C # 2.0

[TestMethod]
public void $TestName$()
{
    throw new NotImplementedException();

    //Arrange.

    //Act.

    //Assert.
}

$END$

NUnit Setup-Methode

Verknüpfung: Setup
Verfügbar in: Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration eines Typmitglieds zulässig ist

[NUnit.Framework.SetUp]
public void SetUp()
{
    $END$
}

NUnit Teardown-Methode

Verknüpfung: Teardown
Verfügbar in: Verfügbar in: C # 2.0+ -Dateien, in denen die Deklaration eines Typmitglieds zulässig ist

[NUnit.Framework.TearDown]
public void TearDown()
{
    $END$
}

Erstellen Sie eine Überprüfung der Integrität, um sicherzustellen, dass ein Argument niemals null ist

Verknüpfung: eann
Verfügbar in: C # 2.0+ -Dateien, in denen die Typanweisung zulässig ist

Enforce.ArgumentNotNull($inner$, "$inner$");

Makros:

• inner - Parameter vorschlagen - # 1

Anmerkungen: Obwohl dieses Snippet auf Open Source .NET Lokad.Shared- Bibliotheken abzielt , kann es problemlos an jede andere Art der Argumentprüfung angepasst werden.

Neue COM-Klasse

Verknüpfung : Klasse

Verfügbar in : C # 2.0+ -Dateien, in denen eine Typmitgliedsdeklaration oder eine Namespace-Deklaration zulässig ist

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[Guid("$GUID$")]
public class $NAME$ : $INTERFACE$
{
    $END$
}

Makros

• GUID - Neue GUID
• NAME - Bearbeitbar
• SCHNITTSTELLE - Bearbeitbar

Assert Invoke nicht erforderlich

Nützlich bei der Entwicklung von WinForms-Anwendungen, bei denen Sie sicherstellen möchten, dass der Code auf dem richtigen Thread für ein bestimmtes Element ausgeführt wird. Beachten Sie, dass Controlimplementiert ISynchronizeInvoke.

Abkürzung : ani

Verfügbar in : Die Anweisung C # 2.0+ files ist zulässig

Debug.Assert(!$SYNC_INVOKE$.InvokeRequired, "InvokeRequired");

Makros

• SYNC_INVOKE - Variable von vorschlagenSystem.ComponentModel.ISynchronizeInvoke

Trace - Writeline mit Format

Sehr einfache Vorlage zum Hinzufügen eines Trace mit einer formatierten Zeichenfolge (wie Debug.WriteLine bereits unterstützt).

Abkürzung: twlf
Verfügbar in: C # 2.0+ -Dateien, in denen Anweisungen zulässig sind

Trace.WriteLine(string.Format("$MASK$",$ARGUMENT$));

Makroeigenschaften:

• Argument - value- EditableOccurence
• Maske - "{0}"- EditableOccurence

Neue gefälschte Typemock-Isolator

Verknüpfung : gefälscht
Verfügbar in : [in c # 2.0-Dateien, in denen Anweisungen zulässig sind]

$ TYPE $ $ Name $ Fake = Isolate.Fake.Instance ();
Isolate.WhenCalled (() => $ Name $ Fake.)

Makroeigenschaften:
* $ TYPE $ - Typ für eine neue Variable vorschlagen
* $ Name $ - Wert einer anderen Variablen ( Typ ) mit dem ersten Zeichen in Kleinbuchstaben

Da ich gerade mit Unity zusammenarbeite, habe ich mir einige ausgedacht, um mein Leben ein bisschen einfacher zu machen:

Geben Sie Alias ​​ein

Verknüpfung : ta
Verfügbar in : * .xml; * .config

<typeAlias alias="$ALIAS$" type="$TYPE$,$ASSEMBLY$"/>

Typdeklaration

Dies ist ein Typ ohne Namen und ohne Argumente

Verknüpfung : tp
Verfügbar in : * .xml; * .config

<type type="$TYPE$" mapTo="$MAPTYPE$"/>

Typdeklaration (mit Namen)

Dies ist ein Typ mit Namen und ohne Argumente

Verknüpfung : tn
Verfügbar in : * .xml; * .config

<type type="$TYPE$" mapTo="$MAPTYPE$" name="$NAME$"/>

Typdeklaration mit Konstruktor

Dies ist ein Typ mit Namen und ohne Argumente

Verknüpfung : tpc
Verfügbar in : * .xml; * .config

<type type="$TYPE$" mapTo="$MAPTYPE$">
  <typeConfig>
    <constructor>
        $PARAMS$
    </constructor>
  </typeConfig>
</type>

etc....

log4net XML-Konfigurationsblock

Sie können die Vorlage direkt importieren:

<TemplatesExport family="Live Templates">
  <Template uid="49c599bb-a1ec-4def-a2ad-01de05799843" shortcut="log4" description="inserts log4net XML configuration block" text="  &lt;configSections&gt;&#xD;&#xA;    &lt;section name=&quot;log4net&quot; type=&quot;log4net.Config.Log4NetConfigurationSectionHandler,log4net&quot; /&gt;&#xD;&#xA;  &lt;/configSections&gt;&#xD;&#xA;&#xD;&#xA;  &lt;log4net debug=&quot;false&quot;&gt;&#xD;&#xA;    &lt;appender name=&quot;LogFileAppender&quot; type=&quot;log4net.Appender.RollingFileAppender&quot;&gt;&#xD;&#xA;      &lt;param name=&quot;File&quot; value=&quot;logs\\$LogFileName$.log&quot; /&gt;&#xD;&#xA;      &lt;param name=&quot;AppendToFile&quot; value=&quot;false&quot; /&gt;&#xD;&#xA;      &lt;param name=&quot;RollingStyle&quot; value=&quot;Size&quot; /&gt;&#xD;&#xA;      &lt;param name=&quot;MaxSizeRollBackups&quot; value=&quot;5&quot; /&gt;&#xD;&#xA;      &lt;param name=&quot;MaximumFileSize&quot; value=&quot;5000KB&quot; /&gt;&#xD;&#xA;      &lt;param name=&quot;StaticLogFileName&quot; value=&quot;true&quot; /&gt;&#xD;&#xA;&#xD;&#xA;      &lt;layout type=&quot;log4net.Layout.PatternLayout&quot;&gt;&#xD;&#xA;        &lt;param name=&quot;ConversionPattern&quot; value=&quot;%date [%3thread] %-5level %-40logger{3} - %message%newline&quot; /&gt;&#xD;&#xA;      &lt;/layout&gt;&#xD;&#xA;    &lt;/appender&gt;&#xD;&#xA;&#xD;&#xA;    &lt;appender name=&quot;ConsoleAppender&quot; type=&quot;log4net.Appender.ConsoleAppender&quot;&gt;&#xD;&#xA;      &lt;layout type=&quot;log4net.Layout.PatternLayout&quot;&gt;&#xD;&#xA;        &lt;param name=&quot;ConversionPattern&quot; value=&quot;%message%newline&quot; /&gt;&#xD;&#xA;      &lt;/layout&gt;&#xD;&#xA;    &lt;/appender&gt;&#xD;&#xA;&#xD;&#xA;    &lt;root&gt;&#xD;&#xA;      &lt;priority value=&quot;DEBUG&quot; /&gt;&#xD;&#xA;      &lt;appender-ref ref=&quot;LogFileAppender&quot; /&gt;&#xD;&#xA;    &lt;/root&gt;&#xD;&#xA;  &lt;/log4net&gt;&#xD;&#xA;" reformat="False" shortenQualifiedReferences="False">
    <Context>
      <FileNameContext mask="*.config" />
    </Context>
    <Categories />
    <Variables>
      <Variable name="LogFileName" expression="getOutputName()" initialRange="0" />
    </Variables>
    <CustomProperties />
  </Template>
</TemplatesExport>

Methode virtuell machen

Fügt ein virtuelles Schlüsselwort hinzu. Besonders nützlich bei Verwendung von NHibernate, EF oder einem ähnlichen Framework, bei dem Methoden und / oder Eigenschaften virtuell sein müssen, um ein verzögertes Laden oder Proxying zu ermöglichen.

Verknüpfung: v

Verfügbar in: C # 2.0+ -Datei, in der die Deklaration eines Typmitglieds zulässig ist

virtual $END$

Der Trick hier ist der Raum nach virtuell, der oben schwer zu sehen sein könnte. Die eigentliche Vorlage ist "virtual $ END $" mit aktiviertem Neuformatierungscode. Auf diese Weise können Sie zum Einfügepunkt unten (gekennzeichnet mit |) gehen und v eingeben:

public |string Name { get; set; }