Nicholas Allen's Indigo Blog

Disabling the Visual Studio Service Host

When debugging a WCF project in Visual Studio the WCF Service Host starts up to host my service. How do I stop this from happening so that I can use my own service host?

One of the new tools in Orcas is the WCF Service Host that allows you to automatically host and test a service that you've implemented. The WCF Service Host comes along with some of the specialized WCF project templates in Visual Studio, such as WCF Service Library and Syndication Service Library.

If you've picked one of these project templates, then I don't know of a good way of disabling the service host. This should be fixed in SP1 by adding some user interface to toggle the service host on and off. In the meantime, you can perform some surgery on the project file to work around this. If you look inside the actual csproj file for your project, then you'll see a PropertyGroup section that defines the project.

  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProductVersion>9.0.21022</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{3CC71D2E-7EC2-46B5-B985-F889B65E3DCD}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>WcfServiceLibrary1</RootNamespace>
    <AssemblyName>WcfServiceLibrary1</AssemblyName>
    <ProjectTypeGuids>{3D9AD99F-2412-4246-B90B-4EAA41C64699};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    <StartArguments>/client:"WcfTestClient.exe"</StartArguments>
    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
  </PropertyGroup>

The ProjectTypeGuids list is what controls these special features of projects. Removing the {3D9AD99F-2412-4246-B90B-4EAA41C64699} entry from the list will disable automatic service hosting.

Next time: Debugging Type Loading

Setting the Configuration Name

What's the difference between the Name and ConfigurationName on service contracts and behaviors?

The Name property sets the name of the service in metadata while the ConfigurationName property sets the name of the service in configuration. Metadata is the part of the service description that is transmitted to others when they interrogate your service. Configuration is the purely local settings for controlling the service.

Since Name is more commonly used, I'll just run through a quick example focusing on setting ConfigurationName instead. Here I've got a service contract and implementation setting both the Name and ConfigurationName properties.

[ServiceContract(Name="NotIService", ConfigurationName="IService")]
public interface IMyService
{
   [OperationContract]
   void DoNothing();
}

[ServiceBehavior(Name = "NotService", ConfigurationName = "Service")]
public class MyService : IMyService
{
   public void DoNothing()
   {
   }
}

In my app.config file, the way I'd refer to that service and service endpoint is by the ConfigurationName.

<service name="Service">
   <endpoint
      address="http://localhost:8000/" binding="basicHttpBinding"
      bindingConfiguration="myBindingConfiguration" contract="IService"/>
</service>

On the other hand, everywhere in the metadata, generated proxy, and even the generated proxy configuration file the service will appear as NotIService and NotService.

Next time: Disabling the Visual Studio Service Host

WCF Silverlight Blog

I haven't had nearly as much time as I wanted to write about our efforts porting WCF to the Silverlight platform or tell you about what we've managed to build. I'm still planning to do feature highlight posts along the way but your best source of day-to-day information is going to be the WCF Silverlight team blog.

Generating Types with Lists

I have a data contract that contains a collection type but the generated proxy appears as an array. How can I make the proxy use a collection type as well?

I've talked in the past about how the representation of a type in metadata is decoupled from the CLR representation of a type in the service. For example, if I have a data contract that uses a List:

[DataContract]
class Data
{
   [DataMember]
   public List<string> data;
}

Then, the metadata representation of this data contract is actually described as an array because arrays are the only primitive type for collections in schema.

<xs:schema xmlns:tns="http://schemas.datacontract.org/2004/07/" elementformdefault="qualified" targetnamespace="http://schemas.datacontract.org/2004/07/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import namespace="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
  <xs:complexType name="Data">
    <xs:sequence>
      <xs:element xmlns:q1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" minoccurs="0" name="data" nillable="true" type="q1:ArrayOfstring">
    </xs:element>
  </xs:sequence>
  <xs:element name="Data" nillable="true" type="tns:Data">
</xs:element>
</xs:complexType></xs:import></xs:schema>

However, just as the metadata representation isn't coupled to the service, the metadata representation also isn't coupled to the client. You can on the client generate proxies with any type for this collection that similarly can be serialized or deserialized to an array. The mechanism for doing this with svcutil.exe is the /ct switch.

The /ct switch, which stands for collectionType, allows you to give a qualified type name that is used for collection data types when generating a proxy.

As an example, to get back to the original collection class used by the server, the proxy would need to be constructed using /ct:System.Collections.Generic.List`1 as the option passed to svcutil.exe. However, you could leave the proxy using arrays or provide a different collection class such as /ct:System.Collections.ObjectModel.Collection`1 and with any of these configurations the proxy would be able to exchange messages with the server.

Next time: Setting the Configuration Name

Updates to WCF Security Guidance

After the first announcement for the WCF Security Guidance Project, the amount of content has grown tremendously. Here's a summary of what's new over the last month.

Seven new application scenarios:

• Intranet - Web to Remote WCF Using Transport Security (Trusted Subsystem TCP)
• Intranet - Web to Remote WCF Using Transport Security (Trusted Subsystem, HTTP)
• Intranet - Web to Remote WCF Using Transport Security (Original Caller, TCP)
• Intranet - Windows Forms to Remote WCF Using Transport Security (TCP)
• Internet - Web to Remote WCF Using Transport Security (Trusted Subsystem)
• Internet - Windows Forms Client Calling WCF Using Message Security
• Internet - WCF and ASMX Client to Remote WCF Using Transport Security (HTTP)

More than eighty annotated guidelines.

Six new how-to guides:

• How To - Perform Input Validation in WCF
• How To - Perform Message Validation with Schemas in WCF
• How To - Use basicHttpBinding with Windows Authentication and TransportCredentialOnly in WCF from Windows Forms
• How To - Use Certificate Authentication and Message Security in WCF calling from Windows Forms
• How To - Use netTcpBinding with Windows Authentication and Message Security in WCF from Windows Forms
• How To - Use wsHttpBinding with Username Authentication and TransportWithMessageCredential in WCF calling from Windows Forms

Answers to more than one hundred security questions.

Private Data Members

Why does a data contract with private or internal members generate a proxy with public fields?

The obvious answer is that the representation for data contracts doesn't contain information about member visibility but that just leads to the question of why the information isn't preserved by the representation.

If we take a data contract that contains both public and private members,

[DataContract]
class Data
{
   [DataMember]
   public int i;

   [DataMember]
   private string s;
}

Then, the type representation used to generate a proxy is based on an XML schema.

<xs:schema xmlns:tns="http://schemas.datacontract.org/2004/07/" elementFormDefault="qualified" targetNamespace="http://schemas.datacontract.org/2004/07/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="Data">
    <xs:sequence>
      <xs:element minOccurs="0" name="i" type="xs:int" />
      <xs:element minOccurs="0" name="s" nillable="true" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="Data" nillable="true" type="tns:Data" />
</xs:schema>

A schema is a type system that is independent of the type system used by the proxy and has no concept of member visibility. However, by saying that a member is part of the data contract, you've effectively said that that member is as intrinsically part of the data as any other public facing member. Member visibility is a facet of information hiding to suppress details that are not needed by other parts of the system, but a data member by definition is needed by other parts of the system. Therefore, regardless of how one of the parties has chosen to represent that data, it's more likely than not that the other side will need to manipulate that data to uphold the contract.

Next time: Generating Types with Lists

Messaging Additions in Orcas, Part 4

Today wraps up the series on detailed messaging changes in Orcas. You can get the whole series here as well as the previous high-level overview of new Orcas features I did.

• Messaging Additions in Orcas
• Messaging Additions in Orcas, Part 2
• Messaging Additions in Orcas, Part 3

Now, let's go on with the list. I've got one last feature to cover and then some of the more notable bug fixes that were reported by customers. If you need one of the bug fixes, you can get them by either installing Orcas or the .NET framework 3.0 service pack.

• Enhancements for web programming. RSS and ATOM syndication, partial trust, JSON, AJAX, and HTTP application programming are all covered reasonably well in the high-level overview so I didn't break them out this time.
• We no longer make shutdown slow. It took a somewhat rare machine configuration but the various services we run for port sharing and activation could prevent the machine from shutting down until they timed out.
• Copying a POX message. There aren't any standard channels that buffer messages and are used with HTTP under MessageVersion.None. However, if you write a message inspector, then you need to copy the message before reading it and that now works.
• Starting a listener while hosted in IIS. I don't recommend starting an independent web service from inside of a web service hosted in IIS. We've made the threading work in this service-within-service case but you're still at the mercy of IIS deciding when to deactivate the outermost service.
• Emptier messages. When doing POX we have to surface messages even when the HTTP payload is empty so that you have an object to get your HTTP message properties from. Until now though, when we did that conversion those messages would stop reporting that they were empty.

Next time: Private Data Members

TIBCO Announces WCF Integration

At their user conference in San Francisco yesterday, TIBCO announced two integration initiatives to bring the TIBCO and Microsoft platforms closer together.

• TIBCO is developing a TIBCO EMS transport channel for WCF. Although Microsoft doesn't have a formal certification process for releasing third-party WCF components, I got to do some code and design reviews over the last few months with the TIBCO developers to understand the work that they are doing. I am very pleased that it was possible to make TIBCO EMS fit naturally into the WCF model. This integration work benefits both Microsoft and TIBCO customers by expanding the reach of applications on each platform. I fully support the partner ecosystem in delivering WCF components and connectivity options that go beyond what Microsoft provides in the framework.
• TIBCO is also going to be making use of Silverlight for development and deployment of Internet applications. Silverlight allows developers to reuse much of the tooling and knowledge that they have from desktop development when creating browser-based applications.

Messaging Additions in Orcas, Part 3

Now that I've covered several of the new feature additions in Orcas I also want to include mention of some of the fixes done to improve interoperability with other platforms.

• Allowing an empty SOAPAction. Previously we required that the HTTP SOAPAction header exactly match the addressing action. We now let you process messages with an empty SOAPAction as many other systems were processing messages based only on the addressing action.
• Handling empty messages that claim to be chunked. Previously we weren't able to process messages that said that they were chunked but didn't have any content. Some systems were transmitting every HTTP message as chunked (even the empty ones) so we now handle this case gracefully.
• Flexible content types. Previously we required that the character set parameter for an HTTP content type be the first parameter in the list. Some systems were generating content types with additional parameters in various orders so we've removed any dependency on the parameter order.
• Parsing MTOM includes. Previously we only supported the canonicalized format for the Include element of an MTOM message. Another system was generating MTOM messages where the elements were not canonicalized so we've added support to read those messages.

Next time: Messaging Additions in Orcas, Part 4

Messaging Additions in Orcas, Part 2

Continuing on with the theme of messaging additions in Orcas, today I'll look at some more of the protocols and community-driven features that were added.

• WS Atomic Transaction 1.1. Transactions tie together multiple participants in a distributed application. The framework of transactions is built on various coordination protocols between parties. Transactions are a kind of coordination in which either all or none of the parties agree to perform an action.
• Validation for issued token certificates. We've added support for configuring the certificate validation policy for issued token authentication, similar to the configuration for other certificates that are used for service credentials.
• Flowing SAML tokens. We've added support to flow a SAML assertion without having to re-sign the token. This allows these assertions to be handled by proxies without special configuration.
• Using message contents for authorization. We've added support to ServiceAuthorizationManager for performing access checks that make use of the body of the message.
• WS Secure Conversation 1.3. A secure conversation is an exchange of multiple, protected messages. Using a conversation mechanism allows a security context to be established across several messages, which performs better than having to exchange security keys with every message.
• WS Trust 1.3. Building a secure conversation requires that the two parties exchange security credentials. In order to perform this exchange, the two parties need to establish a trust relationship where they can evaluate the assertions made by the other side.

The protocols that I've talked about today and last time are available through the new WS2007HttpBinding and WS2007FederationHttpBinding as updates to the previous web service standard bindings.

Next time: Messaging Additions in Orcas, Part 3

WCF, WF, and BizTalk Sessions at TechEd

With TechEd Developer closer at hand, I've put together the latest schedule data for sessions of interest to developers for each of the different products. The first group is sessions of general interest. The second group is sessions focusing on WCF and WF development. The third group is sessions focusing on CardSpace development. The fourth group is sessions focusing on BizTalk development.

• Microsoft Strategy and Vision for SOA by Oliver Sharp

  Services are fundamentally changing the way we build, deploy, and manage applications. In this session we identify common challenges, and share our latest guidance and success stories. In addition, we outline Microsoft's strategy to simplify complexity in a service oriented world using our frameworks, servers, and online services.

• The Road to "Oslo": The Microsoft Services and Modeling Platform by David Chappell

  Microsoft's "Oslo" project aims at creating a unified platform for model-based, service-oriented applications. This new approach will affect the next versions of several products and technologies, including the Microsoft .NET Framework, Microsoft Visual Studio, Microsoft BizTalk Server, Microsoft System Center, and more. Although many details of "Oslo" won't be public until later in 2008, this session provides an overview of what Microsoft has revealed so far. Along with a description of the problems it addresses, the session includes a look at several new "Oslo" technologies, including a general-purpose modeling language, role-specific modeling tools, a shared model repository, and a distributed service bus.

• Platforms for SOA and Business Process Management: Comparing .NET and Java by David Chappell

  The .NET and Java/J2EE worlds have been competitors for several years. How do things stack up today? And what will the future look like? This session provides an independent perspective on how these two environments compare, focused on technologies for SOA and BPM. Comparisons include Windows Workflow Foundation (WF) vs. pure BPEL workflow and Windows Communication Foundation (WCF) vs. Service Component Architecture (SCA).

• Framework and Microsoft BizTalk Best Practices with an Eye Toward "Oslo" by Jon Flanders

  Microsoft has announced "Oslo", the code-name for a wave of technology affecting the Microsoft .NET Framework, Microsoft BizTalk Server, and the idea of building service-oriented systems using Microsoft technologies. In this session we discuss what we know so far about these technologies, and how to think about what you are currently doing with Windows Communication Framework/Windows Workflow Foundation and BizTalk Server to best prepare for the future.

• AJAX-Enable Your Windows Communication Foundation Services by Aaron Skonnard

  While ASP.NET AJAX has taken center stage, it's only compelling when you have interesting data feeds to call upon. This session shows you how to build AJAX-enabled services using some of the new features in Windows Communication Foundation (WCF) 3.5. We specifically cover how to configure your WCF services to respond directly to HTTP requests with JSON (AJAX- friendly) response messages. Along the way we uncover how the underlying implementation works while providing some design guidance and highlighting potential pitfalls.

• Getting Workflows Running and Talking in Your Applications by Brian Noyes

  Once you understand the basics of Windows Workflow Foundation (WF) and can put together a workflow using the built-in activities, you will need to know how to get that workflow running in a variety of hosting environments and communicate between the workflow and the host application or the outside world. This session gives you a solid foundation to get started with these techniques. Gain a better understanding of how workflows exist in a hosting process and how to control the hosting services. Learn about the various forms of communication that can exist between a running workflow and the hosting application as well as with outside Web and WCF Services. Also, learn about the persistence and tracking features of WF.

• Providing Load Balancing, Application-Level Failover, and Centralized Configuration Management with Windows Communication Foundation Services and Microsoft .NET Applications by Gregory Leake

  This session provides a detailed walkthrough of implementing the Configuration Service 1.5, a published MSDN sample application, in your own applications and services using the base classes/base implementation. The Configuration Service 1.5 provides dynamic clustering of scaled-out service nodes for both scale, and application/service reliability. In addition, the Configuration Service 1.5 provides a central Web-based management user interface that works with any application or service implementing the Configuration Service contract. If you need to manage/monitor multiple nodes in a load-balanced cluster, or want to use WCF to build SOA applications with many connecting service layers, this session is for you!

• Durable Windows Communication Foundation Services by Juval Lowy

  Consider using Windows Communication Foundation (WCF) to implement long -running workflows or execution sequences that last days or even weeks, where the clients may connect, do some work and disconnect again. There is obviously little point in keeping proxies and hosts in memory, since it is not robust or scalable enough. You can design around this by persisting the state of the service between operations, but that implies some ability to connect back to that state in each operation. The session starts by discussing the challenges of writing such a durable service and the design options, and then demonstrates several ways of managing and binding to the service state, using message headers, or the new Microsoft .NET 3.5 context binding, contrasting and evaluating the alternatives. Through a series of conceptual demos, the sessions demystifies the WCF-solution of persistence providers, and even how to write a custom provider or use the built-in SQL provider. You also see some advanced .NET and WCF programming techniques.

• Productive Windows Communication Foundation by Juval Lowy

  Windows Communication Foundation (WCF) has much more to it than the raw aspects of the technology. This talk is all about how to deal with common real-life hurdles, and how to effectively apply WCF, by presenting a set of tools, tips, tricks, best practices, original utilities, and ideas that can enhance your productivity significantly. This content-packed talk includes working with WCF-provided test host and clients, instrumentation, tracing and logging, in-proc factory, operation overloading, data contract helpers, type-safe callback proxies, fault debugging techniques, turning Windows Forms into services for easy UI updates, and queued services setup helper classes. All the techniques presented are used in real-life projects.

• What Is the Context of This Conversation? Enabling Long Running Conversations in Workflow Services by Matthew Winkler

  The Microsoft .NET Framework 3.5 will introduce the functionality to call services from Windows Workflow Foundation (WF), and to expose workflows as a Windows Communication Foundation (WCF) service. A common pattern is to have a workflow serve as the coordinator between a number of other processes (including workflows). This talk discusses how these conversations are implemented in WF, and common patterns for conversing over a long period of time, including asynchronous messaging, long-running cancellable work, managing m-of-n responses and check pointing of progress.

• Interoperability Scenarios with Microsoft .NET and J2EE by Gregory Leake

  This session looks at the new .NET StockTrader, which provides bi- directional interoperability between .NET and J2EE using Web services, as well as using the Configuration Service with both .NET clients and hosts via Windows Communication Foundation to interoperate with Java application servers and Java-based clients and services in general. The session is based on fully published sample code, so you can immediately use information from the session in developing your own projects.

• Building Human Workflows with Windows Workflow Foundation State Machines by Keith Pijanowski

  State Machine workflows are workflows that transition from State to State where a state is a well know step, stage, or status of a business process. State Machines can also be passed data via external events. A workflow that measures its status via human readable states and can be passed data via external events is a good tool for building Human workflows. This session shows techniques for using State Machines as Human workflows. Specifically, we investigate persistence services for durability, tracking services for workflow reports, and tools for interacting with a state machine from a user interface.

• Building Secure Web Services Using Windows Communication Foundation by Vittorio Bertocci

  Securing messages between clients and services is essential to protecting data. The Windows Communication Foundation (WCF) provides a versatile and interoperable platform for exchanging secure messages based upon both the existing security infrastructure and the recognized security standards for SOAP messages. In this session learn how to use WCF for transfer security and access control using familiar technologies such as HTTPS, Windows integrated security, X.509 certificates, SAML, and usernames and passwords, and also new technologies such as Windows CardSpace. This session also discusses how to extend WCF security to support custom security tokens, custom authentication methods, claims-based authorization, claims transformation, and custom principals.

• Building RESTful Services Using Windows Communication Foundation 3.5 by Jon Flanders

  One of the key new features of Windows Communication Foundation 3.5 (WCF 3.5) is the Web Programming Model. The Web Programming Model enables developers to build Services using a RESTful architecture. The number of services implemented using this new architectural approach out in the wild is growing by leaps and bounds. In this session we cover the basics of REST versus SOAP/WS-*, and how to build Services using WCF 3.5 that are RESTful in nature. We also talk about adding Web feeds (RSS and/or ATOM) to our Services, which can enable easy access to enterprise data.

• Messaging, Identity, and Workflow in the Cloud by Justin Smith

  Software-plus-services is a major part of the Microsoft strategy for the future. Just as the Microsoft .NET Framework is foundational software that lets you build virtually all manner of applications, Microsoft also hosts a foundational set of services that simplify composite application development. These services allow you to connect applications, implement the publish/subscribe pattern, manage identity and access control across the Internet, and run workflows over services. This talk describes the Microsoft vision for the Internet Service Bus, how to use it via the Windows Communication Foundation (WCF) API, and how these kinds of capabilites impact application architecture going forward. Some knowledge of WCF is useful but not necessary.

• Introduction to the Microsoft Next Generation Server and Developer Framework for Claims-Based Identity and Access by Stuart Kwan

  Significant momentum is building around the industry vision of an Identity Metasystem. Come to this session to learn about the claims-based model for identity and access that lies at the core of this vision, the fundamental benefits it will bring to the next generation of connected applications, and preview the Microsoft server and framework product roadmap in support of this model. Topics include integration with Windows CardSpace and Information cards.

• What's New with Windows CardSpace in the Microsoft .NET Framework 3.5 by Scott Golightly

  Windows CardSpace provides users with a convenient way of authenticating themselves to applications. Windows CardSpace was developed in conjunction with others in the industry to ensure that it will work with more than just Microsoft Web sites. Windows CardSpace is the most visible piece of the larger Identity MetaSystem. In this session we discuss the Identity MetaSystem and how Windows CardSpace works to overcome many of the problems with authentication on the Internet today. We then look at the enhancements to Windows CardSpace and the API that were introduced in version 3.5 of the .NET Framework.

• Using Windows CardSpace for Safe and Convenient Sign-up and Sign-in to Your Web Application by Nigel Watling

  Windows CardSpace provides users with a simple, consistent, and secure way to authenticate to applications. Passwords are made redundant by taking advantage of public key cryptography and presenting the user with a set of Information Cards to represent their digital identity. These identities can be provided by the user and by third parties (e.g., banks, employers, government). CardSpace has privacy features, hardening against phishing, and support for multi-factor authentication (e.g., smart cards). By utilizing standard Web and Web service protocols, CardSpace can be used with any Web or Web service application, regardless of platform, with minimal effort from the developer. In this session learn how to modify a Web application to accept Information Card sign-up and sign-in.

• Microsoft and Mainframes, Taming the Beast, Empowering Developers, Solving Mysteries by Bash Badawi

  Do you work in a Mainframe environment? Are you intimidated by all the jargon? This session arms you with the knowledge you need to connect, speak, and execute with authority. From establishing a simple connection to DB2 and MQSeries, to complying with security and exposing CICS transactions, this session puts it all together to empower the Microsoft .NET/BizTalk Developer to speak and act with authority.

• Microsoft BizTalk RFID in Real World Deployments: Connecting Movements in the Physical World to Enterprise Applications by Sudhir Hasbe

  Every day more high-performing companies connect their internal departments, their support networks, and their demand and supply chains. Reducing the cost and complexity of supply chain management, Microsoft and its large ecosystem of hardware and software partners are working to enable mass adoption of RFID, SOA, and B2B solutions by developing feature-rich, low cost end-to-end RFID solutions. These solutions empower people to gain productivity and business efficiencies. This session showcases real-world deployments and shows how BizTalk RFID, which is part of BizTalk Server 2006 R2, can be used at edge of enterprise to capture physical world transactions and integrate these to existing enterprise applications using core EAI, B2B, and EDI capabilities of BizTalk Server 2006 R2. This session will showcase .NET based SDK of BizTalk RFID which enables Developers to build rich RFID enabled applications.

• Extending the Application Platform with Cloud Services by Tharun Tharian

  Software-plus-services provides new choices for deploying applications and infrastructure on-premise and online. Over the last year Microsoft has introduced an initial wave of software-plus-services applications (Microsoft Dynamics CRM and CRM Live) and infrastructure (Microsoft BizTalk Server and BizTalk Services). In this session we outline Microsoft plans to extend the Application Platform with cloud services.

• Technical Drilldown into Microsoft ESB Guidance by Brian Loesgen

  The Microsoft ESB Guidance uses Microsoft BizTalk Server 2006 R2 to support a loosely coupled messaging architecture, and extends the functionality of BizTalk Server to provide a range of new capabilities focused on building robust, connected, service-oriented applications that incorporate itinerary-based service invocation for lightweight service composition, dynamic resolution of endpoints and maps, Web service and WS-* integration, fault management and reporting, and integration with third- party SOA governance solutions. In this session, we drill down into the capabilities the ESB Guidance provides by stepping through typical use cases. We start by looking at the components that make up the ESB Guidance, including SOA governance integration. Then we show how these components are used to implement dynamic resolution of endpoints and transformations using the various resolvers provided. Lastly, we show how the resolution mechanism can be extended by the creation of custom resolvers.

• Integrating Business Applications with Windows Communication Foundation by Joseph Klug, Jesus Rodriguez

  Do you need to retrieve Siebel contacts from Microsoft Office SharePoint Server? Pull SAP order details into Microsoft SQL Server? Integrate Oracle eBusiness Suite with Microsoft .NET? There are many options for doing this, from disparate API layers offered by the business applications to Web services deployed on different platforms. Now you can access all these business applications on a single platform by using Windows Communication Foundation (WCF) and the BizTalk Adapter Pack. The adapters in the BizTalk Adapter Pack are all based on the WCF LOB Adapter SDK, giving them the look and feel of WCF Bindings. They can be hosted in BizTalk Server, SQL Server, SharePoint Server, and any other .NET-connected application. The first release of the BizTalk Adapter Pack included adapters to SAP, Siebel, and Oracle DB. The next release will add adapters to Oracle eBusiness Suite and SQL Database. In this session, learn about the main features of these five adapters, the different solutions these adapters are applicable to, and demos focusing on Oracle eBusiness Suite integration.

• Windows Communication Foundation Adapters in Microsoft BizTalk Server 2006 R2 by Aaron Skonnard

  This session introduces the new Windows Communication Foundation (WCF) integration found in BizTalk Server 2006 R2. See how R2 incorporates the WCF runtime into the BizTalk Server messaging layer through a suite of new WCF adapters that map to the built-in WCF bindings. We discuss how the WCF adapters work, along with when and how to use them. We also cover more advanced details related to message processing options, hosting, configuration, security, transactions, and service metadata. This session assumes you have basic experience with both WCF and BizTalk Server independently.

• Microsoft BizTalk in the Supply Chain: Providing Supply Chain Visibility with EDI and Business Activity Monitoring by Elizabeth Graham, Chris Kabat

  BizTalk Server 2006 R2 includes two new capabilities that really affect the distribution supply chain. First, it includes EDI capabilities which allow trading partners to talk to each other in a more efficient manner. Second, it includes the ability to gather and process RFID information. This presentation focuses on the new EDI/AS2 features of Microsoft BizTalk Server 2006 R2 using a real-world example. This example demonstrates how a combination of EDI and RFID can be used to track logistical errors or theft. In this example, we explore how trading partners are managed, how EDI messages are parsed, how (and why) EDI Batching is implemented, and how EDI status reporting data is stored. Using the real-world example, we show how the EDI process is developed, maintained, and monitored using BizTalk Server 2006 R2 out-of-box features. We then show how BAM can be used to extend this solution and provide dashboard-like information to the enterprise overall.

• Degrees of Freedom Port Binding in Microsoft BizTalk Server by Matt Milner

  In order to get the most out of your BizTalk implementations you need to understand your options when it comes to binding BizTalk orchestration ports. BizTalk offers many ways to bind ports for the purpose of receiving or sending messages. This session takes an in-depth look at the "degrees of freedom" a developer has when designing port binding strategies for BizTalk applications. Options range from: • Design-time static • Deployment-time static • Runtime dynamic • Runtime direct • Role-based dynamic Furthermore, the relationship that these binding techniques have with correlation and subscription is thoroughly investigated.

• Building Federated Solutions on the Internet Service Bus by Clemens Vasters

  Using the code-name "BizTalk Services," Microsoft is building a set of "cloud" technologies that are developed and operated by Microsoft as a logical extension to the .NET Framework and the Microsoft SOA technologies. They aim to enable corporate software developers and ISVs building solutions that require broad, cross-organizational identity management, the ability to safely and securely traverse NATs and Firewalls to enable bi- directional communication, Internet-scale publish/subscribe services, broad interoperability, and services orchestration. In short, these technologies are expanding the reach of the ESB pattern to the Internet—that's why we call it "Internet Service Bus." In this session, Clemens takes you along on a "lots of code" tour through an exemplary solution built using these technologies.

Messaging Additions in Orcas

I've had scattered posts in the past talking about the messaging features and enhancements in Orcas. Over the next few days I'm going to be doing a bit of consolidating to organize that information into a few listings of the top changes using reasonably sized chunks. Today I'll look at some of the new protocols and community-driven features that were added.

• Remote client address. We've added capture of the address of the remote endpoint for TCP and HTTP connections so that you can act on the client address in your service code.
• Custom password validator for HTTP. We've added support for attaching the existing UserNamePasswordValidator class that performs password-based authentication to the basic HTTP security system.
• WS Addressing 1.0 Metadata. While the base addressing protocol provides a transport-independent way of describing the address of a service, metadata provides additional descriptive capabilities through WSDL and policy to specify how addresses should be used.
• WS Policy 1.5. Policy is a description language for requirements and capabilities that is used to define a model for web service interaction.
• WS Reliable Messaging 1.1. Reliable messaging provides a protocol for reliably transmitting messages between a pair of endpoints despite system or network failures.

Next time: Messaging Additions in Orcas, Part 2

BizTalk R3 Announced

Steve Martin sent out the announcement yesterday that the BizTalk Server line of products would be getting an R3 update during the first half of 2009. BizTalk Server 2006 R3 moves the BizTalk platform to the Windows Server 2008, SQL Server 2008, and .NET Framework 3.5 wave of releases. In addition, there are feature enhancements planned for:

• Supporting UDDI 3.0
• Improved integration and hosting with service-oriented applications
• Connectivity with RFID and mobile devices
• Enhanced interoperability for business protocols such as EDI and SWIFT

You can read the original announcement by Steve on BizTalk Server 2006 R3 for more details.

Manual Context Management

How do I manually manage the context when sharing a client object?

The default mode when using a context binding is for the context to be managed internally by the context channel underneath the client proxy. This is similar to how by default cookies are managed by an HTTP channel to send and receive cookie context. With an HTTP channel you can disable automatic cookie management and control the context yourself. There is a similar process that you can use to take control for a context binding.

Here's a comparison of the two processes. You can get the code for HTTP by using the link above and with the further details on custom cookie handling so I won't print it again.

With HTTP, you first need to turn off automatic cookie handling by setting the AllowCookies property on the HTTP transport binding element to false.

With a context binding, you first need to turn off automatic context handling by setting the Enabled property on the context manager to false.

IContextManager contextManager = channel.GetProperty<IContextManager>();
contextManager.Enabled = false;

Then, for HTTP you attach an HttpRequestMessageProperty that contains the desired cookies to a message using an OperationContextScope.

With a context binding, you use the same OperationContextScope approach but attach the appropriate ContextMessageProperty instead.

using (new OperationContextScope(client.InnerChannel))
{
   ContextMessageProperty contextProperty = new ContextMessageProperty(contextData);
   OperationContext.Current.OutgoingMessageProperties[ContextMessageProperty.Name] = contextProperty;
   client.DoOperation();
}

Next time: Messaging Additions in Orcas

15 Years of Modern Web Browsing

On April 22, 1993 the initial version of the Mosaic web browser was released. Mosaic was the first web browser that had broad adoption as well as the first web browser that supported images embedded together with the marked up text.

Mosaic had been developed over a few months by the National Center for Supercomputing Applications and initially released for UNIX platforms. Releases for Windows and Macintosh happened by the end of the year. In the follow year Mosaic was commercialized by a company called Spyglass, and the people and technology involved variously ended up starting competing browser projects called Netscape Navigator and Microsoft Internet Explorer.