The basic idea is to prevent caret jumps backwards while typing C# code. Kind of surround templates on steroids baked with code completion.
I'm excited to announce that this plugin is now integral part of ReSharper 10!
Further Postfix Templates development happens inside ReSharper codebase, so this repository is no longer maintained and intended to use as a source of code examples for ReSharper plugin development.
9.1
and 9.2
;8.x
and 9.0
is no longer supported, check extension manager for latest versions;7.1
is no longer supported, last build is available here;Available templates:
.if
– checks boolean expression to be true if (expr)
.else
– checks boolean expression to be false if (!expr)
.null
– checks nullable expression to be null if (expr == null)
.notnull
– checks expression to be non-null if (expr != null)
.not
– negates value of inner boolean expression !expr
.foreach
– iterates over collection foreach (var x in expr)
.for
– surrounds with loop for (var i = 0; i < expr.Length; i++)
.forr
– reverse loop for (var i = expr.Length - 1; i >= 0; i--)
.var
– initialize new variable with expression var x = expr;
.arg
– helps surround argument with invocation Method(expr)
.to
– assigns expression to some variable lvalue = expr;
.await
– awaits expression with C# await keyword await expr
.cast
– surrounds expression with cast ((SomeType) expr)
.field
– intoduces field for expression _field = expr;
.prop
– introduces property for expression Prop = expr;
.new
– produces instantiation expression for type new T()
.par
– surrounds outer expression with parentheses (expr)
.parse
– parses string as value of some type int.Parse(expr)
.return
– returns value from method/property return expr;
.typeof
– wraps type usage with typeof-expression typeof(TExpr)
.switch
– produces switch over integral/string type switch (expr)
.yield
– yields value from iterator method yield return expr;
.throw
– throws value of Exception type throw expr;
.using
– surrounds disposable expression using (var x = expr)
.while
– uses expression as loop condition while (expr)
.lock
– surrounds expression with statement lock (expr)
.sel
– selects expression in editorAlso Postfix Templates including more C# code completion features sharing the same idea:
Static members of first argument type capatible available just like instance members:
Enum members are available over values of enumeration types to produce equality/flag checks:
Length/Count code completion solves one of the most common mistypings when dealing with arrays or collections:
Create type parameter from usage helps declaring generic methods in a postfix way:
Tab
key just like ReSharper live templatesFeel free to post any issues or feature requests in YouTrack (use "PostfixCompletion" subsystem).