Arrays
type [*] + array-name = [ new type [ dimension+ ][*]*; | { value1, value2, ... }; ]	byte[] arr1 = new byte[10]; int[] arr2 = {0, 1, 2}; ([*] is the set: [] [,] [,,] etc.)
Attributes
[[target:]? attribute-name ( positional-param+ | [named-param = expr]+ | positional-param+, [named-param = expr]+)?]	[assembly:CLSCompliant(false)] [WebMethod(true, Description="My web method")]
Break statement
break;	break;
Checked/unchecked
checked (expr) unchecked (expr)	// throws exception short x = 32767; int i = checked((short) ++x ); // silently overflows to -32768 short y = 32767; int j = unchecked((short) ++y );
checked [statement | statement-block] unchecked [statement | statement-block]	// throws exception public short foo() { short y = 32767; checked { return ++y; } } // silently overflows public short bar() { short y = 32767; unchecked { return ++y; } }
Class declaration
attributes? unsafe? access-modifier? new? [ abstract | sealed ]? class class-name [: base-class | : interface+ | : base-class, interface+ ]? { class-members }	public class MyClass : Base, IFoo { // ... }
Constant declaration
const type [variable = constant-expr]+;	const int xyzzy = 42;
Constant fields
attributes? access-modifier? new? const type [constant-name = constant-expr]+;	internal const byte fnord = 23;
Continue statement
continue;	continue;
Delegates
attributes? unsafe? access-modifier? new? delegate [ void | type ] delegate-name (parameter-list);	public delegate void MyHandler(object s, EventArgs e);
Destructors
attributes? unsafe? ~class-name () statement-block	~SomeClass() { // destructor code }
Do-While loops
do [statement |statement-block] while (Boolean-expr);	int i = 0; do { // print 0 through 9 Console.WriteLine(i++); } while(i < 10);
Empty statements
;	i = 0; while(i++ < 10) ; // take no action Console.WriteLine(i); // prints 11
Enums
attributes? access-modifier? new? enum enum-name [ : integer-type ]? { [attributes? enum-member-name [ = value ]? ]* }	[Flags] public enum Color : long { Red = 0xff0000, Green = 0x00ff00, Blue = 0x0000ff }; //... // prints "Green, Red" Color yellow = (Color) 0xffff00; Console.WriteLine(yellow);
Events
attributes? unsafe? access-modifier? [ [[sealed | abstract]? override] | new? [virtual | static]? ]? event delegate-type event-name	event MyDelegate OnClickedSomething; // ... OnClickedSomething(arg1, arg2);
Event accessors
attributes? unsafe? access-modifier? [ [[sealed | abstract]? override] | new? [virtual | static]? ]? event delegate-type event-accessor-name { attributes? add statement-block attributes? remove statement-block }	event MyDelegate OnAction { add { // ... } remove { // ... } }
Expression statements
[variable =]? expr;	a = 10 * 10; a++; b = ++a;
Fields
attributes? unsafe? access-modifier? new? static? [readonly | volatile]? type [ field-name [ = expr]? ]+ ;	protected int agent = 0x007;
Fixed statements
fixed ([value-type | void ]* name = [&]? expr ) statement-block	byte[] b = {0, 1, 2}; fixed (byte* p = b) { *p = 100; // b[0] = 100 }
For loops
for (statement?; Boolean-expr?; statement?) [statement | statement-block]	// print 0 through 9 for(int j=0; j<10; j++) Console.WriteLine(j);
Foreach loops
foreach (type-value in IEnumerable ) statement or statement-block	StringCollection sc = new StringCollection(); sc.Add("Hello"); sc.Add("World"); foreach(String s in sc) Console.WriteLine(s);
Goto statement
goto statement-label; goto case-constant;	i = 0; MyLabel: if(++i < 100) goto MyLabel; Console.WriteLine(i);
If-Else statement
if (Boolean-expr) [statement | statement-block] [ else [statement | statement-block] ]?	if(choice == "A") { // ... } else if (choice == "B") { // ... } else { // ... }
Indexers
attributes? unsafe? access-modifier? [ [[sealed | abstract]? override] | new? [virtual | abstract | static]? ]? type this [ attributes? [type arg]+ ] { attributes? get // read-only statement-block | attributes? set // write-only statement-block | attributes? get // read-write statement-block attributes? set statement-block }	string this[int index] { get { return somevalue; } set { // do something with // implicit "value" arg } }
Instance constructors
attributes? unsafe? access-modifier? class-name (parameter-list) [ :[ base | this ] (argument-list) ]? statement-block	MyClass(int i) { // perform initialization } // Initialize with default MyClass() : this(42) { }
Interfaces
attributes? unsafe? access-modifier? new? interface interface-name [ : base-interface+ ]? { interface-members }	interface IFoo : IDisposable, IComparable { // member declarations }
Lock statement
lock (expr) [statement | statement-block]	lock(this) { int tmp = a; a = b; b = tmp; }
Method declaration syntax
attributes? unsafe? access-modifier? [ [[sealed | abstract]? override] | new? [virtual | abstract | static extern?]? ]? [ void | type ] method-name (parameter-list) statement-block	public abstract int MethA(object o); public virtual void MethB(int i, object o) { // statements... }
Namespace
namespace name+ { using-statement* [namespace-declaration | type-declaration]* } (namespace is dot-delimited) (namespace-declaration has no delimiters)	namespace OReilly.CSharp { using System; interface IFoo : IComparable {} public class MyClass {} }
Parameter list
[ attributes? [ref | out]? type arg ]* [ params attributes? type[] arg ]?	void MethA(ref int a, out int b) { b = ++a; } void MethB(params string[] args) { foreach (string s in args) Console.WriteLine(s); } // ... int a = 20, b; MethA(ref a, out b); Console.WriteLine("a={0}, b={1}", a, b); MethB("hello", "world");
Properties
attributes? unsafe? access-modifier? [ [[sealed | abstract]? override] | new? [virtual | abstract | static]? ]? type property-name { [ attributes? get // read-only statement-block | attributes? set // write-only statement-block | attributes? get // read-write statement-block attributes? set statement-block ] }	private string name; public string Name { get { return name; } set { name = value; } }
Return statement
return expr?;	return; return x;
Statements and statement blocks
statement	int x = 100;
statement-block	{ int x = 100; Console.WriteLine(x); return x; }
Static constructors
attributes? unsafe? extern? static class-name () statement-block	static MyClass() { // initialize static members }
Struct declaration
attributes? unsafe? access-modifier? new? struct struct-name [: interface+]? { struct-members }	public struct TwoFer { public int part1, part2; }
Switch statement
switch (expr) { [ case constant-expr : statement* ]* [ default : statement* ]? }	switch(choice) { case "A": // ... do something break; case "B": // ... do something // then branch to A goto case "A"; case "C": case "D": // ... do something break; default: Console.WriteLine("bad choice"); break; }
Throw statement
throw exception-expr?;	throw new Exception("something's wrong");
Try statements and exceptions
try statement-block [catch (exception type value?)? statement-block]+ | finally statement-block | [catch (exception type value?)? statement-block]+ finally statement-block	try { // do something } catch (Exception) { // recover } finally { // this will always // be called }
Using statement
using (declaration-expr) [statement | statement-block]	using(StreamReader s = new StreamReader("README.TXT")) { // ... } // s is disposed here
Variable declaration
type [variable [ = expr ]?]+ ;	long a, b, c; int x = 100;
While loops
while (Boolean-expr) [statement | statement-block]	int i = 0; while(i < 10) { // print 0 through 9 Console.WriteLine(i++); }