Ben Reichelt’s Weblog

I got the opportunity to refactor some code this past week.  We had an .aspx page that streamed an m3u playlist file that would open in Winamp.  We wanted to modify the page so that it would stream an .asx file for Windows Media Player or a playlist for a Flash based mp3 player, based on the user’s preferences.

Since the page wasn’t currently reading any preferences, the code to
create the m3u file was right in the page’s class file.  If I had
wanted to add two more formats, I could have added the code for those
two right into the page as well, but I wanted to make it more flexible
so that we could add even more formats later on, in an easy fashion.

So I created an abstract Playlist class and then made three
subclasses, M3UPlaylist, ASXPlaylist, and FlashPlaylist.  Now all
the logic for creating the appropriate playlist files was contained in
its respective class.  Next, I created a PlaylistFactory class
that had one static method

• static Playlist CreatePlaylist(PlaylistType type)

So now the code on the page looks something like this:

Playlist list = PlaylistFactory.CreatePlaylist(playlistType);
list.Stream(Request);

Now when we want to add a new playlist type, all we need to do is
create the subclass of Playlist, add the new type to the PlaylistType
enum, and we’re all set, no need to change anything on the page. 
This is whats nice about using a factory pattern like this;  when
you want to add something to the system, you just need to write new
code, not change existing code, which makes for less regression
errors.  Theres nothing really like the satisfaction
of refactoring some code.