C# 4 and .NET 4

82 ❘ ChaPTer 3 Objects And types
structs and inheritance
Structs are not designed for inheritance. This means that it is not possible to inherit from a struct. The
only exception to this is that structs, in common with every other type in C#, derive ultimately from the
class System.Object. Hence, structs also have access to the methods of System.Object, and it is even
possible to override them in structs — an obvious example would be overriding the ToString() method.
The actual inheritance chain for structs is that each struct derives from a class, System.ValueType, which
in turn derives from System.Object. ValueType does not add any new members to Object, but provides
implementations of some of them that are more suitable for structs. Note that you cannot supply a different
base class for a struct: every struct is derived from ValueType.
Constructors for structs
You can define constructors for structs in exactly the same way that you can for classes, except that you are
not permitted to define a constructor that takes no parameters. This may seem nonsensical, and the reason
is buried in the implementation of the .NET runtime. Some rare circumstances exist in which the .NET
runtime would not be able to call a custom zero-parameter constructor that you have supplied. Microsoft
has therefore taken the easy way out and banned zero-parameter constructors for structs in C#.
That said, the default constructor, which initializes all fields to zero values, is always present implicitly,
even if you supply other constructors that take parameters. It’s also impossible to circumvent the default
constructor by supplying initial values for fields. The following code will cause a compile-time error:
struct Dimensions
{
public double Length = 1;
public double Width = 2;
}
// error. Initial values not allowed
// error. Initial values not allowed
Of course, if Dimensions had been declared as a class, this code would have compiled without any
problems.
Incidentally, you can supply a Close() or Dispose() method for a struct in the same way you do for
a class.
ParTial Classes
The partial keyword allows the class, struct, method or interface to span across multiple files. Typically, a
class will reside entirely in a single file. However, in situations where multiple developers need access to the
same class, or more likely in the situation where a code generator of some type is generating part of a class,
then having the class in multiple files can be beneficial.
The way that the partial keyword is used is to simply place partial before class, struct, or
interface. In the following example, the class TheBigClass resides in two separate source files,
BigClassPart1.cs and BigClassPart2.cs:
//BigClassPart1.cs
partial class TheBigClass
{
public void MethodOne()
{
}
}
//BigClassPart2.cs
partial class TheBigClass
www.it-ebooks.info