Predefined Live Templates for C#

copyright

NUnit Copyright

Scope C# 2.0+ types and namespaces

Body

// ***********************************************************************
// Copyright (c) $YEAR$ Charlie Poole
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ***********************************************************************

Parameters

• YEAR- Evaluates current date (getCurrentDate)

test

Test Method

Scope C# 2.0+ type members

Body

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

Parameters

• TEST_METHOD- Evaluates to the specified constant value. (constant)

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

tf

Test Fixture

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

Body

[TestFixture]
public class $TEST_CLASS$
{
	[Test]
	public void $TEST_METHOD$()
	{
		$END$
	}
}

Parameters

• TEST_CLASS- Evaluates to the specified constant value. (constant)

• TEST_METHOD- Evaluates to the specified constant value. (constant)

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

something

Scope C# 2.0+

Body

public $AAA$ One()
{
   var x = new $AAA$();
   return null;
}

public $AAA$ Two()
{
   var x = new $AAA$();
   var y = new $AAA$();
   var z = new $AAA$();
   return null;
}

Parameters

• AAA- Guess type expected at this point (guessExpectedType)

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

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

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

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

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

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

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

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

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

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

outv

Print value of a variable

Scope C# 2.0+ statements

Body

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

Parameters

• EXPR- Suggests variables of the specified type. (variableOfType)

Before expansion

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

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

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

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

pci

public const int

Scope C# 2.0+ type members

Body

public const int

Before expansion

pcs

public const string

Scope C# 2.0+ type members

Body

public const string

Before expansion

psr

public static readonly

Scope C# 2.0+ type members

Body

public static readonly

Before expansion

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

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

#if

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

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

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

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 short name of the most inner containing type. (typeName)

• 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 short name of the most inner containing type. (typeName)

• 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. (constant)

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

Exception

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

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

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

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

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

'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. (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

'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. (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

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

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

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

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

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

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

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

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

MessageBox.Show

Scope C# 2.0+ statements

Body

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

Parameters

• string- Evaluates to the specified constant value. (constant)

using

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

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

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

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)