The System.Collections Namespace
Use the System.Collections namespace when you need to create a data
structure that can hold a group of similar objects. The System.Collections
namespace contains all the classes and interfaces needed to define
collections of objects. Some of the classes that you might use most often
are listed in Table 4.4.
Table 4.4. System.Collections Classes Class Description
ArrayList An ArrayList is similar to an array, but the ArrayList class
allows you to add items without managing the size of the list yourself
(much like a VB Collection object).
CollectionBase This class is the base for a strongly typed collection,
which is critical for creating collection classes.
DictionaryBase This class is the base for a strongly typed collection
utilizing associated keys and values. This is similar to the Dictionary
object found in VBScript and used by many ASP developers.
SortedList This class represents a collection of keys and values that you
insert into the list. A SortedList object is always automatically sorted by
the key value. You can access the values with either the key value or an
index number.
A common use of the System.Collections namespace is to create strongly
typed collections. Consider the following scenario:
Assume you create a class called Customer. The Customer class has a number
of properties, methods, and events. You now want to create several Customer
objects within one structure so you can iterate through the collection and
print each customer to the printer. You could just create a variable of
type Array, ArrayList, or SortedList, but these standard collections can
hold any type of object. In other words, you could add a Customer object as
the first item in the collection, but you could then add an Employee object
as the second item, a String object as the third, and so on. If you try to
iterate over this collection and apply the Update method, it might work on
the Customer and Employee objects, but when your loop attempts to call the
Update method of a String object, it will certainly fail.
To get around this sticky situation, you can create your own class that
looks like a generic collection object but restricts its members to only
one data type. This new class will include the standard methods of the
collection base type, such as the Add and Remove methods, as well as an
Item property, but your class's Add method will only allow you to add
Customer objects.
In Visual Basic 6.0, you could provide this functionality, and you
generally started by creating an empty class and then creating an Add
method, a Remove method, an Item property, a Count property, and so on.
This is easier in .NET, thanks to the base classes in the
System.Collections namespace.
A System.Collections Example
Assume that you need to create a Customer object to hold values from a
Customer table in your database. The structure of the Customer object is
very simple, containing just a CompanyName property. Imagine that you want
to create a collection class named Customers (note the letter s on the end)
to hold a set of Customer objects. You first need to create the Customer
class as shown in the following code snippet:
Public Class Customer
Public CustomerName As String
End Class
Next, you create your new Customers collection class. Your class must
inherit from the System.Collections.CollectionBase class. (This base class
gives you all the functionality of a normal collection but allows you to
override any of the base methods, such as Add and Item.) Listing 4.3
provides the new class and its overridden Add and Item members:
Listing 4.3 Building Collection Classes Is Easy with the .NET Framework
Class CollectionBase
Public Class Customers
Inherits System.Collections.CollectionBase
Public Sub Add(ByVal cust As Customer)
Me.List.Add(cust)
End Sub
Public ReadOnly Property Item( _
ByVal Index As Integer) As Customer
Get
If Index > Count - 1 Or Index < 0 Then
' Return error message
Else
Return CType( _
Me.List.Item(Index), Customer)
End If
End Get
End Property
End Class
In your collection class, you'll need to override the Add method so that
instead of accepting a generic Object type, your method accepts only a
Customer object. You can then use the internal List property from the base
class to add the Customer object to the internal collection of generic
objects.
You also need to override the Item method so it returns a Customer object
instead of a generic Object data type. Notice the use of the CType
function. This function converts the data in the built-in List property
from a generic Object data type to a Customer data type.
Using inheritance, you certainly end up writing a lot less code to
implement a collection class when compared to the code you had to write in
Visual Basic 6.0. To use the collection class you created in Listing 4.3,
you could write code like that shown in Listing 4.4.
Listing 4.4 Collection Classes Are Very Easy to Use
Private Sub CustCollection()
Dim cust As Customer
Dim colcust As New Customers()
Dim strMsg As String
cust = New Customer()
cust.CustomerName = "Microsoft Corporation"
colcust.Add(cust)
cust = New Customer()
cust.CustomerName = "SAMS Publishing"
colcust.Add(cust)
strMsg = "Count = " & _
colcust.Count.ToString() & "<BR>"
For Each cust In colcust
strMsg &= cust.CustomerName & "<BR>"
Next
lblMsg.Text = strMsg
colcust.RemoveAt(0)
lblMsg.Text = strMsg & _
"After the removal = " & colcust.Count
End Sub
This code creates two new Customer objects, sets the CustomerName property
of each to a unique name, and then adds each one to the Customers
collection class. You can use the Count property from the base class to
determine the number of items in the collection, even though you did not
implement it in your Customers class. You can use the For Each iterator to
loop through each Customer object. You can also utilize the base class's
RemoveAt method to remove a specific item at a specified index in the
collection.