Overriding is the same as the default behavior of Java; however, this is not the default C# behavior. The virtual modifier must be used to explicitly declare a member as virtual. When a derived class declares a new implementation of an inherited virtual member, the override modifier must be used to explicitly confirm the programmer’s intention to override the inherited member. If the override modifier is not used, the new member hides the inherited member, and a compiler warning occurs. If a derived class attempts to override a nonvirtual inherited member, a compiler error will occur.

By default, members are not virtual. A derived class that implements a member with the same name and signature as a nonvirtual inherited member must use the new modifier to explicitly declare the programmer’s intention to hide the inherited member. Although hiding is the default behavior of C#, a compiler warning will occur if the new modifier is not used.

Hiding breaks the polymorphic behavior provided by virtual members. When invoking nonvirtual members, the type of variable used to reference an object determines which member gets invoked. No attempt is made to execute a more derived version of the member based on the runtime type of the object.

In Java, hiding is possible only with static methods, and not instance methods. As a Java developer learning C#, it can be frustrating having to remember to make members virtual and overridden, but the support for both overriding and hiding inherited members provided by C# gives a level of flexibility unavailable in Java.

It’s possible to use the new modifier in conjunction with the virtual modifier. This results in a new point of specialization in the inheritance hierarchy. Methods derived from the class implementing a new virtual member will inherit the virtual member. Classes further up the inheritance chain will still perceive the member to be nonvirtual.

A member that is overriding an inherited virtual member can use the sealed modifier to ensure that no further derived classes can override the member. This is similar to the use of the final modifier in Java. However, the sealed modifier is valid only in conjunction with the override modifier. This means that the original declaration of a member cannot guarantee that it won’t be overridden. Only through marking an entire class as sealed can the programmer ensure that a member cannot be overridden.

A derived class can access members in a superclass by using the base keyword. This has the same function and syntax as the super keyword in Java.

Constant declarations have the following syntax:

[attributes] [modifiers] const type identifier = value;

More than one constant can be declared on a single line, each having the same type and accessibility but different values. For example:

public const int MyConstant = 60;
private const byte A = 5, B = 10, C = 20;
protected const string MyName = "Allen", HisName = null;
internal const MyClass X = null;
protected internal const int MyOtherConstant = MyConstant * 2;

Constants can be declared as any of the inbuilt simple types as well as string, enum, or any reference type. However, the only valid values for reference type constants are string literals and null.

A constant must be assigned a value at declaration, or a compile-time error will occur. No default values are assigned by the compiler. This value can depend on other constants as long as no circular reference is created.

The modifiers applicable to constants depend on the context of their declaration. Table 5-12 summarizes the available modifiers for each context.

Field declarations have the following syntax:

[attributes] [modifiers] type identifier = value;

A field can be declared with any reference or value type. As with Java, it’s possible to declare more than one field per declaration. Each field will have the same type and accessibility. For example:

public int MyField;
public byte X = 5, Y, Z = 10;

As before, fields can be initialized at declaration. However, if a field is not initialized, the compiler will assign it a default value based on its type. Details of default values for each type can be found in the Types section earlier in this chapter.

The modifiers applicable to fields depend on the context of their declaration. Table 5-13 summarizes the available modifiers for each context.

A compile-time error occurs if an attempt is made to assign an initial value to a field that is a member of a struct. For example:

public struct MyStruct {
    //This will cause a compile time error
    int MyInt = 6;
}

As long as the new keyword is used to instantiate a struct, all the member fields will be initialized to their default values. If the new keyword is not used, each field must be manually assigned a value before an attempt is made to use the fields.

Fields marked with the readonly modifier are the C# equivalent of Java constants. Read-only fields can be assigned a value only at declaration or in a constructor appropriate to the type of field: instance or static. Because read-only fields are unchangeable once initialized, a compile-time error occurs if an attempt is made to pass a read-only field as an out or ref parameter outside the context of a constructor.

The use of both static and readonly modifiers provides a useful alternative to the C# constant in situations in which a type is needed that is not supported by the constant member type, or in which the value cannot be determined at compile time. In the following example, the anObject field cannot be a constant but can be read-only. Although the anInteger field could be a constant, we would have to assign it a value at declaration instead of waiting until the SomeOtherClass was instantiated.

public class SomeClass {
    // SomeClass implementation
}

public class SomeOtherClass {
    readonly SomeClass anObject;
    readonly int anInteger;

    public SomeOtherClass () {
        anObject = new SomeClass();
        anInteger = 5;
    }
}

Constructor declarations have the following form:

[attributes] [modifiers] identifier ([parameters])[:initializer([parameters])] {body}

The following Java code demonstrates a class named MyClass with a public constructor that passes control to a constructor of its superclass:

class MyClass extends MySuperClass{

    public MyClass(int x, String y) {
        super(x, y);
        //other constructor code
    }
}

Java constructors use the super keyword to pass control to a superclass constructor, which must be the first statement in the constructor. C# adopts a different syntax, using the base keyword to identify the superclass constructor to call, as highlighted in the following example:

class MyClass : MySuperClass {

    public MyClass(int x, string y): base(x, y) {
        //other constructor code
    }
}

The this keyword is used instead of base to call an overloaded constructor in the same class, as highlighted in the following example:

class MyClass : MySuperClass {

    public MyClass(string y): this(5, y) {
        //any other constructor code will be executed
        //after the call to the overloaded constructor
    }
    public MyClass(int x, string y): base(x, y) {
        //other constructor code will be executed after
        //the call to the superclass constructor
    }
}

The modifiers applicable to constructors depend on the context of their declaration. Table 5-14 summarizes the available modifiers for each context.

C# static constructors are the equivalent of Java static initialization blocks. The syntax of a C# static constructor is similar to that of an instance constructor, supporting attributes and the extern modifier. No other modifiers are supported, including access modifiers. For example:

public class MyClass {
    // This is a static constructor
    static MyClass() {
        // Static Constructor code goes here
    }
}

Only one static constructor can be defined per class; Java supports multiple static initialization blocks.

As an alternative to destructors, C# provides the System.IDisposable interface for clearing up object resources without waiting for the automated garbage collection process to call a destructor. A class that implements IDisposable should correctly release any resources it holds when its Dispose method is called.

C# provides the using statement, which is shorthand syntax for acquiring and disposing of objects that implement the IDisposable interface. See the Statements section in Chapter 4 for complete details of the using statement.

Method declarations have the following syntax:

[attributes] [modifiers] return-type identifier (parameter-list) {body}

For example, a protected static method named MyMethod that returns an integer and takes a string and a bool as parameters is declared as follows:

protected static int MyMethod (string s, bool b) {
    // implementation code
}

The modifiers applicable to methods depend on the context of their declaration. Table 5-15 summarizes the available modifiers for each context.

When applying modifiers to method declarations, the following restrictions apply:

All parameters are passed by value in Java. In addition to pass-by-value parameters, C# supports two new parameter types: reference and output parameters. C# also provides a mechanism called parameter arrays, which is used to pass a variable number of arguments to a method.We discuss parameter arrays in the following section. See the Variables section later in this chapter for a complete coverage of value, reference, and output parameters.

public void MyMethod(string someParam, params byte[] args) {
    // implementation code
}

byte[] b = {5, 2, 6, 8} ;
string test = "hello" ;

MyMethod(test);           // call with no parameters
MyMethod(test, 3);        // call with a single parameter
MyMethod(test, 2,7,1);    // call with more than one parameter
MyMethod(test, b);        // call using an actual array

An event declaration takes the following form:

[attributes] [modifiers] event type identifier [{access-declarations}];

The event type must be an already defined and accessible delegate type. The optional access-declarations element provides the functionality for adding and removing event listeners. If this element is omitted, the compiler provides a default implementation suitable for most purposes. We’ll discuss custom access-declarations later in this section.

using System;

// Declare a delegate for event notifications
public delegate void
    TemperatureEventHandler (string source, int temp);

// Declare the event source object
public class TempSource {
    private string Name;
    private int temp = 0;
    public event TemperatureEventHandler TemperatureChange;

    //Constructor takes a name for the Temperature Source
    public TempSource (string name) {
        Name = name;
    }

    // Declare a property to set the current temperature
    public int Temp {
        set {
            temp = value; // set the temperature

            // Raise the event if there are any listeners
            if (TemperatureChange != null) {
          TemperatureChange(Name, temp);
            }
        }
    }

    // Declare a method to remove all registered listeners
    public void Reset() {
        TemperatureChange = null;
    }
}

// Declare the event listener
public class TempListener {
    private string Name;

    // Constructor that takes Listener name and an array of source
    public TempListener(string name, params TempSource[] sources) {

        Name = name;

        // Register with each of the temperature sources
        foreach (TempSource t in sources) {
            t.TemperatureChange +=
                new TemperatureEventHandler(this.TempChanged);
        }
    }

    public void TempChanged(string src, int temp) {
        Console.WriteLine(Name + " : Temp is " + temp
            + " F in the " + src);
    }

    public static void Main() {
        TempSource g = new TempSource("garden");
        TempSource r = new TempSource("refrigerator");

        new TempListener("Listener1", new TempSource[] {g, r});
        new TempListener("Listener2", new TempSource[] {g, r});

        g.Temp = 34;
        r.Temp = 16;
    }
}

Listener1 : Temp is 34 F in the garden.
Listener2 : Temp is 34 F in the garden.
Listener1 : Temp is 16 F in the refrigerator.
Listener2 : Temp is 16 F in the refrigerator.

public delegate void EventHandler(object sender, EventArgs e);

public event SomeEventHandler SomeEvent {
    add {
        // Functionality to add event listener
    }
    remove {
        // Functionality to remove an event listener
    }
}

Properties provide a means to manipulate object state but are not stateful mechanisms themselves; something else, often a field member, is the target of the manipulation. The property declaration imposes no requirements on the containing type as to what the stateful item is, or is called.

Property declarations have the following syntax:

[attributes] [modifiers] type identifier {accessor-declaration}

The property type can be any value or reference type and specifies both the data type that can be assigned to the property and the type returned when the property itself is assigned to something else.

Here’s a Java implementation of the getter/setter pattern for the Person class discussed previously:

public class Person {

    private int thePersonsAge;

    public void setAge(int p_age) {
        // Do some validation
        thePersonsAge = p_age;
    }

    public int getAge() {
        return thePersonsAge;
    }
}

The equivalent C# implementation using properties is

public class Person {
    private int thePersonsAge;

    public int Age {
        get {
            return thePersonsAge;
        }
        set {
            thePersonsAge = value;
        }
    }
}

The get and set accessors in this example are simplistic and provide no additional benefit compared with making the thePersonsAge field public; however, as function members, properties can contain any executable code.

The undeclared variable value used in the set accessor is implicitly provided by the compiler, containing the value the caller has assigned to the property. The type is the same as that of the property declaration, in this example an int.

It’s possible to implement only the get or the set accessor, thus providing a read-only or write-only property. However, if the intention is to use the prefix or postfix increment (++) or decrement (--) operator, or any of the compound assignment operators (+=, – =, and so on), both the get and set accessors must be declared. Attempting any action on a property that requires an accessor that has not been implemented will result in a compiler error being raised.

The modifiers applicable to properties depend on the context of their declaration. Table 5-17 summarizes the available modifiers for each context.

A property can be a member of an interface. The structure of the property declaration is the same as discussed earlier in this section; however, the body of the get and set accessors is an empty statement. If only one of the accessors is required, specify this in the interface. For example:

public interface IPerson {
    int Age {get; set;}
    string PayrollNumber {get;}    // No set accessor required.
}

Indexers are similar to properties in that they provide a means to manipulate object state but are not stateful mechanisms themselves. As with properties, the containing class or struct must implement some other program element as the target of the manipulation. The indexer imposes no requirements as to how this is done.

Index declarations have the following syntax:

[attributes] [modifiers] type this [parameters] {accessor-declarations}

Use of an indexer is never performed explicitly through a member name, so indexers do not have identifiers. As a consequence of an unfortunate syntax choice, indexers are declared using the keyword this.

The indexer type can be any value or reference type and specifies both the data type that can be assigned to an indexer element and the type of the indexer element returned when assigned to something else. At least one parameter must be specified in the indexer declaration. Multiple parameters result in a multidimensional index, as in the case of a multidimensional array. For example:

public string this [int index1, byte index2, string index3] {...}

Parameters can be of any value or reference type, but it is not valid to use the ref or out modifier.

Multiple indexers can be defined for a single class. Given that all indexers are declared using the this keyword, additional indexers must be differentiated with different parameter types.

The following example demonstrates the declaration of an indexer:

public class TopTenArtists {

    private string[] artists = new string[10];

    public string this [int index] {
        get {
            if (index > 0 && index < 11) {
                return artists[index-1];
            } else {
                return null;
            }
        }
        set {
            if (index > 0 && index < 11) {
                artists[index-1] = value;
            }
        }
    }
}

The undeclared variable value used in the set accessor is implicitly provided by the compiler. It contains the value the caller is assigning to the property. Its type is the same as that of the property declaration—in this instance, an int.

The following code demonstrates how the indexer of the TopTenArtists class can be used:

public static void Main() {

    TopTenArtists artists = new TopTenArtists();

    artists[1] = "Rubens";
    artists[2] = "Gainsborough";
    artists[3] = "Yevseeva";


    for (int x = 1; x < 11; x++) {
        System.Console.WriteLine("Artist {0} is {1}", x, artists[x]);
    }
}

This example produces the following output:

Artist 1 is Rubens
Artist 2 is Gainsborough
Artist 3 is Yevseeva
Artist 4 is
Artist 5 is
Artist 6 is
Artist 7 is
Artist 8 is
Artist 9 is
Artist 10 is

As was the case with properties, indexers can implement only the get or set accessor; this provides a read-only or write-only member. As with properties, if the intention is to use the prefix or postfix increment or decrement operators, or any of the compound assignment operators, both the get and set accessors must be declared.

The modifiers applicable to indexers depend on the context of their declaration. Table 5-18 summarizes the available modifiers for each context.

Indexers can be declared in interfaces. As with properties, the get and set accessors must be specified as an empty statement. To implement a read-only or write-only indexer, simply omit the accessor that is not required. When implementing the interface, explicit interface implementation must be used to identify the indexer implementation. For example:

public interface IMyInterface {
    string this [int index] {get; set;}
}

public class MyClass : IMyInterface {
    string IMyInterface.this [int index] {
        get {
            // implementation
        }
        set {
            // implementation
        }
    }
}

The problem with this approach is that the indexer cannot be accessed through an instance of the class, only through an instance of the interface. For example:

// This is a compile-time error
MyClass a = new MyClass();
string b = a[1];

// The following statements are valid
MyClass p = new MyClass();
string q = ((IMyInterface)p)[1];   // Cast to an interface instance

IMyInterface x = new MyClass();
string y = x[1];

The declaration of an operator member takes the following general form:

[attributes] [modifiers] operator operator-token (parameters) {body}

The type of operator member determines the specific declaration syntax required, but there are a number of restrictions common to all operator members:

There are three categories of operator members: unary, binary, and conversion. We discuss each of these in the following sections.

public class SomeClass {

    // +, -, !, and ~ operators can return any type
    public static int operator +(SomeClass x) {/*...*/}
    public static SomeOtherClass operator ~(SomeClass x) {/*...*/}

    // ++ and –- operators must return an instance of SomeClass
    public static SomeClass operator ++(SomeClass x) {/*...*/}

    // true and false operators must be declared as a pair
    // and return bool
    public static bool operator true(SomeClass x) {/*...*/}
    public static bool operator false(SomeClass x) {/*...*/}
}

SomeClass x = new SomeClass();    // Instantiate a new SomeClass
SomeClass y = +x;                 // Unary + operator
SomeOtherClass z = ~x;            // Bitwise compliment operator

while (x) {                       // true operator
    x++;                          // postfix increment operator
}

public struct SomeStruct {

    // The == and != operators must be declared in pairs
    // The same arguments types and order must be used
    public static bool operator == (SomeStruct x, int y) {/*...*/}
    public static bool operator != (SomeStruct x, int y) {/*...*/}

    // Binary + operator causes += to be implicitly overloaded
    public static SomeStruct operator + (SomeStruct x, long y) {/*...*/}

    // Binary & operator declared to support usage with "&&" statements
    public static SomeStruct operator & (
        SomeStruct x, SomeStruct y) {/*...*/}

}

SomeStruct x = new SomeStruct();    // Instantiate a new SomeStruct
SomeStruct y = new SomeStruct();    // Instantiate a new SomeStruct

if (x && y) {   // correctly implemented "&" operator supports this
    x += 45 ;   // implicitly provided by overloading "+" operator
}

public static implicit operator SomeClass(String x) {/*...*/}

public static explicit operator int (SomeStruct x) {/*...*/}

Many languages do not support operator overloading, and it is not part of the Common Language Specification (CLS). To provide cross-language support, it’s necessary to provide method alternatives to any overloaded operators. The CLS provides recommendations on appropriate names for each operator type.