Sonu's Tech Log : Windows Communication Foundation

Understanding various WCF communication options

sonua — Thu, 31 Jan 2008 02:56:00 GMT

David Chappell has written an interesting paper outlining various messaging options available in the .NET Framework 3.5 including WCF channels, RESTful communication and BizTalk Services. There is also a section on WCF LOB Adapter SDK in this document...(read more)

SOA, SAAS, ESB, ISB, REST, WCF, BizTalk Services Channel 9 Video

sonua — Mon, 19 Nov 2007 06:30:00 GMT

Check out Steve Swartz, Clemens Vasters and David Chappell talk about above buzzwords in this Channel 9 video. It's a great video that covers a wide variety of topics related to services. See the video also to see what answers were provided when Charles...(read more)

WCF LOB Adapter SDK Performance Counters

sonua — Wed, 25 Jul 2007 05:00:00 GMT

WCF LOB Adapter SDK provides the following built-in performance counters to help gauge performance of the adapter. You can view these performance counters in Performance Management Console (perfmon.msc). Select the performance object named "ServiceModel...(read more)

WCF Transport Channel for WebSphere MQ by IBM

sonua — Sat, 21 Jul 2007 05:00:00 GMT

Do you want your .NET application to talk to WebSphere MQ Series? IBM has utilized the extensibility features of WCF and built a proof-of-concept Custom Channel for WebSphere MQ for Windows Communication Foundation . This proof-of-concept product enables...(read more)

Intermediary Router

sonua — Fri, 13 Jul 2007 05:00:00 GMT

I got queries for potential of using WCF LOB Adapter SDK for developing a "forwarding service" or a "router" adapter. WCF LOB Adapter SDK is useful for communicating with target systems that have large and dynamic metadata. Even though the adapter is...(read more)

Contract Generation from WSDL/XML Schema - DataContractSerializer vs. XmlSerializer

sonua — Sun, 17 Jun 2007 05:00:00 GMT

WCF LOB Adapter SDK metadata object model generates WSDL / XML Schema with constructs that are well-liked by DataContractSerializer . The Svcutil.Exe creates a proxy / service interface from this WSDL containing attributes such as ServiceContract, OperationContract,...(read more)

SOA (WCF, WF, BizTalk) related sessions at Tech.Ed 2007, Orlando

sonua — Sat, 19 May 2007 02:32:00 GMT

Microsoft Tech.ED 2007 is taking place in Orlando, Florida from June 4 to June 8, 2007. There are many exciting sessions being offered at the Tech.Ed. Here is a snapshot of some WCF related sessions that I personally find interesting in no particular...(read more)

Microsoft Visual Studio Code Name "Orcas" and .NET 3.5 Beta 1 Shipped

sonua — Mon, 23 Apr 2007 00:26:00 GMT

Microsoft released beta version of Microsoft Visual Studio 2005 Code Named "Orcas" and .NET 3.5 on April 19, 2007. Get started by downloading - "Orcas" Beta 1 Software (VPC image) "Orcas" Beta 1 Whitepaper "Orcas" Pre-Beta 1 CTP WCF & WF Samples You...(read more)

Setting Client Credentials

sonua — Sun, 22 Apr 2007 00:06:00 GMT

Scenario: The adapter needs the client credentials for establishing connection with the target system. How can a WCF client pass these credentials to the adapter? Remeber, the WCF-based adapter built using WCF LOB Adapter SDK is surfaced within a WCF...(read more)

How to use an Adapter built using WCF LOB Adapter SDK within a WCF Custom Binding?

sonua — Mon, 26 Mar 2007 19:14:00 GMT

Windows Communication Foundation (WCF) ships with a set of pre-defined bindings out of the box in order to satisfy most common scenarios. WCF also provides an ability to create user-defined custom bindings not provided by the system. This can be done in one of the following ways:

1) Create a new binding that derives from a built-in binding such as System.ServiceModel.BasicHttpBinding

2) Create a new binding that derives from System.ServiceModel.Channels.Binding

3) Create a Custom Binding (i.e. use System.ServiceModel.Channels.CustomBinding) and add binding elements to it

See "WCF Bindings in Depth" for more information.

WCF LOB Adapter SDK provides an AdapterBinding class that derives from System.ServiceModel.Binding containing a default profile to surface Adapter as a Standard Adapter Binding (Point #2).

The main objective of this document is to demonstrate how an adapter built using WCF LOB Adapter SDK can also be used within a user-defined Custom Binding (Point #3). Custom Binding is a container in which the user can fill-in various binding elements. These binding elements create the channels and listeners necessary to build incoming/outgoing channel stacks at runtime. Each binding element in the binding represents a processing step when sending or receiving messages. The order of the binding elements is important when creating a binding. A custom binding can be created either programmatically or in an application configuration file.

Contents

· Surfacing Standard Adapter Binding

· Surfacing Adapter as a Binding Element for use in Custom Binding

· Creating Custom Binding configuration using Microsoft Service Configuration Editor

· Using Adapter within a WCF Custom Binding in BizTalk WCF Adapter

· Creating “Custom Binding” programmatically in .NET

· Conclusion

Exposing Standard Adapter Binding

Today, the WCF LOB Adapter is surfaced as a binding and cannot be used within another Custom Binding. Before we talk about how to accomplish that, let’s see how the adapter is surfaced as a standard adapter binding.

The classes MyAdapterBindingCollectionElement, MyAdapterBindingElement and MyAdapterBinding are generated by Adapter Development Code Generation Wizard to provide a standard binding (“sample adapter profile”) to the adapter consumer. The class AdapterBindingCollectionElement is a WCF StandardBindingCollectionElement that links AdapterBinding with the WCF configuration system. The bulk of the implementation is delegated to AdapterBindingElement which derives from WCF System.ServiceModel.Channels.StandardBindingElement.

The AdapterBindingElement has properties that correspond to the properties on AdapterBinding. There are functions in AdapterBindingElement class that map the properties from and to Adapter Binding.

The standard binding AdapterBinding is registered in the WCF configuration as follows.

<system.serviceModel>

</bindingExtensions>

</extensions>

</system.serviceModel>

</configuration>

Once the binding is known to the WCF configuration system, it can be referenced from the serviceModel configuration section by the client endpoint.

<system.serviceModel>

<endpoint

address="hello://"

binding="helloWorldBinding"

bindingConfiguration="HelloWorldAdapterBinding"

contract="helloMicrosoftWCFSamplesAdapters"

name="myHelloConfig">

</endpoint>

</client>

</helloWorldBinding>

</bindings>

</system.serviceModel>

</configuration>

Well, so far we have only talked about how the default adapter binding is exposed to the configuration. Let’s get to the point now and show how it can be exposed as a binding element.

Surfacing Adapter as a Binding Element for use in a Custom Binding

In order to expose the Adapter as a binding element to the WCF configuration system, we need to create a new class that extends from BindingElementExtensionElement class. (Note Adapter Development Code Generation Wizard generates this class).

See attached a sample BindingElementExtensionElement derived class.

The base Adapter class in WCF LOB Adapter SDK derives from System.ServiceModel.Channels.TransportBindingElement. The sub-class of BindingElementExtensionElement creates the custom adapter in overridden CreateBindingElement() method. If adapter wants the end-user to supply custom properties on this binding element, these properties should be explicitly defined within this class. The InitializeFrom() and ApplyConfiguration() functions should map the properties from and to the adapter. If there are properties defined in AdapterBinding (AssuresOrderedDelivery, QueuedDelivery, Scheme, etc.) or Binding (Name, Namespace, CloseTimeout, SendTimeout, etc.) that need to be exposed in this binding element, each property needs to be defined within this new class.

Once this new class is added, recompile the DLL and add to GAC. The next step is to register this with configuration, so that CustomBinding implementations can reference our adapter as a binding element.

<system.serviceModel>

</bindingElementExtensions>

</extensions>

</system.serviceModel>

</configuration>

The extension can be referenced from custom bindings to use adapter with other binding elements, as shown below.

<system.serviceModel>

<endpoint

address="hello://"

binding="customBinding"

bindingConfiguration="HelloWorldAdapterBinding"

contract="helloMicrosoftWCFSamplesAdapters"

name="myHelloConfig">

</endpoint>

</client>

</binding>

</customBinding>

</bindings>

</system.serviceModel>

</configuration>

Creating Custom Binding configuration using Microsoft Service Configuration Editor

The user can also use the Microsoft Service Configuration Editor tool provided with Windows SDK to generate a configuration file. Once the <bindingElementExtension> is specified in the configuration, the tool recognizes it and allows adding this as a binding element during Custom Binding creation.

Using Adapter within a WCF Custom Binding in BizTalk WCF Adapter

Also, once the adapter is registered as a binding element extension. It can be used by the BizTalk WCF Adapter to configure a Static or Dynamic Port using Transport Type “WCF-Custom” and Binding Type “customBinding”. In WCF-Custom Transport Properties dialog, select Binding Type “customBinding” and right-click on CustomBindingElement and select “Add extension”. Selecting “Add extension” will show Select Binding Element Extension dialog, from where the adapter binding element extension can be selected.

Creating “Custom Binding” programmatically in .NET

The following code-snippet shows how a Custom Binding can be created programmatically and used in the context of channel programming (dealing with WCF request and response messages).

// Create custom binding

CustomBinding customBinding = new CustomBinding();

// Create privacy binding element

PrivacyNoticeBindingElement privacyNoticeElement = new PrivacyNoticeBindingElement();

// Create adapter binding element

HelloWorldAdapter adapter = new HelloWorldAdapter();

adapter.Count = 1;

// Add binding elements to the custom binding

customBinding.Elements.Add(privacyNoticeElement);

customBinding.Elements.Add(adapter);

// Enumerate through all the configured custom bindings

EnumerateConfiguredCustomBindings();

// Enumerate through all the available binding element extensions

EnumerateAllAvailableBindingElementExtensions();

// Create EndpointAddress

EndpointAddress address = new EndpointAddress("hello://");

// create channel factory using channel shape IRequestChannel

IChannelFactory<IRequestChannel> requestChannelFactory = customBinding.BuildChannelFactory<IRequestChannel>();

// open channel factory

requestChannelFactory.Open();

...

Conclusion

The Adapter built using WCF LOB Adapter SDK can be exposed to WCF client as both Transport Channel (registered in WCF configuration using System.ServiceModel.Configuration.BindingElementExtensionElement) and a Binding (registed in WCF configuration using System.ServiceModel.Configuration.StandardBindingElement).

The following code-snipped shows a WCF client proxy that uses the endpoint defined in app.config to communicate to a WCF service. The endpoint can use either the Standard Adapter Binding or the Custom Binding that includes one or more binding element extensions.

helloMicrosoftWCFSamplesAdaptersClient proxy = new helloMicrosoftWCFSamplesAdaptersClient("myHelloConfig");

Console.WriteLine(proxy.SayHelloWorld("Sonu"));

Here are two configurations side by side:

WCF Service Model using Standard Adapter Binding

WCF Service Model using Custom Binding

<system.serviceModel>

<endpoint

address="hello:/"

binding="helloWorldBinding"

bindingConfiguration="HelloWorldAdapterBinding"

contract="helloMicrosoftWCFSamplesAdapters"

name="myHelloConfig" />

</client>

<binding

name="HelloWorldAdapterBinding"

closeTimeout="00:01:00"

openTimeout="00:01:00"

receiveTimeout="00:10:00"

sendTimeout="00:01:00"

Count="4" />

</helloWorldBinding>

</bindings>

</system.serviceModel>

<system.serviceModel>

<endpoint

address="hello://"

binding="customBinding"

bindingConfiguration="CustomHelloWorldBinding"

contract="helloMicrosoftWCFSamplesAdapters"

name="myHelloConfig" />

</client>

<customBinding>

</binding>

</customBinding>

</bindings>

</system.serviceModel>

<system.serviceModel>

</bindingExtensions>

</extensions>

</system.serviceModel>

<system.serviceModel>

</bindingElementExtensions>

</extensions>

</system.serviceModel>

References

· Creating User-Defined Bindings

· Transport Extensibility Sample – UDP

About WCF LOB Adapter SDK (ASDK)

sonua — Mon, 26 Mar 2007 10:15:00 GMT

Many large enterprises have disparate systems including legacy mainframe, packaged and homegrown applications that need to be integrated with each other to provide end user solutions. The technology integration becomes more complex after companies go through Mergers and Acquisitions, which are prevalent in Financial and Telecom Industry verticals. Back-end systems such as SAP, PeopleSoft, Siebel, Oracle, IBM CICS, IMS, VSAM and Relational Databases are collectively known as Line-of-Business (LOB) applications. Adapters provides legacy modernization by bridging existing back-end applications with the modern interfaces. Windows Communication Foundation (WCF) provides a unified framework for building distributed applications, including creating adapters to existing applications.

The WCF Line-of-Business (LOB) Adapter SDK is a collection of runtime engine and tools to help Adapter Developers in creating service-oriented interfaces to existing LOB applications using WCF. The goal of the WCF LOB Adapter SDK is to facilitate uniform development of reusable metadata-oriented WCF-based adapters that enable enterprise applications, databases and messaging platforms to integrate with each other. The Adapter SDK is based on WCF Channel Model and it surfaces an adapter to a LOB application as a WCF Binding.

The Adapter Consumer can access an adapter like a typical WCF Service and doesn't have to learn a new programming model. The same adapter developed using the Adapter SDK can be reused in multiple .NET applications including Custom WCF Client Applications, BizTalk Server, SharePoint Server and SQL Server Integration Services (via adapter developer provided ADO.NET shim). In addition, this SDK provides a common facility for Adapter Developers to expose rich LOB metadata to the Adapter Consumers, who can selectively browse, search and retrieve WCF contracts from this available metadata in the adapter.

Architecture

WCF LOB Adapter SDK is based on WCF Channel Model and the adapter built using ASDK is technically a Transport Binding Element, representing a transport channel at the bottom of a WCF Channel Stack. A pre-defined binding is created for an adapter to complement the standard system-provided bindings including BasicHttpBinding, NetTcpBinding and NetNamedPipeBinding. This pre-defined binding can be customized to include other aspects of communication such as Protocols, Security, Reliability, Transanction Propagation and Interoperability. A WCF Custom Binding can also be written using the scratch to add custom Quality of Service (QoS) behaviors on top of the adapter.

The following diagram(s) shows how a WCF LOB Adapter fits within a WCF channel stack.

Outbound	Inbound

Goals

Here are three main goals of the WCF LOB Adapter SDK

1. Uniformity

o Includes API for adapter developers to build adapters in a consistent and repeatable manner

o Every “integration technology” implements its own adapter framework - with WCF LOB Adapter SDK there is just one

o Provides an abstraction layer between service oriented world and proprietary application interfaces

2. Reusability

o Provide building block application components

o Enable uniform interfaces across various integration technologies

o Surfaces adapter as a WCF binding, widening reach

3. Consumer-Driven Contract Generation

o Generate operations and business objects by introspecting target system

o Browse/Search and generate WCF contracts

o Service Contract reflects changes using live function and type model of the target system

WCF LOB Adapter SDK Features

Audience

Tools

Runtime

Adapter Developer

Adapter Development Wizard

· Adapter Development Code Generation Wizard

· Connection Pool Management

· Metadata Cache Management

Adapter Consumer

Metadata Explorer

· Add Adapter Service Reference Visual Studio Plug-In

· Consume Adapter Service BizTalk Project Add-In

Relationship with BizTalk Server

Microsoft BizTalk Server ships with BizTalk Adapter Framework which promotes creating custom adapters for use within BizTalk Server. BizTalk adapters use the BizTalk Server Administration Console for adapter management, BizTalk Explorer for adapter configuration, and the Adapter Framework for design-time APIs. WCF LOB Adapter SDK is the evolution of BizTalk Adapter Framework. Since WCF LOB Adapter SDK is based on new architecture, the adapters built to Adapter SDK will continue to co-exist side-by-side with the adapter written using BizTalk Adapter Framework. Microsoft and Microsoft’s Technology Partners have built adapters using BizTalk Adapter Framework. The future direction recommended by Microsoft is to start using WCF LOB Adapter SDK for building new adapters. The following diagrams show how the new adapters built using the Adapter SDK can co-exist with the adapters built using BizTalk adapter framework.

BizTalk Adapter Framework

WCF LOB Adapter SDK

Relationship with WCF

The base adapter class in WCF LOB Adapter SDK derives from WCF System.ServiceModel.Channels.TransportBindingElement and includes browse, search and resolve metadata interfaces for Adapter Consumer to selectively generate the ServiceDescription. The adapter created using this SDK is surfaced as a WCF binding and is technically a line-of-business system channel.

The following characteristics make adapter channels different from regular WCF transport channels:

• Adapters are metadata-centric

o Require metadata at run-time

o Require metadata cache management

o To provide design-time experience, they need to implement search/browse/resolve API

• Adapters are always connection-oriented

o Connection is very central concept for the adapter

o Require connection pooling and connection life-cycle management

• Adapters are effectively “in-proc WCF Services”

Even though an adapter is NOT a WCF Service, consuming an adapter is similar to using a WCF Service, due to metadata generation capabilities provided by the adapter. The adapter consumer is not required to learn a new programming model. The client can use either the WCF Service Model or WCF Channel Model to communicate with an adapter.

A typical WCF service programming lifecycle begins by a Service Provider defining a static service contract, implementing this contract and hosting the service. Each service is defined entirely by a fixed monolithic contract. This contract needs to be updated by the service provider in order to reflect any changes in the existing application. The Adapter built using WCF LOB Adapter SDK, on the other hand, surfaces the contracts on-demand by consumer. The consumer browses through the available metadata in the adapter using the standard interfaces and then selects the operations and types for inclusion in a dynamic contract. This metadata reflects live changes from the back-end application. Let's take an example of creating service-oriented interfaces for stored procedures in a database. If you were to use WCF service programming model, you can use the very intuitive declartive attributes (ServiceContractAttribute, OperationContractAttribute, etc.) to map each stored procedure as an operation in a WCF contract. But whenever there is a change in the stored procedure or a new stored procedure is added, the service developer has to make changes in the contract and re-host the service. With WCF LOB Adapter SDK on the other hand, the metadata resolver API in the adapter can be implemented to generate the WCF contract dynamically at design-time by querying the stored procedure input/output parameters. So, if there are 50 stored procedures, the adapter consumer can browse/search through these 50 service operations. He/she can then select the desired operations, pass these selected identifiers back to the adapter, so adapter can resolve the operation input and output for these operations and return back a WCF contract. This WCF contract can be then used as raw XML Schemas (in BizTalk Server 2006 R2) or as Common Language Runtime (CLR) proxy (in custom .NET applications).

Adapters are more appropriate in scenarios where a non-WCF based system is required for integration, and this system is dynamic with large amount of metadata.

WCF

Static Contracts

WCF LOB Adapter SDK

Contract Composition

Basic WCF Programming Lifecycle

Service Provider

1. Define the service contract

2. Implement the service contract

3. Configure service by specifiying endpoint information

4. Host the service

Basic Adapter Programming Lifecycle

Adapter Developer

1. Build an adapter and implement Metadata Browse, Search and Resolve interfaces

2. Register the adapter as a WCF Binding with the WCF configuration system

Service Consumer

1. Obtain a service contract, binding and address information for a service endpoint

2. Use Svcutil.Exe or "Add Service Reference Plug-In" to create a WCF client proxy using that information

3. Use the WCF client proxy in the client application

Adapter Consumer

1. Use Add Adapter Service Reference Visual Studio Plug-In/Consume Adapter Service BizTalk Project Add-In to search and browse the operations available in the adapter

2. Select one or more operations and generate a WCF contract

3. Use the generated contract implementation (proxy / XML Schemas / WSDL) in the client application