JetBrains Rider 2024.2 Help

Predefined Live Templates for C#

This topic lists all predefined live templates for C# in JetBrains Rider 2024.2. For more information about live templates, refer to Create source code using live templates.

Template

Details

ctx

Current file context

Scope Everywhere

Body

$CTX$

Parameters

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

This template 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 code completion doesn't work, for example, in comments when documenting a member with a long name.

nguid

Insert new GUID

Scope Everywhere

Body

$GUID$

Parameters

  • GUID - Generates a new Globally Unique Identifier (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 - Shows basic code completion list at the point where the variable is evaluated

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

  • EXPR1 - no macro

  • EXPR2 - no macro

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

from

Language-Integrated Query

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

Body

from $VAR$ in $COLLECTION$ $END$

Parameters

  • COLLECTION - Shows basic code completion list at the point where the variable is evaluated

  • VAR - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

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

foreach

foreach block

Scope C# 2.0+ statements

Body

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

Parameters

  • COLLECTION - Shows basic code completion list at the point where the variable is evaluated

  • TYPE - Suggests a type for a new variable declared in the template

  • VARIABLE - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

  • SELECTION - The text selected by the user before invoking the template.

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

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 a unique name for an index variable at the evaluation point

  • LIST - Shows basic code completion list at the point where the variable is evaluated

  • TYPE - Suggests a type for a new variable declared in the template

  • ITEM - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

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

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 a unique name for an index variable at the evaluation point

  • ARRAY - Suggests a variable whose type is an array type

  • TYPE - Suggests a type for a new variable declared in the template

  • VAR - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

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

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 a unique name for an index variable at the evaluation point

  • ARRAY - Suggests a variable whose type is an array type

  • TYPE - Suggests a type for a new variable declared in the template

  • VAR - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

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

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 a unique name for an index variable at the evaluation point

  • UPPER - no macro

  • SELECTION - The text selected by the user before invoking the template.

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

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 - Shows basic code completion list at the point where the variable is evaluated

  • TYPE - no macro

  • VARTYPE - Suggests a type for a new variable declared in the template

  • VAR - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

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

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.

outv

Print value of a variable

Scope C# 2.0+ statements

Body

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

Parameters

  • EXPR - Shows basic code completion list at the point where the variable is evaluated

JetBrains Rider automatically suggests a list of all variables in the current scope and selects the most recently declared one. The descriptive text string 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.

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.

This template calls the Debug.Assert method. 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

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

    pci

    public const int

    Scope C# 2.0+ type members

    Body

    public const int

      pcs

      public const string

      Scope C# 2.0+ type members

      Body

      public const string

        psr

        public static readonly

        Scope C# 2.0+ type members

        Body

        public static readonly

          prop

          Property

          Scope C# 2.0+ type members

          Body

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

          Parameters

          • TYPE - no macro

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

          ear

          Create an empty array

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • TYPE - no macro

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

          #if

          Scope C# 2.0+ except strings, At line start

          Body

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

          Parameters

          • expression - Evaluates to the specified constant value

          • SELECTION - The text selected by the user before invoking the template.

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

          #region

          Scope C# 2.0+ except strings, At line start

          Body

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

          Parameters

          • name - Evaluates to the specified constant value

          • SELECTION - The text selected by the user before invoking the template.

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

          enum

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

          Body

          enum $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value

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

          else

          else statement

          Scope C# 2.0+ statements

          Body

          else { $END$ }

          Parameters

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

          ~

          Destructor

          Scope C# 2.0+ type members

          Body

          ~$classname$() { $END$ }

          Parameters

          • classname - Evaluates to the short name of the most inner containing type

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

          ctor

          Constructor

          Scope C# 2.0+ type members

          Body

          public $classname$ () { $END$ }

          Parameters

          • classname - Evaluates to the short name of the most inner containing type

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

          cw

          Console.WriteLine

          Scope C# 2.0+ statements

          Body

          System.Console.WriteLine($END$);

          Parameters

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

          class

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

          Body

          class $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value

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

          Exception

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

          Body

          public class $newException$Exception : System.Exception { public $newException$Exception() { } public $newException$Exception( string message ) : base( message ) { } public $newException$Exception( string message, System.Exception inner ) : base( message, inner ) { } }

          Parameters

          • newException - Evaluates to the specified constant value

          struct

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

          Body

          struct $name$ { $END$ }

          Parameters

          • name - Evaluates to the specified constant value

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

          forr

          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

          • max - Evaluates to the specified constant value

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

          namespace

          Scope C# 2.0+ types and namespaces

          Body

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

          Parameters

          • name - Evaluates to the specified constant value

          • SELECTION - The text selected by the user before invoking the template.

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

          interface

          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

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

          sim

          '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

          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

          • type - Evaluates to the specified constant value

          • indextype - Evaluates to the specified constant value

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

          svm

          '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

          unsafe statement

          Scope C# 2.0+ statements

          Body

          unsafe { $END$ }

          Parameters

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

          unchecked

          unchecked block

          Scope C# 2.0+ statements

          Body

          unchecked { $END$ }

          Parameters

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

          tryf

          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

          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

          • EX_NAME - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

          • SELECTION - The text selected by the user before invoking the template.

          switch

          switch statement

          Scope C# 2.0+ statements

          Body

          switch ($expression$) { $END$ }

          Parameters

          • expression - Shows basic code completion list at the point where the variable is evaluated

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

          while

          while loop

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • expression - Shows basic code completion list at the point where the variable is evaluated

          • SELECTION - The text selected by the user before invoking the template.

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

          iterator

          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

          • SystemCollectionsGenericIEnumeratorG - Evaluates to the specified constant value

          propg

          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

          • property - When executed in a variable declaration (where variable name should stand), suggests a name for the variable

          Attribute

          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

          • target - Evaluates to the specified constant value

          • inherited - Evaluates to the specified constant value

          • allowmultiple - Evaluates to the specified constant value

          do

          do...while loop

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • expression - Shows basic code completion list at the point where the variable is evaluated

          • SELECTION - The text selected by the user before invoking the template.

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

          checked

          checked block

          Scope C# 2.0+ statements

          Body

          checked { $END$ }

          Parameters

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

          if

          if statement

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • expr - Shows basic code completion list at the point where the variable is evaluated

          • SELECTION - The text selected by the user before invoking the template.

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

          lock

          lock statement

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • expression - Shows basic code completion list at the point where the variable is evaluated

          • SELECTION - The text selected by the user before invoking the template.

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

          mbox

          MessageBox.Show

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • string - Evaluates to the specified constant value

          using

          using statement

          Scope C# 2.0+ statements

          Body

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

          Parameters

          • resource - Shows basic code completion list at the point where the variable is evaluated

          • 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 - Shows completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated

          • ACTION - Shows completion list with available ASP.NET MVC Actions at the point where the variable is evaluated

          • TEXT - no macro

          ua

          ASP.NET MVC Url.Action

          Scope C# 2.0+ expressions

          Body

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

          Parameters

          • CONTROLLER - Shows completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated

          • ACTION - Shows completion list with available ASP.NET MVC Actions at the point where the variable is evaluated

          rta

          ASP.NET Controller RedirectToAction

          Scope C# 2.0+ expressions

          Body

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

          Parameters

          • CONTROLLER - Shows completion list with available ASP.NET MVC Controllers at the point where the variable is evaluated

          • ACTION - Shows completion list with available ASP.NET MVC Actions at the point where the variable is evaluated

          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 a variable declaration (where variable name should stand), suggests a name for the variable

          • containingType - Evaluates to the short name of the most inner containing type

          • element - no macro

          • dependencyProperty - Evaluates to dependency property type specific to the current framework

          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( $nameofProperty$, 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 a variable declaration (where variable name should stand), suggests a name for the variable

          • containingType - Evaluates to the short name of the most inner containing type

          • dependencyProperty - Evaluates to dependency property type specific to the current framework

          • nameofProperty - Evaluates to 'nameof(entity)' if possible or 'entity' otherwise

          test

          Scope C# 2.0+ type members, MSTest Test Project

          Body

          [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethod] public void $METHOD$() {$END$}

          Parameters

          • METHOD - no macro

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

          baker

          DOTS Baker

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces, Unity C# file, Unity DOTS projects

          Body

          private class $BAKERNAME$ : Unity.Entities.Baker<$AUTHORINGTYPE$> { public override void Bake($AUTHORINGTYPE$ authoring) { } }

          Parameters

          • AUTHORINGTYPE - Current parent Unity type name

          • BAKERNAME - Generate Baker name based on parent Unity type name

          componentdata

          DOTS IComponentData

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces, Unity DOTS projects

          Body

          public struct $COMPONENTNAME$ : Unity.Entities.IComponentData { $END$ }

          Parameters

          • COMPONENTNAME - no macro

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

          jobentity

          DOTS IJob Entity

          Scope C# 2.0+ type members, C# 2.0+ types and namespaces, Unity DOTS projects

          Body

          [Unity.Burst.BurstCompile] public partial struct $JOBNAME$Job : Unity.Entities.IJobEntity { public void Execute($END$) { } }

          Parameters

          • JOBNAME - Evaluates to the current file name without extension and with all non-alphanumeric characters replaced with underscores

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

          Last modified: 18 August 2024