c# - instalar - resharper para visual studio 2013
¿Qué plantillas de ReSharper 4+ live para C#usas? (30)
Assert Invoke Not Required
Es útil al desarrollar aplicaciones WinForms donde quiere asegurarse de que el código se esté ejecutando en el hilo correcto para un artículo dado. Tenga en cuenta que Control implementa 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 de
System.ComponentModel.ISynchronizeInvoke
¿Qué plantillas ReSharper 4.0 para C # usas?
Vamos a compartir esto 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 - EditableOccurence
- Macro2 - Valor - EditableOccurence
- Una macro por respuesta, por favor!
- Aquí hay algunas muestras para el accesorio de prueba NUnit y el caso de prueba Standalone NUnit que describen plantillas en vivo en el formato sugerido.
Invocar si se requiere
Es útil cuando se desarrollan aplicaciones WinForms donde un método debe ser invocable desde subprocesos no UI, y ese método debe ordenar la llamada en el subproceso UI.
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 - que contiene el nombre de miembro de tipo
Normalmente usaría esta plantilla como la primera declaración en un método dado y el resultado se asemeja a:
void DoSomething(Type1 arg1)
{
if (InvokeRequired)
{
Invoke((Action)delegate { DoSomething(arg1); });
return;
}
// Rest of method will only execute on the correct thread
// ...
}
Nueva clase COM
Acceso directo : comclass
Disponible en : C # 2.0+ archivos donde se permite la declaración de tipo de miembro o declaración de espacio de nombres
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[Guid("$GUID$")]
public class $NAME$ : $INTERFACE$
{
$END$
}
Macros
- GUID - Nueva GUID
- NOMBRE - Editable
- INTERFAZ - Editable
Nuevo aislador Typemock falso
Atajo : falso
Disponible en : [en archivos c # 2.0 donde se permite la declaración]
$ TYPE $ $ Nombre $ Fake = Aislar.Fake.Instance ();
Aislar.CuandoCalled (() => $ Name $ Fake.)
Propiedades de macros:
* $ TYPE $ - Sugerir tipo para una nueva variable
* $ Name $ - Valor de otra variable ( Type ) con el primer caracter en minúsculas
Asignación de propiedades de AutoMapper
Atajo: fm
Disponible en: C # 2.0+ archivos 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 para que pueda golpear. de inmediato y obtener la propiedad intellisense. Requiere AutoMapper ( http://automapper.codeplex.com/ ).
Atajo de Quick ExpectedException
Solo un atajo rápido para agregar a los atributos de prueba de mi unidad.
Atajo : ee
Disponible en : Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro de tipo
[ExpectedException(typeof($TYPE$))]
Crea un control de cordura para garantizar que un argumento nunca sea nulo
Atajo: eann
Disponible en: C # 2.0+ archivos donde se permite la declaración de tipo
Enforce.ArgumentNotNull($inner$, "$inner$");
Macros:
- inner - Sugerir parámetro - # 1
Comentarios: Aunque este fragmento se dirige a la biblioteca .NET Lokad.Shared código abierto, podría adaptarse fácilmente a cualquier otro tipo de comprobación de argumento.
Crear un apéndice de caso de prueba para NUnit
Éste podría servir como un recordatorio (de funcionalidad para implementar o probar) que aparece en el corredor de prueba de la unidad (como cualquier otra prueba ignorada),
Atajo: nts
Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro tipo
[Test, Ignore]
public void $TestName$()
{
throw new NotImplementedException();
}
$END$
Crear un nuevo accesorio de prueba unitaria para algún tipo
Atajo: ntf
Disponible en: C # 2.0+ archivos donde se permite la declaración de tipo de miembro o 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 - ninguno - V
Crear un nuevo caso de prueba de unidad independiente
Acceso directo: ntc
Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro tipo
[NUnit.Framework.TestAttribute]
public void $Test$()
{
$END$
}
Macros:
- Prueba - ninguno - V
Escribir el resumen de StyleCop para el constructor de la clase
(si está cansado de escribir constantemente un resumen estándar largo para cada constructor, entonces cumple con la regla SA1642 de StyleCop)
Acceso directo: csum
Disponible en: C # 2.0+
Initializes a new instance of the <see cref="$classname$"/> class.$END$
Macros:
- nombre de clase - que contiene nombre de tipo - V
Espera ...
Pausa para la entrada del usuario antes del final de una aplicación de consola.
Atajo: pausa
Disponible en: C # 2.0+ archivos donde se permite la declaración
System.Console.WriteLine("Press <ENTER> to exit...");
System.Console.ReadLine();$END$
Hacer método virtual
Agrega una palabra clave virtual Especialmente útil cuando se utiliza NHibernate, EF o un marco similar donde los métodos y / o propiedades deben ser virtuales para permitir la carga o el proxing perezosos.
Atajo: v
Disponible en: archivo C # 2.0+ donde se permite la declaración de miembro 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 formateo habilitado. Esto le permite ir al punto de inserción a continuación (indicado por |) y escribir v:
public |string Name { get; set; }
Implementar el método ''Dispose (bool)''
Implementar el patrón de eliminación de Joe Duffy
Atajo: disponer
Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro 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 - Editable Occurence # 1
- CLASE - Nombre de tipo que contiene
Lambda simple
Tan simple, tan útil, una pequeña lambda:
Atajo : x
Disponible : C # donde se permite la expresión.
x => x.$END$
Macros: ninguno
Método NUnit Teardown
Atajo: desmontaje
Disponible en: Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro de tipo
[NUnit.Framework.TearDown]
public void TearDown()
{
$END$
}
Método de configuración NUnit
Acceso directo: configuración
Disponible en: Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro de tipo
[NUnit.Framework.SetUp]
public void SetUp()
{
$END$
}
Método de prueba MSTest
Esto es un poco tonto pero es útil. Con suerte, alguien obtendrá alguna utilidad de esto.
Atajo: testMethod
Disponible en: C # 2.0
[TestMethod]
public void $TestName$()
{
throw new NotImplementedException();
//Arrange.
//Act.
//Assert.
}
$END$
Montones de Lambdas
Cree una expresión lambda con una declaración de variable diferente para facilitar la anidación.
Acceso directo: la, lb, lc
Disponible en: C # 3.0+ archivos donde se permite la expresión o la 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 en vivo de lambda para facilitar el anidamiento de lambdas. " la " es la más comúnmente utilizada, pero otras son útiles cuando se trata de expresiones como esta:
items.ForEach(x => x.Children.ForEach(y => Console.WriteLine(y.Name)));
Notificar Propiedad Cambiada
Este es mi favorito porque lo uso a menudo y me ayuda mucho.
Acceso directo : npc
Disponible en : C # 2.0+ donde se permite la expresión.
if (value != _$LOWEREDMEMBER$)
{
_$LOWEREDMEMBER$ = value;
NotifyPropertyChanged("$MEMBER$");
}
Macros :
- MIEMBRO - Nombre del tipo de miembro que contiene. No editable Nota: asegúrese de que este sea el primero en la lista.
- LOWEREDMEMBER - Valor de MIEMBRO con el primer carácter en minúscula. No editable
Uso : dentro de un organizador de propiedades como este:
private string _dateOfBirth;
public string DateOfBirth
{
get { return _dateOfBirth; }
set
{
npc<--tab from here
}
}
Supone que su variable de respaldo comienza con un "_". Reemplace esto con lo que sea que use. También asume que tienes un método de cambio de propiedad como 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 amo a mi lambda!'') Y produce lo siguiente. Los principios son los mismos que los de arriba.
public decimal CircuitConductorLive
{
get { return _circuitConductorLive; }
set { Set(x => x.CircuitConductorLive, ref _circuitConductorLive, value); }
}
Es entonces cuando no estoy usando el PostSharp extremadamente elegante y útil para hacer todo el trabajo de INotifyPropertyChanged sin ningún esfuerzo , es decir.
Nueva guía C #
Genera una nueva instancia de System.Guid inicializada en un nuevo valor guid generado
Acceso directo: csguid Disponible en: en C # 2.0+ archivos
new System.Guid("$GUID$")
Propiedades de macros :
- GUID - Nueva GUID - False
Prueba de unidad de prueba MS
Nueva prueba de MS Test Unit utilizando la sintaxis AAA y la convención de nomenclatura encontrada en el Art of Unit Testing
Acceso directo: prueba (o tst, o lo que quieras)
Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro 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 intenta probar
- Comportamiento esperado : lo que espera que suceda
Trace - Writeline, con formato
Plantilla muy simple para agregar un seguimiento con una cadena formateada (como Debug.WriteLine ya soporta).
Atajo: twlf
Disponible en: C # 2.0+ archivos donde se permite la declaración
Trace.WriteLine(string.Format("$MASK$",$ARGUMENT$));
Propiedades de macros:
- Argumento -
value- EditableOccurence - Máscara -
"{0}"- EditableOccurence
Verifica si una cadena es nula o está vacía.
Si usa .Net 4, puede preferir utilizar string.IsNullOrWhiteSpace ().
Atajo : sne
Disponible en : C # 2.0+ donde se permite la expresión.
string.IsNullOrEmpty($VAR$)
Propiedades de macro :
- VAR: sugiere una variable de tipo cadena. Editable = verdadero
Verificar si la variable es nula
Atajo: ifn
Disponible en: C # 2.0+ archivos
if (null == $var$)
{
$END$
}
Verificar si la variable no es nula
Atajo: ifnn
Disponible en: C # 2.0+ archivos
if (null != $var$)
{
$END$
}
Como estoy trabajando con Unity en este momento, he llegado a algunos para hacer mi vida un poco más fácil:
Tipo Alias
Atajo : ta
Disponible en : * .xml; * .config
<typeAlias alias="$ALIAS$" type="$TYPE$,$ASSEMBLY$"/>
Tipo de declaración
Este es un tipo sin nombre y sin argumentos
Atajo : tp
Disponible en : * .xml; * .config
<type type="$TYPE$" mapTo="$MAPTYPE$"/>
Tipo de declaración (con nombre)
Este es un tipo con nombre y sin argumentos
Atajo : tn
Disponible en : * .xml; * .config
<type type="$TYPE$" mapTo="$MAPTYPE$" name="$NAME$"/>
Escriba la declaración con el 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 ....
Declare un registrador log4net para el tipo actual.
Acceso directo: registro
Disponible en: C # 2.0+ archivos donde se permite la declaración de miembro tipo
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof($TYPE$));
Propiedades de macros :
- TIPO - Nombre de tipo que contiene
Assert.AreEqual
Plantilla simple para agregar aseveraciones a una prueba unitaria
Atajo : ae
Disponible en : en C # 2.0+ archivos donde se permite la declaración
Assert.AreEqual($expected$, $actual$);$END$
Versión fluida:
Assert.That($expected$, Is.EqualTo($actual$));$END$
Bloque de configuración de log4net XML
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=" <configSections>
 <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
 </configSections>

 <log4net debug="false">
 <appender name="LogFileAppender" type="log4net.Appender.RollingFileAppender">
 <param name="File" value="logs//$LogFileName$.log" />
 <param name="AppendToFile" value="false" />
 <param name="RollingStyle" value="Size" />
 <param name="MaxSizeRollBackups" value="5" />
 <param name="MaximumFileSize" value="5000KB" />
 <param name="StaticLogFileName" value="true" />

 <layout type="log4net.Layout.PatternLayout">
 <param name="ConversionPattern" value="%date [%3thread] %-5level %-40logger{3} - %message%newline" />
 </layout>
 </appender>

 <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
 <layout type="log4net.Layout.PatternLayout">
 <param name="ConversionPattern" value="%message%newline" />
 </layout>
 </appender>

 <root>
 <priority value="DEBUG" />
 <appender-ref ref="LogFileAppender" />
 </root>
 </log4net>
" reformat="False" shortenQualifiedReferences="False">
<Context>
<FileNameContext mask="*.config" />
</Context>
<Categories />
<Variables>
<Variable name="LogFileName" expression="getOutputName()" initialRange="0" />
</Variables>
<CustomProperties />
</Template>
</TemplatesExport>
Generación de propiedad de dependencia
Genera una propiedad de dependencia
Atajo: dp
Disponible en: C # 3.0 donde se permite la declaración del miembro
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: tipo esperado de Guess en este punto: n.º 2
OwnerType - Nombre de tipo que contiene - ninguna ocurrencia editable