modern software development using c#.net chapter 5: more advanced class construction

Modern Software Development Using C# .NET

Chapter 5: More Advanced Class Construction

Modern Software Development Using C# .NET by Richard Wiener 2

Overview

• Some common pitfalls associated with class construction are examined and solutions found to the problems.

• We look at constructor pitfalls, redefining the Equals method from class Object, cloning objects, using StringBuilder instead of String objects, the important and new feature of generic classes and the new and important feature of enumerators that enable the use of the foreach iteration for the instances of a class.


Avoiding protected fields

• Fields earmarked as protected in a base class are directly accessible in all descendent classes.

• Assignment to a base-class field made in a remote descendent class, many levels down in a class hierarchy, may not be easy to decipher and understand unless the programmer making this field assignment has intimate knowledge of the base class that contains the field whose value is being modified.


Avoiding protected fields continued

• Another consequence of making direct assignments to base-class fields in a descendent class is that if in the future the information structure of the base class is changed and the base-class field is removed, the descendent classes that have made direct assignments to this base-class field will be broken.


Constructor pitfall

• Never invoke a method within a base-class constructor that can be redefined in some descendent class.


Overriding method Equals from class Object

• When designing classes for potential reuse in many applications, it is important to consider whether it is appropriate to redefine the Equals method inherited by default from class Object.

• The default Equals method from Object considers two objects to be equal in value if and only if they have the same memory reference.

• Often this default meaning of Equals is incorrect.


Cloning objects

• Cloning an object involves producing a new instance of a class, the target, and copying the features of the source instance to the target instance.

• An important issue is whether the target instance continues to have any dependence on the source object. In principle, it should not. In practice, it often does which can be a major problem.


Cloning objects continued

• There are two types of copying: shallow and deep copying.

• Shallow copying copies references but not the content of the references.

• As a result the target reference becomes another name for the source reference.

• Any change made to the source or target after the copy affects the other.

• With deep copying, an independent autonomous target is created with the content of the source copied to the target and with no residual dependency between the source and the target.



• When one reference-type object, say object1 is assigned to another reference-type object, say object2, as in,

object2 = object1;

a shallow copy results. Any subsequent change to object1 appears to affect object2 since they are both names for the same storage.



• Any C# class that defines a Clone method must implement the interface IClonable. This interface is given as follows:

public interface IClonable {

Object Clone();

}


Using StringBuilder instead of String • A common and potentially expensive pitfall is using

objects of type String instead of StringBuilder when repeatedly concatenating string objects.

• Objects of type String are immutable. That means that once a String object is constructed its contents cannot be changed. String objects are of value type.

• Standard class StringBuilder presents a mutable reference type that may be used as an alternative to String when appropriate.


Generics

• A generic container class contains a set of operations that are independent of the type of objects being held in the container.

• With the advent of object-oriented languages and an omnipresent class Object that all classes are descendents of, the temptation to achieve generic behavior through polymorphism has been present.

• In a landmark paper “Genericity versus Inheritance” published in the ACM SIGPLAN Notices, Vol 21, No 11 in 1986, Bertrand Meyer presents a clear case that using polymorphism through inheritance to achieve generic behavior is the wrong way to achieve generic behavior.


Generics continued

• A class is generic if it contains one or more generic parameters. When an instance of such a class is created, the specific type for each generic parameter must be specified.

• Consider the signature of the following generic class:

public class MyGenericClass<T> {// Details not shown

}

An instance of this class may be created as follows:

MyGenericClass<String> myObject = new MyGenericClass<String>();

Here the generic parameter T is replaced by String.


Constrained generic parameters

• The parameters specified in a generic class may be constrained.

• A generic parameter may be constrained by specifying that it must implement a particular interface or extend a particular class.


Constrained generic parameters continued

• Consider the following class declaration:

public class MyGenericClass<T> : IComparable where T :

IComparable {// Details not shown

}

This declaration implies that MyGenericClass contains a generic parameter T that must implement the IComparable interface. In addition, the class itself must implement this interface (define a method CompareTo).


Generic methods

• Methods may be defined that contain one or more generic parameters even though the class that they are defined within contains no generic parameters.

• Consider the static method SelectionSort that contains the constrained generic parameter T. Its signature is the following:

public static void SelectionSort<T>(T [] data, int size) where T : IComparable

{// Details not shown

}


Generic methods continued

• The constraint on the generic parameter T is that it must be an instance of a class that implements the IComparable interface.

• This makes sense because to sort an array of values, the values must be comparable otherwise there would be no way to determine the smallest, next smallest, etc.


Summary of the benefits of generic classes

• Generic container classes move type checking from the runtime system to the compiler, thus making code safer.

• They also provide for a mechanism for self-documentation since when a generic container instance is created, the type of objects that are intended to be placed inside the container is specified in the code itself.

• Finally, generic classes remove the need for cluttering one’s code with downcasts. This makes the code easier to read and maintain.


Enumerators

• Iteration through a container class allows each object in the container to be visited exactly once.

• Any class that is to support an enumerator must implement the IEnumerable interface.

• Such a class must meet the contract of implementing the GetEnumerator method that returns an instance of IEnumerator.


Enumerators continued

• A class that implements IEnumerator must meet the contract of implementing:• The read-only property Current that returns the

element in the collection that the cursor is currently pointing to.

• The method MoveNext that returns a value true if the enumerator has successfully advanced to the next element in the collection and false if there is no next element in the collection.

• The method Reset that restores the cursor so that it points to the first element in the collection.



• The foreach construct provides a simple

mechanism for iterating through a collection object that is an instance of a class that implements IEnumerable.



• We illustrate the use of the foreach construct on the standard ArrayList collection class in the following segment of code.

• An ArrayList containing four objects of type String is created. Using the foreach iteration construct, the names are output.



using System;using System.Collections;namespace Iteration { public class IterationApplication { static void Main() { ArrayList myList = new ArrayList(); myList.Add("Erik"); myList.Add("Anna"); myList.Add("Marc"); myList.Add("Daniel"); foreach (String name in myList) { Console.WriteLine(name); } Console.ReadLine(); } }}



• An alternative way to iterate through the ArrayList would be:

IEnumerator iterator = myList.GetEnumerator();bool result = iterator.MoveNext();while (result && iterator.Current != null) {

String name = (String)iterator.Current;Console.WriteLine(name);result = iterator.MoveNext();

}

The foreach construct clearly provides a simpler mechanism for accomplishing the iteration through the ArrayList container.


Partial classes

• C# allows a class definition to be distributed over several source files.

• Integrated development environments such as Visual Studio take advantage of this capability by embedding initialization code in a separate file from the code the user develops even though both are part of the same class.


Partial classes continued

• The keyword partial is used to achieve this. So, for example, MyClass might be written in several parts by using,

public partial class MyClass {

// Details not shown

}


Summary

• Fields earmarked as protected in a base class are directly accessible in all descendent classes.

• As a consequence, an assignment to a base-class field made in a remote descendent class, many levels down in a class hierarchy, may not be easy to decipher and understand unless the programmer making this field assignment has intimate knowledge of the base class that contains the field whose value is being modified.


Summary continued

• Never invoke a method within a base-class constructor that can be redefined in some descendent class.

• When designing classes for potential reuse, it is important to consider whether it is appropriate to redefine the Equals method inherited by default from class Object.

• The default Equals method from Object considers two objects to be equal in value if and only if they have the same memory reference.

• Often this default meaning of Equals is incorrect.


Summary continued

There are two types of copying: shallow and deep copying.

The former copies references but not the content of the references.

As a result, the target reference becomes another name for the source reference. Any change made to the source or target after the copy affects the other.

With deep copying, an independent autonomous target is created with the content of the source copied to the target and with no residual dependency between the source and the target.


Summary continued

• Never implement a Clone method by invoking the constructor of the containing class.

• A common and potentially expensive pitfall is using objects of type String instead of StringBuilder when repeatedly concatenating string objects.

• Objects of type String are immutable. That means that once a String object is constructed, its contents cannot be changed.

• String objects are of value type. • Standard class StringBuilder presents a mutable reference type

that may be used as an alternative to String when appropriate.


Summary continued

In a landmark paper “Genericity versus Inheritance” published in the ACM SIGPLAN Notices, Vol 21, No 11 in 1986, Bertrand Meyer presents a clear case that using polymorphism through inheritance to achieve generic behavior is the wrong way to achieve generic behavior.


Summary continued

The use of generic container classes provides for more readable code.

When a generic instance is created, the programmer’s intentions are documented in the code itself.

Any attempt on the part of the programmer to insert an object whose type differs from the type specified when the instance of the generic container is created produces a compile-time error.

This is better than a runtime error that would occur when using the older approach to constructing generic containers.

Discovering errors at compile time is always superior to discovering errors at runtime.


Summary continued

• The parameters specified in a generic class may be constrained. A generic parameter may be constrained by specifying that it must implement a particular interface or extend a particular class.

• Methods may be defined that contain one or more generic parameters even though the class that they are defined within contains no generic parameters.


Summary continued

• Generic container classes move type-checking from the runtime system to the compiler thus making code safer.

• Generic classes provide for a mechanism for self-documentation since when a generic container instance is created, the type of objects that are intended to be placed inside the container is specified in the code itself.

• Generic classes remove the need for cluttering one’s code with downcasts. This makes the code easier to read and maintain.


Summary continued

• Iteration through a container class allows each object in the container to be visited exactly once.

• Any class that is to support an enumerator must implement the IEnumerable interface.

• Such a class must meet the contract of implementing the GetEnumerator method that returns an instance of IEnumerator.


Summary continued

• A class that implements IEnumerator must meet the contract of implementing: • The read-only property Current that returns the element in

the collection to which the cursor is currently pointing. • The method MoveNext that returns a value true if the

enumerator has successfully advanced to the next element in the collection and false if there is no next element in the collection.

• The method Reset that restores the cursor so that it points to the first element in the collection.

modern software development using c#.net chapter 5: more advanced class construction

Documents

base class

class object

baseclass fields

class hierarchy

baseclass constructor

c net

remote descendent class

source object