470 lines
8.8 KiB
Text
470 lines
8.8 KiB
Text
# cs.snippets
|
|
# ===========
|
|
#
|
|
# Standard C-Sharp snippets for snipmate.
|
|
#
|
|
# Largely ported over from Visual Studio 2010 snippets plus
|
|
# a few snippets from Resharper plus a few widely known snippets.
|
|
#
|
|
# Most snippets on elements (i.e. classes, properties)
|
|
# follow suffix conventions. The order of suffixes to a snippet
|
|
# is fixed.
|
|
#
|
|
# Snippet Suffix Order
|
|
# --------------------
|
|
# 1. Access Modifiers
|
|
# 2. Class Modifiers
|
|
#
|
|
# Access Modifier Suffix Table
|
|
# ----------------------------
|
|
# + = public
|
|
# & = internal
|
|
# | = protected
|
|
# - = private
|
|
#
|
|
# Example: `cls&` expands to `internal class $1`.
|
|
# Access modifiers might be doubled to indicate
|
|
# different modifiers for get/set on properties.
|
|
# Example: `pb+-` expands to `public bool $1 { get; private set; }`
|
|
#
|
|
# Class Modifier Table
|
|
# --------------------
|
|
# ^ = static
|
|
# % = abstract
|
|
#
|
|
# Example: `cls|%` expands to `protected abstract class $1`
|
|
#
|
|
# On method and property snippets, you can directly set
|
|
# one of the common types int, string and bool, if desired,
|
|
# just by appending the type modifier.
|
|
#
|
|
# Type Modifier Table
|
|
# -------------------
|
|
# i = integer
|
|
# s = string
|
|
# b = bool
|
|
#
|
|
# Example: `pi+&` expands to `public int $1 { get; internal set; }`
|
|
#
|
|
# I'll most propably add more stuff in here like
|
|
# * List/Array constructio
|
|
# * Mostly used generics
|
|
# * Linq
|
|
# * Funcs, Actions, Predicates
|
|
# * Lambda
|
|
# * Events
|
|
#
|
|
# Feedback is welcome!
|
|
#
|
|
# Main
|
|
snippet sim
|
|
${1:public }static int Main(string[] args) {
|
|
${0}
|
|
return 0;
|
|
}
|
|
snippet simc
|
|
public class Application {
|
|
${1:public }static int Main(string[] args) {
|
|
${0}
|
|
return 0;
|
|
}
|
|
}
|
|
snippet svm
|
|
${1:public }static void Main(string[] args) {
|
|
${0}
|
|
}
|
|
# if condition
|
|
snippet if
|
|
if (${1:true}) {
|
|
${0}
|
|
}
|
|
snippet el
|
|
else {
|
|
${0}
|
|
}
|
|
snippet ifs
|
|
if (${1})
|
|
${0}
|
|
# ternary conditional
|
|
snippet t
|
|
${1} ? ${2} : ${0}
|
|
snippet ?
|
|
${1} ? ${2} : ${0}
|
|
# do while loop
|
|
snippet do
|
|
do {
|
|
${0}
|
|
} while (${1:true});
|
|
# while loop
|
|
snippet wh
|
|
while (${1:true}) {
|
|
${0}
|
|
}
|
|
# for loop
|
|
snippet for
|
|
for (int ${1:i} = 0; $1 < ${2:count}; $1${3:++}) {
|
|
${0}
|
|
}
|
|
snippet forr
|
|
for (int ${1:i} = ${2:length}; $1 >= 0; $1--) {
|
|
${0}
|
|
}
|
|
# foreach
|
|
snippet fore
|
|
foreach (${1:var} ${2:entry} in ${3}) {
|
|
${0}
|
|
}
|
|
snippet foreach
|
|
foreach (${1:var} ${2:entry} in ${3}) {
|
|
${0}
|
|
}
|
|
snippet each
|
|
foreach (${1:var} ${2:entry} in ${3}) {
|
|
${0}
|
|
}
|
|
# interfaces
|
|
snippet interface
|
|
public interface ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet if+
|
|
public interface ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
# class bodies
|
|
snippet class
|
|
public class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls
|
|
${2:public} class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls+
|
|
public class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls+^
|
|
public static class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls&
|
|
internal class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls&^
|
|
internal static class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls|
|
|
protected class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
snippet cls|%
|
|
protected abstract class ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
# constructor
|
|
snippet ctor
|
|
public ${1:`vim_snippets#Filename()`}() {
|
|
${0}
|
|
}
|
|
# properties - auto properties by default.
|
|
# default type is int with layout get / set.
|
|
snippet prop
|
|
${1:public} ${2:int} ${3} { get; set; }
|
|
snippet p
|
|
${1:public} ${2:int} ${3} { get; set; }
|
|
snippet p+
|
|
public ${1:int} ${2} { get; set; }
|
|
snippet p+&
|
|
public ${1:int} ${2} { get; internal set; }
|
|
snippet p+|
|
|
public ${1:int} ${2} { get; protected set; }
|
|
snippet p+-
|
|
public ${1:int} ${2} { get; private set; }
|
|
snippet p&
|
|
internal ${1:int} ${2} { get; set; }
|
|
snippet p&|
|
|
internal ${1:int} ${2} { get; protected set; }
|
|
snippet p&-
|
|
internal ${1:int} ${2} { get; private set; }
|
|
snippet p|
|
|
protected ${1:int} ${2} { get; set; }
|
|
snippet p|-
|
|
protected ${1:int} ${2} { get; private set; }
|
|
snippet p-
|
|
private ${1:int} ${2} { get; set; }
|
|
# property - bool
|
|
snippet pi
|
|
${1:public} int ${2} { get; set; }
|
|
snippet pi+
|
|
public int ${1} { get; set; }
|
|
snippet pi+&
|
|
public int ${1} { get; internal set; }
|
|
snippet pi+|
|
|
public int ${1} { get; protected set; }
|
|
snippet pi+-
|
|
public int ${1} { get; private set; }
|
|
snippet pi&
|
|
internal int ${1} { get; set; }
|
|
snippet pi&|
|
|
internal int ${1} { get; protected set; }
|
|
snippet pi&-
|
|
internal int ${1} { get; private set; }
|
|
snippet pi|
|
|
protected int ${1} { get; set; }
|
|
snippet pi|-
|
|
protected int ${1} { get; private set; }
|
|
snippet pi-
|
|
private int ${1} { get; set; }
|
|
# property - bool
|
|
snippet pb
|
|
${1:public} bool ${2} { get; set; }
|
|
snippet pb+
|
|
public bool ${1} { get; set; }
|
|
snippet pb+&
|
|
public bool ${1} { get; internal set; }
|
|
snippet pb+|
|
|
public bool ${1} { get; protected set; }
|
|
snippet pb+-
|
|
public bool ${1} { get; private set; }
|
|
snippet pb&
|
|
internal bool ${1} { get; set; }
|
|
snippet pb&|
|
|
internal bool ${1} { get; protected set; }
|
|
snippet pb&-
|
|
internal bool ${1} { get; private set; }
|
|
snippet pb|
|
|
protected bool ${1} { get; set; }
|
|
snippet pb|-
|
|
protected bool ${1} { get; private set; }
|
|
snippet pb-
|
|
private bool ${1} { get; set; }
|
|
# property - string
|
|
snippet ps
|
|
${1:public} string ${2} { get; set; }
|
|
snippet ps+
|
|
public string ${1} { get; set; }
|
|
snippet ps+&
|
|
public string ${1} { get; internal set; }
|
|
snippet ps+|
|
|
public string ${1} { get; protected set; }
|
|
snippet ps+-
|
|
public string ${1} { get; private set; }
|
|
snippet ps&
|
|
internal string ${1} { get; set; }
|
|
snippet ps&|
|
|
internal string ${1} { get; protected set; }
|
|
snippet ps&-
|
|
internal string ${1} { get; private set; }
|
|
snippet ps|
|
|
protected string ${1} { get; set; }
|
|
snippet ps|-
|
|
protected string ${1} { get; private set; }
|
|
snippet ps-
|
|
private string ${1} { get; set; }
|
|
# members - void
|
|
snippet m
|
|
${1:public} ${2:void} ${3}(${4}) {
|
|
${0}
|
|
}
|
|
snippet m+
|
|
public ${1:void} ${2}(${3}) {
|
|
${0}
|
|
}
|
|
snippet m&
|
|
internal ${1:void} ${2}(${3}) {
|
|
${0}
|
|
}
|
|
snippet m|
|
|
protected ${1:void} ${2}(${3}) {
|
|
${0}
|
|
}
|
|
snippet m-
|
|
private ${1:void} ${2}(${3}) {
|
|
${0}
|
|
}
|
|
# members - int
|
|
snippet mi
|
|
${1:public} int ${2}(${3}) {
|
|
${0:return 0;}
|
|
}
|
|
snippet mi+
|
|
public int ${1}(${2}) {
|
|
${0:return 0;}
|
|
}
|
|
snippet mi&
|
|
internal int ${1}(${2}) {
|
|
${0:return 0;}
|
|
}
|
|
snippet mi|
|
|
protected int ${1}(${2}) {
|
|
${0:return 0;}
|
|
}
|
|
snippet mi-
|
|
private int ${1}(${2}) {
|
|
${0:return 0;}
|
|
}
|
|
# members - bool
|
|
snippet mb
|
|
${1:public} bool ${2}(${3}) {
|
|
${0:return false;}
|
|
}
|
|
snippet mb+
|
|
public bool ${1}(${2}) {
|
|
${0:return false;}
|
|
}
|
|
snippet mb&
|
|
internal bool ${1}(${2}) {
|
|
${0:return false;}
|
|
}
|
|
snippet mb|
|
|
protected bool ${1}(${2}) {
|
|
${0:return false;}
|
|
}
|
|
snippet mb-
|
|
private bool ${1}(${2}) {
|
|
${0:return false;}
|
|
}
|
|
# members - string
|
|
snippet ms
|
|
${1:public} string ${2}(${3}) {
|
|
${0:return "";}
|
|
}
|
|
snippet ms+
|
|
public string ${1}(${2}) {
|
|
${0:return "";}
|
|
}
|
|
snippet ms&
|
|
internal string ${1}(${2}) {
|
|
${0:return "";}
|
|
}
|
|
snippet ms|
|
|
protected string ${1:}(${2:}) {
|
|
${0:return "";}
|
|
}
|
|
snippet ms-
|
|
private string ${1}(${2}) {
|
|
${0:return "";}
|
|
}
|
|
# structure
|
|
snippet struct
|
|
public struct ${1:`vim_snippets#Filename()`} {
|
|
${0}
|
|
}
|
|
# enumeration
|
|
snippet enum
|
|
enum ${1} {
|
|
${0}
|
|
}
|
|
|
|
snippet enum+
|
|
public enum ${1} {
|
|
${0}
|
|
}
|
|
# preprocessor directives
|
|
snippet #if
|
|
#if
|
|
${0}
|
|
#endif
|
|
# inline xml documentation
|
|
snippet ///
|
|
/// <summary>
|
|
/// ${0}
|
|
/// </summary>
|
|
snippet <p
|
|
<param name="${1}">${2:$1}</param>
|
|
snippet <ex
|
|
<exception cref="${1:System.Exception}">${2}</exception>
|
|
snippet <r
|
|
<returns>${1}</returns>{
|
|
snippet <s
|
|
<see cref="${1}"/>
|
|
snippet <rem
|
|
<remarks>${1}</remarks>
|
|
snippet <c
|
|
<code>${1}</code>
|
|
|
|
snippet cw
|
|
Console.WriteLine(${1});
|
|
|
|
# equals override
|
|
snippet eq
|
|
public override bool Equals(object obj) {
|
|
if (obj == null || GetType() != obj.GetType()) {
|
|
return false;
|
|
}
|
|
${0:throw new NotImplementedException();}
|
|
return base.Equals(obj);
|
|
}
|
|
# exception
|
|
snippet exc
|
|
public class ${1:MyException} : ${2:Exception} {
|
|
public $1() { }
|
|
public $1(string message) : base(message) { }
|
|
public $1(string message, Exception inner) : base(message, inner) { }
|
|
protected $1(
|
|
System.Runtime.Serialization.SerializationInfo info,
|
|
System.Runtime.Serialization.StreamingContext context)
|
|
: base(info, context) { }
|
|
}
|
|
# indexer
|
|
snippet index
|
|
public ${1:object} this[${2:int} index] {
|
|
get { ${0} }
|
|
set { ${0} }
|
|
}
|
|
# eventhandler
|
|
snippet inv
|
|
EventHandler temp = ${1:MyEvent};
|
|
if (${2:temp} != null) {
|
|
$2();
|
|
}
|
|
# lock
|
|
snippet lock
|
|
lock (${1:this}) {
|
|
${0}
|
|
}
|
|
# namespace
|
|
snippet namespace
|
|
namespace ${1:MyNamespace} {
|
|
${0}
|
|
}
|
|
# property
|
|
snippet prop
|
|
public ${1:int} ${2:MyProperty} { get; set; }
|
|
snippet propf
|
|
private ${1:int} ${2:myVar};
|
|
public $1 ${3:MyProperty} {
|
|
get { return $2; }
|
|
set { $2 = value; }
|
|
}
|
|
snippet propg
|
|
public ${1:int} ${2:MyProperty} { get; private set; }
|
|
# switch
|
|
snippet switch
|
|
switch (${1:switch_on}) {
|
|
${0}
|
|
default:
|
|
}
|
|
# try
|
|
snippet try
|
|
try {
|
|
${0}
|
|
}
|
|
catch (${1:System.Exception}) {
|
|
throw;
|
|
}
|
|
snippet tryf
|
|
try {
|
|
${0}
|
|
}
|
|
finally {
|
|
${1}
|
|
}
|
|
# using
|
|
snippet usi
|
|
using(${1:resource}) {
|
|
${0}
|
|
}
|