Patterns Everyone Knows: Unhelpful Terminology

The patterns book is 15 years old, that’s about 150 in developer years.  All told, it’s amazing that more of the patterns aren’t out of date.  Here are some that I think could be safely retired.  Again, they’re not necessarily bad ideas, it’s just that they’re special cases of more general principles, and I favour understanding the principles.


I’ll be honest, I’m not sure I get the point of the Bridge pattern.  A bridge is exemplified by the following example from finance:

  • You have an interface for a traded instrument.  Call it IInstrument.
  • Shares are one of the simplest kinds of instrument.  We extend the interface to IEquity.
  • We provide a base implementation of Instruments that developers can inherit from.  We call this InstrumentBase.
  • We implement shares using the concrete class Equity which inherits from InstrumentBase.

In this case, we could modify the IInstrument interface.  This would affect the InstrumentBase classes, but not the Equity class.  Equally, we could modify the implementation of Instrument without modifying the external interfaces.

Now, I have a problem with all of this.  Basically, as far as I can tell, the Bridge pattern is what I call object-orientated development.  There’s two components of the pattern:

  • The use of interfaces to shield implementations from the consumers.  This is the Open/Closed principle.
  • The use of inheritance to specialize.  This is also known as coding in C#.

In short, Bridge doesn’t say anything other than “built according to good design principles”.

Template and Strategy

Template patterns are the same as Bridge patterns, only the emphasis is different.  Rather than specializing an entity, you’re specializing an algorithm.  Now, the interesting thing here is: there’s two ways to create a general algorithm with specialization.

  • Inheritance (which the Template pattern requires)
  • Composition (in which case you call it a Strategy pattern)

Typically, I’d favour the latter, as would Gamma et al. 

Usually, in C#, you can generalize an algorithm just by passing in a function.  For instance, consider the following code:

gofPatterns.FirstOrDefault(pattern => pattern.Name == “Template”)

FirstOrDefault is a parameterized algorithm.  The expression ”  pattern => pattern.Name == “Template”  ” specializes it.  Implementing the same algorithm through inheritance would just be plain painful.  In short, Bridge and Template are both names for specific cases of more general problems, and the specialization isn’t useful.  So, I wouldn’t really recommend using the terminology.  That’s not to say that you won’t use the pattern, just that you’ll probably not help anyone by telling them you used a template pattern when you did so.

In practice, I have been known to use the term “Strategy Pattern”, but usually I just mean “I outsourced some decision making”.  In general I think you’re better off just understanding that there are multiple ways of parameterizing an algorithm.


Basically, a flyweight object is a representation of an entity which strips out most of the information and just keeps the truly vital information.  This is done for memory conservation.  I’m including this under “obvious” because it will have occurred to anyone who has run into the problem it solves (and because I can’t think of a better place to put it).  You could also describe this as a “reference” pattern, since often the flyweight objects contain just enough information to find the true entity in a database if needed.

An interesting case is lazy loading in NHibernate.  NHibernate generates proxy objects which are themselves initially flyweight, but become heavyweight on their first access.

Again, I don’t think this is particularly useful terminology.  In the time since Design Patterns was written, the whole idea of a “true” object representation has declined in importance.  Finely-grained interfaces customized by consumer, pervasive proxying, presentation models are all part of a general principle that objects matter at point of use.  The world has moved on.


Bridge, Template and Strategy are also obvious patterns, but unlike Facade, Builder and Adapter, aren’t really useful for communication. 

  • In the case of Bridge, typically just saying that you’ve a) hidden something behind an interface or b) used inheritance to specialize is more clear. 
  • In the case of Template or Strategy, it’s better to refer to what you’re doing as a parameterized algorithm, irrespective of the form that parameterization takes.
  • “Strategy Pattern” is nonetheless a popular term, and I’m not advocating getting into a terminology war with something who wants to call what they’re doing a strategy pattern.  But you might wish to introduce them to Erlang sometime…

The Flyweight pattern is part of a general principle that objects can have more than one representation.  I wouldn’t personally use the term.

Object Creation: Factory and Abstract Factory

Okay, we’re onto the first of what I described as the “stone cold brilliant patterns”.  This particular one looks obvious, but its benefits are actually quite subtle.  There are basically only two ways of creating an object in .NET:

  • Call new
  • Call a function that calls new

The factory pattern is basically just using the latter.  Now, this might strike you as an unnecessary level of indirection, and you might be right.  You’d be right if:

  • The class is a pure data transfer object.
  • The class doesn’t have a complex data structure.
  • The class has no functional logic.

I’d rather not talk about testing too much, but what this comes down to is “The object could be easily created in a test.”  Now, if you’re not that into testing (because, I don’t know, maybe you like bugs…) you might be wondering why I’m going on about testing.  Well, testing is re-use.  These objects are what I term “Leaf Objects”.  They’re the basic values in our system.  Everything else, you need a factory.

The whole point of the pattern is to avoid the basic drawback of new: that it isn’t polymorphic.  You can’t call new Employee() and receive a MicrosoftEmployee object.  And even if you don’t want that to happen, one day you probably will wish you could.

Incidentally, don’t create a static factory method.  If you do, you’ve missed the whole point.  The same goes for putting significant logic into your factory.  Logic mixed with object creation is inflexible.  In C++, you can overload the behaviour of the new operator.  This, sadly, isn’t as useful as it first appears, since again it’s a static operation and cannot be varied according to runtime context.  There’s no way to achieve the design benefits of the factory pattern.

The Difference between Factory and Abstract Factory

To be honest, I don’t really think the distinction between factory and abstract factory is useful:

  • Factory Method.  You declare a variable of type Func<>.  There’s not much more to it, really.
  • Abstract Factory:  You declare an interface in which every method returns or creates an object

It’s the difference between one function and multiple functions.


I don’t honestly think I’ve done this pattern justice.  It’s probably the single most important design pattern we’ve got.  It falls into an interesting category: one where it’s obvious what you do, but much less obvious when you should use it.  It took me years to appreciate how important it was to well-designed code.  I started to understand it through reading Miško Hevery‘s work and applying that to my own experience of where my own testing approach was falling down. 

Patterns Everyone Knows: Useful Terminology

I guarantee, you already know these patterns.  However, the patterns terminology is useful, if only to communicate the concepts quickly.


An object used to build another object.  The most obvious implementation of this pattern in the framework is StringBuilder.  It can be quite useful to have a builder in cases where what you’re constructing is complex and you don’t need to read from the constructed object as you’re going.  (If you do, just using the object’s own method is often simpler.)  The Builder pattern is used in fluent interfaces to support method chaining.  In this case, the builder constructs the object internally, but returns itself.

Arguably, this pattern should be marked “Caution: Hazardous Material”.  Although everyone is familiar with it, every so often someone gets it into their head that every object should have a builder.  The code rapidly becomes a mass of useless indirection.


You want to expose one interface from an object, but it exposes a different interface.  You write an adapter object to translate calls from one to the other.  Differs from the proxy pattern only in as much as the proxy pattern mandates that the exposed and the internal interface should be the same, but it’s definitely a proxy in the looser sense that we commonly use.

Adapters usually occur at sub-system or system boundaries.  Third-party libraries should typically be wrapped


Now, this pattern is so general it’s going to cover a lot of code you’ve written over time, but the terminology is actually useful, simply because we do actually need a word for it.  Say you’ve got an extremely complex trading system.  However, all that your code needs is a list of accounts and the cash in each.  A Facade is an interface that just exposes the bit you need. 


Facade, Builder and Adapter are amongst the most common patterns in software development.  Most developers will have independently come up with these solutions, since they’re pretty obvious.  The terminology can, however, be useful to communicate between developers.

Bridge and Template are also obvious, but unlike Facade, Builder and Adapter, aren’t really useful for communication. 

  • In the case of bridge, typically just saying that you’ve hidden something behind an interface is more clear. 
  • In the case of Template, it’s better to refer to what you’re doing as a parameterized algorithm, irrespective of the form that parameterization takes.

The Flyweight pattern is part of a general principle that objects can have more than one representation.  I wouldn’t personally use the term.

There’s one more “obvious” pattern: factory.  However, when you should use it isn’t as obvious, so it’s getting a post of its own.

Gang of Four Anti-Patterns

These is basically patterns where you’re better off avoiding them.  Seriously, just skip those parts of the book:


All patterns are a trade-off.  The trade-off with singleton is reducing the number of parameters certain functions take and trading them for more static methods.  From the perspective of code agility, a every method on singleton might as well be a static method.  Not only that, but everything the singleton touches might as well be a static method.  The testing implications of the Singleton pattern are horrendous.  Steve Yegge has written far more than I intend to on the subject, so I’m really not going to spend any more time on telling you what a stupid, stupid idea it is.  Singletons, static methods and global variables all expose the same problem.  In fact, they’re pretty much effectively the same thing most of the time. 

So, what should you do instead of a singleton?  Well, let’s say, for instance, that you have a network connection (call it X) wrapped as an XConnection object.  There’s only one physical connection, and that needs to be accessed from various parts of the system.  Well, actually, the answer is very simple: you pass the object into the contructor of the objects that need it.  If some of those objects get created before the network connection gets called, you could pass in an object that creates the connection on the first call, or you could pass in a promise/lazy object/future/whatever it’s called in the language of your choice.  Basically, take the static methods you were thinking of, and turn them into instance methods.

Now, the technique that we’ve just described is called Dependency Injection (DI), and is made easier by using a DI container.  Ironically, you tend to tell the container that the connection object has a “Singleton” lifecycle.  But all that means is that there’s one connection referenced by the container, not one connection usable in the whole of your memory space.  The distinction may appear small, but it’s the difference between a flexible design and a brittle nightmare.  Much as certain extremely talented people may use the technique, don’t make your container a singleton.  That way lies madness.

Singletons are, of course, a special case of the concept of shared state.  In general terms, state and especially shared state, is problematic.  Designs that share very little state or, even better, have no state at all tend to be less prone to hard to analyze bugs and easier to repurpose when requirements change.


This one basically says you shouldn’t create your objects, you should copy them.  We already know this concept in .NET, it’s called ICloneable.  There’s all sorts of problems with cloning objects, number one of which is that it’s not that well defined.  If X has Y as a property, when you clone X, do you clone Y?  Seriously, semantically, the prototype pattern is a mess.

The BCL team were talking about demising ICloneable five years ago

The thing with prototype is: you can see how it might look sensible if you’re a C++ programmer.  Copy means something quite specific: a memory-based clone.  Any good C++ developer would know exactly what that would do.  It’d copy things declared as values and re-use things declared as pointers.  Let’s just think about that for a second: what happens when your data structure changes a value to a reference?  Well, the semantics of your copy change.  And, of course, you can’t copy anything that uses an external resource.

Now, JavaScript is based around the idea of prototypes instead of classes.  These are not the same thing as the prototype pattern. 

On the other hand, it’s important to note that sometimes context is everything. 


The Singleton and Prototype pattern have no place in the arsenal of the educated C# developer.  Prototype just makes no real sense, Singleton will positively ruin your code.  Most people know that singleton is a bad idea, but are still enamoured with the concept of shared state.  On the other hand, I don’t think anyone is seriously attempting to use the prototype pattern in C# in the first place.

EDIT: Thanks to Svend Koustrup for pointing out a dangling sentence.

Publish/Subscribe Patterns

Previously, I talked about patterns where you were unlikely to implement them yourself, since they are now considered part of the infrastructure that goes with a modern language.  The publish/subscribe model isn’t quite ready to be described as infrastructure, but it’s getting close.  So, here are two patterns I don’t honestly think it’s worth knowing.  Here, it’s not so much that the patterns are bad, just that you’re better off understanding and using the publish/subscribe model.  Here’s how the pub/sub model works:

  • Participants are called services.
  • They do not communicate directly with one another, but through messages/events raised by one and consumed by others.
  • Each service can register its interest in the messages for any other participant.
  • However, no service references any other participant.  Instead, messages are placed on a message bus, and consumed by means of method calls on the destination object or objects.
  • In asynchronous scenarios, when an event is raised, it is placed on a queue.  The service consumes the messages in the order they were sent, but not necessarily on the same box and definitely with no guarantee of exactly when it happens.

Now, here’s some implementations of the pub/sub pattern you can use for free:

Of these, each has their advantages.  Personally, I dislike .NET events because getting a message from one service to another pretty much requires you to be able to reference both objects, which cuts down on the decoupling that pub/sub gives you.  Of the others:

  • nServiceBus is most appropriate for long running processes, and those that split across machines. 
  • retlang is preferable when you’ve got low-latency requirements, and you’re happy with everything running on one machine.
  • Udi Dahan’s code is incredibly short, and appropriate when you don’t feel the need for a more complex solution.  It is synchronous and single threaded, which can be a blessing or a curse depending on your context.

Now, I was promising that I’d talk about GoF patterns, so let’s get back to it:


One object listens to events/messages pushed out by another.  Any consuming service in a pub/sub framework could be considered an observer, as could anything that listens to .NET events.  However, it’s very generality means that it’s not really that useful as a concept.


A term used to describe an object that is used when services don’t directly communicate with one another.  In the publish/subscribe model, this is the message bus. 


The Observer and Mediator patterns should not be implemented directly by your code.  If it looks like one or the other might be appropriate, you should consider the use of a publish/subscribe framework.

NOTE:  I’m going to have to revise this in light of Rx, a useful framework that targets the observer pattern directly.

Infrastructure Patterns

Some patterns are so good they become part of the way that people think about systems.  They get implemented using general solutions and then people just use them as a piece of technology.  In these cases, a modern developer is himself unlike to implement the pattern, he’s much more likely to just use the libraries that implement the pattern.  I’m terming these infrastructure patterns.

Proxy and Decorator

A modern developer lives with proxy objects the whole time.  If you have an object X, a proxy for object X behaves is an object that exposes the same interface as X and delegates calls through to X.

In many ways, Decorator and Proxy are the same pattern.  If you don’t believe me, check the UML diagrams on Wikipedia (this from the guy who hates UML).  The major difference is one of intent.  We call it a decorator if it modifies functionality, or a proxy if it doesn’t. 

You can do quite a few things with a proxy/decorator:

  • NHibernate uses entity proxies to allow objects to be lazily loaded.
  • You could use Castle DynamicProxy to log all calls to a destination object.
  • Equally, you could a use a proxy to restrict access and add a permissioning system.
  • You use client proxies in WCF to make it look like you’re calling a service directly.  In practice, you call a proxy, the proxy performs network communication with the server and then the server calls the real object.

In practice, quite a lot of the time the boundary between the two terms is blurred.  It’s usually called a proxy if you’re crossing a system boundary, but if you’re checking permissions?  Strictly it’s a decorator.

In practice, most of your needs for true proxy objects are handled by framework libraries.  Those that aren’t, I recommend using a general proxy solution like DynamicProxy.  Krzysztof has written an excellent tutorial.  However, just because you’re not implementing proxies yourself, it doesn’t mean you don’t need to know what one is.  On the other hand, most modern developers do understand this stuff already, because much of what we write these days involves some form of remote component.

The classic example of the decorator pattern in the .NET Framework is the IO library (it pretty much copies Java’s approach).  In the call “new BufferedStream(stream)”, the BufferedStream is a decorator that buffers the calls to the underlying stream.  It’s exactly the same as the original stream, except that it’s buffered. 

For large APIs such as System.IO.Stream, it’s rarely advisable to do this stuff by hand, because delegating methods is both dull and error prone. 


Steve Yegge pointed out that this pattern basically just works around a deficiency in the design of C++.  In C#, it’s the foreach statement.  Call it iterator if you want, I tend to call it IEnumerable.


An interpreter is a language that is executed without going through a compilation state.  The interpreter pattern is basically the same.  Now, there’s basically two cases in which you’d be hit with this as a requirement:

  • You’ve been provided with an external language specification that you need to parse and process.
  • You need to create a small language to deal with a particularly flexible requirement.

In the first case, it doesn’t matter what you do, you’re writing an interpreter or compiler.  Since anything you did could be described as matching the interpreter pattern, it’s hard to see how useful the terminology is.  Interpreter was a term of art in the 1960s, not a design pattern in the 80s.

In the second case, you’re writing a DSL.  And here, frankly, I wouldn’t use an interpreter.  Most modern thinking on this subject says that you’re better off using a language that already exists and tweaking it to your purpose. 

The most obvious language choices are IronPython, IronRuby or Boo. 

  • IronPython has a relatively inflexible syntax, but it’s extremely sophisticated and can be happily used for scripting purposes. 
  • IronRuby (and Ruby in general) is the most popular DSL base language in the world, with a very flexible syntax.  It’s not as mature as IronPython, though, which may put you off.
  • Boo has a customizable syntax, is mature and is open source.  However, it’s syntax is possibly over-flexible, to the extent that it can be very hard to figure out what a DSL does without reading its source code.  You can mitigate this by writing decent documentation, but typically DSLs don’t come with much.


The iterator and interpreter patterns are both terminology that ought to be retired.  This is not to say they’re bad patterns, it’s just that it’s not useful to name the concepts anymore.  The term “interpreter” is best used simply to denote the same concept it represented in the 1960s: runtime evaluation of a programming language.  The proxy pattern is something you’re highly unlikely to need to implement yourself, but it’s extremely important you understand the concept it represents and when your code is using proxies.  Decorator is just a proxy that modifies behaviour.  You’re actually quite likely to implement your own decorators, though.

UPDATE:  The text about decorators has been revised.  The original text can be found here.

Gang of Four Patterns

I’m about to give a talk on Gang of Four patterns.  I’ve got to admit, I’d rather have been talking about the seminal post-punk band.  For one thing, if people disagree with my opinions (“Entertainment” is genius, for the record…) they’re unlikely to take it personally.  The thing is, everyone treats the book as being something akin to the Bible in the 16th century:

  • It’s incredibly important
  • It’s full of useful ideas
  • It’s hugely respected
  • But no-one’s read it
  • And a fair number of those that do don’t understand it, and take it out context.

None of these are actually problems with the book per se, but misinterpretation is annoyingly common.  You hear people boasting of how many different patterns they managed to implement in their code base, as if increased complexity were something of which to be proud.  You see people shoehorning patterns into problems which don’t match the use cases.  Personally, I wish more people bothered to read Chapter 1, especially the section on favouring composition over inheritance.

Taking Another Look

I have to admit, these attitudes coloured my own stance on the book for years.  I was leery of developers who espoused patterns because it seemed that use of patterns was more important to them than delivering solutions.  I’m hardly the first person to say this

Like the Bible, it’s better when you have a modern translation, since frankly 15 years is a long time in software development.  To give you an idea, Java was released a year later.  Some were a stupid idea, some just aren’t as important anymore, some are special cases of more general ideas, some people use all the time and the only real benefit is terminology.  And some…

…well actually, some are so important that you really, really, need to understand them.  So, I decided to write a skeptic’s guide to design patterns.  You’re almost certainly going to disagree with me, but for the record, the patterns I think are still relevant and unobvious today are:

  • Factory / Abstract Factory
  • Command
  • Chain of Responsibility
  • State

Sorry, that’s it.  Don’t worry, I’m wearing asbestos.

Initial Observations

Going through the book again, a couple of themes keep cropping up:

  • Unlike most modern patterns, the use cases often overlap.  Because the focus is on low-level programming constructs, there’s often more than one way to do something.
  • The design patterns are, contrary to popular belief, extremely language dependent.  Iterator is irrelevant in C#, Visitor is irrelevant in JavaScript.
  • The patterns are often special cases of more general concepts and techniques.

You’re not going to find any diagrams in this stuff.  Frankly, I think that UML is a positive hindrance to understanding what’s going on in most of these patterns.

  • For one, I don’t regard the presence or absence of an abstract interface as fundamentally changing a design, it’s just a refinement (one that you should pretty much always be using).
  • For another, the difference between composition and inheritance is significant, but I’d argue doesn’t actually change a pattern.  Hence, I’d argue that Template and Strategy are actually the same.
Technorati Tags: ,

Retlang 0.4

Retlang 0.4 has been out for quite a while, but I’ve never written about it.  Worse, my example code doesn’t work in it, which has garnered complaints (in my defence, the Retlang wiki is out of date as well).  The version is again a restructuring that you shouldn’t apply to your own code without a bit of thought, but it’s added a killer feature: the ability to interact with WinForms.  Or WPF if you’re that way inclined.

Anyway, I’ve drawn up a new version of the spider, but it differs quite a bit from the previous versions:

  • It now has something resembling an architecture.
  • Keeping track of progress is now handled separately from keeping track of which URLs have been encountered.
  • I’ve used the ability to throw a command directly onto a fiber.  (Note for old users:  where you used to say “Context” or “Queue”, you now say “Fiber”)
  • I’ve abstracted out the basic graph-walking functionality from the URL reading functionality.  It’s not clear to me that it’s more readable this way, although the advantages of abstraction tend to grow with scale.
  • If you pass an argument of “interactive” in, it will show a progress bar.

I still haven’t gone with Mike Rettig’s suggestion to group channels together into service classes, which are then passed into the constructors of their consumers.  Instead, I’ve mostly gone for a single top-level routine that sets up the whole routing.  However, this ran into trouble when dealing with the new feature, the ability to switch on a progress bar.

Basically, UI fibers look the same in Retlang as threads, but ultimately they’re not.  So the main set up routine needed access to the particular fiber.  I achieved that by actually making the fiber a property of the object.  At one point in the design (yes, there is some design…) this produced a chicken-and-egg problem. 

  • I wanted the form to have a fiber property
  • I wanted to pass that in in the constructor to the form
  • But the fiber itself wanted the form in its constructor

This looked like a serious problem until I realized that there was a better design, which separated out the job of tracking progress from reporting progress.  This is reflective of a more general fact about retlang: it really punishes you sometimes if your design isn’t SOLID.  This isn’t a criticism, in fact it’s one of the best features of Retlang: it pushes you towards better designs.

Anyway, enough rambling and on with the code.  Feedback on whether or not this is better at illustrating principles than the old version will be appreciated.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Net;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using Retlang.Channels;
using Retlang.Core;
using Retlang.Fibers;

delegate IEnumerable<TNode> NodeWalker<TNode>(TNode root);

interface IProgressCounter<TNode> {
    void NodeQueued(TNode node);
    void NodeCompleted(TNode node);

    IFiber Fiber { get; }

    void WaitUntilComplete();

interface IGraphListener<TNode>
    bool HasEncounteredNode(TNode node);

    void ProcessNode(TNode node);

class GeneralGraphListener<TNode> : IGraphListener<TNode>
    private readonly HashSet<TNode> alreadyProcessed;

    public GeneralGraphListener(IEqualityComparer<TNode> comparer)
        alreadyProcessed = new HashSet<TNode>(comparer);

    public virtual bool HasEncounteredNode(TNode node)
        return alreadyProcessed.Contains(node);

    public virtual void ProcessNode(TNode node)

    public IEnumerable<TNode> NodesEncountered
        get { return alreadyProcessed; }

static class RetlangMacros
    internal static Action<TValue> Distribute<TValue>(Func<Action<TValue>> processorFactory, int numberOfProcessors)
        var distributeChannel = new QueueChannel<TValue>();
        for (int index = 0; index < numberOfProcessors; index++) {
            var processor = processorFactory();
            var queue = new ThreadFiber();
            distributeChannel.Subscribe(queue, processor);
        return distributeChannel.Publish;

    internal static IPublisher<TNode> CreateGraphWalker<TNode>(
        Func<NodeWalker<TNode>> nodeWalkerFactory, 
        int numberOfProcessors, 
        IGraphListener<TNode> listener,
        IProgressCounter<TNode> progressCounter)
        var foundNodeChannel = new Channel<TNode>();
        var enqueuedNodeChannel = new Channel<TNode>();
        var finishedNodeChannel = new Channel<TNode>();

        Func<Action<TNode>> nodeProcessorFactory = () => {
            var walker = nodeWalkerFactory();
            return node => {
                foreach (TNode child in walker(node)) {
        var walkChildren = Distribute(nodeProcessorFactory, numberOfProcessors);
        var trackerQueue = new PoolFiber();
        enqueuedNodeChannel.Subscribe(progressCounter.Fiber, progressCounter.NodeQueued);
        finishedNodeChannel.Subscribe(progressCounter.Fiber, progressCounter.NodeCompleted);
        foundNodeChannel.Subscribe(trackerQueue, node =>
            if (!listener.HasEncounteredNode(node)) {

        return foundNodeChannel;

class ProgressCounter<TNode> : IProgressCounter<TNode>
    private readonly IFiber fiber;
    private readonly IProgressReporter reporter;
    private readonly AutoResetEvent waitHandle;
    int nodesEncountered;
    int nodesProcessed;

    internal ProgressCounter(AutoResetEvent waitHandle, IFiber fiber, IProgressReporter reporter)
        this.waitHandle = waitHandle;
        this.fiber = fiber;
        this.reporter = reporter;

    public IFiber Fiber
        get { return fiber; }

    public virtual void NodeQueued(TNode node)

    public virtual void NodeCompleted(TNode node) {
        reporter.Report(nodesProcessed, nodesEncountered);
        if (nodesProcessed == nodesEncountered) {

    ///NOTE that this routine is called on a separate fiber from the other functions in
    ///this class.  All other classes stick to their fibers.
    public virtual void WaitUntilComplete() {

interface IProgressReporter : IDisposable
    void Report(int nodesProcessed, int nodesEncountered);

class ConsoleProgressReporter : IProgressReporter
    public void Report(int nodesProcessed, int nodesEncountered)
        Console.WriteLine(string.Format("{0}/{1}", nodesProcessed, nodesEncountered));

    public void Dispose()
        // Not needed

class FormProgressReporter : Form, IProgressReporter {
    private readonly ProgressBar progressBar;

    public FormProgressReporter()
        progressBar = new ProgressBar();
        progressBar.Dock = DockStyle.Fill;
        progressBar.Location = new System.Drawing.Point(0, 0);
        progressBar.Name = "progressBar";
        progressBar.Size = new System.Drawing.Size(292, 266);
        progressBar.TabIndex = 0;
        Height = 75;
        Width = 600;

    public void Report(int nodesProcessed, int nodesEncountered)
        Text = string.Format("{0}/{1}", nodesProcessed, nodesEncountered);
        progressBar.Maximum = nodesEncountered;
        progressBar.Value = nodesProcessed;

class Program
    static void Main(string[] args)
        string baseUrl = "http://www.yourwebsite.xyzzy/";
        int spiderThreadsCount = 15;
        bool hasUI = args.Length > 0;
        if (hasUI)
        var waitHandle = new AutoResetEvent(false);
        var reporter = hasUI
            ? (IProgressReporter)new FormProgressReporter()
            : new ConsoleProgressReporter();
        var form = reporter as FormProgressReporter;
        if (form != null) {
            new Thread(() => Application.Run(form)).Start();
        using (var fiber = hasUI 
            ? new FormFiber(form, new BatchAndSingleExecutor())
            : (IFiber) new PoolFiber())
            var progressCounter = new ProgressCounter<string>(
                waitHandle, fiber, reporter);
            var listener = new GeneralGraphListener<string>(
            var walker = RetlangMacros.CreateGraphWalker(
                () => new Spider(baseUrl).FindReferencedUrls,
            foreach (string url in listener.NodesEncountered.OrderBy(url => url)) {

    class Spider
        string _baseUrl;

        public Spider(string baseUrl)
            _baseUrl = baseUrl.ToLowerInvariant();

        public IEnumerable<string> FindReferencedUrls(string pageUrl) {
            if (Path.GetExtension(pageUrl) == "css")
                return new string[0];
            string content = GetContent(pageUrl);
            return from url in Urls(content, "href='(?<Url>[^'<>]+)'")
                            .Union(Urls(content, "href="(?<Url>[^"<>]+)""))
                            .Union(Urls(content, "href=(?<Url>[^'" <>]+)"))
                       where url != null && url.Length > 0
                            && IsInternalLink(url) && url[0] != '#'
                            && !url.Contains("&lt")
                            && !url.Contains("[")
                            && !url.Contains("\")
                            && !url.EndsWith(".css")
                            && !url.Contains("css.axd")
                       select ToAbsoluteUrl(pageUrl, url);

        static int BaseUrlIndex(string url)
            // This finds the first / after //
            return url.IndexOf('/', url.IndexOf("//") + 2);

        string ToAbsoluteUrl(string url, string relativeUrl)
            int hashIndex = relativeUrl.IndexOf('#');
            if (hashIndex >= 0) {
                relativeUrl = relativeUrl.Substring(0, hashIndex);
            if (relativeUrl.Contains("//"))
                return relativeUrl;
            if (relativeUrl.Length > 0)
                bool isRoot = relativeUrl.StartsWith("/");
                int index = isRoot 
                    ? BaseUrlIndex(url) 
                    : url.LastIndexOf('/') + 1;
                if (index < 0) {
                    throw new ArgumentException(string.Format("The url {0} is not correctly formatted.", url));
                var result = url.Substring(0, index) + relativeUrl;
                return result;
            return null;

        bool IsInternalLink(string url)
            url = url.ToLowerInvariant();
            if (url.StartsWith(_baseUrl))
                return true;
            if (url.StartsWith("http") || url.StartsWith("ftp") || url.StartsWith("javascript"))
                return false;
            if (url.Contains("javascript-error"))
                return false;
            return true;

        static IEnumerable<string> Urls(string content, string pattern)
            var regex = new Regex(pattern);
            // Why exactly doesn't MatchCollection implement IEnumerable<Match> ?
            return from match in regex.Matches(content).Cast<Match>()
                   select match.Groups["Url"].Value;

        static string GetContent(string url)
            var request = WebRequest.Create(url);
            request.Proxy = WebRequest.DefaultWebProxy;
            try {
                using (var response = request.GetResponse()) {
                    using (var reader = new StreamReader(response.GetResponseStream())) {
                        return reader.ReadToEnd();
            } catch (WebException ex) {
                Console.Error.WriteLine("Problem reading url {0}, message {1}.", url, ex.Message);
                return "";


Technorati Tags: ,