Quais modelos ReSharper 4.0 para C # você usa?

Vamos compartilhá-los no seguinte formato:

[Título]

Descrição opcional

Atalho: atalho
Disponível em: [AvailabilitySetting]

// Resharper template code snippet
// comes here

Propriedades das macros (se houver):

• Macro1 - Valor - EditableOccurence
• Macro2 - Valor - EditableOccurence

• Uma macro por resposta, por favor!
• Aqui estão alguns exemplos de fixação de teste NUnit e caso de teste NUnit autônomo que descrevem modelos ativos no formato sugerido.

Lambda Simples

Tão simples, tão útil - um pequeno lambda:

Atalho : x

Disponível : C # onde a expressão é permitida.

x => x.$END$

Macros: nenhum.

Implementar método 'Dispose (bool)'

Implementar o padrão de descarte de Joe Duffy

Atalho: dispor

Disponível em: arquivos C # 2.0+ onde a declaração do membro do tipo é permitida

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;

Propriedades das macros :

• MEMBER - Sugerir variável de System.IDisposable - Editable Occurence # 1
• CLASSE - Contendo o nome do tipo

Crie um novo dispositivo de teste de unidade para algum tipo

Atalho: ntf
Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo ou declaração de namespace é permitida

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

Macros:

• TypeToTest - nenhum - # 2
• Teste - nenhum - V

Verifique se uma string é nula ou vazia.

Se você estiver usando .Net 4, você pode preferir usar string.IsNullOrWhiteSpace ().

Atalho : sne

Disponível em : C # 2.0+ onde a expressão é permitida.

string.IsNullOrEmpty($VAR$)

Propriedades da macro :

• VAR - sugere uma variável do tipo string. Editável = verdadeiro.

Crie um novo caso de teste de unidade autônomo

Atalho: ntc
Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

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

Macros:

• Teste - nenhum - V

Declare um criador de logs log4net para o tipo atual.

Atalho: log

Disponível em: arquivos C # 2.0+ onde a declaração do membro do tipo é permitida

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

Propriedades das macros :

• TYPE - Contendo o nome do tipo

Teste de Unidade de Teste MS

Novo teste de unidade de teste MS usando sintaxe AAA e a convenção de nomenclatura encontrada no Art Of Unit Testing

Atalho: teste (ou tst, ou o que você quiser)
Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

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

    // Act


    // Assert

}

Propriedades das macros (se houver):

• MethodName - o nome do método em teste
• StateUnderTest - o estado que você está tentando testar
• ExpectedBehavior - O que você espera que aconteça

Verifique se a variável é nula

Atalho: ifn
Disponível em: arquivos C # 2.0+

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

Verifique se a variável não é nula

Atalho: ifnn
Disponível em: arquivos C # 2.0+

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

Escreva um resumo compatível com StyleCop para o construtor de classe

(se você está cansado de digitar constantemente um longo resumo padrão para cada construtor, de modo que esteja em conformidade com a regra StyleCop SA1642)

Atalho: csum

Disponível em: C # 2.0+

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

Macros:

• classname - Contendo o nome do tipo - V

Assert.AreEqual

Modelo simples para adicionar declarações a um teste de unidade

Atalho : ae
Disponível em : em arquivos C # 2.0+ onde a instrução é permitida

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

Versão fluente:

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

Muitos lambdas

Crie uma expressão lambda com uma declaração de variável diferente para facilitar o aninhamento.

Atalho: la, lb, lc

Disponível em: arquivos C # 3.0+ em que a cláusula de expressão ou consulta é permitida

la é definido como:

x => x.$END$

lb é definido como:

y => y.$END$

lc é definido como:

z => z.$END$

Isso é semelhante ao Sean Kearon acima, exceto que eu defino vários modelos ao vivo lambda para facilitar o aninhamento de lambdas. " la " é o mais comumente usado, mas outros são úteis ao lidar com expressões como esta:

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

Espere por isso...

Faça uma pausa para entrada do usuário antes do final de um aplicativo de console.

Atalho: pausa

Disponível em: arquivos C # 2.0+ onde a instrução é permitida

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

Geração de propriedade de dependência

Gera uma propriedade de dependência

Atalho: dp
Disponível em: C # 3.0 onde a declaração de membro é permitida

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$

Propriedades das macros (se houver):

PropertyName - Sem macro - # 3
PropertyType - Tipo de
estimativa esperado neste ponto - # 2 OwnerType - Contendo o nome do tipo - nenhuma ocorrência editável

Notificar propriedade alterada

Este é o meu favorito porque eu o uso com frequência e ele funciona muito para mim.

Atalho : npc

Disponível em : C # 2.0+ onde a expressão é permitida.

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

Macros :

• MEMBER - Contém o nome do tipo de membro. Não editável. Nota: certifique-se de que este seja o primeiro da lista.
• LOWEREDMEMBER - Valor de MEMBER com o primeiro caractere em minúsculas. Não editável.

Uso : dentro de um configurador de propriedade como este:

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

Ele assume que sua variável de apoio começa com um "_". Substitua isso pelo que você usar. Também pressupõe que você tenha um método de alteração de propriedade parecido com este:

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

Na realidade, a versão que uso é baseada em lambda (porque adoro meus lambdas!) E produz a seguinte. Os princípios são iguais aos anteriores.

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

É quando não estou usando o PostSharp extremamente elegante e útil para fazer toda a coisa do INotifyPropertyChanged sem esforço .

Atalho ExpectedException rápido

Apenas um atalho rápido para adicionar aos meus atributos de teste de unidade.

Atalho : ee

Disponível em : Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

[ExpectedException(typeof($TYPE$))]

Mapeamento de propriedade do AutoMapper

Atalho: fm

Disponível em: arquivos C # 2.0+ onde a instrução é permitida

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

Macros:

• propriedade - ocorrência editável
• src_property - ocorrência editável

Nota:

Deixo o lambda "ponto" desligado para que eu possa acertar. imediatamente e obter intelisense propriedade. Requer AutoMapper ( http://automapper.codeplex.com/ ).

Criar esboço de caso de teste para NUnit

Este pode servir como um lembrete (da funcionalidade para implementar ou testar) que aparece no executor de teste de unidade (como qualquer outro teste ignorado),

Atalho: nts
Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

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

Invocar se necessário

Útil ao desenvolver aplicativos WinForms em que um método deve ser chamado a partir de threads não UI, e esse método deve então empacotar a chamada no thread de UI.

Atalho : inv

Disponível em : A instrução de arquivos C # 3.0+ é permitida

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

Macros

• METHOD_NAME - Contém o nome do membro do tipo

Você normalmente usaria este modelo como a primeira instrução em um determinado método e o resultado será semelhante a:

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

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

Novo C # Guid

Gera uma nova instância System.Guid inicializada com um novo valor guid gerado

Atalho: csguid Disponível em: em arquivos C # 2.0+

new System.Guid("$GUID$")

Propriedades das macros :

• GUID - Novo GUID - Falso

Método de teste MSTest

Isso é um pouco chato, mas é útil. Esperançosamente, alguém obterá alguma utilidade disso.

Atalho: testMethod

Disponível em: C # 2.0

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

    //Arrange.

    //Act.

    //Assert.
}

$END$

Método de configuração NUnit

Atalho: configuração
Disponível em: Disponível em: Arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

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

Método NUnit Teardown

Atalho: teardown
Disponível em: Disponível em: arquivos C # 2.0+ onde a declaração de membro do tipo é permitida

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

Crie uma verificação de integridade para garantir que um argumento nunca seja nulo

Atalho: eann
Disponível em: arquivos C # 2.0+ onde a instrução de tipo é permitida

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

Macros:

• interno - sugestão de parâmetro - nº 1

Observações: Embora este snippet seja direcionado à biblioteca .NET Lokad.Shared de código-fonte aberto , ele pode ser facilmente adaptado a qualquer outro tipo de verificação de argumento.

Nova Classe COM

Atalho : comclass

Disponível em : arquivos C # 2.0+ onde a declaração de membro do tipo ou declaração de namespace é permitida

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

Macros

• GUID - Novo GUID
• NAME - editável
• INTERFACE - Editável

Assert Invoke Not Required

Útil ao desenvolver aplicativos WinForms em que você deseja ter certeza de que o código está sendo executado no thread correto para um determinado item. Observe que Controlimplementa ISynchronizeInvoke.

Atalho : ani

Disponível em : A declaração de arquivos C # 2.0+ é permitida

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

Macros

• SYNC_INVOKE - Sugerir variável deSystem.ComponentModel.ISynchronizeInvoke

Trace - Writeline, com formato

Modelo muito simples para adicionar um traço com uma string formatada (como Debug.WriteLine já suporta).

Atalho: twlf
Disponível em: arquivos C # 2.0+ onde a instrução é permitida

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

Propriedades das macros:

• Argumento - value- EditableOccurence
• Máscara - "{0}"- EditableOccurence

Novo isolador Typemock falso

Atalho : fake
Disponível em : [em arquivos c # 2.0 onde a declaração é permitida]

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

Propriedades das macros:
* $ TYPE $ - Sugerir tipo para uma nova variável
* $ Name $ - Valor de outra variável ( Tipo ) com o primeiro caractere em minúsculas

Como estou trabalhando com o Unity agora, criei alguns para tornar minha vida um pouco mais fácil:

Digite o Alias

Atalho : ta
Disponível em : * .xml; * .config

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

Declaração de tipo

Este é um tipo sem nome e sem argumentos

Atalho : tp
Disponível em : * .xml; * .config

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

Declaração de tipo (com nome)

Este é um tipo com nome e sem argumentos

Atalho : tn
Disponível em : * .xml; * .config

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

Declaração de tipo com construtor

Este é um tipo com nome e sem argumentos

Atalho : tpc
Disponível em : * .xml; * .config

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

etc ....

Bloco de configuração XML log4net

Você pode importar o modelo diretamente:

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

Tornar Método Virtual

Adiciona palavra-chave virtual. Especialmente útil ao usar NHibernate, EF ou estrutura semelhante, onde métodos e / ou propriedades devem ser virtuais para permitir carregamento lento ou proxy.

Atalho: v

Disponível em: arquivo C # 2.0+ onde a declaração do membro do tipo é permitida

virtual $END$

O truque aqui é o espaço depois do virtual, que pode ser difícil de ver acima. O modelo real é "virtual $ END $" com código de reformatação habilitado. Isso permite que você vá para o ponto de inserção abaixo (denotado por |) e digite v:

public |string Name { get; set; }