List<T> and Collection in c#

Basically, the Collection class provides us with a customizable wrapper for a generic indexable collection such as List. 

It allows us to implement customized behavior when items are added to, inserted in or removed from the collection. You can also control what happens when items are replaced by other items or the entire collection is cleared.

Although you could do this by writing your own class or deriving directly from List, it saves a lot of work if you derive from Collection instead.

This is because Collection provides the following protected virtual methods over and above what List provides:

InsertItem

RemoveItem

ClearItems

SetItem

When the Add, Insert, Remove, RemoveAt, Clear methods or the Indexer setter are invoked, these methods are called internally to do the actual work.

However, as they are virtual, you can override them to provide your own customized behavior. You'd normally call the base class method before or after adding your own code, depending on the circumstances.

There's a good example of using Collection in its MSDN documentation (example 2):

Here a collection of dinosaurs is being created. However, it is desired to add an event which fires whenever there's a change to the collection so a simple List will not suffice. You therefore need to create a Dinsoaurs class which derives from Collection so you can override each of the above methods to fire an event when a change occurs.

Unless you override these methods, Collection will behave much the same as List as example 1 in the above MSDN link shows.

So, if you don't want to customize its behavior, then it's better to use List directly rather than Collection as the former should be slightly faster and smaller without the wrapper code including the hooks to the protected methods.