Members defined in a class are scoped to that class. However, the visibility of the member is defined by accessibility keywords. The most common accessibility keywords are public and private. Public members are visible inside and outside the class. The visibility of private members is restricted to the containing class. Private is the default accessibility of a class member. Table 2-3 details the accessibility keywords.

Attributes are usually the first element of the member declaration and further describe a member by extending the metadata of that element. The Obsolete attribute is an example of an attribute and marks a function as deprecated. Attributes are optional. By default, a member has no attributes.

Modifiers refine the definition of the applicable member. Modifiers are optional, and there are no defaults. Some modifiers are reserved depending on the classification of members. For example, the override modifier is applicable to member functions but not data members. Table 2-4 lists the available member modifiers.

Members belong either to an instance of a class or to the class itself. Static members are bound to a class. Except for constants, class members default to instance members and are bound to an object via the this reference. Constant members are implicitly static. Static members are classwise and have no implied this context. Certain types of members cannot be static and others cannot be instance members; destructors and operator member functions are an example. Destructors cannot be static, whereas operator member functions cannot be instance members.

Instance members when used are qualified by the object name. Here is the syntax of an instance member:

Static members are prefixed with the class name:

The lifetime of static members is closely linked to the lifetime of the application. The lifetime of instance members is linked to an instance and is accessible from the point of instantiation. Access to instance members of a local reference cease when the instance variable is no longer in scope. Therefore, the lifetime of an instance member is a subset of the lifetime of an application. Static members are essentially always available, whereas instance members are not. Static members are similar to global functions and variables but have the benefit of encapsulation. Static members can be private to limit their visibility.

Your design analysis should determine which members are instance members and which are static members. For example, in a personnel application for small businesses, there is an Employee class. The employee number is an instance member of the class. In the problem domain, each employee is assigned a unique identifier. However, the company name member is static because all employees work for the same company. The company name does not belong to a single employee, but to the classification.

public static class ZClass {
    public static void MethodA() {}
    public static void MethodB() {}
}

The this reference is a readonly reference to the current object. Instance member functions are passed a this reference as a hidden parameter of the function. In an instance function, the this reference is automatically applied to any instance members. This assures that within an instance member function, you can implicitly refer to members of the same object. In the following code, GetEmployeeInfo is an instance member function referring to other instance members (the this reference is implied):

public void GetEmployeeInfo() {
    PrintEmployeeName();
    PrintEmployeeAddress();
    PrintEmployeeId();
}

Here is the same code, except that the this pointer is explicit (the behavior of the function remains the same):

public void GetEmployeeInfo() {
    this.PrintEmployeeName();
    this.PrintEmployeeAddress();
    this.PrintEmployeeId();
}

In the preceding code, the this reference was not required. The this reference is sometimes useful as a function return value or as a parameter. In addition, the this reference can improve code readability and provide IntelliSense for class members when editing the code in Microsoft Visual Studio.

Static member functions are not passed a this reference as a hidden parameter. For this reason, a static function member cannot directly access nonstatic members of the class. Therefore, you cannot refer to an instance member from a static member. Static members are essentially limited to accessing other static members. Instance members have access to both instance and static members of the class.

Members are broadly grouped into data and function members. As mentioned, types consist of states and behaviors. Data members are states, whereas function members define behavior. Data members include constants, fields, and nested types. As previously mentioned, data members are typically private to enforce encapsulation and to adhere to the principle of data hiding and abstraction. The class developer gains implementation independence and the freedom to modify the type so long as the public interface is not changed. Once published, the interface should be immutable.

Constants are data members. They are initialized at compile time using a constant expression and cannot be modified at run time. Constants are assigned a type and must be used within the context of that type. This makes constants type-safe. Constants are usually value types, such as integer or double. A constant can be a reference type, but with limitations. Reference types are typically initialized at run time, which is prohibited with a constant. Therefore, reference types as constants must be set to null at declaration. The sole exception are strings, which are reference types but can be assigned a non-null value at declaration.

The following is the syntax of a constant member:

With constants, the only allowable modifier is new, which hides an inherited constant of the same name in the base type. Constants are implicitly static. The initialization is performed at compile time. You can declare and initialize several constants simultaneously.

The following class has several constant data members:

public class ZClass {
    public const int fielda = 5, fieldb = 15;
    public const int fieldc = fieldd + 10;  // Error

    public static int fieldd = 15;
}

The assignment to fieldc causes a compile error. The fieldd member is a nonconstant member variable and is evaluated at run time. Thus, fieldd cannot be used in an assignment to a constant variable.

Instance fields hold state information bound to a specific object. The state information is stored in managed memory created for the object. Static fields are data owned by the class. A single instance of static data is created for the class. It is not replicated for each instance. Fields can be reference or value types. Here is the syntax for declaring a field:

Fields support the full assortment of accessibility. Valid modifiers for a field include new, static, readonly, and volatile.

Initialization is optional but recommended. Uninitialized fields are assigned a default value of zero or null. Fields can be initialized individually or in an initialization list.

Initialization is performed in the textual order in which the fields appear in the class, which is top-down. The textual order is demonstrated in the following code:

using System;

namespace Donis.CSharpBook{
    internal class ZClass {
        public int iField1 = FuncA(), iField2 = FuncC();
        public int iField3 = FuncB();

        public static int FuncA() {
            Console.WriteLine("ZClass.FuncA");
            return 0;
        }
        public static int FuncB() {
            Console.WriteLine("ZClass.FuncB");
            return 1;
        }

        public static int FuncC() {
            Console.WriteLine("ZClass.FuncC");
            return 2;
        }

    }

    public class Starter {
        public static void Main() {
            ZClass obj = new ZClass();
        }
    }
}

Running this code confirms that FuncA, FuncC, and FuncB are called in sequence based on the textual order of field initialization.

Constants must be initialized at compile time. This limits some of the flexibility of a constant. For example, if the constant value is not known until run time, a constant variable cannot be used. This is where a readonly field is helpful. A readonly field is similar to a constant except that it also can be initialized in a constructor at run time. In addition, the initialization expression of a readonly field can refer to other static fields. However, you cannot refer to a instance field. Unlike constant fields, readonly fields can be instance or static members.

The following code contains an example of a readonly field:

public class ZClass {
    public ZClass() { // constructor
        fieldc = 10;
    }

    public static int fielda = 5;
    public readonly int fieldb = fielda + 10;
    public int fieldc;
};

Methods contain the code of the class. A method can contain one or more return statements, which provide an orderly exit to a function. Void functions do not require a return statement and can simply fall through the end of the function. The C# compiler extrapolates all possible paths within the function. One reason for this is to make sure that all possible code paths have an appropriate return statement. Another is that the compiler is looking for unreachable code. The following code, stored in unreachable.cs, includes both unreachable code and a code path without a proper return statement:

public static int Main() {
    if (true) {
        Console.WriteLine("true");
    }
    else {
        Console.WriteLine("false");
    }
}

The if statement is always true. Therefore, the else code is unreachable. Main returns int. However, the method has no return statement. For these reasons, the application generates the following errors when compiled:

unreachable.cs(10,17): warning CS0162: Unreachable code detected
unreachable.cs(5,27): error CS0161: 'Donis.CSharpBook.Starter.Main()': not all code
paths return a value

Keep functions relatively short. Longer functions are harder to debug and test. A class comprised of a number of short functions, which is the class interface, is preferable to a class that contains only a few convoluted long functions. Remoted components are the exception: A narrower interface is preferred because it minimizes client calls and optimizes network traffic. Comparatively, local invocations are quick and efficient.

In addition to code, functions own local variables and parameters. The local variables and parameters represent the private state of the function.

static void Main(string [] arg) {
    if (arg.Length > 0) {
        // do something
         return;
    }

    // implicit return
}

public class ZClass {
    public int MethodA() {
        return 5;
    }

    public void MethodB() {
        return;
    }

    public int MethodC() {
        int value1 = 10;
        value1 = 5 + MethodA() + value1;  // Valid
        MethodB();                        // Valid
        value1 = MethodB();               // Invalid
        return value1;
    }
}

using System;

namespace Donis.CSharpBook {
    public class XInt {
        public int iField = 0;
    }

    public class Starter {

        public static XInt MethodA() {
            XInt inner = new XInt();
            inner.iField = 5;
            return inner;
        }

        public static void Main() {
            XInt outer = MethodA();
            Console.WriteLine(outer.iField);
        }
    }
}

using System;

namespace Donis.CSharpBook {
    public class Starter {

        public static void MethodA(int parameter) {
            parameter = parameter + 5;
        }    //  change discarded

        public static void Main() {
            int local = 2;
            MethodA(local);
            Console.WriteLine(local); // Writes 2
        }
    }
}

using System;

namespace Donis.CSharpBook {

    public class XInt {
        public int iField = 2;
    }

    public class Starter {

        public static void MethodA(XInt alias) {
            alias.iField += 5;
        }

        public static void Main() {
            XInt obj = new XInt();
            MethodA(obj);
            Console.WriteLine(obj.iField);  // Writes 7
        }
    }
}

using System;

namespace Donis.CSharpBook {
    public class Starter {

        public static void MethodA(ref int parameter) {
            parameter = parameter + 5;
        }

        public static void Main() {
            int var = 2;
            MethodA(ref var);
            Console.WriteLine(var); // Writes 7
        }
    }
}

using System;

namespace Donis.CSharpBook {

    public class XInt {
        public int iField = 2;
    }

    public class Starter {

        public static void MethodA(XInt alias) {
            XInt inner = new XInt();
            inner.iField = 5;
            alias = inner;
        }  // reference change lost

        public static void Main() {
            XInt obj = new XInt();
            MethodA(obj);
            Console.WriteLine(obj.iField);  // Writes 2
        }
    }
}

using System;

namespace Donis.CSharpBook {

    public class XInt {
        public int iField = 2;
    }

    public class Starter {

        public static void MethodA(ref XInt alias) {
            XInt inner = new XInt();
            inner.iField = 5;
            alias = inner;
         }
         public static void Main() {
             XInt obj=new XInt();
             MethodA(ref obj);
             Console.WriteLine(obj.iField);  // Writes 5
         }
    }
}

using System;

namespace Donis.CSharpBook {

    public class XInt {
        public int iField = 5;
    }

    public class Starter {

        public static void MethodA(ref XInt alias) {
            XInt inner = new XInt();
            alias = inner;
        }

        public static void Main() {
            XInt obj;
            MethodA(ref obj); // Error
            Console.WriteLine(obj.iField);  // Won't compile
        }
    }
}

using System;

namespace Donis.CSharpBook {

    class XInt {
        public int iField = 5;
    }

    class Starter {
        public static void MethodA(out XInt alias) {
            XInt inner = new XInt();
            alias = inner;
        }

        public static void Main() {
            XInt obj;
            MethodA(out obj);
            Console.WriteLine(obj.iField);  // Writes 5
        }
    }
}

Function overloading allows multiple implementations of the same function in a class, which promotes a consistent interface for related behavior. Overloaded methods share the same name but have unique signatures. Parameter attributes, such as out, are distinctive and considered part of the signature (the function header minus the return type). Because the return type is excluded from the signature, functions cannot be overloaded on the basis of a different return type alone. The number of parameters, the type of parameters, or both must be different. With the exception of constructors, a function cannot be overloaded based on whether it is a static or instance member.

The process of selecting a function from a set of overloaded methods, which occurs during compile time, is called function resolution. The compiler calls the function that matches the number and types of parameters in the function invocation. Sometimes a call site matches more than one function in the overloaded set. When function resolution matches two or more methods, the call is considered ambiguous and a compile error occurs. A compiler error also results if no overloaded function matches the call site.

This sample code overloads the SetName method:

using System;

namespace Donis.CSharpBook {

    public class Employee {

        public string name;

        public void SetName(string last) {
            name = last;
        }

        public void SetName(string first, string last) {
            name = first + " " + last;
        }

        public void SetName(string saluation, string first, string last) {
            name = saluation + " " + first + " " + last;
        }
        }

        public class Personnel {
            public static void Main() {
               Employee obj = new Employee();
               obj.SetName("Bob", "Kelly");
        }
    }
}

Functions with variable-length parameter lists can be included in the set of overloaded functions. The function first is evaluated with a fixed-length parameter list. If function resolution does not yield a match, the function is evaluated with variable-length parameters.

Local variables can be either reference or value types. You can declare a local variable anywhere in a method, but there is one caveat. The local variable must be defined before use. There are competing philosophies as to when to declare local variables. Some developers prefer to declare local variables at the beginning of a method or block, where they are readily identifiable; others like to declare local variables near where they are used because they think that local variables are more maintainable when located near the affected code. Local variables are not assigned a default value prior to initialization. They can be initialized at declaration or later. At declaration, local variables can be initialized separately or in an initialization list. It is good practice to initialize local variables to something at declaration. That way, the local variable always has a known state. Referring to an unassigned local variable in an expression causes a compiler error.

This is the syntax for declaring a local variable:

modifier type variablename = initialization;

The only modifier available to local variables is const. Variables that are const must be initialized at compile time and cannot be changed thereafter.

The scope of a local variable is the entire function—regardless of where the local variable is declared. The scope of a parameter is also the entire function. Basically, local variables cannot have the same name as a parameter.

Visibility

Local variables are declared at the top level or in a child block within the method. The visibility of a local variable starts where the local variable is declared. Visibility ends when the block where the local variable is declared ends. Local variables are visible in child blocks, but not in parent blocks. Because local variables maintain scope throughout the block in which they are declared, names of local variables cannot be reused in a child block. Figure 2-1 illustrates the relationship between scope and visibility of local variables.

Figure 2-1. Diagram of the scope and visibility of a local variable

Local variables of a value type are removed from the stack when the function is exited. Local references are also removed from the stack at that time, but the reference object may or may not become a candidate for garbage collection. Assuming that no other references exist at function exit, the object will become a candidate for garbage collection. It is a good idea to assign null to a reference when the reference is no longer needed. Local variables are private to the current function and are not accessible from another function. Identically named local variables in different functions are distinct and separate entities, which are stored at different memory addresses. To share data between functions, declare a field.

Methods are the most common function member. Methods accept parameters as input, perform an operation, and return the result of the operation. Both parameters and a return result are optional. Methods are described through the method header, and implemented in the method body. Here is the syntax of a method:

Various attributes apply to methods, such as Obsolete, StrongNameIdentityPermission, and InternalsVisibleTo. Methods can be private, public, protected, or internal. Methods can be assigned the sealed, abstract, new, and other modifiers, as explained in Chapter 3. The return_type is the result of the method. Methods that return nothing must have a void return_type. The parameter list, which consists of zero or more parameters, is the input of the method. The method body contains zero or more statements.

A constructor is a specialized function for initializing the state. An instance constructor initializes an instance of a class, while a static constructor initializes the classwise state. This guarantees that the class or object is always in a known state. Constructors have the same name as the class. Instance constructors are invoked with the new operator and cannot be called in the same manner as other member functions. Here is the syntax of a constructor:

The accessibility of a constructor determines where new instances of the reference type can be created. For example, a public constructor allows an object to be created in the current assembly or a referencing assembly. A private or protected constructor prevents an instance from being created outside the class or a descendant of the class. The extern modifier is the only modifier applicable to constructors. Constructors can have zero or more parameters. Finally, note that constructors return void but do not have an explicitly declared return type.

This code shows one constructor for an Employee class:

using System;

namespace Donis.CSharpBook {

     public class Employee {

        public Employee(params string []_name) {
             switch(_name.Length) {
                case 1:
                    name = _name[0];
                    break;
                case 2:
                    name = _name[0] + " " + _name[1];
                    break;
                default:
                    // Error handler
                    break;
            }

        }

        public void GetName() {
            Console.WriteLine(name);
        }

        private string name = "";
    }

    public class Personnel {

        public static void Main() {
            Employee jim = new Employee("Jim", "Wilson");
            jim.GetName();
        }
    }
}

Classes with no constructors have an implicit constructor—the default constructor, which is a parameterless constructor. Default constructors assign default values to fields. A new statement with no parameters invokes the default constructor. You can replace a default constructor with a custom parameterless constructor. The following new statement calls the default constructor of a class:

Employee empl = new Employee();

Constructors can be overloaded. The function resolution of overloaded constructors is determined by the parameters of the new statement. The following Employee class has overloaded constructors:

using System;

namespace Donis.CSharpBook {

    public class Employee {

        public Employee(string _name) {
            name = _name;
        }

        public Employee(string _first, string _last) {
            name = _first + " " + _last;
        }

        private string name = "";
    }

    public class Personnel {
        public static void Main() {
            Employee jim = new Employee("Jim", "Wilson");  // 2 argument constructor
        }
    }
}

In the preceding code, an instance of the Employee class (jim) is created using the two-argument constructor. Creating an instance using the default constructor would cause a compile error:

Employee jim = new Employee();

This is the error message:

Donis.CSharpBook.Employee' does not contain a constructor that takes '0' arguments

Why does this error occur? Although the statement is syntactically correct, the Employee class does not have a default constructor. Adding any custom constructor to a class removes the default constructor. A custom one-argument and two-argument constructor were added to the Employee class, which removed the default constructor. In this circumstance, you could explicitly add a default (parameterless) constructor to the class if needed.

A constructor can call another constructor using the this reference, which is useful for reducing redundant code. A constructor cannot call another constructor in the method body. Instead, constructors call other constructors using the colon syntax after the constructor header. This syntax is available with constructors but not with other member functions. In the following code, all the constructors of the Employee class delegate to the one-argument constructor:

class Employee {

    public Employee()
        : this("") {
    }

    public Employee(string _name) {
        name = _name;
    }

    public Employee(string _first, string _last)
        : this(_first + " " + _last) {
    }

    public void GetName() {
        Console.WriteLine(name);
    }

    private string name = "";
}

Constructors also can be static. You create a static constructor to initialize static fields. The static constructor is called when the class is first referenced. These are the limitations to static constructors:

Static constructors are not called explicitly with the new statement. As mentioned, static constructors are called when the class is first referenced. In the following code, ZClass has a static constructor. The static constructor is stubbed to output the time. In Main, the time is also displayed, execution is paused for about five seconds, and then ZClass is accessed. ZClass.GetField is called and that triggers the invocation of the static constructor. This will display the time, which should be about five seconds later:

using System;
using System.Threading;

namespace Donis.CSharpBook {

    public class ZClass {

        static private int fielda;
        static ZClass() {
            Console.WriteLine(DateTime.Now.ToLongTimeString());
            fielda = 42;
        }
        static public void GetField() {
            Console.WriteLine(fielda);
        }
    }

    public class Starter {
        public static void Main() {
            Console.WriteLine(DateTime.Now.ToLongTimeString());
            Thread.Sleep(5000);
            ZClass.GetField();
        }
    }
}

using System;

namespace Donis.CSharpBook {

    public class Chessboard {
        private Chessboard() {
        }

        static Chessboard() {
            board = new Chessboard();
            board.start = DateTime.Now.ToShortTimeString();
        }

        public static Chessboard board=null;
        public string player1;
        public string player2;
        public string start;
    }

    public class Game {
        public static void Main() {
            Chessboard game = Chessboard.board;
            game.player1 = "Sally";
            game.player2 = "Bob";
            Console.WriteLine("{0} played {1} at {2}",
                game.player1, game.player2,
        game.start);
        }
    }
}

public class Name
{
    public string GetName()
    {
        return first + " " + middle +
               " " + last;
    }

    public string first = "";
    public string last = "";
    public string middle = "";
}

class Names
{
    public static void Main()
    {
        Name donis = new Name { first = "Donis",
            last = "Marshall" };
        Name lisa = new Name { first = "Lisa",
            last = "Miller" };
        Console.WriteLine(donis.GetName());
        Console.WriteLine(lisa.GetName());
    }
}

It is good practice to remove unused objects from resources. That is the purpose of the destructor method. Destructors are not called directly in source code but during garbage collection. This provides an opportunity for an object to clean itself before it is removed from memory. Garbage collection is nondeterministic. A destructor is invoked at an undetermined moment in the future. Like a constructor, the destructor has the same name as the class, except a destructor is prefixed with a tilde (_~). The destructor is called by the Finalize method, which is inherited from System.Object. In C#, you cannot override the Finalize method. For deterministic garbage collection, inherit the IDisposable interface and implement IDisposable.Dispose based on the disposable pattern. The disposable pattern is discussed in Chapter 18.

Destructors differ from other member functions in the following ways:

Here is the syntax of a destructor:

Destructors have usage patterns. They also have performance and efficiency implications. Understand the ramifications of destructors before adding a destructor in a class. These topics are also reviewed in Chapter 18.

The following code implements a destructor and a Dispose method. The WriteToFile class is a wrapper for a StreamWriter object. The constructor initializes the internal object, and the Dispose method closes the file resource. The destructor delegates to this Dispose method. You can call the Dispose method explicitly or have the destructor called implicitly at garbage collection. The Main method tests the class:

using System;
using System.IO;

namespace Donis.CSharpBook {

    public class WriteToFile: IDisposable {

        public WriteToFile(string _file, string _text) {
            file = new StreamWriter(_file, true);
            text = _text;
        }

        public void WriteText() {
            file.WriteLine(text);
        }

        public void Dispose() {
            if (null != file)
            {
                file.Close();
                file = null;
            }
        }

        ~WriteToFile() {
            if (null != file)
            {
                Dispose();
            }
        }

        private StreamWriter file;
        private string text;
    }

    public class Writer {
        public static void Main() {
            WriteToFile sample = new WriteToFile("sample.txt", "My text file");
            sample.WriteText();
            sample.Dispose();
        }
    }
}

A property provides the convenience of a field but the safety of a function. Properties are visible like a field but are actually a get and set method. The get method is called when a value is returned from the property. Conversely, the set method is used when a value is assigned to the property. Fields are typically private, which protects the state of the object or class. You access the private fields through the public interface. Properties combine a private field and a public interface in a single entity. There are several benefits of using properties instead of public fields:

A property is a get and set method. Neither method is called directly. Depending on how the property is being used, the correct method is called implicitly. As a left-value of an assignment, the set method of the property is called. When used as a right-value, the get method of the property is called. The get method also is called if a property is used within an expression.

Here is the syntax of a property declaration:

The accessibility and modifier apply to both the get and set method. However, either the set or get method can override the accessibility when necessary. In this way, for example, the get method could be public, while the set method is private. Type is the underlying type of the property. Neither the get nor set method has an explicit return type or parameter list. Both are inferred. The get method returns the property type and has no parameters. The set method returns void and has a single parameter, which is the same type as the property. In the set method, the value keyword represents the implied parameter.

In this code, the Person class has an age property:

using System;

namespace Donis.CSharpBook {

    public class Person {
        private int prop_age;
        public int age {
            set {
                // perform validation
                prop_age = value;
            }
            get {
                return prop_age;
            }
        }
    }

    class People{

        public static void Main() {
            Person bob = new Person();
            bob.age = 30; // Calls set method
            Console.WriteLine(bob.age);  // Call gets method
        }
    }
}

Properties have no inherent data storage, which can be efficient because data storage is not always required. For example, computed properties might not require data storage. If desired, a corresponding data store can be declared in the class. The data store of a property can be a single field. This one-to-one relationship between the property and the data store is not required. A composite property can consist of multiple fields. Conversely, multiple properties can rely on the same field. The latter case is demonstrated in the following code, where the name, first, and last properties rely on the prop_name field:

using System;

namespace Donis.CSharpBook {

    public class Employee {

        private string prop_name;
        public string name {
            get {
               return prop_name;
            }
            set {
               prop_name = value;
            }
        }

        public string first {
            get {
               return (prop_name.Split(' '))[0];
            }
            set {
                 string lastname = name.Split(' ')[1];
                 prop_name = value + " " + lastname;
            }
        }
        public string last {
            get {
               return (prop_name.Split(' '))[1];
            }
            set {
                 string firstname = name.Split(' ')[0];
                 prop_name = firstname + " " + value;
            }
        }
    }

    public class Personnel{
        public static void Main() {
            Employee jim=new Employee();
            jim.name="Jim Wilson";
            jim.first="Dan";
            Console.WriteLine(jim.name);  // Dan Wilson
            Console.WriteLine(jim.last);  // Wilson
        }
    }
}

public class SensitiveForm{
    private string prop_password;
    public string password {
        set {
            prop_password = value;
        }
    }
}

using System;
namespace Donis.CSharpBook {
    public class Person {
        public int age {
            get;
            set;
        }
    }

    class People {
        public static void Main() {
            Person bob = new Person();
            bob.age = 30; // Calls set method
            Console.WriteLine(bob.age);  // Call gets method
        }
    }
}

public class Person {

    private int prop_age;
    public int age {
        set {
            if (value < 0 || value > 120) {
                throw new ApplicationException("Invalid age!");
            }
            prop_age = value;
        }
        get {
            return prop_age;
        }
    }
}

public class Person {
    private int? prop_age;
    public int? age {
        set {
            if (value < 0 || value > 120) {
                prop_age = null;
                return;
            }
            prop_age = value;
        }
        get {
            return prop_age;
        }
    }
}

Nested types are created inside a class or structure. This is an example of a nested class:

public class Outer {

    public void FuncA() {
    }

    public class Inner {

        static public void FuncB() {
            Console.WriteLine("Outer.Inner.FuncB()");
        }
    }
}

Nested types can be public or private or have other accessibility. The full complement of modifiers is available. Use the dot syntax to access members of the nested class. The following code calls a static method of the Inner class:

Outer.Inner.FuncB();

You can create an instance of the nested class. If the nested class is public, references to the nested class can be created inside or outside the outer class depending on the visibility. A nested class that is private can be instantiated only inside the outer class. This is one reason for using nested classes. Invoking the this object within the nested class refers to members of the nested class alone. Instance members of the outer class are not accessible from the this object within the nested class. You can provide access to the outer object through the constructor of the nested class. Pass a reference of the outer object as a parameter. The back reference is then available to access the instance members of the outer object from within the nested class. The static members of the outer class, regardless of accessibility, are available to the nested class.

The Automobile class models a car engine, which is a system. An automobile system contains an alternator, ignition, steering, and other subsystems. This is an abbreviated version of an Automobile class:

using System;

namespace Donis.CSharpBook {

    public class Automobile {

        public Automobile() {
            starter = new StarterMotor(this);
        }

        public void Start() {
            starter.Ignition();
        }

        private bool prop_started = false;
        public bool started {
            get {
                return prop_started;
            }
        }

        private class StarterMotor {
            public StarterMotor(Automobile _auto) {
                auto = _auto;
            }

            public void Ignition() {
                auto.prop_started = true;
            }
            Automobile auto;
        }
        private StarterMotor starter;
    }

    public class Starter {
        public static void Main() {
            Automobile car = new Automobile();
            car.Start();
            if (car.started) {
                Console.WriteLine("Car started");
            }
        }
    }
}

A partial type can span multiple source files. When compiled, the elements of the partial type are combined into a single type in the assembly. With partial types, each source file has a complete type declaration and body. The type declaration is preceded with the partial keyword. The type body in each source file includes only the members that the partial type is contributing to the overall type. Code generators benefit from partial types. You can rely on the Integrated Development Environment (IDE) or wizard to generate the core code. The developer can then extend the code in a separate source file without disturbing the core code. Teams of developers collaborating on an application also benefit from partial types. The type can be parceled based on responsibility. Each developer works in a separate source file, which isolates changes and allows each developer to focus only on code for which he or she is directly responsible.

Consistency is the key to partial types, with the rules as follows:

Here is an example of a class separated into partial types:

// partial1.cs

using System;

namespace Donis.CSharpBook {

    public partial class ZClass {
        public void CoreMethodA() {
            Console.WriteLine("ZClass.CoreMethodA");
        }
    }

    public class Starter {
        public static void Main() {
            ZClass obj = new ZClass();
            obj.CoreMethodA();
            obj.ExtendedMethodA();
        }
   }
}

// partial2.cs

using System;

namespace Donis.CSharpBook {

    public partial class ZClass {

        public void ExtendedMethodA() {
            Console.WriteLine("ZClass.ExtendedMethodA");
        }
    }
}

Figure 2-2 shows the ZClass in the Intermediate Language Disassembler (ILDASM) tool. It confirms that the partial types are merged into a single class.

Figure 2-2. ZClass depicted in ILDASM

A partial method is a method that is declared in one partial class but implemented in another. There can be only one declaration and only one implementation of the partial method across the related partial classes. Partial methods have many of the same benefits of a partial class. The declaration can be provided by the code generator but implementation is completed by the developer. Partial methods must return void and default to private accessibility. In addition, partial methods cannot have out parameters. If the partial method is not implemented, the declaration and any calls to the method are removed at compile time by the compiler. This is another new feature of Visual C# 2008.

This is sample code of a partial method:

// corecode.cs

public partial class XClass{
    partial void ToBeImplemented();
}

// source2.cs

public partial class XClass{
    partial void ToBeImplemented() {
        Console.WriteLine("XClass.ToBeImplemented");
    }
}