The C# compiler will implicitly box value types as required—for example, invoking a function member of a struct or passing a value type where an object is expected. Given the overheads associated with boxing, overuse can affect program performance. Where performance is an issue, you should write programs to avoid the unnecessary use of implicit boxing.

A struct declaration takes the following form:

[attributes] [modifiers] struct identifier : interfaces {body}

Apart from the fact that structs do not support inheritance (discussed in the next section), structs are declared the same way as classes. For example, a public struct named MyStruct that implements the IMyInterface interface is declared as follows:

public struct MyStruct : IMyInterface {
    // function and data members
}

Structs do not support user-defined inheritance. However, all structs implicitly derive from System.ValueType, which is in turn derived from System.Object.

The applicability of modifiers to a struct declaration depends on the context in which the struct is declared. Structs can be declared as top-level types (that is, direct members of an enclosing namespace) or nested within the definition of another struct or class. Table 5-2 summarizes modifier availability.

An empty constructor is one that takes no parameters. Although it’s valid to define an empty constructor for a class, it’s not valid to define one for a struct. The compiler implicitly defines an empty constructor for a struct, the body of which sets all of the struct members to their default values. This means that it’s impossible to stop the instantiation of a struct using a private empty constructor. If the accessibility of the struct makes it visible, it can always be instantiated.

Unlike classes, struct instances are allocated memory as soon they are declared; the new keyword is not required. However, if the new keyword is not used, all field members of the struct must be explicitly assigned values prior to use; otherwise, a compiler error occurs. If the new keyword is used, the field members of the struct will be initialized to their default values. Struct variables can never be assigned the value null.

Structs can contain the following member types: constant, field, method, property, event, indexer, operator, instance constructor, static constructor, and nested type declarations. Structs cannot contain destructors, as stack-based object structs are not subject to the garbage collection process.

If a struct instance is passed as a function member parameter, returned from a function member, or assigned to a variable, a copy of the complete struct will be created. The copy is independent of the original struct; any changes made to the content of the new struct will not be reflected in the original.

Should the need arise to pass a struct reference, use the ref or out modifier on the parameter. The need to use ref may indicate that a class would be a more appropriate alternative. See the Variables section later in this chapter for full details of the ref and out parameter modifiers.

Thought should be given to how a data structure will be used before deciding whether to implement a class or a struct. The decision can affect the performance of an application. There are no definitive rules; only guidelines can be offered:

An enum declaration has the form

[attributes] [modifiers] enum identifier [:base] {body}

The base component of the enum declaration specifies the underlying type of the enum and can be any of the simple integer types; the default is int. The base type limits the range of values that can be assigned to the enum members.

The body of the enum declaration contains a list of member names with optional values. Member names must be unique, but multiple members can have the same value. By default, the first member will have the integer value 0 and subsequent members will be assigned values sequentially.

Using explicit numbering, the programmer can assign an integer value to each enum member. The assigned value must be valid for the specified base type. Any members without explicit values are assigned a value sequentially based on the value of the previous member.

The following example declares an enum named PokerChip with a byte base type:

public enum PokerChip : byte {

    Blue = 1,
    Green,            // Automatically assigned the value 2 (Blue + 1)
    Red = 5,          // Explicitly assigned the value 5
    Orange = 10,
    Brown = 25,
    Silver = 50,
    Gold = Silver * 2, // Any determinable constant is acceptable
    Min = Blue,        // Multiple members with the same value are ok
    Max = Gold
}

The following example demonstrates the PokerChip enum used as a method argument and a switch statement expression:

public void PlaceBet(PokerChip chip) {
    switch (chip) {
        case PokerChip.Blue:
            //Do something
            break;
        case PokerChip.Green:
            //Do something else
            break;
        default:
            //Do something else
            break;
    }
}

As shown in the PlaceBet method, function members can specify enum types as arguments. Using an enum type argument restricts the range of values that are valid for the argument. However, the integer constant 0 (zero) is implicitly convertible to any enum type and can always be passed in place of a valid enum member.

Enums can be declared as top-level structures or contained within a class or struct. The modifiers available depend on the context of the enum declaration. Table 5-4 summarizes the available modifiers for each context.

The user-defined members of an enum are restricted to the set of public name/value pairs contained within the enum. Enums do not support user-defined inheritance, but all enums implicitly derive from System.Enum, which derives from System.ValueType and ultimately from System.Object. The System.Enum class provides a number of static methods for working with enum member names and values, summarized in Table 5-5.

A C# class declaration takes the following form:

[attributes] [modifiers] class identifier [:superclass] [interfaces] {body}

The Java keywords extends and implements are not used. C# uses the colon to separate the class name from its superclasses and interfaces. Commas are used to separate the superclass and each subsequent interface name; the superclass must come first, or a compiler error will occur.

For example, the following is the C# code to declare a public class named MyClass that inherits from the superclass MyBaseClass and implements two interfaces named IAnInterface and IAnotherInterface:

public MyClass : MyBaseClass, IAnInterface, IAnotherInterface {
    // Implementation code
}

The applicability of modifiers to class declarations depends on the context in which the class is declared. Classes can be declared as a top-level type, being direct members of an enclosing namespace, or they can be nested within the definition of a class or struct. Table 5-6 summarizes modifier availability for classes.

Classes can contain the following member types: constant, field, method, property, event, indexer, operator, instance constructor, static constructor, and nested type declarations. For comprehensive coverage of member types, see the Members section later in this chapter.

The implementation of interface members represents an important difference in the default behavior of how abstract classes are handled in Java and C#. In Java, any interface members that are not implemented simply become abstract members that concrete classes must implement. C# abstract classes must provide implementations for all interface members, but the abstract class may declare the member as abstract. For example:

public interface MyInterface {
    int MyMethod(int x);
}

public abstract class MyClass : MyInterface {
    // Compile time error if the following declaration is missing
    public abstract int MyMethod(int x);
}

The C# compiler, like the Java compiler, will provide a default constructor if one is not explicitly defined for a class. The accessibility Java assigns to this default constructor is the same as the accessibility of the containing class; C# defines the default constructor as protected if the class is abstract, otherwise as public.

Both Java and C# offer the same capabilities for creating concrete classes that cannot be instantiated. Declaring at least one constructor ensures that the compiler does not generate a default constructor. Declaring this constructor private renders it inaccessible to other code, so the class cannot be instantiated.

It’s not possible to define anonymous or local classes in C#; all classes must be explicitly defined before use. Java anonymous classes are regularly used for event handling, especially with GUI components. See the Events section later in this chapter for details of event handling in C#.

A C# interface declaration takes the following form:

[attributes] [modifiers] interface identifier [:superinterfaces] {body}

For example, the C# code to declare a public interface named MyInterface that extends the superinterfaces IAnInterface and IAnotherInterface follows:

public MyInterface : IAnInterface, IAnotherInterface {
    // member declarations
}

C# uses a colon followed by a comma-separated list of superinterfaces to specify inheritance.

The applicability of modifiers to an interface declaration depends on the context in which the interface is declared. Interfaces can be declared as a top-level type, being direct members of an enclosing namespace, or they can be nested within the definition of a class or struct. Table 5-7 summarizes modifier availability.

Interfaces can contain the following member types: method, property, event, and indexer. Aside from support for the member types introduced by C#, the major difference from Java is that constants cannot be declared in interfaces. The alternative provided by C# is to use a peer-level enum; however, this does not keep associated constants together with the interface.

C# classes and structs implement interfaces using the same syntax. The following example shows a struct MyStruct and a class MyClass both declaring the implementation of two interfaces IAnInterface and IAnotherInterface:

public struct MyStruct :IAnInterface, IAnotherInterface {
    // Implementation code
}

public class MyClass :IAnInterface, IAnotherInterface {
    // Implementation code
}

C# includes a feature called explicit interface implementation, which gives greater control over interface member implementations. Explicit interface implementation is most commonly used when implementing multiple interfaces that contain members with conflicting names or signatures. The only mandatory use of explicit interface implementation is when implementing an indexer declared in an interface.

The following is an example of a class implementing two interfaces with conflicting member declarations. Explicit interface implementation is used to differentiate between the implementation of the interface methods.

 public interface IMyInterface {
    void SomeMethod();
}

public interface IMyOtherInterface {
    void SomeMethod();
}

public class MyClass : IMyInterface, IMyOtherInterface {
    void IMyInterface.SomeMethod() {
        // Implementation Code
    }
    void IMyOtherInterface.SomeMethod() {
        // Implementation Code
    }
}

Each implementation of SomeMethod is qualified using the name of the interface from which it’s derived.

Explicit interface implementation provides the following benefits:

The use of explicit interface implementation has some consequences worth mentioning:

C# provides three syntax variants for declaring arrays, including two variants to deal with arrays of multiple dimensions: single-dimensional, multidimensional (rectangular), and jagged (arrays of arrays). Java makes no distinction between multidimensional and jagged arrays.

The syntax for array declaration and creation in C# is less flexible than in Java; the square brackets must follow the type specification. If anything, however, this avoids confusion, improving code clarity without reducing functionality.

Table 5-8 demonstrates the Java and C# syntax for array declaration and creation. We use arrays of type int in these examples, but C#, like Java, will support arrays of any valid type, including delegates, interfaces, and abstract classes.

As with Java, it’s possible to initialize a declared array without explicitly creating it. An array of the appropriate size will be implicitly created based on the initialization values. For example, the following two statements are equivalent:

int[,,] x = {{{2,3,4}, {5,8,2}}, {{4,6,8}, {7,9,0}}};
int[,,] x = new int [2,2,3] {{{2,3,4}, {5,8,2}}, {{4,6,8}, {7,9,0}}};

C# provides the foreach statement that simplifies the syntax required to iterate over the elements of an array. Full details of the foreach statement are included in the Statements section in Chapter 4.

Arrays are considered objects in both Java and C#; however, the objectlike features of arrays in C# are more extensive than those in Java. In Java, arrays are not directly exposed as objects, but the runtime enables an instance of an array to be assigned to a variable of type java.lang.Object and for any of the methods of the Object class to be executed against it.

In C#, all arrays inherit from the abstract base class System.Array, which derives from System.Object. The System.Array class provides functionality for working with the array, some of which is available in java.util.Arrays. Arrays are also considered to be one of the fundamental collection types.

A delegate declaration takes the following form:

[attributes] [modifiers] delegate type identifier (parameters);

The type and parameters of the delegate declaration define the return type and signature template a method must have so that it can be added to the delegate invocation list. For example:

//Declare a new delegate type
public delegate int MyDelegate(int x, string y);

//The following methods are valid delegate references
public int Method1(int a, string b) { /* ... */}
public int Method2(int e, string f) {/* ... */}
public int Method3(int p, string q) {/* ... */}

//The following methods are not valid
public void Method4(int p, string q) {/* ... */}
public int Method5(ref int p, string q) {/* ... */}

In this example, Method1, Method2, and Method3 are all valid to be used with MyDelegate. Method4 and Method5 are not because their return types and signatures do not match those defined in the MyDelegate declaration.

Delegates are instantiated using a single parameter: the name of a method that matches the template specified in the delegates declaration. Existing delegate instances can also be assigned to another instance of the same delegate type, in which case a copy of the delegate invocation list will be assigned to the target delegate.

Delegates can be added together using the + and += operators. This results in the target delegate having the combined invocation list of the two operand delegates. Method references are maintained in the order in which they are added. Adding the same method twice results in two references to the same method being maintained on the invocation list.

Removing method references from a delegate instance is achieved using the - or -= operator. Where there are multiple references to the method, only the last instance will be removed. Attempting to remove a method that is not on the invocation list is not an error. Continuing from the foregoing example:

//Instantiating and modifying delegates
MyDelegate d1 = new MyDelegate(Method1);
MyDelegate d2 = new MyDelegate(Method2);
MyDelegate d3 = d1 + d2;
d3 += new MyDelegate(Method3);
d3 -= d1;
d3 -= new MyDelegate(Method3);

A delegate is concerned only with the signature and return type of a method, not the type that implements the method; any instance or static method that matches the template can be used with a delegate.

Invoking a delegate is achieved using the delegate instance as if it were a method with the return type and parameters specified in the delegate declaration. For example:

//Invoking a delegate
int i = d3(6, "Test");

This will cause each method on the invocation list to be called in sequence using the parameters provided. If passing an object reference or using a ref parameter, subsequent methods will see any changes made to the arguments by previous methods. The return value will be the value returned from the last method in the invocation list.

The applicability of modifiers to a delegate declaration depends on the context in which the delegate is declared. Delegates can be declared as a top-level type, being direct members of an enclosing namespace, or they can be nested within the definition of a class or struct. Table 5-9 summarizes modifier availability.

In the .NET Framework, delegates are most frequently used in conjunction with event members. For a complete description of events, see the Events section later in this chapter.

For the simple numeric types, the implicit conversions described in Table 5-10 are possible.

The integer literal 0 (zero) implicitly converts to any enumeration type. Function members should accommodate the fact that 0 is valid where an enum type is expected.

Implicit reference conversion allows use of a reference type where an instance of a different reference type is expected.

Implicit boxing conversion allows the conversion of any value type to System.Object or any interface that the value type implements. The process of boxing is discussed in the Boxing and Unboxing sections earlier in this chapter.

Explicit numeric conversion allows conversion from any numeric type to another. Depending on the types and values converted, information loss or exceptions can occur. See the section The checked and unchecked Keywords in Chapter 4 for details of how to handle numeric overflow.

Explicit enumeration conversion supports the following conversions:

Explicit reference conversion permits the conversion of one reference type to another. If an explicit reference conversion fails at runtime, the CLR will throw a System.InvalidCastException.

Unboxing conversions allow a previously boxed value type to be unboxed. The process of unboxing is discussed in the Boxing and Unboxing sections earlier in this chapter.