ReSharper 2019.3 Help

Predefined Live Templates for C#

ReSharper | Templates Explorer | Live Templates | C#

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

Template

Details

myTest

Scope C# 2.0+

Body

[Foo("$member$")]

Parameters

  • member - Evaluates to short name of the most inner containing type member (e.g. method or property). (typeMember)

cognitive

Scope C# 2.0+

Body

    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, that is 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

    ReSharper: Live templates
    Expansion options
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    outv

    Print value of a variable

    Scope C# 2.0+ statements

    Body

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

    Parameters

    Before expansion

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

    ReSharper: Live templates
    After expansion
    ReSharper: Live templates

    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

      ReSharper: Live templates
      After expansion
      ReSharper: Live templates

      pci

      public const int

      Scope C# 2.0+ type members

      Body

      public const int

        Before expansion

        ReSharper: Live templates
        After expansion
        ReSharper: Live templates

        pcs

        public const string

        Scope C# 2.0+ type members

        Body

        public const string

          Before expansion

          ReSharper: Live templates
          After expansion
          ReSharper: Live templates

          psr

          public static readonly

          Scope C# 2.0+ type members

          Body

          public static readonly

            Before expansion

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            prop

            Property

            Scope C# 2.0+ type members

            Body

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

            Parameters

            • TYPE - no macro

            • NAME - When executed in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)

            Before expansion

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            ear

            Create an empty array

            Scope C# 2.0+ statements

            Body

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

            Parameters

            • TYPE - no macro

            • NAME - When executed in variable declaration (where variable name should stand), suggests name for the variable. (suggestVariableName)

            Before expansion

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            #if (Imported Visual C# Snippets)

            Scope C# 2.0+ except strings, at line start

            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, at line start

            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 executed 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 - Show basic code completion list at the point where the variable is evaluated (complete)

            • 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 executed 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 ($expr$) { $SELECTION$$END$ }

            Parameters

            • expr - Show basic code completion list at the point where the variable is evaluated (complete)

            • 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 - Show basic code completion list at the point where the variable is evaluated (complete)

            • 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

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            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

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            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

            ReSharper: Live templates
            After expansion
            ReSharper: Live templates

            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 executed 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 executed 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: 11 December 2019