Professional ASP.NET 1.1 [Electronic resources] نسخه متنی

Strongly Typed Collections

The fact that most of the collections classes in the .NET Framework class library are designed to work with the

System.Object type makes them very versatile. However, this flexibility can also be viewed as a minor problem, since it means you have to do a lot of casting (assuming you know the type in the first place). For example, assuming a

Hashtable contains a number of items of the type

Product , you have to cast each item you retrieve. Using C#, you would write:

Hashtable products; 
Product p; 
p = (Product) product["ProductCode"]; 

Using VB.NET, you would write:

Dim products As Hashtable 
Dim p As Product 
p = CType(products("ProductCode"), Product) 

Casting types like this isn't difficult, but it can make code less readable, and often leads to silly compiler errors when you forget to cast. Strongly typed collections can resolve these problems. Rather than directly using the collection classes such as

Hashtable in your class, you should instead provide a custom type that encapsulates the collection type being used, and also removes the need for casting.

For example, using C# you would write:

ProductCollection products; 
Product p; 
p = products["ProductCode"]; 

Using VB.NET, you would write:

Dim products As ProductCollection 
Dim p As Product 
p = products("ProductCode") 

Implementing a strongly typed collection like this is relatively simple, and it allows you to build in additional rules and error handling, saving you from duplicating them throughout the code.

To a strongly typed collection, you have to:

Define the custom type of the item held in the collection.

Create the collection class, and implement the

Add ,

Remove , and

GetEnumerator methods, as well as the

Item property.

Let's look at each of these in turn.

Defining the Custom Type

In the strongly typed example, a

Product type was used. When implementing a collection, you should always have a custom type, and a collection for that custom type in which the collection name is simply the custom type name appended with

Collection; for example,

Product and

ProductCollection , or

Address and

AddressCollection .

Here is a class definition for a

Product type, written using VB.NET:

Public Class Product 
 
' private fields 
Private _code As string 
Private _description As string 
Private _price As Double 
 
' constructor 
Public Sub New(initialCode As String, _ 
initialDescription As String, _ 
initialPrice As Double) 
Code = initialCode 
Description = initialDescription 
Price = initialPrice 
End Sub 
 
Public Property Description As String 
Get 
Description = _description 
End Get 
Set 
_description = Value 
End Set 
End Property 
 
Public Property Code As String 
Get 
Code = _code 
End Get 
Set 
_code = Value 
End Set 
End Property 
 
Public Property Price As Double 
Get 
Price = _price 
End Get 
Set 
_price = Value 
End Set 
End Property 
 
End Class 

The

Product type has three public properties:

Code : A unique code assigned to the product.

Description : A description of the product.

Price : The cost of the product.

All of the properties have a get and set accessor, and their implementation simply stores or retrieves the property value in a private field. The field name is the same as the property name, but prefixed with an underscore. The

Product type has a constructor that accepts three parameters, allowing quick initialization. For example:

Dim p As Product 
p = New Product("PROASP3", "Professional ASP 3.0", 39.99) 

For the purposes of this example, let's define the classes within the ASP.NET page. Typically, you would define these in a separate compiled assembly. That topic was introduced in Chapters 3 and 4, and is covered in more detail in Chapter 17.

Creating the Collection Class

The

ProductCollection class will support two key features:

Unordered enumeration of all the contained products.

Direct access of a product using a product code.

Since the

Hashtable class provides the collection functionality necessary for implementing these features, you can use a

Hashtable internally within your collection class for holding items. Then, you can aggregate the functionality of

Hashtable and expose it, to provide access to your items in a type safe way that doesn't require casting.

Since an internal

Hashtable is being used to hold the

Product items, define a private field called

_products of type

Hashtable within the collection class. A new object instance is assigned to this field in the constructor:

Dim _products as Hashtable 
Public Sub New() 
_products = New Hashtable() 
End Sub 

Implementing the Add Method

The

Add method allows a new

Product to be added to the collection:

Public Sub Add( Item as Product ) 
If Item Is Nothing Then 
Throw New ArgumentException("Product cannot be null") 
End If 
_products.Add(Item.Code, Item) 
End Sub 

This method throws an

ArgumentException if a

null item parameter is passed. If the parameter is not

null , the

Code property of the passed

Product is used as the key for the

Product in the contained

Hashtable . Depending on your requirements, you could perform additional business logic validation here and throw additional exceptions.

Implementing the Remove Method

The

Remove method removes a

Product from the collection. The implementation of the method simply calls the

Remove method of the

Hashtable :

Public Sub Remove(Item as Product) 
_products.Remove(Item.Code) 
End Sub 

Implementing the Item Property

The

Item property allows a

Product to be retrieved from, or added to the collection by specifying the product code:

Public Default Property Item(Code as String) as Product 
Get 
Item = CType(_products(Code), Product) 
End Get 
Set 
Add(Value) 
End Set 
End Property 

The implementation of the

Set accessor calls the

Add method in order to add the new product to the internal

Hashtable . The process is implemented in a way so that any business logic in the

Add method (such as the Null check) is neither duplicated nor missed.

Implementing the GetEnumerator Method

To use your collection class with the

for..each statements in VB.NET and C#, your collection class must have a method called

GetEnumerator . Although not strictly necessary, the

IEnumerable interface is also implemented using the VB.NET

Implements keyword. This is good practice and requires very little work:

Public Class ProductCollection 
Implements IEnumerable 
' ... 
' implement an enumerator for the products 
Public Function GetEnumerator() As IEnumerator 
Implements IEnumerable.GetEnumerator 
GetEnumerator = _products.Values.GetEnumerator() 
End Function 
' ... 
End Class 

The

GetEnumerator method has to return an enumerator object that implements the

IEnumerator interface. You could implement this interface by creating another class, but since your collection class is using a

Hashtable internally, it makes much more sense to reuse the enumerator object provided by that class when its values are enumerated. The

Hashtable.Values property returns an

ICollection interface and since the

ICollection interface derives from

IEnumerable , you can call

GetEnumerator to create an enumerator object for the collection of values.

Using the Collection Class

With the

Product and

ProductCollection classes created, you can use them just like the other collections in this chapter, but this time with no casting. For example:

' Page-level variable 
Dim _products as ProductCollection = New ProductCollection 
 
Sub Page_Load(sender as Object, events As EventArgs) 
' Runs when page is loaded 
 
Dim products As New ProductCollection() 
Dim p As product 
 
p = New Product("CAR", "A New Car", 19999.99) 
products.Add(p) 
 
p = New Product("HOUSE", "A New House", 299999.99) 
products.Add(p) 
 
p = New Product("BOOK", "A New Book", 49.99) 
products(p.Code) = p 
 
For Each p In products 
outResult1.InnerHtml &= p.Code & " - " & p.Description _ 
& " - $" & p.Price & "<br />" 
Next 
 
products.Remove( products("HOUSE") ) 
For Each p In products 
outResult2.InnerHtml &= p.Code & " - " & p.Description _ 
& " - $" & p.Price & "<br />" 
Next 
 
outResult3.InnerHtml = "Description for code CAR is: " _ 
& products("CAR").Description 
 
End Sub 

The complete code for this example is contained in the samples available for download, in both VB.NET and C#. The result of running this page is shown in Figure 15-16:

Figure 15-16:

The DictionaryBase and CollectionBase Classes

The

DictionaryBase and

CollectionBase classes allow you to create a

Hashtable or

ArrayList collection that can validate, and therefore restrict, the types it contains. It's a simple process to create your own collection class by deriving from these classes.

This simple ASP.NET page defines a

MyStringCollection collection class, adds three strings and one integer, and then displays the contents:

'our custom collection 
Class MyStringCollection 
Inherits CollectionBase 
... implementation goes here... 
End Class 
 
Dim names As IList 
 
names = New MyStringCollection 
 
names.Add("Richard") 
names.Add("Alex") 
names.Add("Dave") 
 
Try 
names.Add(2002) 
Catch e As Exception 
outResult1.InnerHtml = "Error: " & e.Message 
End Try 
 
For Each name As String in names 
outResult2.InnerHtml &= name & "<br />" 
Next 

The

Collection base class implements the

IList and

ICollection interfaces. All the members of these interfaces are defined explicitly, which is why in the sample code the

names variables have been defined as type

IList .

Each of the collection base classes provides a number of virtual functions that are called when the collection is modified. For example,

OnClear is called when a collection is cleared;

OnInsert is called when an item is added;

OnRemove when an item is deleted, and so on. By overriding one of these methods, you can perform additional checks and throw an exception if an undesired condition arises. For example, in the collection class, you could implement an

OnInsert method that throws an

ArgumentException if anything other than a string is added:

Class MyStringCollection
Inherits CollectionBase
Overrides Protected Sub OnInsert(index as Integer, item as Object) 
If Not(TypeOf item Is String) Then 
Throw New ArgumentException("My collection only supports strings") 
End If 
End Sub 
End Class

Figure 15-17 shows the results of running this code:

Figure 15-17:

The

DictionaryBase class is used in the same way as the

CollectionBase class and implements the

IDictionary and

ICollection interfaces.

The ReadOnlyCollectionBase Class

The

ReadOnlyCollectionBase class provides functionality for exposing a read-only collection. The class implements the

ICollection and

IEnumerable interface. The items exposed are internally held in a protected

ArrayList variable called

InnerList . To use this class, you have to derive your own class from it, and populate the contents of the

InnerList array.

Disposable Enumerators

When you enumerate a collection, the enumerator objects that implement the

IEnumerator interface may require expensive resources. For example, depending on how underlying items are stored, a custom enumerator could be using a database connection, or be holding temporary files on disk. In these scenarios, it is important that the enumerable object releases resources it holds as soon as possible.

Due to the non-deterministic way the CLR releases object references, any code you write that directly uses an

IEnumerator interface must always check if the enumerator objects that provided the interface support the

IDisposable interface. You must then call the

Dispose method when you've finished with the enumerator. If you do not do this, the resources held by the enumerator may not be released for some time. When you use the

for..each language statement in C# and VB.NET, this is done automatically .

When you use the

IEnumerator interface directly (or any other enumerable type), if you do not know whether an enumerator object supports the

IDisposable interface, always check once you have finished with it. For example, in C#, you might write:

IEnumerator e = c.GetEnumerator(); 
try 
{ 
while (e.MoveNext()) 
{ 
Foo x = e.Current; 
// ... 
} 
} 
finally 
{ 
IDisposable d = e as IDisposable; 
if (d != null) d.Dispose(); 
} 

If you know that an enumerator object supports

IDisposable , you can call it directly:

IEnumerator e = c.GetEnumerator(); 
try 
{ 
while (e.MoveNext()) 
{ 
Foo x = e.Current; 
// ... 
} 
} 
finally 
{ 
((IDisposable)e).Dispose(); 
}