ReSharper 2017.3 Help

Predefined Live Templates for C#

ReSharper | Templates Explorer | Live Templates | C#

This topic lists all predefined live templates for C# in ReSharper 2017.3. For more information about live templates, see Creating Source Code Using Live Templates

TemplateDetails
ctx

Current file context

Scope everywhere

Body

$CTX$

Parameters

  • CTX - Provides list of items describing current context. This includes file name, containing type name, namespace name, etc. (context)

This could be useful:

  • In string literals that contain references to the current context, i.e. Logger.LogError("Cannot find action ActionNameDerivedFromContext");
  • As an alternative to code completion where IntelliSense doesn't work properly - for example, in comments when documenting a member with a long name (see example below).

Before expansion

Reference Options Templates Live Templates Predefined No Language ctx before

Expansion options
Reference Options Templates Live Templates Predefined No Language ctx expansion

nguid

Insert new GUID

Scope everywhere

Body

$GUID$

Parameters

  • GUID - Generates new Globally Unique Identifier (GUID) (guid)
join

Join clause in language integrated query

Scope C# 2.0+ queries

Body

join $NAME$ in $COL$ on $EXPR1$ equals $EXPR2$ $END$

Parameters

  • COL - Suggests variables of the specified type. (variableOfType)
  • NAME - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • EXPR1 - no macro
  • EXPR2 - no macro
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other join before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other join after

from

Language-Integrated Query

Scope C# 3.0+ expressions, C# 3.0+ queries

Body

from $VAR$ in $COLLECTION$ $END$

Parameters

  • COLLECTION - Suggests variables of the specified type. (variableOfType)
  • VAR - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other from before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other from after

foreach

foreach block

Scope C# 2.0+ statements

Body

foreach ($TYPE$ $VARIABLE$ in $COLLECTION$) { $SELECTION$$END$ }

Parameters

  • COLLECTION - Show basic code completion list at the point where the variable is evaluated (complete)
  • TYPE - Suggest type for a new variable declared in the template (suggestVariableType)
  • VARIABLE - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • SELECTION - The text selected by the user before invoking the template.
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Iteration foreach before

After expansion
Reference Options Templates Live Templates Predefined CSharp Iteration foreach after

After you specify the parameters, the caret is positioned so that you can continue coding the loop body.

itli

Iterate a IList<T>

Scope C# 2.0+ statements

Body

for (int $INDEX$ = 0; $INDEX$ < $LIST$.Count; $INDEX$++) { $TYPE$ $ITEM$ = $LIST$[$INDEX$]; $END$ }

Parameters

  • INDEX - Suggests non-used name which can be used for an index variable at the evaluation point. (suggestIndexVariable)
  • LIST - Suggests variables of the specified type. (variableOfType)
  • TYPE - Suggest type for a new variable declared in the template (suggestVariableType)
  • ITEM - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Iteration itli before

After expansion
Reference Options Templates Live Templates Predefined CSharp Iteration itli after

The template generates a for loop which iterates over an instance of System.Collections.IList. Includes a customizable statement in the loop body with a variable holding container elements.

After you specify the parameters, the caret is positioned so that you can continue coding the loop body.

itar

Iterate an array

Scope C# 2.0+ statements

Body

for (int $INDEX$ = 0; $INDEX$ < $ARRAY$.Length; $INDEX$++) { $TYPE$ $VAR$ = $ARRAY$[$INDEX$]; $END$ }

Parameters

  • INDEX - Suggests non-used name which can be used for an index variable at the evaluation point. (suggestIndexVariable)
  • ARRAY - Suggests variable which type is array type (arrayVariable)
  • TYPE - Suggest type for a new variable declared in the template (suggestVariableType)
  • VAR - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Iteration itar before

After expansion
Reference Options Templates Live Templates Predefined CSharp Iteration itar after

After you specify the parameters, the caret is positioned so that you can continue coding the loop body.

ritar

Iterate an array in inverse order

Scope C# 2.0+ statements

Body

for (int $INDEX$ = $ARRAY$.Length - 1; $INDEX$ >= 0; $INDEX$--) { $TYPE$ $VAR$ = $ARRAY$[$INDEX$]; $END$ }

Parameters

  • INDEX - Suggests non-used name which can be used for an index variable at the evaluation point. (suggestIndexVariable)
  • ARRAY - Suggests variable which type is array type (arrayVariable)
  • TYPE - Suggest type for a new variable declared in the template (suggestVariableType)
  • VAR - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Iteration ritar before

After expansion
Reference Options Templates Live Templates Predefined CSharp Iteration ritar after

The template generates a for loop for iterating over an array in reverse order. Includes a customizable statement in the loop body with a variable holding container elements.

After you specify the parameters, the caret is positioned so that you can continue coding the loop body.

for

Simple "for" loop

Scope C# 2.0+ statements

Body

for (int $INDEX$ = 0; $INDEX$ < $UPPER$; $INDEX$++) { $SELECTION$$END$ }

Parameters

  • INDEX - Suggests non-used name which can be used for an index variable at the evaluation point. (suggestIndexVariable)
  • UPPER - no macro
  • SELECTION - The text selected by the user before invoking the template.
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Iteration loop before

After expansion
Reference Options Templates Live Templates Predefined CSharp Iteration loop after

After you specify the parameters, the caret is positioned so that you can continue coding the loop body.

sfc

Safely cast variable

Scope C# 2.0+ statements

Body

$VARTYPE$ $VAR$ = $VAR1$ as $TYPE$; if ($VAR$ != null) { $END$ }

Parameters

  • VAR1 - Suggests variables of the specified type. (variableOfType)
  • TYPE - no macro
  • VARTYPE - Suggest type for a new variable declared in the template (suggestVariableType)
  • VAR - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other sfc before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other sfc after

psvm

The "Main" method declaration

Scope C# 2.0+ type members

Body

public static void Main( string[] args ) { $END$ }

Parameters

  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other psvm before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other psvm after

outv

Print value of a variable

Scope C# 2.0+ statements

Body

System.Console.Out.WriteLine("$EXPR$ = {0}", $EXPR$);

Parameters

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other outv before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other outv after

ReSharper automatically suggests a list of all variables in the current scope and, by default, selects the most recently declared one. The descriptive text string (s = in the example above) is automatically synchronized with the name of the selected variable.

out

Print a string

Scope C# 2.0+ statements

Body

System.Console.Out.WriteLine("$END$");

Parameters

  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other out before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other out after

asrt

Make an assertion

Scope C# 2.0+ statements

Body

System.Diagnostics.Debug.Assert($END$);

Parameters

  • END - The caret position after the template is applied.

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other asrt before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other asrt after

This template calls the Debug.Assert method, which is used for debugging purposes. After the template expanded, the caret moves between the parentheses so that you can specify a condition.

asrtn

Assert expression not null

Scope C# 2.0+ statements

Body

System.Diagnostics.Debug.Assert($EXPR$ != null, "$MESSAGE$");

Parameters

  • EXPR - no macro
  • MESSAGE - no macro

Before expansion

Reference Options Templates Live Templates Predefined CSharp Other asrtn before

After expansion
Reference Options Templates Live Templates Predefined CSharp Other asrtn after

The template inserts the Debug.Assert method, which checks a condition and displays a message if the condition is false.

thr

throw new

Scope C# 2.0+ statements

Body

throw new

    Before expansion

    Reference Options Templates Live Templates Predefined CSharp Other thr before

    After expansion
    Reference Options Templates Live Templates Predefined CSharp Other thr after

    pci

    public const int

    Scope C# 2.0+ type members

    Body

    public const int

      Before expansion

      Reference Options Templates Live Templates Predefined CSharp Other pci before

      After expansion
      Reference Options Templates Live Templates Predefined CSharp Other pci after

      pcs

      public const string

      Scope C# 2.0+ type members

      Body

      public const string

        Before expansion

        Reference Options Templates Live Templates Predefined CSharp Other pcs before

        After expansion
        Reference Options Templates Live Templates Predefined CSharp Other pcs after

        psr

        public static readonly

        Scope C# 2.0+ type members

        Body

        public static readonly

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other psr before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other psr after

          prop

          Property

          Scope C# 2.0+ type members

          Body

          public $TYPE$ $NAME$ { get; set; }

          Parameters

          • TYPE - no macro
          • NAME - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other prop before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other prop after

          ear

          Create an empty array

          Scope C# 2.0+ statements

          Body

          $TYPE$[] $NAME$ = new $TYPE$[] {};

          Parameters

          • TYPE - no macro
          • NAME - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other ear before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other ear after

          #if (Imported Visual C# Snippets)

          Scope C# 2.0+ except strings

          Body

          #if $expression$ $SELECTION$$END$ #endif

          Parameters

          • expression - Evaluates to the specified constant value. (constant)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          #region (Imported Visual C# Snippets)

          Scope C# 2.0+ except strings

          Body

          #region $name$ $SELECTION$$END$ #endregion

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          enum (Imported Visual C# Snippets)

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          enum $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          else (Imported Visual C# Snippets)

          else statement

          Scope C# 2.0+ statements

          Body

          else { $END$ }

          Parameters

          • END - The caret position after the template is applied.
          ~ (Imported Visual C# Snippets)

          Destructor

          Scope C# 2.0+ type members

          Body

          ~$classname$() { $END$ }

          Parameters

          • classname - Evaluates to short name of the most inner containing type. (typeName)
          • END - The caret position after the template is applied.
          ctor (Imported Visual C# Snippets)

          Constructor

          Scope C# 2.0+ type members

          Body

          public $classname$ () { $END$ }

          Parameters

          • classname - Evaluates to short name of the most inner containing type. (typeName)
          • END - The caret position after the template is applied.
          cw (Imported Visual C# Snippets)

          Console.WriteLine

          Scope C# 2.0+ statements

          Body

          System.Console.WriteLine($END$);

          Parameters

          • END - The caret position after the template is applied.
          class (Imported Visual C# Snippets)

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          class $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          Exception (Imported Visual C# Snippets)

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          [System.Serializable] public class $newException$Exception : System.Exception { // // For guidelines regarding the creation of new exception types, see // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp // and // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp // public $newException$Exception() { } public $newException$Exception( string message ) : base( message ) { } public $newException$Exception( string message, System.Exception inner ) : base( message, inner ) { } protected $newException$Exception( System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context ) : base( info, context ) { } }

          Parameters

          • newException - Evaluates to the specified constant value. (constant)
          struct (Imported Visual C# Snippets)

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          struct $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          forr (Imported Visual C# Snippets)

          Reverse 'for' loop

          Scope C# 2.0+ statements

          Body

          for (int $index$ = $max$ - 1; $index$ >= 0 ; $index$--) { $END$ }

          Parameters

          • index - Evaluates to the specified constant value. (constant)
          • max - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          namespace (Imported Visual C# Snippets)

          Scope C# 2.0+ types and namespaces

          Body

          namespace $name$ { $END$$SELECTION$ }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          interface (Imported Visual C# Snippets)

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          interface I$name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          sim (Imported Visual C# Snippets)

          'int Main' method

          Scope C# 2.0+ type members

          Body

          static int Main(string[] args) { $END$ return 0; }

          Parameters

          • END - The caret position after the template is applied.
          indexer (Imported Visual C# Snippets)

          Scope C# 2.0+ type members

          Body

          $access$ $type$ this[$indextype$ index] { get {$END$ /* return the specified index here */ } set { /* set the specified index to value here */ } }

          Parameters

          • access - Evaluates to the specified constant value. (constant)
          • type - Evaluates to the specified constant value. (constant)
          • indextype - Evaluates to the specified constant value. (constant)
          • END - The caret position after the template is applied.
          svm (Imported Visual C# Snippets)

          'void Main' method

          Scope C# 2.0+ type members

          Body

          static void Main(string[] args) { $END$ }

          Parameters

          • END - The caret position after the template is applied.
          unsafe (Imported Visual C# Snippets)

          unsafe statement

          Scope C# 2.0+ statements

          Body

          unsafe { $END$ }

          Parameters

          • END - The caret position after the template is applied.
          unchecked (Imported Visual C# Snippets)

          unchecked block

          Scope C# 2.0+ statements

          Body

          unchecked { $END$ }

          Parameters

          • END - The caret position after the template is applied.
          tryf (Imported Visual C# Snippets)

          try finally

          Scope C# 2.0+ statements

          Body

          try { $SELECTION$ } finally { $END$ }

          Parameters

          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          try (Imported Visual C# Snippets)

          try catch

          Scope C# 2.0+ statements

          Body

          try { $SELECTION$ } catch ($EXCEPTION$ $EX_NAME$) { $SELSTART$System.Console.WriteLine($EX_NAME$); throw;$SELEND$ }

          Parameters

          • EXCEPTION - Evaluates to the specified constant value. (constant)
          • EX_NAME - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
          • SELECTION - The text selected by the user before invoking the template.
          switch (Imported Visual C# Snippets)

          switch statement

          Scope C# 2.0+ statements

          Body

          switch ($expression$) { $END$ }

          Parameters

          • expression - Suggests variables of the specified type. (variableOfType)
          • END - The caret position after the template is applied.
          while (Imported Visual C# Snippets)

          while loop

          Scope C# 2.0+ statements

          Body

          while ($expression$) { $SELECTION$$END$ }

          Parameters

          • expression - Evaluates to the specified constant value. (constant)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          iterator (Imported Visual C# Snippets)

          simple iterator

          Scope C# 2.0+ type members

          Body

          public $SystemCollectionsGenericIEnumeratorG$<$type$> GetEnumerator() { $SELSTART$throw new System.NotImplementedException(); yield return default($type$); $SELEND$ }

          Parameters

          • type - Evaluates to the specified constant value. (constant)
          • SystemCollectionsGenericIEnumeratorG - Evaluates to the specified constant value. (constant)
          propg (Imported Visual C# Snippets)

          Property with a 'get' accessor and a private 'set' accessor

          Scope C# 2.0+ type members

          Body

          public $type$ $property$ { get; private set; }

          Parameters

          • type - Evaluates to the specified constant value. (constant)
          • property - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
          Attribute (Imported Visual C# Snippets)

          Attribute using recommended pattern

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces

          Body

          [System.AttributeUsage(System.AttributeTargets.$target$, Inherited = $inherited$, AllowMultiple = $allowmultiple$)] sealed class $name$Attribute : System.Attribute { // See the attribute guidelines at // http://go.microsoft.com/fwlink/?LinkId=85236 public $name$Attribute () { $SELSTART$// TODO: Implement code here throw new System.NotImplementedException();$SELEND$ } }

          Parameters

          • name - Evaluates to the specified constant value. (constant)
          • target - Evaluates to the specified constant value. (constant)
          • inherited - Evaluates to the specified constant value. (constant)
          • allowmultiple - Evaluates to the specified constant value. (constant)
          do (Imported Visual C# Snippets)

          do...while loop

          Scope C# 2.0+ statements

          Body

          do { $SELECTION$$END$ } while ($expression$);

          Parameters

          • expression - Suggests variables of the specified type. (variableOfType)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          checked (Imported Visual C# Snippets)

          checked block

          Scope C# 2.0+ statements

          Body

          checked { $END$ }

          Parameters

          • END - The caret position after the template is applied.
          if (Imported Visual C# Snippets)

          if statement

          Scope C# 2.0+ statements

          Body

          if ($expression$) { $SELECTION$$END$ }

          Parameters

          • expression - Suggests variables of the specified type. (variableOfType)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          lock (Imported Visual C# Snippets)

          lock statement

          Scope C# 2.0+ statements

          Body

          lock ($expression$) { $SELECTION$$END$ }

          Parameters

          • expression - Suggests variables of the specified type. (variableOfType)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          mbox (Imported Visual C# Snippets)

          MessageBox.Show

          Scope C# 2.0+ statements

          Body

          System.Windows.Forms.MessageBox.Show("$string$");

          Parameters

          • string - Evaluates to the specified constant value. (constant)
          using (Imported Visual C# Snippets)

          using statement

          Scope C# 2.0+ statements

          Body

          using($resource$) { $SELECTION$$END$ }

          Parameters

          • resource - Suggests variables of the specified type. (variableOfType)
          • SELECTION - The text selected by the user before invoking the template.
          • END - The caret position after the template is applied.
          hal

          ASP.NET MVC Html.ActionLink

          Scope C# 2.0+ expressions

          Body

          Html.ActionLink("$TEXT$", "$ACTION$", "$CONTROLLER$")

          Parameters

          • CONTROLLER - Show completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated (AspMvcController)
          • ACTION - Show completion list with available ASP.NET MVC Actions at the point where the variable is evaluated (AspMvcAction)
          • TEXT - no macro

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other hal before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other hal after

          ua

          ASP.NET MVC Url.Action

          Scope C# 2.0+ expressions

          Body

          Url.Action("$ACTION$", "$CONTROLLER$")

          Parameters

          • CONTROLLER - Show completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated (AspMvcController)
          • ACTION - Show completion list with available ASP.NET MVC Actions at the point where the variable is evaluated (AspMvcAction)

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other ua before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other ua after

          rta

          ASP.NET Controller RedirectToAction

          Scope C# 2.0+ expressions

          Body

          RedirectToAction("$ACTION$", "$CONTROLLER$")

          Parameters

          • CONTROLLER - Show completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated (AspMvcController)
          • ACTION - Show completion list with available ASP.NET MVC Actions at the point where the variable is evaluated (AspMvcAction)

          Before expansion

          Reference Options Templates Live Templates Predefined CSharp Other rta before

          After expansion
          Reference Options Templates Live Templates Predefined CSharp Other rta after

          attachedProperty

          Attached property

          Scope C# 2.0+ type members

          Body

          public static readonly $dependencyProperty$ $propertyName$Property = $dependencyProperty$.RegisterAttached( "$propertyName$", typeof($propertyType$), typeof($containingType$), new PropertyMetadata(default($propertyType$))); public static void Set$propertyName$(DependencyObject $element$, $propertyType$ value) { $element$.SetValue($propertyName$Property, value); } public static $propertyType$ Get$propertyName$(DependencyObject $element$) { return ($propertyType$) $element$.GetValue($propertyName$Property); }

          Parameters

          • propertyType - no macro
          • propertyName - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
          • containingType - Evaluates to short name of the most inner containing type. (typeName)
          • element - no macro
          • dependencyProperty - Evaluates to dependency property type specific to current framework (dependencyPropertyType)

          The template creates an attached property with required get and set procedures.

          dependencyProperty

          Dependency property

          Scope C# 2.0+ type members

          Body

          public static readonly $dependencyProperty$ $propertyName$Property = $dependencyProperty$.Register( "$propertyName$", typeof($propertyType$), typeof($containingType$), new PropertyMetadata(default($propertyType$))); public $propertyType$ $propertyName$ { get { return ($propertyType$) GetValue($propertyName$Property); } set { SetValue($propertyName$Property, value); } }

          Parameters

          • propertyType - no macro
          • propertyName - When exectuted in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)
          • containingType - Evaluates to short name of the most inner containing type. (typeName)
          • dependencyProperty - Evaluates to dependency property type specific to current framework (dependencyPropertyType)
          test

          Scope C# 2.0+ type members, References nunit.framework|nunit

          Body

          [Test] public void $METHOD$() {$END$}

          Parameters

          • METHOD - no macro
          • END - The caret position after the template is applied.
          Last modified: 7 December 2017