Inside Windows Communication Foundation Table of Contents

A recent commenter on this blog indicated that the TOC of Inside Windows Communication Foundation (my book) was not available online. I’m not sure why this is the case, but I’ve found that I don’t have much control over what Amazon (or other) book retailers post online. I’m reaching out to the publisher to see if we can initiate the changes. In the meantime, it seems reasonable to post the TOC here.

I’ve also included a short bit about the way I explain WCF in the book. I think my approach is different from other WCF books, and I hope it resonates with readers.

I don’t think it is possible to plagarize oneself. Just in case it is, I’ve taken some of the following from the book:

My Approach

WCF is a powerful, but complex part of the .NET Framework. Whenever I approach a technology, I tend to try to view it from a bottom-up perspective. Admittedly, this is getting harder as technology becomes more advanced and layered. I give myself a pass on some technologies, but not on others. For example, I haven’t bothered to study the all of the low-level architectural changes in Vista, but I use it anyway. I have not given myself this sort of a pass with WCF, and I did not give myself that sort of a pass with the .NET Framework. This seeming contradiction is a direct result of the way I use these technologies in application development. I write code using WCF and many other parts of the .NET Framework, and I like to understand the platform I am using. This paradigm is practical if you consider where most developers spend their time: testing, maintenance, debugging. I’ve found that it is impossible to test, maintian, or debug a platform I don’t understand. Similarly, it is only through an inside-out understanding that one can make wise design decisions. There are simplly too many hidden pitfalls in designing an application without it, especially when you consider that we approach a new technology with a builtin bias to what we already know. This is not a new concept. Consider the following example (from the book):

A C++ developer moving to C# without any knowledge of the garbage collector will instinctively add a finalizer to all type declarations. Unknowingly, this developer will have increased the time required to allocate these objects and increased the lifetime of these objects. For most C++ developers, simply saying “don’t do it” isn’t enough. They want to know why. Technically, adding a finalizer to a type is not a bug, but it is certainly (often) an inefficiency that could have been averted with a couple of hours spent in a book or a good training course.

It is my hope that this book strikes the right balance between coverage of the object model and coverage of the underlying concepts that should be incorporated into WCF applications. This book gives you an inside look at WCF so that you will be able to design, build, debug, and maintain scalable and reliable distributed applications.

Part I Introduction to WCF

Chapter 1 The Moon is Blue

In my view, WCF represents a tectonic shift in the way we build distributed applications. This chapter provides context around WCF for the purpose of understanding why it was built and introduces the goals that drove WCF features.

Chapter 2 Service Orientation

Though Service Orientation (SO) is not a new concept, a solid understanding of SO is key in understanding WCF. Unfortunately, there is quite a bit of noise on the internet and the blogsphere about what SO really is. It’s my hope that this chapter distills SO into practical terms, without oversimplifying it.

Chapter 3 Message Exchange Patterns, Topologies, and Choreographies

If I ask a group of developers to define a “web service”, experience has taught me that I will get as many different answers as there are people in the audience. This is not saying anything about the audience, but rather making a statement about the mess we (who write papers and speak at conferences) have made of the topic. This chapter introduces a taxonomy that you can use to describe any web service. These terms are not new, but I hope that adding them to the book solidifies their use within the community. Furthermore, I use these terms throughout the rest of the book.

Chapter 4 WCF 101

Now that the background is in place, it’s time to start looking more directly at WCF. This chapter takes a quick run through WCF at a 101 level, and sets context for the rest of the chapters.

Part II WCF in the Channel Layer

Chapter 5 Messages

The Message type is the fundemental unit of communication in WCF applications. In my view, the rest of the types in the WCF infrastructure are designed to send, receive, or otherwise mangle a WCF message. In direct contrast to the central role of the Message type in WCF applications, it is not often the target of much attention. This chapter takes you deep into the Message type. Topics covered are Message encodings, Message composition, Message to MessageFault mapping, and lots of other cool stuff.

Chapter 6 Channels

Channels are objects that send, receive, or otherwise mangle Message objects. A channel object is often arranged with other channel objects in a stack. The composition of this channel stack represents the messaging features of an application (many WCF applications can create several different configurations of channel stacks – this is part of the power of WCF). Though hidden from the purview of application developers by the ServiceModel layer, channel objects are busy behind the scenes sending and receiving messages. This chapter takes you deep into channel types by explaining how they work, their API and type hierarchy, shows you how to build your own, and outlines when it is appropriate to do so.

Chapter 7 Channel Managers

Channels are created by a set of types known as Channel Managers. Channel Managers come in two flavors: Channel Listeners and Channel Factories. Channel Factories build channel stacks that send messages, and Channel Listeners listen for incoming bytes, and create channel stacks to process those bytes. Once again, these types are often hidden from the purview of the application developer, but that does not absolve the WCF application developer from understanding Channel Managers. This chapter closely examines Channel Manager anatomy and demonstrates how to build custom Channel Managers.

Part III WCF in the ServiceModel Layer

Chapter 8 Bindings

Bindings are the primary way that the WCF API surfaces messaging functionality to the application developer. Functionally, Binding objects create Channel Managers. This chapter discusses the Binding type hierarchy and API, how a Binding object creates Channel Listeners and Channel Factories, demonstrates how to build your own Binding type, and describes when it is appropriate to do so.

Chapter 9 Contracts

Contracts describe the composition of a WCF service. This includes information about the service, the operations it defines, and the messages an operation sends and receives. On the surface, a Contract is nothing more than a type definition that is annotated with attributes from the WCF API. At runtime, the WCF infrastructure reflects over this metadata and builds the appropriate ServiceModel plumbing. This plumbing is vital to the way the application interacts with the channel stack(s). This chapter walks through the different contract types and how a developer can use them. I also describe how the WCF infrastrucre uses a contract definition to build the ServiceModel plumbing described previously.

Chapter 10 Dispatchers and Clients

Architecturally, the Dispatcher is the topmost layer of the WCF infrastructure in a receiving application. In the spirit of sender / receiver symmetry, the Client is the topmost layer in a sending application. Both the Dispatcher and the Client have multi-facted roles. This chapter distills these functions into manageable chunks, and, at the same time, describes their composition and API. In my view, understanding the Dispatcher and the Client is vital when building a custom behavior.