Well, as a thought, you might want to abstract the implementation from
the public API - especially if your code is being consumed by external
parties. That way, you can change the internals without breaking the
clients - for instance, switching to a dictionary of some kind.

This is also necessary if the base container is sealed (or doesn't
provide many virtuals), and you want to customize the behaviour - i.e.
extra methods (can't do if sealed) or extra checks (can't do if not
virtual). You can also limit the methods available - perhaps Clear()
isn't sensible for your scenario?

Marc

Note that you do not need to inherit from Collection in order to implement
the "foreach" construct.  Just write a method that returns IEnumerable<T>,
as in

public IEnumerable<T> Astar()

{

}

which I implemented in a class called Graph.

This allows you to use the "yield return" construct (in Astar) so that
callers can invoke the "foreach" function on the method, as in

foreach (KSnode ksn in graph.Astar())

{

}

This makes Astar look like a collection to your users, without your needing
to inherit from collection (or even making use of List<T>, etc).

For other examples of using generics in combination with the "foreach"
construct, in order to implement collection-like behavior,  see
http://www.frontiernet.net/~fredm/dps/Contents.htm .

The advantage of generics is that you generally don't need custom
collection classes any more.  In .NET 1.1 people used to create custom
collections so that they could enforce a constraint on the type of the
contents of the collection.  With Generics in .NET 2.0 you no longer
need a custom class for this.

Most of the time you'll just use List<T> or Dictionary<TKey, TValue>
directly instead of creating a custom collection.

The exception is when you need different behavior.  That is a far
rarer situation than simply different contents.  One example of
different behavior from my current application is a custom KeySet<T>
collection.  This is basically a dictionary without a value, just keys
as I've found myself often needing to use a dictionary to store a
unique set of keys and checking existence in the collection without
caring about any actual value.  Implementing this as a custom generic
class made usage of the class cleaner than when using
IDictionary<T,T>.

HTH,

Sam

------------------------------------------------------------
We're hiring!  B-Line Medical is seeking .NET
Developers for exciting positions in medical product
development in MD/DC.  Work with a variety of technologies
in a relaxed team environment.  See ads on Dice.com.