Professional Excel Development [Electronic resources] : The Definitive Guide to Developing Applications Using Microsoft® Excel and VBA® نسخه متنی

Creating a Collection

Now that we have a Cell object, we will want to create many instances of the object so we can analyze a worksheet or ranges of cells within a worksheet. The easiest way to manage these new objects is to store them in a collection. VBA provides a Collection object that we can use to store objects and data. The Collection object has four methods:

Add

Count

Item

Remove

There is no restriction on the type of data that can be stored within a Collection object, and items with different data types can be stored in the same Collection object. In our case, we want to be consistent and store just Cell objects in our collection.

To create a new Collection, the first step is to add a new standard module to contain global variables. This module will be called MGlobals. Next, add the following variable declaration to the MGlobals module to declare a global Collection object variable to hold the collection, as follows:

Public gcolCells As Collection

Now add the CreateCellsCollection procedure shown in Listing 7-4 to the MEntryPoints module. The modified code is contained in the Analysis2.xls workbook in the \Concepts\Ch07Using Class Modules to Create Objects folder on the CD that accompanies this book.

Listing 7-4. Creating a Collection of Cell Objects

Public Sub CreateCellsCollection()
Dim clsCell As CCell
Dim rngCell As Range
' Create new Cells collection
Set gcolCells = New Collection
' Create Cell objects for each cell in Selection
For Each rngCell In Application.Selection
Set clsCell = New CCell
Set clsCell.Cell = rngCell
clsCell.Analyze
'Add the Cell to the collection
gcolCells.Add Item:=clsCell, Key:=rngCell.Address
Next rngCell
' Display the number of Cell objects stored
MsgBox "Number of cells stored: " & CStr(gcolCells.Count)
End Sub

We declare gcolCells as a public object variable so that it persists while the workbook is open and is visible to all procedures in the VBA project. The CreateCellsCollection procedure creates a new instance of the collection and loops through the currently selected cells, creating a new instance of the Cell object for each cell and adding it to the collection. The address of each cell, in $A$1 reference style, is used as a key to uniquely identify it and to provide a way of accessing the Cell object later.

We can loop through the objects in the collection using a For... Each loop or we can access individual Cell objects by their position in the collection or by using the key value. Because the Item method is the default method for the collection, we can use code like the following to access a specific Cell object:

Set rngCell = gcolCells(3)
Set rngCell = gcolCells("$A$3")

Creating a Collection Object

The collection we have established is easy to use but it lacks some features we would like to have. As it stands, there is no control over the type of objects that can be added to the collection. We would also like to add a method to the collection that enables us to highlight cells of the same type and another method to remove the highlights.

We will first add two new methods to the CCell class module. The Highlight method adds color to the Cell object according to the CellType. The UnHighlight method removes the color. Listing 7-5 shows the new code.

Note that we are applying the principle of encapsulation. All the code that relates to the Cell object is contained in the CCell class module, not in any other module. Doing this ensures that the code can be easily found and maintained and means that it can be easily transported from one project to another.

Listing 7-5. New Code for the CCell Class Module

Public Sub Highlight()
Cell.Interior.ColorIndex = Choose(muCellType + 1, 5, 6, 7, 8)
End Sub
Public Sub UnHighlight()
Cell.Interior.ColorIndex = xlNone
End Sub

We can now create a new class module named CCells to contain the Cells collection, as shown in Listing 7-6. The complete code is contained in the Analysis3.xls workbook in the \Concepts\Ch07Using Class Modules to Create Objects folder on the CD that accompanies this book.

Listing 7-6. The CCells ClassModule

Option Explicit
Private mcolCells As Collection
Property Get Count() As Long
Count = mcolCells.Count
End Property
Property Get Item(ByVal vID As Variant) As CCell
Set Item = mcolCells(vID)
End Property
Private Sub Class_Initialize()
Set mcolCells = New Collection
End Sub
Public Sub Add(ByRef rngCell As Range)
Dim clsCell As CCell
Set clsCell = New CCell
Set clsCell.Cell = rngCell
clsCell.Analyze
mcolCells.Add Item:=clsCell, Key:=rngCell.Address
End Sub
Public Function NewEnum() As IUnknown
Set NewEnum = mcolCells.[_NewEnum]
End Function
Public Sub Highlight(ByVal uCellType As anlCellType)
Dim clsCell As CCell
For Each clsCell In mcolCells
If clsCell.CellType = uCellType Then
clsCell.Highlight
End If
Next clsCell
End Sub
Public Sub UnHighlight(ByVal uCellType As anlCellType)
Dim clsCell As CCell
For Each clsCell In mcolCells
If clsCell.CellType = uCellType Then
clsCell.UnHighlight
End If
Next clsCell
End Sub

The mcolCells Collection object variable is declared as a private, module-level variable and is instantiated in the Initialize procedure of the class module. Because the Collection object is now hidden from the outside world, we need to write our own Add method for it. We also have created Item and Count property procedures to emulate the corresponding properties of the collection. The input argument for the Item property is declared as a Variant data type because it can be either a numeric index or the string key that identifies the collection member.

The Highlight method loops through each member of the collection. If the CellType property of the Cell object is the same as the type specified by the uCellType argument, we execute the Cell object's Highlight method. The UnHighlight method loops through the collection and executes the UnHighlight method of all Cell objects whose type is the same as the type specified by the uCellType argument.

We've modified the public Collection variable declaration in MGlobals to refer to our new custom collection class, as shown here:

Public gclsCells As CCells

We've also modified the CreateCellsCollection procedure in the MEntryPoints module to instantiate and populate our custom collection, as shown in Listing 7-7.

Listing 7-7. MEntryPoints Code to Create a Cells Object Collection

Public Sub CreateCellsCollection()
Dim clsCell As CCell
Dim lIndex As Long
Dim lCount As Long
Dim rngCell As Range
Set gclsCells = New CCells
For Each rngCell In Application.ActiveSheet.UsedRange
gclsCells.Add rngCell
Next rngCell
' Count the number of formula cells in the collection.
For lIndex = 1 To gclsCells.Count
If gclsCells.Item(lIndex).CellType = anlCellTypeFormula Then
lCount = lCount + 1
End If
Next lIndex
MsgBox "Number of Formulas = " & CStr(lCount)
End Sub

We declare gclsCells as a public object variable to contain our custom Cells collection object. The CreateCellsCollection procedure instantiates gclsCells and uses a For...Each loop to add all the cells in the active worksheet's used range to the collection. After loading the collection, the procedure counts the number of cells that contain formulas and displays the result.

The MEntryPoints module contains a ShowFormulas procedure that can be executed to highlight and unhighlight the formula cells in the worksheet. Several additional variations are provided for other cell types.

This code illustrates two shortcomings of our custom collection class. You can't process the members of the collection in a For...Each loop. You must use an index and the Item property instead. Also, our collection has no default property, so you can't shortcut the Item property using the standard collection syntax gclsCells(1) to access a member of the collection. You must specify the Item property explicitly in your code. We explain how to solve these problems using Visual Basic or just a text editor in the next section.

Addressing Class Collection Shortcomings

It is possible to make your custom collection class behave like a built-in collection. It requires nothing more than a text editor to make the adjustments, but first we explain how to do it by setting procedure attributes using Visual Basic 6 (VB6) to better illustrate the nature of the changes required.

Using Visual Basic

In VB6, unlike Visual Basic for Applications used in Excel, you can specify a property to be the default property of the class. If you declare the Item property to be the default property, you can omit .Item when referencing a member of the collection and use a shortcut such as gclsCells(1) instead.

If you have VB6 installed you can export the code module CCells to a file and open that file in VB6. Place your cursor anywhere within the Item property procedure and select Tools > Procedure Attributes from the menu to display the Procedure Attributes dialog. Then click the Advanced >> button and under the Advanced options select (Default) from the Procedure ID combo box. This will make the Item property the default property for the class. When you save your changes and import this file back into your Excel VBA project, the attribute will be recognized even though there is no way to set attribute options within the Excel Visual Basic editor.

VB6 also enables you to set up the special procedure in Listing 7-8.

Listing 7-8. Code to Allow the Collection to be Referenced in a For ... Each Loop

Public Function NewEnum() As IUnknown
Set NewEnum = mcolCells.[_NewEnum]
End Function

This procedure must be given an attribute value of 4, which you enter directly into the Procedure ID combo box in the Procedure Attributes dialog. Giving the NewEnum procedure this attribute value enables a For... Each loop to process the members of the collection. After you have made this addition to your class module in VB6 and saved your changes, you can load the module back into your Excel VBA project, and once again the changes will be recognized.

Using a Text Editor

Even without VB6, you can easily create these procedures and their attributes using a text editor such as Notepad. Export the CCells class module to a file and open it using the text editor. Modify your code to look like the example shown in Listing 7-9.

Listing 7-9. Viewing the Code in a Text Editor

Property Get Item(ByVal vID As Variant) As CCell
Attribute Item.VB_UserMemId = 0
Set Item = mcolCells(vID)
End Property
Public Function NewEnum() As IUnknown
Attribute NewEnum.VB_UserMemId = -4
Set NewEnum = mcolCells.[_NewEnum]
End Function

When the modified class module is imported back into your project, the Attribute lines will not be visible, but the procedures will work as expected. You can now refer to a member of the collection as gclsCells(1) and use your custom collection class in a For ... Each loop as shown in Listing 7-10.

Listing 7-10. Referencing the Cells Collection in a For ... Each Loop

For Each clsCell In gclsCells
If clsCell.CellType = anlCellTypeFormula Then
lCount = lCount + 1
End If
Next clsCell