Now the project should compile with no errors in Visual Studio .NET. If you are not using Visual Studio, multiple files can be included in the library by simply providing the list of files to the compiler. An example of how this might look is shown here.

>csc /target:library /out:MyPhotoAlbum.dll PhotoAlbum.cs Photograph.cs /r:System.dll /r:System.Drawing.dll

Before we deal with the possible exception that can occur in the Photograph.Image property, let’s return to our PhotoAlbum class to make some initial use of the Photograph class.

5.3INTERFACES REVISITED

Back in our PhotoAlbum class, we are ready to implement the interfaces required. As you’ll recall, an interface defines the set of required members, but does not provide any implementation. Supporting an interface requires that we define the class as supporting the interface, and include the required members for that interface within the class.

For the PhotoAlbum class, the CollectionBase class defines itself as supporting the IEnumerable, ICollection, and IList interfaces. An implementation for the single method GetEnumerator required by the IEnumerable interface is provided by CollectionBase. As a result, we are left to implement the ICollection and IList interfaces. A list of ICollection members is provided in the following table:

PhotoAlbum members required for the ICollection interface

The IList interface has a slightly longer list of members. Some of them are already provided by the CollectionBase class, but the bulk of them will be implemented using the protected CollectionBase.List property.

PhotoAlbum members required for the IList interface

PhotoAlbum members required for the IList interface (continued)

We will examine the implementation of these interfaces separately.

5.3.1SUPPORTING THE ICOLLECTION INTERFACE

The implementation of the ICollection members will use the protected List property from our base class, so let’s get to it. We will make these and our IList members virtual to allow any subclass to override them as needed.

Set the version number for the application to 5.3.

SUPPORT THE ICOLLECTION INTERFACE

5.3.2SUPPORTING THE ILIST INTERFACE

Our implementation for IList will be very similar in spirit to our implementation for ICollection. A key difference between the signatures of the IList members and

our implementation is that we will use the Photograph class explicitly rather than the more generic object. Since a Photograph is still an object instance, a construct that requires an IList instance will still be able to use our PhotoAlbum object.

This may seem a bit boring and tedious, but it needs to be done for a complete implementation. Note that C# does not support C++ style templates at this time, which would have been handy for implementing this and other interfaces.

SUPPORT THE ILIST INTERFACE

These methods simply use the equivalent version in the protected List property, except that our implementation will only accept Photograph objects. The Item property is worth noting since it defines zero-based array-style indexing for our class, such as myAlbum[1] to specify the second Photograph in an album. The syntax

defines an indexer for the class. Indexers define array-style access to a class, using a syntax employing access methods similar to the declaration of properties. An indexer is defined using the this keyword to refer to the class itself, with the index variable defining the index value within the definition. In this manner the indexer defines retrieval and assignment access to the array of Photograph objects in the collection. Any collection class can be treated as an indexed array through the use of a similar indexer definition.

public virtual Photograph this[int index]

{

get { return (Photograph)(List[index]); } set ( List[index] = value; }

}

5.3.3IMPLEMENTING ALBUM POSITION OPERATIONS

This is a good place to insert the position operations for tracking the current location within an album. This position will be used by our application to display the current photo from the album as well as other tasks.

From a design perspective, we will use the word “Current” as a prefix for these operations. This is the name of a property used by the IEnumerator interface, and

is consistent with the meaning we intend here. We will add the following members to our class:2

PhotoAlbum position members

2Some might argue for using the GetEnumerator method to track the position, or for creating a mechanism similar to database cursors to allow an application to track multiple locations within the album at the same time. The former is problematic if the application inserts or removes photos while the enumerator is active. The latter is a good idea, but a bit beyond what we intend to cover in this chapter.