I am interested in the design patterns that where used in the development of wcf. As an example of what I am looking for: the ChannelFactory class is used to create the channel between the client and the service; does this represent an implementation of the Abstract Factory pattern or the Builder pattern? Or a combination of the two? The reason why I am asking the question is that in the documenting of design patterns the examples of its usage are frequently contrived, particularly in the area of how design patterns can be combined together. It seems to me that looking at a practical example of existing software that is in production (such as wcf, especially since a person can use Reflector to do a detailed examination of the classes and their object model) would greatly further understanding of design patterns.
Share
Abstract Factory builds on the Builder pattern. Instead of the factory knowing how to create one type of object, it knows how to create many different, but related, types of objects. Builder is a basic building block for a pattern that encapsulates initialization of another object in a separate location from the object or consumer code. Abstract Factory uses Builder to create a pure fabrication that has the sole purpose of creating objects.
More to your point:
Services in general, but especially WCF, make heavy use of Adapter-style patterns, such as Proxy. The WCF service creates a “proxy” that looks like the class behind the service endpoint, but is in reality a very different type of class; the proxy class is an “adapter” between your code (which expects a basic service class) and the service implementation (which maintains communication channels, serialization/deserialization, etc that dependent classes shouldn’t know about) that sits on top of the class that does the real work.
Anything having to deal with communication channels, as you found, generally involves a Factory to initialize the object representing the data channel. These objects are expensive, and require knowledge of implementation details that the consuming class shouldn’t know.
Behind the scenes, the service calls represent a use of the Command pattern. The message sent over the wire encapsulates the service method to call, which is digested by the web server and translated into a call to the method attached to that service endpoint. However, as it looks like you’re actually calling the method, instead of encapsulating the operation to be performed and calling a generic method, you may not consider it to be in that family.
Asynchronous and message-passing patterns also abound in SOA.