}

We define a class using the class keyword followed by the name of the class and then the class body contained in curly braces. In this example, the Person class body contains fields, methods, and properties. These are collectively known as class members. Fields, also called data members, are regular variables. Methods, also known as function members, contain executable code.

The Test class in listing A.2 is used to execute the program and create an instance of the Person class:

Person p = new Person("Joe", "Bloggs", 33);

This creates a reference p to an instance of the Person class. Creating a class instance causes a special method, known as a constructor, to be executed. A constructor method always has the same name as the class itself and no return type. It is executed automatically when an instance of the class is created at run time. In this case, the constructor takes three arguments representing the first name, last name, and age of the person. These values are used by the constructor to initialize the fields in the class instance, as in:

this.firstName = firstName;

The this keyword is used within a method to reference the current class instance.

The DisplayName method is used here to display the firstName and lastName fields. The method is called using the ref.MethodName(...) syntax:

p.DisplayName();

In C#, the dot operator is typically used for member access. C# also supports C-style pointers and pointer member access ( p->m ) when operating in an unsafe context, denoted by the use of the unsafe modifier in a type or member declaration.

Note that all methods, except the constructor, must declare a return type. If a method does not return a value, then it should declare a void return type, as DisplayName does in listing A.2.

It is generally considered poor programming practice to allow calling code to reach into a class instance and change field values. Instead, C# provides properties for this purpose:

public int Age {

  get { return age; } // get age

  set { age = value; } // set age field

}

A property may have a get and/or set accessor associated with it. In this example, the get accessor returns the value of the age field. The set accessor is used to set the value of the age field. Within a set accessor block, C# automatically provides a variable called value which holds the new value to which the property can be set, as follows:

p.Age = 34;

Note that the methods and properties of the Person class are marked with the access modifier public . (We look at the full list of access modifiers later in this article.) This makes them publicly accessible to calling code through a reference to the class instance, as in p.Age . Members which omit an access modifier, such as the fields in the Person class, are private by default. This means that they are inaccessible outside the class. Therefore the following attempt to access the firstName field will generate a compiler error:

Console.WriteLine("First name is " + p.firstName); // error!

The recommended naming convention is that private member names should begin with a lowercase letter while other member names should begin with an uppercase letter. However, this is not a rule.

A class can include static members which can be accessed without first creating an instance of the class. For example, the following snippet defines a static MinimumAge field in the Person class:

class Person {

public static int MinimumAge = 18;

...

}

We can access the static MinimumAge field directly using the class name, as follows:

int age = Person.MinimumAge;

Since C# does not provide global variables, static fields are often used to store global values.

Finally, classes can be nested:

class C1 {

  int i, j;

  string s;

  void m() {

  // ...

  }

  class c2 {

    // ...

  }

}

The class is at the heart of object-oriented programming in C#. We'll return to this topic when we consider inheritance.

}

Inheritance is used to model an is-a relationship. (A man is a person). In this example, we've changed the accessibility of the firstName and lastName fields of the Person class to protected , thus making them accessible to any derived class. We specify that Man derives from Person , as follows:

// Man derives from Person class...

class Man : Person {

...

}

The only difference between the Man and Person classes is the greeting displayed. Therefore, we leverage the base Person class constructor to build an instance of Man , as follows:

// create a Man by calling base Person constructor...

public Man(string fName, string lName) : base(fName, lName) {}

The base keyword is used to refer to the parent object. In this example, the body of the Man constructor is empty. Instead the Person constructor is called to construct the object.

In the derived Man class, we reimplement the Greet method using the new keyword to make clear to the compiler that we are not inadvertently hiding the parent's Greet method.

}

Placing the virtual modifier in front of the base class's method definition causes the compiler to generate code to look up a data structure, known as a virtual dispatch table, at run time to find the correct method. A corresponding override modifier is required in front of the derived class's method in order for virtual dispatching to locate the correct method. So virtual dispatching allows an object to assume different forms, Man or Person in this example, as necessary. This is sometimes referred to as polymorphism.

}

We use the abstract modifier in front of the Person class definition to prevent the class being instantiated. Attempting to instantiate the Person class causes a compiler error. We also declare the Greet method to be abstract, thus requiring all derived classes to override this method. In other words, the Person class specifies a template, or contract, for classes which derive from it.