A type contains data members and function members. The data member of UnitConverter is the field called ratio. The function members of UnitConverter are the Convert method and the UnitConverter's constructor.

A beautiful aspect of C# is that predefined types and custom types have few differences. The primitive int type serves as a blueprint for integers. It holds data—32 bits—and provides function members that use that data, such as ToString. Similarly, our custom UnitConverter type acts as a blueprint for unit conversions. It holds data—the ratio—and provides function members to use that data.

Data is created by instantiating a type. Primitive types can be instantiated simply by using a literal. For example, the following line instantiates two integers (12 and 30), which are used to compute a third instance, x:

	int x = 12 * 30;

The new operator is needed to create a new instance of a custom type. We created and declared an instance of the UnitConverter type with this statement:

	UnitConverter feetToInchesConverter =
	  new UnitConverter(12);

Immediately after the new operator instantiates an object, the object’s constructor is called to perform initialization. A constructor is defined like a method, except that the method name and return type are reduced to the name of the enclosing type:

	public class UnitConverter
	{
	  ...
	  public UnitConverter (int r)   // Constructor
	    { ratio = r; }
	  ...
	}

The data members and function members that operate on the instance of the type are called instance members. The UnitConverter's Convert method and the int's ToString method are examples of instance members. By default, members are instance members.

Data members and function members that don’t operate on the instance of the type, but rather on the type itself, must be marked as static. The Test.Main and Console.WriteLine methods are static methods. The Console class is actually a static class, where all its members are static. You never actually create instances of a Console—one console is shared across the whole application.

To contrast instance versus static members, the instance field Name pertains to an instance of a particular Panda, whereas Population pertains to the set of all Panda instances:

	using System;

	public class Panda
	{
	  public string Name;              // Instance field
	  public static int Population;    // Static field

	  public Panda (string n)       // Constructor
	  {
	    Name = n;                   // Assign instance field
	    Population = Population+1;  // Increment static field
	  }
	}

The following code creates two instances of the Panda, prints their names and then the total population:

	Panda p1 = new Panda ("Pan Dee");
	Panda p2 = new Panda ("Pan Dah");

	Console.WriteLine (p1.Name);     // Pan Dee
	Console.WriteLine (p2.Name);     // Pan Dah

	Console.WriteLine (Panda.Population);  // 2

The public keyword exposes members to other classes. In this example, if the Name field in Panda was not public, the Test class could not access it. Marking a member public is how a type communicates: “Here is what I want other types to see—everything else is my own private implementation details.” In object-oriented terms, we say that the public members encapsulate the private members of the class.

The content of a value type variable or constant is simply a value. For example, the content of the built-in value type int is 32 bits of data.

You can define a custom value type with the struct keyword as follows (see Figure 1-1).

	public struct Point { public int X, Y; }

Figure 1-1. A value type instance in memory

The assignment of a value type instance always copies the instance. For example:

	Point p1 = new Point( );
	p1.X = 7;

	Point p2 = p1;               // Assignment causes copy

	Console.WriteLine (p1.X);    // 7
	Console.WriteLine (p2.X);    // 7

	p1.X = 9;                    // Change p1.X

	Console.WriteLine (p1.X);    // 9
	Console.WriteLine (p2.X);    // 7

Figure 1-2 shows that p1 and p2 have independent storage.

Figure 1-2. Assignment copies a value type instance

A reference type is more complex than a value type, having two parts: an object and the reference to that object. The content of a reference type variable or constant is a reference to an object that contains the value. Here is the Point type from our previous example rewritten as a class, rather than a struct (seeFigure 1-3).

	public class Point { public int X, Y; }

Figure 1-3. A reference type instance in memory

Assigning a reference type variable copies the reference, not the object instance. This allows multiple variables to refer to the same object—something not ordinarily possible with value types. If we repeat the previous example, but with Point now a class, an operation to X affects Y:

	Point p1 = new Point( ); 
	p1.X = 7;

	Point p2 = p1;              // Copies p1 reference

	Console.WriteLine (p1.X);   // 7
	Console.WriteLine (p2.X);   // 7

	p1.X = 9;                   // Change p1.X

	Console.WriteLine (p1.X);   // 9
	Console.WriteLine (p2.X);   // 9

Figure 1-4 shows that p1 and p2 are two references that point to the same object.

Figure 1-4. Assignment copies a reference

A reference can be assigned the literal null, indicating that the reference points to no object:

	class Point {...}
	...

	Point p = null;
	Console.WriteLine (p == null);   // True

	// The following line generates a runtime
	// error (a NullReferenceException is thrown):
	Console.WriteLine (p.X);

In contrast, a value type cannot ordinarily have a null value:

	struct Point {...}
	...

	Point p = null;  // Compile-time error
	int x = null;    // Compile-time error

Value type instances occupy precisely the sum of the memory occupied by their fields.

Reference types require separate allocations of memory for the reference and object. The object consumes as many bytes as its fields, plus additional administrative overhead (typically 12 bytes). Each reference to an object requires an extra 4 or 8 bytes, depending on whether the .NET runtime is running on a 32- or 64-bit platform.