Diffrence between Collection<T> and custom implement class - vb.net

Question

Some people advice to inherit from Collection to get collection class. Some other people advice to have class and implement interfaces from scratch. I would like to understand when to use one over another.
I see that when i use:
class MyCollection
Inherits Collection(Of SomeObject)
I have possibility to add, insert, for each etc that's probably because Collection<T> uses internally List<T>
However if i just do:
class MyCollection : IList(Of SomeObject), IEnumerable<SomeObject>, IEnumerable(Of SomeObject)
myList As List(Of SomeObject)
i can also implement such things like Add(), Remove(), for each
Is it like it's good to use Collection(Of T) because it's already contains all of this implemented interfaces and inner List(Of T) rather that implementing all interfaces myself in self class from scratch? Is it the point people advice to inherit from COllection(Of T)?
EDIT (for further discussion):
Public Class Merge
Property Size As Integer
Property Datee As Date
Property Min As Integer
Property Max As Integer?
Property Value As Double
Public Sub New(min As Integer, max As Integer?, value As Integer)
Me.Min = min
Me.Max = max
Me.Value = value
End Sub
End Class
Public Enum SortCriteria
MinThenMax
MaxThenMin
End Enum
Public Class MergeComparer
Implements IComparer(Of Merge) 'do oddzielnej klasy sortowania obiektu jak tutaj potrzebujemy IComparer a nie IComparable (ten jest bezposrednio na klasie)
Public SortBy As SortCriteria = SortCriteria.MinThenMax
Public Function Compare(x As Merge, y As Merge) As Integer Implements IComparer(Of Merge).Compare
'to be implemented
End Function
End Class
Public Class MergeCollection
Inherits Collection(Of Merge)
Public SortBy As SortCriteria = SortCriteria.MinThenMax
''' <summary>
''' Ovveride because
''' There could be only one item on list which contains Max prop = Nothing
''' </summary>
''' <param name="index"></param>
''' <param name="item"></param>
Protected Overrides Sub InsertItem(index As Integer, item As Merge)
if IsNothing(item.Max)
If Items.Any(Function(myObject) IsNothing(Items.Max)) Then
Return
End If
End If
MyBase.InsertItem(index, item)
End Sub
Public Sub Sort()
Dim allItems = Items.ToArray()
Array.Sort(allItems)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
Public Sub Sort(comparison As Comparison(Of Merge))
Dim allItems = Items.ToArray()
Array.Sort(allItems, comparison)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
Public Sub Sort(comparer As IComparer(Of Merge))
Dim allItems = Items.ToArray()
Array.Sort(allItems, comparer)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
End Class

Answer 1

Here's an example of a custom collection that implements Collection(Of T) and then adds it's own Sort method:
Public Class StringCollection
Inherits Collection(Of String)
Public Sub Sort()
Dim allItems = Items.ToArray()
Array.Sort(allItems)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
End Class
Sample usage:
Dim strings As New StringCollection
strings.Add("Peter")
strings.Add("Paul")
strings.Add("Mary")
strings.Sort()
For Each s In strings
Console.WriteLine(s)
Next
That Sort method relies on the IComparable implementation of the items themselves. If you want to support other sorting methods or your items don't implement IComparable then you can implement different Sort methods, e.g.
Public Class StringCollection
Inherits Collection(Of String)
Public Sub Sort()
Dim allItems = Items.ToArray()
Array.Sort(allItems)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
Public Sub Sort(comparison As Comparison(Of String))
Dim allItems = Items.ToArray()
Array.Sort(allItems, comparison)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
End Class
Sample usage:
Dim strings As New StringCollection
strings.Add("Peter")
strings.Add("Paul")
strings.Add("Mary")
strings.Sort(Function(a, b) a.Length.CompareTo(b.Length))
For Each s In strings
Console.WriteLine(s)
Next
In that case, we're explicitly comparing the String items by their Length rather than their implicit "alphabetic" IComparable implementation.
You can include an overload of Sort for every relevant overload of Array.Sort and/or you can provide your own explicit comparisons if you want. Note that one of those overloads takes an IComparer. Here's how you might make use of that:
Public Class StringCollection
Inherits Collection(Of String)
Public Sub Sort()
Dim allItems = Items.ToArray()
Array.Sort(allItems)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
Public Sub Sort(comparison As Comparison(Of String))
Dim allItems = Items.ToArray()
Array.Sort(allItems, comparison)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
Public Sub Sort(comparer As IComparer(Of String))
Dim allItems = Items.ToArray()
Array.Sort(allItems, comparer)
For i = 0 To allItems.GetUpperBound(0)
Items(i) = allItems(i)
Next
End Sub
End Class
Here's an example comparer:
Public Class StringLengthComparer
Implements IComparer, IComparer(Of String)
Public Function Compare(x As Object, y As Object) As Integer Implements IComparer.Compare
Return Compare(CStr(x), CStr(y))
End Function
Public Function Compare(x As String, y As String) As Integer Implements IComparer(Of String).Compare
Return x.Length.CompareTo(y.Length)
End Function
End Class
Sample usage:
Dim strings As New StringCollection
strings.Add("Peter")
strings.Add("Paul")
strings.Add("Mary")
Dim comparer As New StringLengthComparer
strings.Sort(comparer)
For Each s In strings
Console.WriteLine(s)
Next
We're sorting the items by their Length again but, this time, we're using an object that implements IComparer to make the comparisons rather than a Comparison(Of T) delegate. You should notice, though, that the Compare method of the IComparer in this last example takes pretty much the exact same form as the Lambda used to create the Comparison(Of T) delegate in the previous example.