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



    Part II: Programming with the .NET Framework
    Part IV: API Quick Reference
     
    ASPTreeView.com
     
    Evaluation has У·ЖЛКШРПЧexpired.
    Info...