# 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:}) {
		${5:}
	}
snippet m+
	public ${1:void} ${2:}(${3:}) {
		${4:}
	}
snippet m&
	internal ${1:void} ${2:}(${3:}) {
		${4:}
	}
snippet m|
	protected ${1:void} ${2:}(${3:}) {
		${4:}
	}
snippet m-
	private ${1:void} ${2:}(${3:}) {
		${4:}
	}
# members - int
snippet mi
	${1:public} int ${2:}(${3:}) {
		${4:return 0;}
	}
snippet mi+
	public int ${1:}(${2:}) {
		${3:return 0;}
	}
snippet mi&
	internal int ${1:}(${2:}) {
		${3:return 0;}
	}
snippet mi|
	protected int ${1:}(${2:}) {
		${3:return 0;}
	}
snippet mi-
	private int ${1:}(${2:}) {
		${3:return 0;}
	}
# members - bool
snippet mb
	${1:public} bool ${2:}(${3:}) {
		${4:return false;}
	}
snippet mb+
	public bool ${1:}(${2:}) {
		${3:return false;}
	}
snippet mb&
	internal bool ${1:}(${2:}) {
		${3:return false;}
	}
snippet mb|
	protected bool ${1:}(${2:}) {
		${3:return false;}
	}
snippet mb-
	private bool ${1:}(${2:}) {
		${3:return false;}
	}
# members - string
snippet ms
	${1:public} string ${2:}(${3:}) {
		${4:return "";}
	}
snippet ms+
	public string ${1:}(${2:}) {
		${3:return "";}
	}
snippet ms&
	internal string ${1:}(${2:}) {
		${3:return "";}
	}
snippet ms|
	protected string ${1:}(${2:}) {
		${3:return "";}
	}
snippet ms-
	private string ${1:}(${2:}) {
		${3: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 { ${3:} }
            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}
    }