It looks okay to me, although the second code bit should enqueue the
circle.

Which bit do you think is specifically wrong?

On Feb 28, 2:15 pm, "Tony Johansson" <johansson.anders...@telia.com>
wrote:

This looks like a perfect example of what Jon was saying: If you only
put (Circle) objects in the Queue then the cast is a technicallity to
us since we know all the "Objects" are really "Circles".

BUT if you put more than one kind of object (say a Circle and two
Clocks) in the queue then be careful when you dequeue because if you
dequeue a Clock into a Circle type variable you'll get an
InvalidCastException.

Look the text over again and you'll see that the examples that compile
always have a cast, what the author is saying is be careful that you
are casting them correctly because the compiler can't tell what will
eventually end up in the queue.

Tom P.

You should post those examples then, as you didn't post any text that was  
wrong.

In the text, where it says a compile error will occur, it's talking about  
trying to assign an instance of "Object" to an instance of something  
else.  And it's correct...without an explicit cast, a compiler error will  
occur.

Where is says no compile error will occur, it's talking about what happens  
once you _do_ use an explicit cast.  This is an entirely different  
situation, and is completely consistent with the text's previous statement  
that an explicit cast is required to avoid a compile error.  It goes on to  
explain that if in fact the type is not the correct type in the collection  
(as would be the case if you've added a Circle to the collection but then  
tried to cast that to a Clock), you would get an error _but only at  
run-time_.  That's also correct.

A simpler example would be something like this:

    Circle circle = new Circle();
    Object obj = circle;
    Clock clock = (Clock)obj;

The compiler is perfectly happy to compile that.  But at run-time you are  
guaranteed to fail with an invalid cast exception.  This is the error that  
the text is warning you against.

Basically, the text you did post doesn't say what you said it says, and it  
is in fact correct.

The text you posted specifically says that because the Queue.Dequeue()  
method returns an object, you must cast it.  For the Queue class it's  
talking about, it's exactly correct.  Even the discussion regarding the  
risks of doing that is correct.  That is, when using the non-generic Queue  
class, just as with the ArrayList, there's nothing to protect you at  
compile time against putting the wrong type in the collection, or  
incorrectly casting an instance retrieved from the collection.

If you want compile-time protection, you should use the generic classes  
Queue<T> and List<T>.  With those, you specify the type contained in the  
collection when you declare the collection instance, and no casting is  
necessary when retrieving instances from the collection, and trying to  
retrieve something into the wrong type will generate a compiler error.  In  
addition, because adding to the collections is also typed more  
specifically than "Object", the compiler will only let you add things of  
the correct type to the collection.

Pete

No book covering 2005 should be using the untyped collections.  We have
List<T> and Stack<T> for a reason.