Chapter 20. C Language Reference

Chapter 20. C# Language Reference

The following table describes the syntax of various C# language elements. The left column shows the syntax for each element, and the right column includes one or more examples.

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++); }