This print for content only-size & color not accurate 7" X 9-1/4" / casebound / malloy

// Two references to same object!

Point p1 = new Point(50, 50);

Point p2 = p1;

p2.x = 0;

Console.WriteLine(p1);

Console.WriteLine(p2);

Console.ReadLine();

}

When you wish to equip your custom types to support the ability to return an identical copy of

itself to the caller, you may implement the standard ICloneable interface. As shown at the start of

this chapter, this type defines a single method named Clone():

C H A P T E R   9  

■

W O R K I N G   W I T H   I N T E R FA C E S

295

8849CH09.qxd  10/1/07  10:41 AM  Page 295

---

public interface ICloneable

{

object Clone();

}

■

Note

The usefulness of the 

ICloneable

interface is currently under debate within the .NET community. The

problem has to do with the fact that the official specification does not explicitly say that objects implementing this

interface must return a deep copy of the object (i.e., internal reference types of an object result in brand-new

objects with identical state). Thus, it is technically possible that objects implementing 

ICloneable

actually return

a shallow copy of the interface (i.e., internal references point to the same object on the heap), which clearly gener-

ates a good deal of confusion. In our example, I am assuming we are implementing 

Clone()

to return a full, deep

copy of the object.

Obviously, the implementation of the Clone() method varies between objects. However, the

basic functionality tends to be the same: copy the values of your member variables into a new

object instance of the same type, and return it to the user. To illustrate, ponder the following update

to the Point class: