¿Qué plantillas de ReSharper 4.0 para C # usas?

Compartamos estos en el siguiente formato:

[Título]

Descripción opcional

Atajo: atajo
Disponible en: [AvailabilitySetting]

// Resharper template code snippet
// comes here

Propiedades de macros (si están presentes):

• Macro1 - Valor - Precisión editable
• Macro2 - Valor - Precisión editable

• ¡Una macro por respuesta, por favor!
• Aquí hay algunos ejemplos para el dispositivo de prueba NUnit y el caso de prueba Standalone NUnit que describen plantillas en vivo en el formato sugerido.

Lambda simple

Tan simple, tan útil, un pequeño lambda:

Atajo : x

Disponible : C # donde se permite la expresión.

x => x.$END$

Macros: ninguna.

Implementar el método 'Dispose (bool)'

Implementar el patrón de eliminación de Joe Duffy

Atajo: desechar

Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de 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;

Propiedades de macros :

• MIEMBRO - Sugerir variable de System.IDisposable - Ocurrencia editable # 1
• CLASE : contiene el nombre del tipo

Crear un nuevo dispositivo de prueba de unidad para algún tipo

Acceso directo: ntf
Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo o la declaración de espacio de nombres

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

Macros:

• TypeToTest - ninguno - # 2
• Prueba - ninguna - V

Compruebe si una cadena es nula o está vacía.

Si está utilizando .Net 4, es posible que prefiera utilizar string.IsNullOrWhiteSpace ().

Atajo : sne

Disponible en : C # 2.0+ donde se permite la expresión.

string.IsNullOrEmpty($VAR$)

Propiedades macro :

• VAR: sugiere una variable de tipo cadena. Editable = verdadero.

Crear un nuevo caso de prueba de unidad independiente

Acceso directo: ntc
Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

Macros:

• Prueba - ninguna - V

Declare un registrador log4net para el tipo actual.

Atajo: registro

Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

Propiedades de macros :

• TYPE : contiene el nombre del tipo

Prueba de unidad de prueba de MS

Nueva prueba MS Test Unit con sintaxis AAA y la convención de nomenclatura que se encuentra en Art Of Unit Testing

Acceso directo: prueba (o tst, o lo que desee)
Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

    // Act


    // Assert

}

Propiedades de macros (si están presentes):

• MethodName : el nombre del método bajo prueba
• StateUnderTest : el estado que está intentando probar
• Comportamiento esperado : lo que espera que suceda

Compruebe si la variable es nula

Acceso directo: ifn
Disponible en: archivos C # 2.0+

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

Compruebe si la variable no es nula

Acceso directo: ifnn
Disponible en: archivos C # 2.0+

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

Escriba un resumen compatible con StyleCop para el constructor de clases

(si está cansado de escribir constantemente un resumen estándar largo para cada constructor para que cumpla con la regla StyleCop SA1642)

Atajo: csum

Disponible en: C # 2.0+

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

Macros:

• classname : contiene el nombre del tipo: V

Assert.AreEqual

Plantilla simple para agregar afirmaciones a una prueba unitaria

Acceso directo : ae
Disponible en : en archivos C # 2.0+ donde se permite la declaración

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

Versión fluida:

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

Muchas Lambdas

Cree una expresión lambda con una declaración de variable diferente para facilitar el anidamiento.

Atajo: la, lb, lc

Disponible en: archivos C # 3.0+ donde se permite la expresión o cláusula de consulta

la se define como:

x => x.$END$

lb se define como:

y => y.$END$

lc se define como:

z => z.$END$

Esto es similar a Sean Kearon anterior, excepto que defino múltiples plantillas lambda en vivo para anidar fácilmente lambdas. " la " es el más utilizado, pero otros son útiles cuando se trata de expresiones como esta:

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

Espéralo ...

Haga una pausa para la entrada del usuario antes de que finalice una aplicación de consola.

Atajo: pausa

Disponible en: archivos C # 2.0+ donde se permite la declaración

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

Generación de propiedades de dependencia

Genera una propiedad de dependencia

Atajo: dp
Disponible en: C # 3.0 donde se permite la declaración de miembros

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$

Propiedades de macros (si están presentes):

PropertyName - Sin macro - # 3
PropertyType - Adivina el tipo esperado en este punto - # 2
OwnerType - Contiene el nombre del tipo - sin ocurrencia editable

Notificar cambio de propiedad

Este es mi favorito porque lo uso a menudo y me resulta muy útil.

Atajo : npc

Disponible en : C # 2.0+ donde se permite la expresión.

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

Macros :

• MIEMBRO: contiene el nombre del tipo de miembro. No editable. Nota: asegúrese de que este sea el primero en la lista.
• LOWEREDMEMBER: valor de MEMBER con el primer carácter en minúsculas. No editable.

Uso : Dentro de un establecedor de propiedades como este:

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

Asume que su variable de respaldo comienza con un "_". Reemplaza esto con lo que uses. También asume que tiene un método de cambio de propiedad similar a este:

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

En realidad, la versión de esto que uso está basada en lambda (¡porque me encantan mis lambdas!) Y produce lo siguiente. Los principios son los mismos que los anteriores.

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

Ahí es cuando no estoy usando PostSharp extremadamente elegante y útil para hacer todo el proceso de INotifyPropertyChanged sin esfuerzo , es decir.

Atajo rápido de excepción esperada

Solo un atajo rápido para agregar a mis atributos de prueba unitaria.

Atajo : ee

Disponible en : Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

[ExpectedException(typeof($TYPE$))]

Asignación de propiedades de AutoMapper

Atajo: fm

Disponible en: archivos C # 2.0+ donde se permite la declaración

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

Macros:

• propiedad - ocurrencia editable
• src_property - ocurrencia editable

Nota:

Dejo el "punto" lambda apagado para poder golpear. inmediatamente y obtener propiedad intellisense. Requiere AutoMapper ( http://automapper.codeplex.com/ ).

Crear código auxiliar de caso de prueba para NUnit

Este podría servir como un recordatorio (de la funcionalidad para implementar o probar) que aparece en el corredor de pruebas unitarias (como cualquier otra prueba ignorada),

Acceso directo: nts
Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

Invocar si es necesario

Útil cuando se desarrollan aplicaciones de WinForms en las que un método debe poder llamarse desde subprocesos que no son de la interfaz de usuario, y ese método debe luego asignar la llamada al subproceso de la interfaz de usuario.

Atajo : inv

Disponible en : Se permite la declaración de archivos C # 3.0+

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

Macros

• METHOD_NAME : contiene el nombre del miembro del tipo

Normalmente usaría esta plantilla como la primera declaración en un método dado y el resultado es similar a:

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

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

Nueva guía de C #

Genera una nueva instancia de System.Guid inicializada a un nuevo valor de guid generado

Acceso directo: csguid Disponible en: en archivos C # 2.0+

new System.Guid("$GUID$")

Propiedades de macros :

• GUID - Nuevo GUID - Falso

Método de prueba MSTest

Esto es un poco escaso pero útil. Con suerte, alguien obtendrá algo de utilidad.

Atajo: testMethod

Disponible en: C # 2.0

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

    //Arrange.

    //Act.

    //Assert.
}

$END$

Método de configuración de NUnit

Acceso directo: configuración
Disponible en: Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

Método de desmontaje de NUnit

Acceso directo: desmontaje
Disponible en: Disponible en: archivos C # 2.0+ donde se permite la declaración de miembro de tipo

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

Cree una verificación de cordura para asegurarse de que un argumento nunca sea nulo

Acceso directo: eann
Disponible en: archivos C # 2.0+ donde se permite la declaración de tipo

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

Macros:

• inner - Sugerir parámetro - # 1

Observaciones: aunque este fragmento se dirige a la biblioteca de código abierto .NET Lokad.Shared , podría adaptarse fácilmente a cualquier otro tipo de verificación de argumentos.

Nueva clase COM

Atajo : comclass

Disponible en : archivos C # 2.0+ donde se permite la declaración de miembro de tipo o la declaración de espacio de nombres

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

Macros

• GUID : nuevo GUID
• NAME : editable
• INTERFAZ - Editable

Assert Invoke No Required

Útil cuando se desarrollan aplicaciones de WinForms en las que desea asegurarse de que el código se esté ejecutando en el hilo correcto para un elemento determinado. Tenga en cuenta que Controlimplements ISynchronizeInvoke.

Atajo : ani

Disponible en : Se permite la declaración de archivos C # 2.0+

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

Macros

• SYNC_INVOKE - Sugerir variable deSystem.ComponentModel.ISynchronizeInvoke

Trace - Writeline, con formato

Plantilla muy simple para agregar un rastro con una cadena formateada (como ya es compatible con Debug.WriteLine).

Acceso directo: twlf
Disponible en: archivos C # 2.0+ donde se permite la declaración

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

Propiedades de macros:

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

Nuevo aislador Typemock falso

Atajo : falso
Disponible en : [en archivos c # 2.0 donde se permite la declaración]

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

Propiedades de las macros:
* $ TYPE $ - Sugerir tipo para una nueva variable
* $ Name $ - Valor de otra variable ( Tipo ) con el primer carácter en minúsculas

Como estoy trabajando con Unity en este momento, se me han ocurrido algunos para hacer mi vida un poco más fácil:

Tipo de alias

Atajo : ta
Disponible en : * .xml; * .config

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

Declaración de tipo

Este es un tipo sin nombre y sin argumentos

Atajo : tp
Disponible en : * .xml; * .config

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

Declaración de tipo (con nombre)

Este es un tipo con nombre y sin argumentos

Atajo : tn
Disponible en : * .xml; * .config

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

Declaración de tipo con constructor

Este es un tipo con nombre y sin argumentos

Atajo : tpc
Disponible en : * .xml; * .config

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

etc ....

Bloque de configuración XML log4net

Puede importar la plantilla directamente:

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

Hacer que el método sea virtual

Agrega una palabra clave virtual. Especialmente útil cuando se usa NHibernate, EF o un marco similar donde los métodos y / o propiedades deben ser virtuales para permitir la carga diferida o el proxy.

Atajo: v

Disponible en: archivo C # 2.0+ donde se permite la declaración de miembro de tipo

virtual $END$

El truco aquí es el espacio después de virtual, que puede ser difícil de ver arriba. La plantilla real es "virtual $ END $" con el código de reformateo habilitado. Esto le permite ir al punto de inserción a continuación (indicado por |) y escribir v:

public |string Name { get; set; }