Classy Generics: Writing Your Own in C#

Draw Code 39 Extended in C# Classy Generics: Writing Your Own

// Wait for user to acknowledge the results ConsoleWriteLine( Press Enter to terminate ); ConsoleRead(); }

Here s what happens in Main():

1 Instantiate a PriorityQueue object for type Package 2 Create a PackageFactory object whose job is to create new packages

with randomly selected priorities, on demand A factory is a class or method that creates objects for you You tour PackageFactory in the section Using a (nongeneric) Simple Factory class, later in this chapter

4 Add each package to the PriorityQueue by using pqEnqueue(pack) 5 Write the number of packages created and then randomly remove some

of them from the PriorityQueue by using pqDequeue()

Now you have to figure out how to go about writing a generic class, with all those <T>s Looks confusing, doesn t it Well, it s not so hard, as this section demonstrates The simple way to write a generic class is to write a nongeneric version first and then substitute the <T>s For example, you would write the PriorityQueue class for Package objects, test it, and then genericize it Here s a small piece of a nongeneric PriorityQueue, to illustrate:

public class PriorityQueue { //Queues -- The three underlying queues: all generic! private Queue<Package> _queueHigh = new Queue<Package>(); private Queue<Package> _queueMedium = new Queue<Package>(); private Queue<Package> _queueLow = new Queue<Package>(); //Enqueue -- Prioritize a Package and add it to correct queue public void Enqueue(Package item) { switch(itemPriority) // Package has this property { case PriorityHigh: queueHighEnqueue(item); break;

case PriorityLow: queueLowEnqueue(item); break; case PriorityMedium: queueMediumEnqueue(item); break; } } // And so on

Testing the logic of the class is easier when you write the class nongenerically first When all the logic is straight, you can use find-and-replace to replace the name Package with T (I explain a little later that there s a bit more to it than that, but not much)

Why would a priority queue be last Seems a little backward to us But you ve seen the rest Now it s time to examine the PriorityQueue class itself This section shows the code and then walks you through it and shows you how to deal with a couple of small issues Take it a piece at a time

PriorityQueue is a wrapper class that hides three ordinary Queue<T> objects, one for each priority level Here s the first part of PriorityQueue, showing the three underlying queues (now generic):

//PriorityQueue -- A generic priority queue class // Types to be added to the queue *must* implement IPrioritizable interface class PriorityQueue<T> where T : IPrioritizable { // Queues -- the three underlying queues: all generic! private Queue<T> _queueHigh = new Queue<T>(); private Queue<T> _queueMedium = new Queue<T>(); private Queue<T> _queueLow = new Queue<T>(); // The rest will follow shortly

These lines declare three private data members of type Queue<T> and initialize them by creating the Queue<T> objects I say more later in this chapter about that odd-looking class declaration line above the subqueue declarations

Enqueue() adds an item of type T to the PriorityQueue This method s job is to look at the item s priority and put it into the correct underlying queue In the first line, it gets the item s Priority property and switches based on that value To add the item to the high-priority queue, for example, Enqueue() turns around and enqueues the item in the underlying queue High Here s PriorityQueue s Enqueue() method:

//Enqueue -- Prioritize T and add it to correct queue; an item of type T // The item must know its own priority public void Enqueue(T item) { switch (itemPriority) // Require IPrioritizable to ensure this property { case PriorityHigh: _queueHighEnqueue(item); break; case PriorityMedium: _queueMediumEnqueue(item); break; case PriorityLow: _queueLowEnqueue(item); break; default: throw new ArgumentOutOfRangeException( itemPriorityToString(), bad priority in PriorityQueueEnqueue ); } }