Tài liệu The Problem with Objects docx

The Problem with Objects
In order to understand Generics, it is worth looking in detail at the problems they are
designed to solve, specifically when using the object type.
You can use the object type as a reference to any type of value or variable. All reference
types automatically inherit (either directly or indirectly) from the System.Object class in
the .NET Framework. You can use this information to create highly generalized classes
and methods. For example, many of the classes in the System.Collections namespace
exploit this fact to allow you to create collections of any type. You will also notice in the
System.Collections.Queue class that you can create queues containing almost anything
(you have already been introduced to the collection classes in Chapter 10, “Using Arrays
and Collections”). The following fragment shows how to create and manipulate a queue
of Circle objects:
using System.Collections;
...
Queue myQueue = new Queue();
Circle myCircle = new Circle();
myQueue.Enqueue(myCircle);
...
myCircle = (Circle)myQueue.Dequeue();
The Enqueue method adds an object to the head of a queue, and the Dequeue method
removes the object at the other end of the queue. These methods are defined like this:
public void Enqueue( object item );
public object Dequeue();
Because the Enqueue and Dequeue methods manipulate objects, you can operate on
queues of Circles, PhoneBooks, Clocks, or any of the other classes you have seen in
earlier exercises in this book. However, it is important to notice that you have to cast the
value returned by the Dequeue method to the appropriate type because the compiler will
not perform the conversion from the object type automatically. If you don't cast the
returned value, you will get the compiler error “Cannot implicitly convert type 'object' to

'Circle'” as shown in the following code fragment:
Circle myCircle = new Circle();
myQueue.Enqueue(myCircle);
...
myCircle = (Circle)myQueue.Dequeue(); // Cast is mandatory
This need to perform an explicit cast denigrates much of the flexibility afforded by the
object type. It is very easy to write code such as this:
Queue myQueue = new Queue();
Circle myCircle = new Circle();
myQueue.Enqueue(myCircle);
...
Clock myClock = (Clock)myQueue.Dequeue();
Although this code will compile, it is not valid and throws a
System.InvalidCastException at runtime. The error is caused by trying to store a
reference to a Circle in a Clock variable, and the two types are not compatible. This error
is not spotted until runtime because the compiler does not have enough information. It
can only determine the real type of the object being dequeued at runtime.
Another disadvantage of using the object approach to create generalized classes and
methods is that it can use additional memory and processor time if the runtime needs to
convert an object into a value type and back again. Consider the following piece of code
that manipulates a queue of ints:
Queue myQueue = new Queue();
int myInt = 99;
myQueue.Enqueue(myInt); // box the int to an object
...
myInt = (int)myQueue.Dequeue(); // unbox the object to an int
The Queue data type expects the items it holds to be reference types. Enqueueing a value
type, such as an int, requires that it is boxed to convert it into a reference type. Similarly,
dequeueing into an int requires that the item is unboxed to convert it back to a value type.
See the sections “Boxing” and “Unboxing” in Chapter 8 for more details. Although

boxing and unboxing happen transparently, they add a performance overhead as they
involve dynamic memory allocations. While this overhead is small for each item, it adds
up when a program creates queues of large numbers of value types.