Services are all the rage these days, but there's a lot more to building a service than just slapping an interface on top of some business and data access logic. Robust services need to take into account usage patterns, security, reliability, scalability, monitoring, and more. Covering all of those areas is not a simple task, which is why you should consider building your services using Microsoft BizTalk Server 2006 R2. BizTalk is an extensive development and runtime platform that includes workflow, monitoring, service hosting, message tracking, management tools, centralized configuration, a rules engine and more. In other words, it includes a vast amount of code that you don't need to write the next time you create a service!

This article will walk you through the process of designing and building a service using a contract-first design approach on top of BizTalk's infrastructure and its integration with Windows Communication Foundation (WCF). This article is neither a comprehensive introduction to BizTalk nor to WCF, so it will help to have some existing experience with these technologies.

First of all, let's talk briefly about services. The goal behind creating a service is simply to encapsulate some useful functionality behind one or more structured interfaces, or "contracts." We all know that we can browse a fast-food menu, make a selection, pay for it, and get food in return. It is not important to us how the food was created, where the money was stored, who decides what ingredients need to be reordered and when, and so on. This real-world example of abstraction and encapsulation is exactly what we are striving to accomplish with our own services.

Before we move on, let's establish that "service" does not equate to Web Service. True, a service may be exposed as a Web Service, but it may also be an endpoint of a message queue, a TCP endpoint, a Distributed COM server and so on. Whether we walk up to a fast-food restaurant counter or use the drive-in window, the transaction is the same. Windows Communication Foundation (WCF) is the framework that we can use to expose our services to these various transports, and BizTalk Server 2006 R2 includes built-in support for both creating and consuming WCF services. In the remainder of this article we'll be focused on creating services with WCF in combination with BizTalk.

A common method for designing service interfaces today is called "contract-first" design. A "contract" specifically defines the way that clients will interact with a service and what data passes from client to service and back. The typical and interoperable format for data contracts in a service is XML Schema (XSD), and here we will define our service's data structures and messages entirely in XSD. Visual Studio does not provide any visual tools that are specific to contract-first design. BizTalk, on the other hand, natively works with XML Schemas, so contract-first design is very straightforward. For more background on contract-first design, please check out a couple of Aaron Skonnard's "Service Station" columns in MSDN Magazine (http://msdn2.microsoft.com/en-us/magazine/cc163850.aspx, http://msdn2.microsoft.com/en-us/magazine/cc163800.aspx).