Simple Lambda

Si simple, si utile – un petit lambda:

Raccourci : x

Disponible : C # où l’expression est autorisée.

 x => x.$END$ 

Macros: aucune.

Implémenter la méthode ‘Dispose (bool)’

Implémenter le pattern Dispose de Joe Duffy

Raccourci: disposer

Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

 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; 

Propriétés des macros :

• MEMBER – Suggérer une variable de System.IDisposable – Occurrence modifiable # 1
• CLASS – Nom du type contenant

Créer un nouveau dispositif de test unitaire pour certains types

Raccourci: ntf
Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre ou la déclaration d’espace de noms est autorisée

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

Macros:

• TypeToTest – aucun – # 2
• Test – aucun – V

Vérifiez si une chaîne est nulle ou vide.

Si vous utilisez .Net 4, vous pouvez préférer utiliser ssortingng.IsNullOrWhiteSpace ().

Raccourci : sne

Disponible dans : C # 2.0+ où expression est autorisée.

 ssortingng.IsNullOrEmpty($VAR$) 

Propriétés de la macro :

• VAR – suggère une variable de type ssortingng. Editable = true.

Créer un nouveau cas de test unitaire autonome

Raccourci: ntc
Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Macros:

• Test – aucun – V

Déclarez un enregistreur log4net pour le type actuel.

Raccourci: log

Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Propriétés des macros :

• TYPE – Nom du type contenant

Test de test MS

Nouveau test MS Test Unit utilisant la syntaxe AAA et la convention de nommage trouvée dans Art Of Unit Testing

Raccourci: test (ou tst, ou ce que vous voulez)
Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Propriétés de macros (si présentes):

• MethodName – Le nom de la méthode en cours de test
• StateUnderTest – L’état que vous essayez de tester
• ExpectedBehavior – Ce que vous attendez

Vérifiez si la variable est nulle

Raccourci: ifn
Disponible dans: Fichiers C # 2.0+

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

Vérifiez si la variable n’est pas nulle

Raccourci: ifnn
Disponible dans: Fichiers C # 2.0+

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

Écrire un résumé conforme à StyleCop pour le constructeur de classe

(si vous en avez assez de taper constamment un long résumé standard pour chaque constructeur afin qu’il soit conforme à la règle StyleCop SA1642)

Raccourci: csum

Disponible dans: C # 2.0+

 Initializes a new instance of the  class.$END$ 

Macros:

• nom de classe – contenant le nom de type – V

Assert.AreEqual

Modèle simple à append assert à un test unitaire

Raccourci : ae
Disponible dans : dans les fichiers C # 2.0+ où l’instruction est autorisée

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

Version courante:

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

Beaucoup de Lambdas

Créez une expression lambda avec une déclaration de variable différente pour faciliter l’imbrication.

Raccourci: la, lb, lc

Disponible dans: Fichiers C # 3.0+ où l’expression ou la clause de requête est autorisée

la est définie comme:

 x => x.$END$ 

lb est défini comme suit:

 y => y.$END$ 

lc est défini comme suit:

 z => z.$END$ 

Ceci est similaire à Sean Kearon ci-dessus, sauf que je définis plusieurs modèles lambda en direct pour faciliter la nidification des lambda. ” la ” est le plus couramment utilisé, mais d’autres sont utiles pour traiter des expressions comme celle-ci:

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

Attends ça …

Pause pour l’entrée de l’utilisateur avant la fin d’une application de console.

Raccourci: pause

Disponible dans: Fichiers C # 2.0+ où l’instruction est autorisée

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

Génération de propriété de dépendance

Génère une propriété de dépendance

Raccourci: dp
Disponible dans: C # 3.0 où la déclaration de membre est autorisée

 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$ 

Propriétés de macros (si présentes):

PropertyName – No Macro – # 3
PropertyType – Devinez le type attendu à ce stade – # 2
OwnerType – contenant le nom du type – aucune occurrence modifiable

Notification de propriété modifiée

Ceci est mon préféré car je l’utilise souvent et il fait beaucoup de travail pour moi.

Raccourci : npc

Disponible dans : C # 2.0+ où expression est autorisée.

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

Macros :

• MEMBER – Contient le nom du type de membre. Non modifiable Remarque: assurez-vous que celui-ci est le premier dans la liste.
• LOWEREDMEMBER – Valeur de MEMBER avec le premier caractère en minuscule. Non modifiable

Utilisation : Dans un setter de propriété comme ceci:

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

Cela suppose que votre variable de support commence par un "_". Remplacez-le par ce que vous utilisez. Il suppose également que vous avez une méthode de modification de propriété comme celle-ci:

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

En réalité, la version que j'utilise est basée sur lambda (parce que j'adore mes lambda!) Et produit ce qui suit. Les principes sont les mêmes que ci-dessus.

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

C'est à ce moment-là que je n'utilise pas le postSharp extrêmement élégant et utile pour réaliser l'intégralité de INotifyPropertyChanged sans effort , c'est-à-dire.

Raccourci rapide d’ExceptionException

Juste un raccourci rapide pour append à mes atsortingbuts de test d’unité.

Raccourci : ee

Disponible dans : Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

 [ExpectedException(typeof($TYPE$))] 

Mappage de propriétés AutoMapper

Raccourci: fm

Disponible dans: Fichiers C # 2.0+ où l’instruction est autorisée

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

Macros:

• propriété – occurrence modifiable
• src_property – occurrence modifiable

Remarque:

Je laisse le “point” lambda pour que je puisse bash. immédiatement et obtenir la propriété intellisense. Nécessite AutoMapper ( http://automapper.codeplex.com/ ).

Créer un module de test pour NUnit

Celui-ci pourrait servir de rappel (de fonctionnalité à mettre en œuvre ou à tester) qui apparaît dans le testeur d’unité (comme tout autre test ignoré),

Raccourci: nts
Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Invoquer si nécessaire

Utile lors du développement d’applications WinForms où une méthode devrait pouvoir être appelée à partir de threads non-UI, et cette méthode devrait ensuite rassembler l’appel sur le thread d’interface utilisateur.

Raccourci : inv

Disponible dans : L’instruction de fichiers C # 3.0+ est autorisée

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

Macros

• METHOD_NAME – Contient le nom du membre de type

Vous utiliseriez normalement ce modèle comme première déclaration dans une méthode donnée et le résultat ressemble à:

 void DoSomething(Type1 arg1) { if (InvokeRequired) { Invoke((Action)delegate { DoSomething(arg1); }); return; } // Rest of method will only execute on the correct thread // ... } 

Nouveau C # Guid

Génère une nouvelle instance System.Guid initialisée à une nouvelle valeur guidée générée

Raccourci: csguid Disponible dans: dans les fichiers C # 2.0+

 new System.Guid("$GUID$") 

Propriétés des macros :

• GUID – Nouveau GUID – Faux

Méthode de test MSTest

C’est un peu boiteux mais c’est utile. J’espère que quelqu’un en tirera parti.

Raccourci: testMethod

Disponible dans: C # 2.0

 [TestMethod] public void $TestName$() { throw new NotImplementedException(); //Arrange. //Act. //Assert. } $END$ 

Méthode d’installation NUnit

Raccourci: configuration
Disponible dans: Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Méthode NUnit Teardown

Raccourci: déassembly
Disponible dans: Disponible dans: Fichiers C # 2.0+ où la déclaration de type membre est autorisée

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

Créer une vérification de validité pour s’assurer qu’un argument n’est jamais nul

Raccourci: anean
Disponible dans: Fichiers C # 2.0+ où l’instruction de type est autorisée

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

Macros:

• inner – Suggérer le paramètre – # 1

Remarques: Bien que cet extrait cible la bibliothèque .NET Lokad.Shared open source, il peut être facilement adapté à tout autre type de vérification d’argument.

Nouvelle classe COM

Raccourci : comclass

Disponible dans : Fichiers C # 2.0+ où la déclaration de type membre ou la déclaration d’espace de noms est autorisée

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

Macros

• GUID – Nouveau GUID
• NOM – Modifiable
• INTERFACE – Modifiable

Assert Invoke Not Required

Utile lors du développement d’applications WinForms où vous voulez être sûr que le code s’exécute sur le thread approprié pour un élément donné. Notez que Control implémente ISynchronizeInvoke .

Raccourci : ani

Disponible dans : L’instruction de fichiers C # 2.0+ est autorisée

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

Macros

• SYNC_INVOKE – Suggère une variable de System.ComponentModel.ISynchronizeInvoke

Trace – Writeline, avec format

Modèle très simple pour append une trace avec une chaîne formatée (comme le supporte déjà Debug.WriteLine).

Raccourci: twlf
Disponible dans: Fichiers C # 2.0+ où l’instruction est autorisée

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

Propriétés des macros:

• Argument – value – EditableOccurence
• Masque – "{0}" – EditableOccurence

Nouveau séparateur Typemock faux

Raccourci : faux
Disponible dans : [dans les fichiers c # 2.0 où l’instruction est autorisée]

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

Propriétés des macros:
* $ TYPE $ – Type de suggestion pour une nouvelle variable
* $ Nom $ – Valeur d’ une autre variable ( Type ) avec le premier caractère en minuscule

Depuis que je travaille avec Unity en ce moment, j’en ai trouvé quelques-uns pour me faciliter la vie:

Alias ​​de type

Raccourci : ta
Disponible dans : * .xml; * .config

Déclaration de type

Ceci est un type sans nom et sans arguments

Raccourci : tp
Disponible dans : * .xml; * .config

Déclaration de type (avec nom)

C’est un type avec nom et sans arguments

Raccourci : tn
Disponible dans : * .xml; * .config

Déclaration de type avec constructeur

C’est un type avec nom et sans arguments

Raccourci : tpc
Disponible dans : * .xml; * .config

    $PARAMS$    

etc….

Bloc de configuration XML log4net

Vous pouvez importer le modèle directement:

Rendre la méthode virtuelle

Ajoute un mot clé virtuel. Particulièrement utile lorsque vous utilisez NHibernate, EF ou un environnement similaire où les méthodes et / ou les propriétés doivent être virtuelles pour permettre un chargement ou un proxy paresseux.

Raccourci: v

Disponible dans: Fichier C # 2.0+ où la déclaration de type membre est autorisée

 virtual $END$ 

L’astuce ici est l’espace après le virtuel, ce qui pourrait être difficile à voir ci-dessus. Le modèle actuel est “virtual $ END $” avec le code de reformatage activé. Cela vous permet d’aller au point d’insertion ci-dessous (noté |) et tapez v:

 public |ssortingng Name { get; set; }