Generally, you must create instances of a type to use that type. Those data members and function members that require a type to be instantiated are called instance members. Data members and function members that can be used on the type itself are called static members.

In this program, we build our own type called Counter and another type called Test that uses instances of the Counter. The Counter type uses the predefined type int, and the Test type uses the static function member WriteLine of the Console class defined in the System namespace:

// Imports types from System namespace, such as Console
using System;
class Counter { // New types are typically classes or structs
  // --- Data members ---
  int value; // field of type int
  int scaleFactor; // field of type int

  // Constructor, used to initialize a type instance
  public Counter(int scaleFactor) { 
    this.scaleFactor = scaleFactor;  
  }
  // Method
  public void Inc(  ) {
    value+=scaleFactor;
  }
  // Property
  public int Count {
    get {return value; }
  }
}
class Test {
  // Execution begins here
  static void Main(  ) {

    // Create an instance of counter type
    Counter c = new Counter(5);
    c.Inc(  );
    c.Inc(  );
    Console.WriteLine(c.Count); // prints "10";

    // Create another instance of counter type
    Counter d = new Counter(7);
    d.Inc(  );
    Console.WriteLine(d.Count); // prints "7";
   }
}

Each type has its own set of rules defining how it can be converted to and from other types. Conversions between types may be implicit or explicit. Implicit conversions can be performed automatically, while explicit conversions require a cast usingthe C cast operator, ( ):

int x = 123456; // int is a 4-byte integer
long y = x; // implicit conversion to 8-byte integer
short z =(short)x; // explicit conversion to 2-byte integer

The rationale behind implicit conversions is that they are guaranteed to succeed and not lose information. Conversely, an explicitconversion is required when runtime circumstances determine whether the conversion succeeds or when information might be lost during the conversion.

Most conversion rules are supplied by the language, such as the previous numeric conversions. Occasionally it is useful for developers to define their own implicit and explicit conversions (see Section 2.4 later in this chapter).

All C# types, including both predefined types and user-defined types, fall into one of three categories: value, reference, and pointer.

C# has two categories of predefined types:

Aliases for all these types can be found in the System namespace. For example, the following two statements are semantically identical:

int i = 5;
System.Int32 i = 5;

sbyte

System.Sbyte

short

System.Int16

int

System.Int32

long

System.Int64

byte

System.Byte

ushort

System.UInt16

uint

System.UInt32

ulong

System.UInt64

int x = 5;
ulong y = 0x1234AF; // prefix with 0x for hexadecimal

int 
uint 
long 
ulong.

int x = 123456;
long y = x; // implicit, no information lost
short z = (short)x; // explicit, truncates x

float

System.Single

double

System.Double

float x = 9.81f;
double y = 7E-02; // 0.07
double z = 1e2;   // 100

short strength = 2;
int offset = 3;
float x = 9.53f * strength - offset;

float x = 3.53f;
int offset = (int)x;

decimal

System.Decimal

decimal x = 80603.454327m; // holds exact value

char

System.Char

'A' // simple character
'u0041' // Unicode
'x0041' // unsigned short hexadecimal
'
' // escape sequence character

'

0x0027

"

0x0022

\

0x005C

0x0000

a

0x0007



0x0008

f

0x000C

0x000A

0x000D

0x0009

v

0x000B

bool

System.Boolean

object

System.Object

string

System.String

string a = "Heat";

public void StringDemo(  ) {
  string a1 = "\\server\fileshare\helloworld.cs";
  string a2 = @"\serverfilesharehelloworld.cs";
  Console.WriteLine(a1==a2); // Prints "True"
  
  string b1 = "First Line
Second Line";
  string b2 = @"First Line
Second Line";
  Console.WriteLine(b1==b2); // Prints "True"
}

The fundamental difference between value and reference types is how they are stored in memory.

// Reference-type declaration
class PointR {
  public int x, y;
}
// Value type declaration
struct PointV {
  public int x, y;
}
class Test {
  public static void Main(  ) {
    PointR a; // Local reference-type variable, uses 4 bytes of
              // memory on the stack to hold address
    PointV b; // Local value-type variable, uses 8 bytes of
              // memory on the stack for x and y
    a = new PointR(  ); // Assigns the reference to address of new
                      // instance of PointR allocated on the
                      // heap. The object on the heap uses 8
                      // bytes of memory for x and y and an
                      // additional 8 bytes for core object
                      // requirements, such as storing the 
                      // object's type & synchronization state
    b = new PointV(  ); // Calls the value type's default
                      // constructor.  The default constructor 
                      // for both PointR and PointV will set 
                      // each field to its default value, which 
                      // will be 0 for both x and y.
    a.x = 7;
    b.x = 7;
  }
}
// At the end of the method the local variables a and b go out of
// scope, but the new instance of a PointR remains in memory until
// the garbage collector determines it is no longer referenced

    ...
    PointR c = a;
    PointV d = b;
    c.x = 9;
    d.x = 9;
    Console.WriteLine(a.x); // Prints 9
    Console.WriteLine(b.x); // Prints 7
  }
}

C# provides a unified type system, whereby the object class is the ultimate base type for both reference and value types. This means that all types, apart from the occasionally used pointer types, share a basic set of characteristics.

int i = 3;
string s = i.ToString(  );

// This is an explanatory version of System.Int32
namespace System {
  struct Int32 {
    ...
    public string ToString(  ) {
      return ...;
    }
  }
}
// This is valid code, but we recommend you use the int alias
System.Int32 i = 5;
string s = i.ToString(  );

int[] iarr = new int [1000];

struct PointV {
  public int x, y;
}
PointV[] pvarr = new PointV[1000];

class PointR {
   public int x, y;
}
PointR[] prarr = new PointR[1000];
for( int i=0; i<prarr.Length; i++ )
   prarr[i] = new PointR(  );

class Queue {
  ...
  void Enqueue(object o) {...}
  object Dequeue(  ) {return ...}
}

Queue q = new Queue(  );
q.Enqueue(9); // box the int
int i = (int)q.Dequeue(  ); // unbox the int

Variables in C# (except in unsafe contexts) must be assigned a value before they are used. A variable is either explicitly assigned a value or automatically assigned a default value. Automatic assignment occurs for static fields, class instance fields, and array elements not explicitly assigned a value. For example:

using System;
class Test {
  int v;
  // Constructors that initialize an instance of a Test
  public Test(  ) {} // v will be automatically assigned to 0
  public Test(int a) { // explicitly assign v a value
     v = a;
  }
  static void Main(  ) {
    Test[] iarr = new Test [2]; // declare array
    Console.WriteLine(iarr[1]); // ok, elements assigned to null
    Test t;
    Console.WriteLine(t); // error, t not assigned
  }
}

The following table shows that, essentially, the default value for all primitive (or atomic) types is zero:

0

false

''

0

null

The default value for each field in a complex (or composite) type is one of these aforementioned values.

When an expression contains multiple operators, the precedence of the operators controls the order in which the individual operators are evaluated. When the operators are of the same precedence, their associativity determines their order of evaluation. Binary operators (except for assignment operators) are left-associative and are evaluated from left to right. The assignment operators, unary operators, and the conditional operator are right-associative, evaluated from right to left.

For example:

1 + 2 + 3 * 4

is evaluated as:

((1 + 2) + (3 * 4))

because * has a higher precedence than +, and + is a left-associative binary operator. You can insert parentheses to change the default order of evaluation. C# also overloads operators, which means the same operator symbols can have different meanings in different contexts (e.g., primary, unary, etc.) or different meanings for different types.

Table 2-2 lists C#’s operators in order of precedence. Operators in the same box have the same precedence, and operators in italic may be overloaded for custom types (see Section 2.9.8 later in this chapter).

checked (expression)
unchecked (expression)

checked statement-or-statement-block
unchecked statement-or-statement-block

The checked operator tells the runtime to generate an OverflowException if an integral expression exceeds the arithmetic limits of that type. The checked operator affects expressions with the ++, --, (unary)-, +, -, *, /, and explicit conversion operators ( ) between integral types (see Section 2.2.5.1 later in this chapter). Here’s an example:

int a = 1000000;
int b = 1000000;

// Check an expression
int c = checked(a*b);

// Check every expression in a statement block
checked {
   ...
   c = a * b;
   ...
}

The checked operator applies only to runtime expressions, because constant expressions are checked during compilation (though this can be turned off with the /checked [+|-] command-line compiler switch). The unchecked operator disables arithmetic checking at compile time and is seldom useful, but it can enable expressions such as this to compile:

const int signedBit = unchecked((int)0x80000000);

[variable =]? expression;

An expression statement evaluates an expression either by assigning its result to a variable or generating side effects, (i.e., invocation, new, ++, or --). An expression statement ends in a semicolon (;). For example:

x = 5 + 6; // assign result
x++; // side effect
y = Math.Min(x, 20); // side effect and assign result
Math.Min (x, y); // discards result, but ok, there is a side effect
x == y; // error, has no side effect, and does not assign result

type [variable [ = expression ]?]+ ;

const type [variable = constant-expression]+ ;

A declaration statement declares a new variable. You can initialize a variable at the time of its declaration by optionally assigning it the result of an expression.

The scope of a local or constant variable extends to the end of the current block. You can’t declare another local variable with the same name in the current block or in any nested blocks. For example:

bool a = true;
while(a) {
   int x = 5;
   if (x==5) {
      int y = 7;
      int x = 2; // error, x already defined
   }
   Console.WriteLine(y); // error, y is out of scope
}

A constant declaration is like a variable declaration, except that the value of the variable can’t be changed after it has been declared:

const double speedOfLight = 2.99792458E08;
speedOfLight+=10; // error

;

The empty statement does nothing. It is used as a placeholder when no operations need to be performed, but a statement is nevertheless required. For example:

while(!thread.IsAlive);

C# has many ways to conditionally control the flow of program execution. This section covers the simplest two constructs, the if-else statement and the switch statement. In addition, C# also provides a conditional operator and loop statements that conditionally execute based on a Boolean expression. Finally, C# provides object-oriented ways of conditionally controlling the flow of execution, namely virtual method invocations and delegate invocations.

if (Boolean-expression)
  statement-or-statement-block
[ else
  statement-or-statement-block ]?

int Compare(int a, int b) {
   if (a>b)
      return 1;
   else if (a<b)
      return -1;
   return 0;
}

switch (expression) {
[ case constant-expression : statement* ]*
[ default : statement* ]?
}

void Award(int x) {
  switch(x) {
    case 1:
      Console.WriteLine("Winner!");
      break;
    case 2:
      Console.WriteLine("Runner-up");
      break;
    case 3:
    case 4:
      Console.WriteLine("Highly commended");
      break;
    default:
      Console.WriteLine("Don't quit your day job!");
      break;
  }
}

void Greet(string title) {
  switch (title) {
    case null:
      Console.WriteLine("And you are?");
      goto default;
    case "King":
      Console.WriteLine("Greetings your highness");
      // error, should specify break, otherwise...
    default :
      Console.WriteLine("How's it hanging?");
      break;
  }
}

C# enables a group of statements to be executed repeatedly using the while, do while, and for statements.

while (Boolean-expression)
  statement-or-statement-block

int i = 0;
while (i<5) {
  i++;
}

do 
  statement-or-statement-block
while (Boolean-expression);

int i = 0;
do
  i++;
while (i<5);

for (statement?; Boolean-expression?; statement?)
  statement-or-statement-block

for (int i=0; i<10; i++)
  Console.WriteLine(i);

for (;;)
  Console.WriteLine("Hell ain't so bad");

foreach ( type-value in IEnumerable )
  statement-or-statement-block

for (int i=0; i<dynamite.Length; i++)
  Console.WriteLine(dynamite [i]);

foreach (Stick stick in dynamite)
  Console.WriteLine(stick);

IEnumerator ie = dynamite.GetEnumerator(  );
while (ie.MoveNext(  )) {
  Stick stick = (Stick)ie.Current;
  Console.WriteLine(stick);
}

The C# jump statements are: break, continue, goto, return, and throw. All jump statements obey sensible restrictions imposed by try statements (see Section 2.15 later in this chapter). First, a jump out of a try block always executes the try’s finally block before reaching the target of the jump. Second, a jump can’t be made from the inside to the outside of a finally block.

break;

int x = 0;
while (true) {
  x++;
  if (x>5)
    break; // break from the loop
}

continue;

int x = 0;
int y = 0;
while (y<100) {
  x++;
  if ((x%7)==0)
    continue; // continue with next iteration
  y++;
}

goto statement-label;
goto case-constant;

int x = 4;
start:
x++;
if (x==5)
 goto start;

return expression?;

int CalcX(int a) {
  int x = a * 100;
  return x; // return to the calling method with value
}

throw exception-expression?;

if (w==null)
  throw new Exception("w can't be null");

lock (expression)
  statement-or-statement-block

using (declaration-expression)
   statement-or-statement-block

using (FileStream fs = new FileStream (fileName, FileMode.Open)) {
  // do something with fs
}

FileStream fs = new FileStream (fileName, FileMode.Open);
try {
  // do something with fs
} finally {
  if (fs != null)
  ((IDisposable)fs).Dispose(  );
}

File organization is of almost no significance to the C# compiler: an entire project can be merged into a single .cs file and still compile successfully (preprocessor statements are the only exception to this). However, it’s generally tidy to have one type in one file, with a filename that matches the name of the class and a directory name that matches the name of the class’s namespace.

namespace name+a {
  using-statement*
  [namespace-declaration | type-declaration]*b
}

A namespace enables you to group related types into a hierarchical categorization. Generally the first name in a namespace name is the name of your organization, followed by names that group types with finer granularity. For example:

namespace MyCompany.MyProduct.Drawing {
  class Point {int x, y, z;}
  delegate void PointInvoker(Point p);
}

namespace MyCompany {
  namespace MyProduct {
    namespace Drawing {
      class Point {int x, y, z;}
      delegate void PointInvoker(Point p);
    }
  }
}

namespace TestProject {
  class Test {
    static void Main(  ) {
      MyCompany.MyProduct.Drawing.Point x;
    }
  }
}

namespace TestProject {
  using MyCompany.MyProduct.Drawing;
  class Test {
    static void Main(  ) {
      Point x;
    }
  }
}

using sys = System;        // Namespace alias
using txt = System.String; // Type alias
class Test {
  static void Main(  ) {
    txt s = "Hello, World!";
    sys.Console.WriteLine(s); // Hello, World!
    sys.Console.WriteLine(s.GetType(  )); // System.String
  }
}

A class D may be implicitly upcast to the class B it derives from, and a class B may be explicitly downcast to a class D that derives from it. For instance:

URL u = new URL("http://microsoft.com");
Location l = u; // upcast
u = (URL)l; // downcast

If the downcast fails, an InvalidCastException is thrown.

u = l as URL;

if (l is URL)
  ((URL)l).Navigate(  );

Polymorphism is the ability to perform the same operation on many types, as long as each type shares a common subset of characteristics. C# custom types exhibit polymorphism by inheriting classes and implementing interfaces (see Section 2.10 later in this chapter).

In the following example, the Show method can perform the operation Display on both a URL and a LocalFile because both types inherit the characteristics of Location:

class LocalFile : Location {
  public void Execute(  ) {
    Console.WriteLine("Executing "+Name);
  }
  // The constructor for LocalFile, which calls Location's constructor
  public LocalFile(string name) : base(name) {}
}
class Test {
  static void Main(  ) {
    URL u = new URL("http://www.microsoft.com");
    LocalFile l = new LocalFile( "C:\LOCAL\README.TXT");
    Show(u);
    Show(l);
  }
  public static void Show(Location loc) {
    Console.Write("Location is: ");
    loc.Display(  );
  }
}

A key aspect of polymorphism is that each type can implement a shared characteristic in its own way. One way to permit such flexibility is for a base class to declare function members as virtual. Derived classes can provide their own implementations for any function members marked virtual in the base class (see Section 2.10 later in this chapter):

class Location {
  public virtual void Display(  ) {
    Console.WriteLine(Name);
  }
    ...
}
class URL : Location {
  // chop off the http:// at the start
  public override void Display(  ) {
    Console.WriteLine(Name.Substring(7));
  }
  ...
}

URL now has a custom way of displaying itself. The Show method of the Test class in the previous section will now call the new implementation of Display. The signatures of the overridden method and the virtual method must be identical, but unlike Java and C++, the override keyword is also required.

A class can be declared abstract. An abstract class may have abstractmembers, which are function members without implementation that are implicitly virtual. In earlier examples, we specified a Navigate method for the URL type and anExecute method for the LocalFile type. You can, instead, declare Location an abstract class with an abstract method called Launch:

abstract class Location {
  public abstract void Launch(  );
}
class URL : Location {
  public override void Launch(  ) {
    Console.WriteLine("Run Internet Explorer...");
  }
}
class LocalFile : Location {
  public override void Launch(  ) {
    Console.WriteLine("Run Win32 Program...");
  }
}

A derived class must override all its inherited abstract members or must itself be declared abstract. An abstract class can’t be instantiated. For instance, if LocalFile doesn’t override Launch, LocalFile itself must be declared abstract, perhaps to allow Shortcut and PhysicalFile to derive from it.

An overridden function member may seal its implementation so it cannot be overridden. In our previous example, we could have made the URL’s implementation of Display sealed. This prevents a class that derives from URL from overriding Display, which provides a guarantee on the behavior of a URL.

public sealed override void Display(  ) {...}

A class can prevent other classes from inheriting from it by specifying the sealed modifier in the class declaration:

sealed class Math {
  ...
}

The most common scenario for sealing a class is when that class comprises only static members, as is the case with the Math class of the FCL. Another effect of sealing a class is that it enables the compiler to seal all virtual method invocations made on that class into faster, nonvirtual method invocations.

Aside from its use for calling a constructor, the new keyword can also hide the data members, function members, and type members of a base class. Overriding a virtual method with the new keyword hides, rather than overrides, the base class implementation of the method:

class B {
  public virtual void Foo(  ) {
    Console.WriteLine("In B.");
  }
}
class D : B {
  public override void Foo(  ) {
    Console.WriteLine("In D.");
  }
}
class N : D {
  public new void Foo(  ) {  // hides D's Foo
    Console.WriteLine("In N.");
  }
}
public static void Main(  ) {
  N n = new N(  );
  n.Foo(  ); // calls N's Foo
  ((D)n).Foo(  ); // calls D's Foo
  ((B)n).Foo(  ); // calls D's Foo
}

A method declaration with the same signature as its base class should explicitly state whether it overrides or hides the inherited member.

In C#, a method is compiled with a flag that is true if the method overrides a virtual method. This flag is important for versioning. Suppose you write a class that derives from a base class in the .NET Framework and then deploy your application to a client computer. The client later upgrades the .NET Framework, and the .NET base class now contains a virtual method that happens to match the signature of one of your methods in the derived class:

public class Base { // written by the library people
  public virtual void Foo(  ) {...} // added in latest update
}
public class Derived : Base { // written by you
  public void Foo(  ) {...} // not intended as an override
}

In most object-oriented languages, such as Java, methods are not compiled with this flag, so a derived class’s method with the same signature is assumed to override the base class’s virtual method. This means a virtual call is made to type Derived’s Foo method, even though Derived’s Foo is unlikely to have been implemented according to the specification intended by the author of type Base. This can easily break your application. In C#, the flag for Derived’s Foo will be false, so the runtime knows to treat Derived’s Foo as new, which ensures that your application will function as it was originally intended. When you get the chance to recompile with the latest framework, you can add the new modifier to Foo, or perhaps rename Foo something else.

A type or type member can’t declare itself to be more accessible than any of the types it uses in its declaration. For instance, a class can’t be public if it derives from an internal class, or a method can’t be protected if the type of one of its parameters is internal to the assembly. The rationale behind this restriction is that whatever is accessible to another type is actually usable by that type.

In addition, access modifiers can’t be used when they conflict with the purpose of inheritance modifiers. For example, a virtual (or abstract) member can’t be declared private, since it would then be impossible to override. Similarly, a sealed class can’t define new protected members, since there is no class that can benefit from this accessibility.

Finally, to maintain the contract of a base class, a function member with the override modifier must have the same accessibility as the virtual member it overrides.

Classes differ from structs in the following ways:

Data members and function members may be either instance (default) or static members. Instance members are associated with an instance of a type, whereas static members are associated with the type itself. Furthermore, invocation of static members from outside their enclosing type requires specifying the type name. In this example, the instance method PrintName prints the name of a particular Panda, while the static method PrintSpeciesName prints the name shared by all Pandas in the application (AppDomain):

using System;
class Panda {
  string name;
  static string speciesName = "Ailuropoda melanoleuca";
  // Initializes Panda (see the later section "Instance Constructors")
  public Panda(string name) {
    this.name = name;
  }
  public void PrintName(  ) {
    Console.WriteLine(name);
  }
  public static void PrintSpeciesName(  ) {
    Console.WriteLine(speciesName);
  }
}
class Test {
  static void Main(  ) {
    Panda.PrintSpeciesName(  ); // invoke static method
    Panda p = new Panda("Petey");
    p.PrintName(  ); // invoke instance method
  }
}

attributes? unsafe? access-modifier?
new?
static?
[readonly | volatile]?
type [ field-name [ = expression]? ]+ ;

Fields hold data for a class or struct. Fields are also referred to as member variables:

class MyClass {
  int x;
  float y = 1, z = 2;
  static readonly int MaxSize = 10;
  ...
}

As the name suggests, the readonly modifier ensures a field can’t be modified after it’s assigned. Such a field is termed a read-only field. Assignment to a read-only field is always evaluated at runtime, not at compile time. To compile, a read-only field’s assignment must occur in its declaration or within the type’s constructor (see Section 2.9.9 later in this chapter). Both read-only and non-read-only fields generate a warning when left unassigned.

The volatile modifier indicates that a field’s value may be modified in a multi-threaded scenario, and that neither the compiler nor the runtime should perform optimizations with that field.

attributes? access-modifier?
new?
const type [ constant-name = constant-expression ]+;

The type must be one of the following predefined types: sbyte, byte, short, ushort, int, uint, long, ulong, float, double, decimal, bool, char, string, or enum.

A constant is a field that is evaluated at compile time and is implicitly static. The logical consequence of this is that a constant can’t defer evaluation to a method or constructor and can only be one of a few built-in types (see the preceding syntax definition).

public const double PI = 3.14159265358979323846;

The benefit of a constant is that since it is evaluated at compile time, the compiler can perform additional optimization. For instance:

public static double Circumference(double radius) {
  return 2 * Math.PI * radius;
}

evaluates to:

public static double Circumference(double radius) {
  return 6.28318530717959 * radius;
}

attributes? unsafe? access-modifier?
[
  [[sealed | abstract]? override] |
  new? [virtual | abstract | static]?
]?
type property-name { [ 
attributes? get statement-block |  // read-only
attributes? set statement-block |  // write-only 
attributes? get statement-block    // read-write 
attributes? set statement-block
] }

abstract accessors don’t specify an implementation, so they replace a get/set block with a semicolon. Also see Section 2.8.1 earlier in this chapter.

A property can be characterized as an object-oriented field. Properties promote encapsulation by allowing a class or struct to control access to its data and by hiding the internal representation of the data. For instance:

public class Well {
  decimal dollars; // private field
  public int Cents {
    get { return(int)(dollars * 100); }
    set {
      // value is an implicit variable in a set
      if (value>=0) // typical validation code
         dollars = (decimal)value/100;
    }
  }
}
class Test {
   static void Main(  ) {
      Well w = new Well(  );
      w.Cents = 25; // set
      int x = w.Cents; // get
      w.Cents += 10; // get and set(throw a dime in the well)
   }
}

The get accessor returns a value of the property’s type. The set accessor has an implicit parameter value that is of the property’s type.

public int get_Cents {...}
public void set_Cents (int value) {...}

attributes? unsafe? access-modifier?
[
  [[sealed | abstract]? override] |
  new? [virtual | abstract]?
]?
type this [ attributes? [type arg]+ ] {  
 attributes? get statement-block |  // read-only 
 attributes? set statement-block |  // write-only  
 attributes? get statement-block    // read-write 
 attributes? set statement-block
}

abstract accessors don’t specify an implementation, so they replace a get/set block with a semicolon. Also see Section 2.8.1 earlier in this chapter.

An indexer provides a natural way to index elements in a class or struct that encapsulates a collection, using the open and closed bracket ([]) syntax of the array type. For example:

public class ScoreList {
  int[] scores = new int [5];
  // indexer
  public int this[int index] {
    get {
      return scores[index]; }
    set {
      if(value >= 0 && value <= 10)
        scores[index] = value;
    }
  }
  // property (read-only)
  public int Average {
    get {
      int sum = 0;
      foreach(int score in scores)
        sum += score;
      return sum / scores.Length;
    }
  }
}
class IndexerTest {
  static void Main(  ) {
    ScoreList sl = new ScoreList(  );
    sl[0] = 9;
    sl[1] = 8;
    sl[2] = 7;
    sl[3] = sl[4] = sl[1];
    System.Console.WriteLine(sl.Average);
  }
}

A type may declare multiple indexers that take different parameters.

public Story get_Item (int index) {...}
public void set_Item (int index, Story value) {...}

attributes? unsafe? access-modifier?
[
  [[sealed | abstract]? override] | 
  new? [ virtual | abstract | static extern? ]?
]?
[ void | type ] method-name (parameter-list)
statement-block

[ attributes? [ref | out]? type arg ]*
[ params attributes? type[ ] arg ]?

abstract and extern methods don’t contain a method body. Also see Section 2.8.1 earlier in this chapter.

All C# code executes in a method or in a special form of a method (constructors, destructors, and operators are special types of methods, and properties and indexers are internally implemented with get/set methods).

static void Foo(int p) {++p;}
public static void Main(  ) {
  int x = 8;
  Foo(x); // make a copy of the value type x
  Console.WriteLine(x); // x will still be 8
}

static void Foo(ref int p) {++p;}
public static void Test(  ) {
  int x = 8;
  Foo(ref x); // send reference of x to Foo
  Console.WriteLine(x); // x is now 9
}

using System;
class Test {
  static void Split(string name, out string firstNames, 
                    out string lastName) {
     int i = name.LastIndexOf(' '),
     firstNames = name.Substring(0, i);
     lastName = name.Substring(i+1);
  }
  public static void Main(  ) {
    string a, b;
    Split("Nuno Bettencourt", out a, out b);
    Console.WriteLine("FirstName:{0}, LastName:{1}", a, b);
  }
}

using System;
class Test {
  static int Add(params int[] iarr) {
    int sum = 0;
    foreach(int i in iarr)
      sum += i;
    return sum;
  }
  static void Main(  ) {
    int i = Add(1, 2, 3, 4);
    Console.WriteLine(i); // 10
  }
}

void Foo(int x);
viod Foo(double x);
void Foo(int x, float y);
void Foo(float x, int y);
void Foo(ref int x);

void Foo(int x);
float Foo(int x); // compile error
void Goo (int[] x);
void Goo (params int[] x); // compile error

+ - ! ~ ++ -- + - 
* (binary only) / % & (binary only)
| ^ << >> ++ != > < 
>= <=  ==

true false

C# lets you overload operators to work with operands that are custom classes or structs using operators. An operator is a static method with the keyword operator preceding the operator to be overloaded (instead of a method name), parameters representing the operands, and return type representing the result of an expression.

using System;
class Note {
  int value;
  public Note(int semitonesFromA) {
    value = semitonesFromA;
  }
  public static bool operator ==(Note x, Note y) {
    return x.value == y.value;
  }
  public static bool operator !=(Note x, Note y) {
    return x.value != y.value;
  }
  public override bool Equals(object o) {
    if(!(o is Note))
      return false;
    return this ==(Note)o;
  }
  public static void Main(  ) {
    Note a = new Note(4);
    Note b = new Note(4);
    Object c = a;
    Object d = b;
    
    // To compare a and b by reference:
    Console.WriteLine((object)a ==(object)b); // false 
    
    // To compare a and b by value:
    Console.WriteLine(a == b); // true
    
    // To compare c and d by reference:
    Console.WriteLine(c == d); // false
    
    // To compare c and d by value:
    Console.WriteLine(c.Equals(d)); // true
  }
}

...
// Convert to hertz
public static implicit operator double(Note x) {
  return 440*Math.Pow(2,(double)x.value/12);
}

// Convert from hertz (accurate only to nearest semitone)
public static explicit operator Note(double x) {
  return new Note((int)(0.5+12*(Math.Log(x/440)/Math.Log(2))));
}
...

Note n =(Note)554.37; // explicit conversion
double x = n; // implicit conversion

public struct SQLBoolean ... {
  int value;
  ...
  public SQLBoolean(int value) {
    this.value = value;
  }
  public static bool operator true(SQLBoolean x) {
    return x.value == 1;
  }
  public static bool operator false(SQLBoolean x) {
    return x.value == -1;
  }
  public static SQLBoolean operator !(SQLBoolean x) {
    return new SQLBoolean(- x.value);
  }
  public bool IsNull {
    get { return value == 0;}
  }
  ...
}
class Test {
  public static void Foo(SQLBoolean a) {
    if (a)
      Console.WriteLine("True");
    else if (! a)
      Console.WriteLine("False");
    else
      Console.WriteLine("Null");
   }
}

attributes? unsafe? access-modifier?
unsafe?
class-name (parameter-list)
[ :[ base | this ] (argument-list) ]?
statement-block

An instance constructor allows you to specify the code to be executed when a class or struct is instantiated. A class constructor first creates a new instance of that class on the heap and then performs initialization, while a struct constructor merely performs initialization.

Unlike ordinary methods, a constructor has the same name as the class or struct in which it is declared, and has no return type:

class MyClass {
  public MyClass(  ) {
    // initialization code
  }
}

A class or struct can overload constructors and may call one of its overloaded constructors before executing its method body using the this keyword:

using System;
class MyClass {
  public int x;
  public MyClass(  ) : this(5) {}
  public MyClass(int v) {
    x = v;
  }
  public static void Main(  ) {
    MyClass m1 = new MyClass(  );
    MyClass m2 = new MyClass(10);
    Console.WriteLine(m1.x); // 5
    Console.WriteLine(m2.x); // 10;
  }
}

If a class does not define any constructors, an implicit parameterless constructor is created. A struct can’t define a parameterless constructor, since a constructor that initializes each field with a default value (effectively zero) is always implicitly defined.

class B {
  public int x ;
  public B(int a) {
    x = a;
  }
  public B(int a, int b) {
    x = a * b;
  }
  // Notice that all of B's constructors need parameters
}
class D : B {
  public D(  ) : this(7) {} // call an overloaded constructor
  public D(int a) : base(a) {} // call a base class constructor
}

class MyClass {
  int x = 5;
}

attributes? unsafe? extern?
static class-name ( ) 
statement-block

Note that extern static constructors don’t specify an implementation, so they replace a statement-block with a semicolon.

A static constructor allows initialization code to be executed before the first instance of a class or struct is created, or before any static member of the class or struct is accessed. A class or struct can define only one static constructor, and it must be parameterless and have the same name as the class or struct:

class Test {
  static Test(  ) {
    Console.WriteLine("Test Initialized");
  }
}

class Test {
  public static int x = 5;
  public static void Foo(  ) {}
  static Test(  ) {
    Console.WriteLine("Test Initialized");
  }
}

class Test2 {
  public static void Foo(  ) {}
  static Test2(  ) {
    Console.WriteLine("Test2 Initialized");
  }
}
...
Test.Foo(  );
Test2.Foo(  );

C# provides the keywords for accessing the members of a class itself or of the class from which it is derived, namely the this and base keywords.

class Dude {
  string name;
  public Dude(string name) {
    this.name = name;
  }
  public void Introduce(Dude a) {
    if (a!=this)
      Console.WriteLine("Hello, I'm "+name);
  }
}

class Hermit : Dude {
  public Hermit(string name): base(name) {}
  public new void Introduce(Dude a) {
    base.Introduce(a);
    Console.WriteLine("Nice Talking To You");
  }
}

attributes? unsafe?
~class-name ( )
statement-block

Destructors are class-only methods used to clean up non-memory resources just before the garbage collector reclaims the memory for an object. Just as a constructor is called when an object is created, a destructor is called when an object is destroyed. C# destructors are very different from C++ destructors, primarily because of the garbage collector’s presence. First, memory is automatically reclaimed with a garbage collector, so a destructor in C# is solely used for non-memory resources. Second, destructor calls are non-deterministic. The garbage collector calls an object’s destructor when it determines it is no longer referenced. However, it may determine that this is an undefined period of time after the last reference to the object disappeared.

The C# compiler expands a destructor into a Finalize method override:

protected override void Finalize(  ) {
  ...
  base.Finalize(  );
}

For more details on the garbage collector and finalizers, see Section 3.12 in Chapter 3.

A nested type is declared within the scope of another type. Nesting a type has three benefits:

Here’s an example of a nested type:

using System;
class A {
  int x = 3; // private member
  protected internal class Nested {// choose any access level
    public void Foo (  ) {
      A a = new A (  );
      Console.WriteLine (a.x); // can access A's private members
    }
  }
}
class B {
  static void Main (  ) {
    A.Nested n = new A.Nested (  ); // Nested is scoped to A
    n.Foo (  );
  }
}
// an example of using "new" on a type declaration
class C : A {
   new public class Nested {} // hide inherited type member
}

An interface declaration is like a class declaration, but it provides no implementation for its members, since all its members are implicitly abstract. These members are intended to be implemented by a class or struct that implements the interface.

Here’s a simple interface that defines a single method:

public interface IDelete {
  void Delete(  );
}

Classes or structs that implement an interface may be said to “fulfill the contract of the interface.” In this example, GUI controls that support the concept of deleting, such as a TextBox or TreeView, or your own custom GUI control, can implement the IDelete interface:

public class TextBox : IDelete {
  public void Delete(  ) {...}
}
public class TreeView : IDelete {
  public void Delete(  ) {...}
}

If a class inherits from a base class, the name of each interface to be implemented must appear after the base-class name:

public class TextBox : Control, IDelete {...}
public class TreeView : Control, IDelete {...}

An interface is useful when you need multiple classes to share characteristics not present in a common base class. In addition, an interface is a good way to ensure that these classes provide their own implementation for the interface member, since interface members are implicitly abstract.

The following example assumes a form containing many GUI controls, including some TextBox and TreeView controls, in which the currently focused control is accessed with the ActiveControl property. When a user clicks Delete on a menu item or a toolbar button, you test to see if ActiveControl implements IDelete, and if so, cast it to IDelete to call its Delete method:

class MyForm {
   ...
   void DeleteClick(  ) {
      if (ActiveControl is IDelete) {
         IDelete d = (IDelete)ActiveControl;
         d.Delete(  );
      }
   }
}

Interfaces may extend other interfaces. For instance:

interface ISuperDelete : IDelete {
   bool CanDelete {get;}
   event EventHandler CanDeleteChanged;
}

In implementing the ISuperDelete interface, an ActiveControl implements the CanDelete property to indicate it has something to delete and isn’t read-only. The control also implements the CanDeleteChanged event to fire an event whenever its CanDelete property changes. This framework lets the application ghost its Delete menu item and toolbar button when the ActiveControl is unable to delete.

If there is a name collision between an interface member and an existing member in the class or struct, C# allows you to explicitly implement an interface member to resolve the conflict. In this example, we resolve a conflict that arises when we implement two interfaces that each define a Delete method:

public interface IDesignTimeControl {
   ...
   object Delete(  );
}
public class TextBox : IDelete, IDesignTimeControl {
   ...
   void IDelete.Delete(  ) {...}
   object IDesignTimeControl.Delete(  ) {...}
   // Note that explicitly implementing just one of them would
   // be enough to resolve the conflict
}

Unlike implicit interface implementations, explicit interface implementations can’t be declared with abstract, virtual, override, or new modifiers. In addition, they are implicitly public, while an implicit implementation requires the use of the public modifier. However, to access the method, the class or struct must be cast to the appropriate interface first:

TextBox tb = new TextBox(  );
IDesignTimeControl idtc = (IDesignTimeControl)tb;
IDelete id = (IDelete)tb;
idtc.Delete(  );
id.Delete(  );

If a base class implements an interface member with the virtual (or abstract) modifier, a derived class can override it. If not, the derived class must reimplement the interface to override that member:

public class RichTextBox : TextBox, IDelete {
   // TextBox's IDelete.Delete is not virtual (since explicit
   // interface implementations cannot be virtual)
   public void Delete(  ) {}
}

The implementation in this example lets you use a RichTextBox object as an IDelete object and call RichTextBox’s version of Delete.

A class or struct T can be implicitly cast to an interface I that T implements. Similarly, an interface X can be implicitly cast to an interface Y that X inherits from. An interface can be explicitly cast to any other interface or nonsealed class. However, an explicit cast from an interface I to a sealed class or struct T is permitted only if T can implement I. For example:

interface IDelete {...}
interface IDesignTimeControl {...}
class TextBox : IDelete, IDesignTimeControl {...}
sealed class Timer : IDesignTimeControl {...}

TextBox tb1 = new TextBox (  );
IDelete d = tb1; // implicit cast
IDesignTimeControl dtc = (IDesignTimeControl)d;
TextBox tb2 = (TextBox)dtc;
Timer t = (Timer)d; // illegal, a Timer can never implement IDelete

Standard boxing conversions happen when converting between structs and interfaces.

Multidimensional arrays come in two varieties, rectangular and jagged. Rectangular arrays represent an n-dimensional block; jagged arrays are arrays of arrays:

// rectangular
int [,,] matrixR = new int [3, 4, 5]; // creates one big cube
// jagged
int [][][] matrixJ = new int [3][][];
for (int i = 0; i < 3; i++) {
   matrixJ[i] = new int [4][];
   for (int j = 0; j < 4; j++)
      matrixJ[i][j] = new int [5];
} 
// assign an element
matrixR [1,1,1] = matrixJ [1][1][1] = 7;

For convenience, local and field declarations can omit the array type when assigning a known value, because the type is specified in the declaration:

int[,] array = {{1,2},{3,4}};

Arrays know their own length. For multidimensional arrays, the GetLength method returns the number of elements for a given dimension, which is counted from (the outermost) to the array’s Rank-1 (the innermost):

// one-dimensional
for(int i = 0; i < vowels.Length; i++);
// multidimensional
for(int i = 0; i < matrixR.GetLength(2); i++);

All array indexing is bounds-checked by the CLR, with IndexOutOf-RangeException thrown for invalid indexes. As in Java, bounds checking prevents program faults and debugging difficulties while enabling code to be executed with security restrictions.

Arrays of reference types can be converted to other arrays using the same logic you apply to its element type (this is called array covariance). All arrays implement System.Array, which provides methods to generic get and set elements regardless of array type.

The operators relevant to enums are:

Enums can be explicitly converted to other enums. Enums and numeric types can be explicitly converted to one another. A special case is the numeric literal 0, which can be implicitly converted to an enum.

Delegates can hold and invoke multiple methods. In this example, we declare a simple delegate called MethodInvoker, which can hold and then invoke the Foo and Goo methods sequentially. The += method creates a new delegate by adding the right delegate operand to the left delegate operand.

using System;
delegate void MethodInvoker(  );
class Test {
  static void Main(  ) {
     new Test(  ); // prints "Foo", "Goo"
  }
  Test(  ) {
    MethodInvoker m = null;
    m += new MethodInvoker(Foo);
    m += new MethodInvoker(Goo);
    m(  );
  }
  void Foo(  ) {
    Console.WriteLine("Foo");
  }
  void Goo(  ) {
    Console.WriteLine("Goo");
  }
}

A delegate can also be removed from another delegate using the -= operator:

Test(  ) {
  MethodInvoker m = null;
  m += new MethodInvoker(Foo);
  m -= new MethodInvoker(Foo);
  m(  ); // m is now null, throws NullReferenceException
}

Delegates are invoked in the order they are added. If a delegate has a non-void return type, then the value of the last delegate invoked is returned. Note that the += and -= operations on a delegate are not thread-safe.

A delegate is behaviorally similar to a C function pointer (or Delphi closure) but can hold multiple methods and the instance associated with each nonstatic method. In addition, delegates, like all other C# constructs used outside unsafe blocks, are type-safe and secure, which means you’re protected from pointing to the wrong type of method or a method that you don’t have permission to access.

A problem that can be solved with a delegate can also be solved with an interface. For instance, here is how to solve the filter problem using an IFilter interface:

using System;
interface IFilter {
   bool Filter(string s);
}
class Test {
  class FirstHalfOfAlphabetFilter : IFilter {
    public bool Filter(string s) {
      return ("N".CompareTo(s) > 0);
    }      
  }
  static void Main(  ) {
    FirstHalfOfAlphabetFilter f = new FirstHalfOfAlphabetFilter(  );
    Display(new string [] {"Ant", "Lion", "Yak"}, f);
  }
  static void Display(string[] names, IFilter f) {
    int count = 0;
    foreach (string s in names)
      if (f.Filter(s))
        Console.WriteLine("Item {0} is {1}", count++, s);
  }
}

In this case, the problem was slightly more elegantly handled with a delegate, but generally delegates are best used for event handling.

The FCL defines numerous public delegates used for event handling, but you can also write your own. For example:

delegate void MoveEventHandler(object source, MoveEventArgs e);

By convention, an event delegate’s first parameter denotes the source of the event, and the delegate’s second parameter derives from System.EventArgs and stores data about the event.

You can define subclasses of EventArgs to include information relevant to a particular event:

public class MoveEventArgs : EventArgs {
  public int newPosition;
  public bool cancel;
  public MoveEventArgs(int newPosition) {
    this.newPosition = newPosition;
  }
}

A class or struct can declare an event by applying the event modifier to a delegate field. In this example, the Slider class has a Position property that fires a Move event whenever its Position changes:

class Slider {
  int position;
  public event MoveEventHandler Move;
  public int Position {
    get { return position; }
    set {
      if (position != value) { // if position changed
        if (Move != null) { // if invocation list not empty
          MoveEventArgs args = new MoveEventArgs(value);
          Move(this, args); // fire event
          if (args.cancel)
            return;
        }
        position = value;
      }
    }  
  }
}

The event keyword promotes encapsulation by ensuring that only the += and -= operations can be performed on the delegate. This means other classes can register themselves to be notified of the event, but only the Slider can invoke the delegate (fire the event) or clear the delegate’s invocation list.

You can act on an event by adding an event handler to an event. An event handler is a delegate that wraps the method you want invoked when the event is fired.

In the next example, we want our Form to act on changes made to a Slider’s Position. You do this by creating a MoveEventHandler delegate that wraps the event-handling method, the slider.Move method. This delegate is added to the Move event’s existing list of MoveEventHandlers (which starts off empty). Changing the position on the Slider object fires the Move event, which invokes the slider.Move method:

class Form {
  static void Main(  ) {
    Slider slider = new Slider(  );
    // register with the Move event
    slider.Move += new MoveEventHandler(slider_Move);
    slider.Position = 20;
    slider.Position = 60;
  }
  static void slider_Move(object source, MoveEventArgs e) {
    if(e.newPosition < 50)
      Console.WriteLine("OK");
    else {
      e.cancel = true;
      Console.WriteLine("Can't go that high!");
    }
  }
}

Typically, the Slider class would be enhanced to fire the Move event whenever its Position is changed by a mouse movement, keypress, or other user action.

attributes? unsafe? access-modifier?
[
  [[sealed | abstract]? override] |
  new? [virtual | static]?
]? 
event delegate type event-property accessor-name
{   
attributes? add statement-block   
attributes? remove statement-block
}

Note that abstract accessors don’t specify an implementation, so they replace an add/remove block with a semicolon.

Similar to the way properties provide controlled access to a field, event accessors provide controlled access to an event. Consider the following field declaration:

public event MoveEventHandler Move;

Except for the underscore prefix added to the field (to avoid a name collision), this is semantically identical to:

private MoveEventHandler _Move;
public event MoveEventHandler Move {
  add {
    _Move += value;
  }
  remove {
    _Move -= value;
 }
}

The ability to specify a custom implementation of add and remove handlers for an event allows a class to proxy an event generated by another class, thus acting as a relay for an event rather than as the generator of that event. Another advantage of this technique is to eliminate the need to store a delegate as a field, which can be costly in terms of storage space. For instance, a class with 100 event fields would store 100 delegate fields, even though maybe only four of those events are actually assigned. Instead, you can store these delegates in a dictionary and add and remove the delegates from that dictionary (assuming the dictionary holding four elements uses less storage space than 100 delegate references).

The purpose of a try statement is to simplify dealing with program execution in exceptional circumstances. A try statement does two things. First, it lets exceptions thrown during the try block’s execution be caught by the catch block. Second, it ensures that execution can’t leave the try block without first executing the finally block. A try block must be followed by one or more catch blocks, a finally block, or both.

C# exceptions are objects that contain information representing the occurrence of an exceptional program state. When an exceptional state has occurred (e.g., a method receives an illegal value), an exception object may be thrown, and the call stack is unwound until the exception is caught by an exception handling block.

In the following example, we have an Account class. An exceptional state for the account class is when its balance is below zero, which occurs when the Withdraw method receives a withdraw amount larger than the current balance. Our test class makes our customer tiffanyTaylor perform several actions that involve despositing and withdrawing from an account. When she attempts to withdraw more money than she has in her account, a FundException is thrown, which we will catch so we can notify the user and display her current account balance.

using System;

public class FundException : Exception {
  public FundException(decimal balance) :
    base("Total funds are "+balance+" dollars") {}
}

class Account {
  decimal balance;
  public decimal Balance {
    get {return balance;}
  }
  public void Deposit(decimal amount) {
    balance += amount;
  }
  public void Withdraw(decimal amount) {
    if (amount > balance)
      throw new FundException(balance);
    balance -= amount;
  }
}

class Customer {
  Account savingsAccount = new Account(  );
  public void SellBike(  ) {
    savingsAccount.Deposit (1000);
  }
  public void BuyCar(  ) {
    savingsAccount.Withdraw (30000);
  }
  public void GoToMovie(  ) {
    savingsAccount.Withdraw (20);
  }
}

class Test {
  static void Main(  ) {
    Customer tiffanyTaylor = new Customer(  );
    bool todaysTasksDone = false;
    try {
      tiffanyTaylor.SellBike(  );
      tiffanyTaylor.BuyCar(  );
      tiffanyTaylor.GoToMovie(  );
      todaysTasksDone = true;
    }
    catch (FundException ex) {
      Console.WriteLine(ex.Message);
    }
    finally {
      Console.WriteLine(todaysTasksDone);
    }
  }
}

At the point when the FundException is thrown, the call stack is comprised of three methods: Withdraw, BuyCar, and Main. Each of these methods will in succession return immediately to its calling method until one of them has a catch block that can handle the exception, in this case Main. Without a try statement, the call stack would have been unwound completely, and our program would have terminated without displaying what caused the problem and without letting the user know whether today’s tasks were completed.

A catch clause specifies which exception type (including derived types) to catch. An exception must be of type System.Exception or of a type that derives from System.Exception. Catching System.Exception provides the widest possible net for catching errors, which is useful if your handling of the error is totally generic, such as with an error-logging mechanism. Otherwise, you should catch a more specific exception type to prevent your catch block from dealing with a circumstance it wasn’t designed to handle (for example, an out-of-memory exception).

catch(FundException) { // don't specify variable
  Console.WriteLine("Problem with funds");
}

catch {
  Console.WriteLine("Something went wrong...");
}

try {...}
catch (NullReferenceException) {...}
catch (IOException) {...}
catch {...}

finally blocks are always executed when control leaves the try block. A finally block is executed at one of the following times:

finally blocks add determinism to a program’s execution by ensuring that particular code always gets executed.

In our main example, if some other exception occurred such as a memory exception, the finally block would have still been executed. This ensures that the user would know whether today’s tasks were completed. The finally block can also be used to gracefully restore program state when an exception occurs. Had our example used a connection to a remote account object, it would have been appropriate to close the account in the finally block.

You will most frequently use the following properties of System.Exception:

An attribute is defined by a class that inherits (directly or indirectly) from the abstract class System.Attribute. When specifying an attribute on an element, the attribute name is the name of the type. By convention the derived type name ends with the word “Attribute”, but this suffix isn’t required.

In this example we specify that the Foo class is serializable using the Serializable attribute:

[Serializable]
public class Foo {...}

The Serializable attribute is actually a type declared in the System namespace, as follows:

class SerializableAttribute : Attribute {...}

We could also specify the Serializable attribute using its fully qualified typename, as follows:

[System.SerializableAttribute]
public class Foo {...}

The preceding two examples that use the Serializable attribute are semantically identical.

Attributes can take parameters, which specify additional information on the code element beyond the mere presence of the attribute.

In this next example, we use the WebPermission attribute to specify that methods in class Foo cannot make web connections to any URL starting with http://www.oreilly.com/. This attribute allows you to include parameters that specify a security action and a URL:

[WebPermission(SecurityAction.Deny, 
    ConnectPattern="http://www.oreilly.com/.*")]
public class Foo {...}

Attribute parameters fall into one of two categories: positional and named parameters. In the preceding example, SecurityAction.Deny is a positional parameter, and ConnectPattern="http://www.oreilly.com/.*" is a named parameter.

The positional parameters for an attribute correspond to the parameters passed to one of the attribute type’s public constructors. The named parameters for an attribute correspond to the set of public read/write or write-only instance properties and fields on the attribute type.

Since the parameters used when specifying an attribute are evaluated at compile time, they are generally limited to constant expressions.

Implicitly, the target of an attribute is the code element it immediately precedes. However, sometimes it is necessary to explicitly specify that the attribute applies to a particular target. The possible targets are assembly, module, type, method, property, field, param, event, and return.

Here is an example that uses the CLSCompliant attribute to specify the level of CLS compliance for an entire assembly:

[assembly:CLSCompliant(true)]

You can specify multiple attributes on a single code element. Each attribute can be listed within the same pair of square brackets (separated by a comma), in separate pairs of square brackets, or any combination of the two.

Consequently, the following three examples are semantically identical:

[Serializable, Obsolete, CLSCompliant(false)]
public class Bar {...}

[Serializable] 
[Obsolete] 
[CLSCompliant(false)]
public class Bar {...}

[Serializable, Obsolete] 
[CLSCompliant(false)]
public class Bar {...}

For every value type or pointer type V in a C# program, there is a corresponding C# pointer type named V*. A pointer instance holds the address of a value. That value is considered to be of type V, but pointer types can be (unsafely) cast to any other pointer type. Table 2-3 summarizes the principal pointer operators supported by the C# language.

&

*

->

By marking a type, type-member, or statement block with the unsafe keyword, you’re permitted to use pointer types and perform C++-style pointer operations on memory within that scope. Here is an example that uses pointers with a managed object:

unsafe void RedFilter(int[,] bitmap) {
  const int length = bitmap.Length;
  fixed (int* b = bitmap) {
    int* p = b;
    for(int i = 0; i < length; i++)
      *p++ &= 0xFF;
  }
}

Unsafe code typically runs faster than a corresponding safe implementation, which in this case would have required a nested loop with array indexing and bounds checking. An unsafe C# method can be faster than calling an external C function too, since there is no overhead associated with leaving the managed execution environment.

fixed ([value type | void ]* name = [&]? expression )
  statement-block

The fixed statement is required to pin a managed object, such as the bitmap in the previous pointer example. During the execution of a program, many objects are allocated and deallocated from the heap. In order to avoid the unnecessary waste or fragmentation of memory, the garbage collector moves objects around. Pointing to an object would be futile if its address can change while referencing it, so the fixed statement tells the garbage collector to pin the object and not move it around. This can impact the efficiency of the runtime, so fixed blocks should be used only briefly, and preferably, heap allocation should be avoided within the fixed block.

C# returns a pointer only from a value type, never directly from a reference type. Arrays and strings are an exception to this, but only syntactically, since they actually return a pointer to their first element (which must be a value type), rather than the objects themselves.

Value types declared inline within reference types require the reference type to be pinned, as follows:

using System;
class Test {
  int x;
  static void Main(  ) {
    Test test = new Test(  );
    unsafe {
       fixed(int* p = &test.x) { // pins Test
         *p = 9;
       }
       System.Console.WriteLine(test.x);
    }
  }
}

In addition to the & and * operators, C# also provides the C++-style -> operator, which can be used on structs:

using System;
struct Test {
   int x;
   unsafe static void Main(  ) {
      Test test = new Test(  );
      Test* p = &test;
      p->x = 9;
      System.Console.WriteLine(test.x);
   }
}

Memory can be allocated in a block on the stack explicitly using the stackalloc keyword. Since it is allocated on the stack, its lifetime is limited to the execution of the method in which it is used, just as with other local variables. The block may use [] indexing but is purely a value type with no additional self-describing information or bounds checking, which an array provides:

int* a = stackalloc int [10];
for (int i = 0; i < 10; ++i)
   Console.WriteLine(a[i]); // print raw memory

Rather than pointing to a specific value type, a pointer may make no assumptions about the type of the underlying data. This is useful for functions that deal with raw memory. An implicit conversion exists from any pointer type to a void*. A void* cannot be dereferenced, and arithmetic operations cannot be performed on void pointers. For example:

class Test {
  unsafe static void Main (  ) {
    short[  ] a = {1,1,2,3,5,8,13,21,34,55};
      fixed (short* p = a) {
        // sizeof returns size of value-type in bytes
        Zap (p, a.Length * sizeof (short));
      }
    foreach (short x in a)
      System.Console.WriteLine (x); // prints all zeros
  }
  unsafe static void Zap (void* memory, int byteCount) {
    byte* b = (byte*)memory;
      for (int i = 0; i < byteCount; i++)
        *b++ = 0;
  }
}

Pointers are also useful for accessing data outside the managed heap, such as when interacting with C DLLs or COM or when dealing with data not in the main memory, such as graphics memory or a storage medium on an embedded device.

The C# language supports the preprocessor directives shown in Table 2-4.

Single- and multiline comments use the C++ syntax: // and /*...*/:

int x = 3; // this is a comment
MyMethod(  ); /* this is a
comment that spans two lines */

The disadvantage of this style of commenting is that there is no predetermined standard for documenting your types. Consequently, it can’t be easily parsed to automate the production of documentation. C# improves on this by allowing you to embed documentation comments in the source and by providing an automated mechanism for extracting and validating documentation at compile time.

Documentation comments are similar to C# single-line comments but start with /// and can be applied to any user-defined type or member. These comments can include embedded XML tags as well as descriptive text. These tags allow you to mark up the descriptive text to better define the semantics of the type or member and also to incorporate cross-references.

These comments can then be extracted at compile time into a separate output file containing the documentation. The compiler validates the comments for internal consistency, expands cross-references into fully qualified type IDs, and outputs a well-formed XML file. Further processing is left up to you, although a common next step is to run the XML through an XSL/T, generating HTML documentation.

Here is an example documentation for a simple type:

// Filename: DocTest.cs
using System;
class MyClass {
  /// <summary>
  /// The Foo method is called from
  ///   <see cref="Main">Main</see> 
  /// </summary>
  /// <mytag>Secret stuff</mytag>
  /// <param name="s">Description for s</param>
  static void Foo(string s) { Console.WriteLine(s); }
  static void Main(  ) { Foo("42"); }
}

When the preceding source file is run through the compiler with the /doc:<filename> command-line options, this XML file is generated:

<?xml version="1.0"?>
<doc>
  <assembly>
    <name>DocTest</name>
  </assembly>
  <members>
    <member name="M:MyClass.Foo(System.String)">
      <summary>
      The Foo method is called from
        <see cref="M:MyClass.Main">Main</see> 
      </summary>
      <mytag>Secret stuff</mytag>
      <param name="s">Description for s</param>
     </member>
  </members>
</doc>

The <?xml...>, <doc>, and <members> tags are generated automatically and form the skeleton for the XML file. The <assembly> and <name> tags indicate the assembly that this type lives in. Every member preceded by a documentation comment is included in the XML file via a <member> tag with a name attribute that identifies the member. Note that the cref attribute in the <see> tag has also been expanded to refer to a fully qualified type and member. The predefined XML documentation tags embedded in the documentation comments are also included in the XML file. The tags have been validated to ensure that all parameters are documented, that the names are accurate, and that any cross-references to other types or members can be resolved. Finally, any additional user-defined tags are transferred verbatim.

This section lists the predefined set of XML tags that can be used to mark up the descriptive text:

There is little that is special about the predefined XML tags recognized by the C# compiler, and you are free to define your own. The only special processing done by the compiler is on the <param> tag (where it verifies the parameter name and confirms that all the parameters on the method are documented) and the cref attribute (where it verifies that the attribute refers to a real type or member and expands it to a fully qualified type or member ID). The cref attribute can also be used in your own tags and is verified and expanded just as it is in the predefined <exception>, <permission>, <see>, and <seealso> tags.

Type names and type or member cross-references are translated into IDs that uniquely define the type or member. These names are composed of a prefix that defines what the ID represents and a signature of the type or member. Table 2-5 lists the set of type and member prefixes.

N

T

F

P

M

E

!

The rules describing how the signatures are generated are well-documented, although fairly complex.

Here is an example of a type and the IDs that are generated:

// Namespaces do not have independent signatures
namespace NS {
  // T:NS.MyClass
  class MyClass {
    // F:NS.MyClass.aField
    string aField;
    // P:NS.MyClass.aProperty
    short aProperty {get {...} set {...}}
    // T:NS.MyClass.NestedType
    class NestedType {...};
    // M:NS.MyClass.X(  )
    void X(  ) {...}
    // M:NS.MyClass.Y(System.Int32,System.Double@,System.Decimal@)
    void Y(int p1, ref double p2, out decimal p3) {...}
    // M:NS.MyClass.Z(System.Char[],System.Single[0:,0:])
    void Z(char[] p1, float[,] p2) {...}
    // M:NS.MyClass.op_Addition(NS.MyClass,NS.MyClass)
    public static MyClass operator+(MyClass c1, MyClass c2) {...}
    // M:NS.MyClass.op_Implicit(NS.MyClass)~System.Int32
    public static implicit operator int(MyClass c) {...}
    // M:NS.MyClass.#ctor
    MyClass(  ) {...}
    // M:NS.MyClass.Finalize
    ~MyClass(  ) {...}
    // M:NS.MyClass.#cctor
    static MyClass(  ) {...}
  }
}