Quali modelli ReSharper 4.0 per C # usi?

Condividiamoli nel seguente formato:

[Titolo]

Descrizione facoltativa

Scorciatoia: scorciatoia
Disponibile in: [AvailabilitySetting]

// Resharper template code snippet
// comes here

Proprietà delle macro (se presenti):

• Macro1 - Valore - EditableOccurence
• Macro2 - Valore - EditableOccurence

• Una macro per risposta, per favore!
• Di seguito sono riportati alcuni esempi per il dispositivo di test NUnit e il test case Standalone NUnit che descrivono modelli live nel formato suggerito.

Lambda semplice

Così semplice, così utile - un po 'di lambda:

Scorciatoia : x

Disponibile : C # dove è consentita l'espressione.

x => x.$END$

Macro: nessuna.

Implementa il metodo "Dispose (bool)"

Implementa il modello Dispose di Joe Duffy

Scorciatoia: smaltire

Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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;

Proprietà delle macro :

• MEMBER - Suggerisci una variabile di System.IDisposable - Editable Occurence # 1
• CLASS - contenente il nome del tipo

Crea un nuovo dispositivo di unit test per qualche tipo

Collegamento: ntf
Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo o la dichiarazione dello spazio dei nomi

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

Macro:

• TypeToTest - nessuno - # 2
• Test - nessuno - V

Controlla se una stringa è nulla o vuota.

Se stai usando .Net 4 potresti preferire usare string.IsNullOrWhiteSpace ().

Scorciatoia : sne

Disponibile in : C # 2.0+ dove è consentita l'espressione.

string.IsNullOrEmpty($VAR$)

Proprietà macro :

• VAR: suggerisce una variabile di tipo stringa. Modificabile = vero.

Crea un nuovo caso di unit test autonomo

Collegamento: ntc
Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

Macro:

• Test - nessuno - V

Dichiarare un logger log4net per il tipo corrente.

Scorciatoia: registro

Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

Proprietà delle macro :

• TIPO : contenente il nome del tipo

MS Test Unit Test

Nuovo test unitario di test MS utilizzando la sintassi AAA e la convenzione di denominazione che si trova in Art Of Unit Testing

Scorciatoia: testing (o tst, o quello che vuoi)
Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

    // Act


    // Assert

}

Proprietà delle macro (se presenti):

• MethodName : il nome del metodo sottoposto a test
• StateUnderTest : lo stato che stai tentando di testare
• ExpectedBehavior - Cosa ti aspetti che accada

Controlla se la variabile è nulla

Scorciatoia: ifn
Disponibile in: C # 2.0+ file

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

Controlla se la variabile non è nulla

Scorciatoia: ifnn
Disponibile in: C # 2.0+ file

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

Scrivi un riepilogo conforme a StyleCop per il costruttore di classi

(se sei stanco di digitare costantemente un lungo riepilogo standard per ogni costruttore in modo che sia conforme alla regola StyleCop SA1642)

Scorciatoia: csum

Disponibile in: C # 2.0+

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

Macro:

• classname - contenente il nome del tipo - V

Assert.AreEqual

Modello semplice per aggiungere asserzioni a uno unit test

Collegamento : ae
Disponibile in : nei file C # 2.0+ in cui è consentita l'istruzione

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

Versione fluente:

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

Ci sono un sacco di Lambdas

Crea un'espressione lambda con una dichiarazione di variabile diversa per una facile nidificazione.

Scorciatoia: la, lb, lc

Disponibile in: C # 3.0+ file in cui sono consentite espressioni o clausole di query

la è definita come:

x => x.$END$

lb è definito come:

y => y.$END$

lc è definito come:

z => z.$END$

Questo è simile a Sean Kearon sopra, tranne per il fatto che definisco più modelli live lambda per un facile annidamento dei lambda. " la " è più comunemente usato, ma altri sono utili quando si tratta di espressioni come questa:

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

Aspettalo...

Pausa per l'input dell'utente prima della fine di un'applicazione console.

Scorciatoia: pausa

Disponibile in: C # 2.0+ file in cui è consentita l'istruzione

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

Generazione di proprietà di dipendenza

Genera una proprietà di dipendenza

Scorciatoia: dp
Disponibile in: C # 3.0 dove è consentita la dichiarazione dei membri

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$

Proprietà delle macro (se presenti):

PropertyName - Nessuna macro - # 3
PropertyType - Indovina il tipo previsto a questo punto - # 2
OwnerType - Contiene il nome del tipo - nessuna occorrenza modificabile

Notifica proprietà modificata

Questo è il mio preferito perché lo uso spesso e fa molto lavoro per me.

Scorciatoia : npc

Disponibile in : C # 2.0+ dove è consentita l'espressione.

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

Macro :

• MEMBER: contenente il nome del tipo di membro. Non modificabile. Nota: assicurati che questo sia il primo nell'elenco.
• LOWEREDMEMBER - Valore di MEMBER con il primo carattere in minuscolo. Non modificabile.

Utilizzo : all'interno di un setter di proprietà come questo:

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

Si presuppone che la variabile di supporto inizi con "_". Sostituiscilo con quello che usi. Presuppone inoltre che tu abbia un metodo di modifica delle proprietà simile a questo:

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

In realtà, la versione di questo che uso è basata su lambda (perché adoro i miei lambda!) E produce quanto segue. I principi sono gli stessi di cui sopra.

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

È allora che non sto usando PostSharp estremamente elegante e utile per fare l'intera cosa di INotifyPropertyChanged senza alcuno sforzo , cioè.

Collegamento rapido ExpectedException

Solo una rapida scorciatoia da aggiungere ai miei attributi di unit test.

Scorciatoia : ee

Disponibile in : Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

[ExpectedException(typeof($TYPE$))]

Mappatura proprietà AutoMapper

Scorciatoia: fm

Disponibile in: C # 2.0+ file in cui è consentita l'istruzione

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

Macro:

• proprietà - occorrenza modificabile
• src_property - occorrenza modificabile

Nota:

Lascio il "punto" lambda spento in modo che possa colpire. immediatamente e ottenere proprietà intellisense. Richiede AutoMapper ( http://automapper.codeplex.com/ ).

Crea uno stub di test case per NUnit

Questo potrebbe servire come promemoria (della funzionalità da implementare o testare) che si presenta nel runner di unit test (come qualsiasi altro test ignorato),

Collegamento: nts
Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

Invoca se necessario

Utile durante lo sviluppo di applicazioni WinForms in cui un metodo deve essere richiamabile da thread non dell'interfaccia utente e tale metodo dovrebbe quindi eseguire il marshalling della chiamata sul thread dell'interfaccia utente.

Scorciatoia : inv

Disponibile in : L'istruzione file C # 3.0+ è consentita

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

Macro

• METHOD_NAME : contenente il nome del membro del tipo

Normalmente useresti questo modello come prima istruzione in un dato metodo e il risultato è simile a:

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

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

Nuovo C # Guid

Genera una nuova istanza System.Guid inizializzata con un nuovo valore guid generato

Collegamento: csguid Disponibile in: nei file C # 2.0+

new System.Guid("$GUID$")

Proprietà delle macro :

• GUID - Nuovo GUID - Falso

Metodo di prova MSTest

Questo è un po 'noioso ma è utile. Si spera che qualcuno ne trarrà vantaggio.

Scorciatoia: testMethod

Disponibile in: C # 2.0

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

    //Arrange.

    //Act.

    //Assert.
}

$END$

Metodo di installazione di NUnit

Collegamento: installazione
Disponibile in: Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

Metodo NUnit Teardown

Scorciatoia: smontaggio
Disponibile in: Disponibile in: C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo

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

Crea un controllo di integrità per assicurarti che un argomento non sia mai nullo

Collegamento: eann
Disponibile in: C # 2.0+ file in cui è consentita l'istruzione type

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

Macro:

• interno - Suggerisci parametro - # 1

Note: sebbene questo frammento di codice sia destinato alla libreria .NET Lokad.Shared open source , potrebbe essere facilmente adattato a qualsiasi altro tipo di controllo degli argomenti.

Nuova classe COM

Scorciatoia : comclass

Disponibile in : C # 2.0+ file in cui è consentita la dichiarazione del membro del tipo o la dichiarazione dello spazio dei nomi

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

Macro

• GUID - Nuovo GUID
• NOME - Modificabile
• INTERFACCIA - Modificabile

Asserire Invoke Not Required

Utile durante lo sviluppo di applicazioni WinForms in cui si desidera essere sicuri che il codice venga eseguito sul thread corretto per un determinato elemento. Nota che Controlimplementa ISynchronizeInvoke.

Scorciatoia : ani

Disponibile in : L'istruzione file C # 2.0+ è consentita

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

Macro

• SYNC_INVOKE - Suggerisci una variabile diSystem.ComponentModel.ISynchronizeInvoke

Traccia - Writeline, con formato

Modello molto semplice per aggiungere una traccia con una stringa formattata (come già supportato da Debug.WriteLine).

Scorciatoia: twlf
Disponibile in: C # 2.0+ file dove l'istruzione è consentita

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

Proprietà delle macro:

• Argomento - value- EditableOccurence
• Maschera - "{0}"- EditableOccurence

Nuovo isolatore Typemock falso

Scorciatoia : fake
Disponibile in : [nei file c # 2.0 dove l'istruzione è consentita]

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

Proprietà macro:
* $ TYPE $ - Suggerisci tipo per una nuova variabile
* $ Name $ - Valore di un'altra variabile ( Tipo ) con il primo carattere in minuscolo

Dato che sto lavorando con Unity in questo momento, ne ho escogitati alcuni per semplificarmi la vita:

Digita Alias

Scorciatoia : ta
Disponibile in : * .xml; * .config

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

Tipo di dichiarazione

Questo è un tipo senza nome e senza argomenti

Scorciatoia : tp
Disponibile in : * .xml; * .config

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

Dichiarazione di tipo (con nome)

Questo è un tipo con nome e senza argomenti

Scorciatoia : tn
Disponibile in : * .xml; * .config

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

Dichiarazione di tipo con costruttore

Questo è un tipo con nome e senza argomenti

Scorciatoia : tpc
Disponibile in : * .xml; * .config

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

eccetera....

Log4net XML Configuration Block

Puoi importare il modello direttamente:

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

Rendi il metodo virtuale

Aggiunge una parola chiave virtuale. Particolarmente utile quando si utilizza NHibernate, EF o framework simili in cui i metodi e / o le proprietà devono essere virtuali per abilitare il caricamento lento o il proxy.

Scorciatoia: v

Disponibile in: file C # 2.0+ in cui è consentita la dichiarazione del membro del tipo

virtual $END$

Il trucco qui è lo spazio dopo il virtuale, che potrebbe essere difficile da vedere sopra. Il modello effettivo è "virtual $ END $" con il codice di riformattazione abilitato. Ciò ti consente di andare al punto di inserimento sottostante (indicato con |) e digitare v:

public |string Name { get; set; }