Copy the code associated with this chapter downloaded from http://www.cryptmaker.com/WindowsCommunicationFoundationUnleashed to the folder C:WCFHandsOn. The code is all in a folder called CustomChannels. The completed solution is the subfolder called CompletedSolution, and the starting point for the step-by-step instructions that follow is in the subfolder called StartingPoint.

Open the solution CustomChannels.sln in the StartingPoint subfolder. It consists of four projects. The Service project is for building a simple Windows Communication Foundation service. The ServiceHost project is for building a console application for hosting that service. The Client project is for building a console application that is a client of the service. The project called MyCustomBindingElement is a blank class library project to which the classes required for the custom binding element will be added.

Examine the service contract in the ISimple.cs file of the Service project. It has a single operation that anticipates a reply in response to a request:

[ServiceContract]
public interface ISimple
{
    [OperationContract]
    string AcceptRequest(string someRequest);
}

Study the code for the client application in the Program.cs file of the Client project. The application constructs a Windows Communication Foundation client using a custom binding consisting solely of an instance of one of the predefined transport binding elements, System.ServiceModel.Channels.HttpTransportBindingElement. The application then calls the client’s Open() method, and pauses for input. Then the application proceeds to use the client to send two messages to the service before calling the client’s Close() method.

public class Program
{
  static void Main(string[] args)
  {
    Console.WriteLine("Press any key when the service is ready.");
    Console.ReadKey(true);
    Client client = new Client(
      new CustomBinding(
        new BindingElement[]{new HttpTransportBindingElement()}),
      new EndpointAddress(
        "http://localhost:8000/SimpleService/Endpoint"));
    client.Open();
    Console.WriteLine("The client is open: press any key to continue.");
    Console.ReadKey(true);
    Console.WriteLine(client.AcceptRequest("Hello, World!"));
    Console.WriteLine(client.AcceptRequest("Hello, World!"));
    client.Close();
    Console.WriteLine("Done.");
    Console.ReadKey(true);
   }
}

Choose Debug, Start Debugging from Visual Studio 2005’s menus.

When the console of the ServiceHost application confirms that the service is ready, enter a keystroke into the console of the client application.

When the console of the client application confirms that the Windows Communication Foundation client is open, enter a keystroke into the console of the client application. The output in both consoles should confirm that the service received both messages from the client and responded to each of them.

Enter a keystroke into both consoles to close the applications.

Add a class called MyCustomBindingElement.cs to the MyCustomBindingElement project.

Modify the contents of the class to look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;

namespace Extensibility
{
    public class MyCustomBindingElement: BindingElement
    {
    }
}

By deriving from System.ServiceModel.Channels.BindingElement, the class signifies that it is in fact a binding element.

Add a default constructor and a copy constructor:

public MyCustomBindingElement()
{
    Console.WriteLine("Constructing binding element.");
}

public MyCustomBindingElement(MyCustomBindingElement original)
{
    Console.WriteLine("Copying binding element.");
}

Implement the abstract Clone() method using the copy constructor. That method allows the Windows Communication Foundation to make deep copies of the binding element:

public override BindingElement Clone()
{
    Console.WriteLine("Cloning binding element.");
    return new MyCustomBindingElement(this);
}

Implement the abstract, generic GetProperty<T>() method by which the Windows Communication Foundation can query the stack of binding elements for the values of properties:

public override T GetProperty<T>(BindingContext context)
{
    return context.GetInnerProperty<T>();
}

Provide an override for the key CanBuildChannelFactory<T>() method, the significance of which was explained earlier in this chapter:

public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
{
    Console.WriteLine(
"Querying if the binding element can build a channel factory of type {0}.",
                typeof(TChannel).Name);

    if (typeof(TChannel) == typeof(IRequestChannel))
    {
        return context.CanBuildInnerChannelFactory<TChannel>();
    }
    else
    {
        return false;
    }
}

Add a class called MyCustomChannelFactory.cs to the MyCustomBindingElement project.

Modify the contents of that class to look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;

namespace Extensibility
{
    class MyCustomChannelFactory<TChannel> :
                ChannelFactoryBase<IRequestChannel>
    {
    }
}

By deriving from System.ServiceModel.Channels.ChannelFactoryBase<IRequestChannel>, the class signifies that it is in fact a channel factory, and that it can provide channels with the shape defined by the System.ServiceModel.Channels.IRequestChannel interface.

Recall that a channel factory is responsible for having the next binding element after its own create another channel factory—the next channel factory in the stack of channel factories that the binding elements construct. Recall, as well, that when a channel factory creates a channel, it has the next channel factory in the stack create a channel that it then provides to its own channel, so that its own channel can pass messages through to a subordinate channel. So, a channel factory has need of a reference to the next channel factory in the stack. Add a member by which to maintain that reference:

class MyCustomChannelFactory<TChannel>:
        ChannelFactoryBase<IRequestChannel>
{
    IChannelFactory<TChannel> innerChannelFactory = null;
}

Add a constructor that has the next channel factory in the stack constructed as well, and that stores the reference to that next channel factory in the member that was added in the previous step:

public MyCustomChannelFactory(
        MyCustomBindingElement bindingElement,
        BindingContext context)
    : base(context.Binding)
{
    Console.WriteLine("Constructing the channel factory.");
    this.innerChannelFactory =
                context.BuildInnerChannelFactory<TChannel>();
    if (this.innerChannelFactory == null)
    {
        throw new InvalidOperationException(
        "MyCustomChannelFactory requires an inner IChannelFactory.");
    }
}

Right-click on the term ChannelFactoryBase<IRequestChannel> in the declaration of the class, and choose Implement Abstract Class from the context menu. Visual Studio will create stubs for the OnCreateChannel(), OnBeginOpen(), OnEndOpen(), and OnOpen() methods.

Modify the implementation of the OnOpen() method so that when the Windows Communication Foundation tells the channel factory that the host application has called the Open() method of the Windows Communication Foundation client in preparation for outbound communication, the channel factory passes that information on to the next channel factory:

protected override void OnOpen(TimeSpan timeout)
{
        Console.WriteLine("Channel factory OnOpen() method.");
        this.innerChannelFactory.Open(timeout);
}

Add a class called MyCustomRequestChannel.cs to the solution, and modify the contents to look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;

namespace Extensibility
{
    class MyCustomRequestChannel: IRequestChannel
    {
    }
}

By implementing the System.ServiceModel.Channels.IRequestChannel interface, the class signifies that it is a channel with the shape defined by that interface.

As a channel, it is responsible for passing instructions and messages along to the channel beneath itself in a stack of channels. Define a member for maintaining a reference to that next channel:

class MyCustomRequestChannel: IRequestChannel
{
        private IRequestChannel innerChannel = null;
}

Provide a constructor by which the channel will accept a reference to the channel beneath itself from the channel factory, and store that in the member defined in the previous step. Also have the constructor monitor events of the subordinate channel so as to be notified of changes in that channel’s state:

public MyCustomRequestChannel(IRequestChannel innerChannel)
{
        Console.WriteLine("Constructing request channel.");
        this.innerChannel = innerChannel;

        this.innerChannel.Closed += new EventHandler(innerChannel_Closed);
}

Add the handler for the subordinate channel’s Closed event, referred to in the constructor. Have that handler signify that because the subordinate channel is finished closing, the current channel can be considered to have closed as well.

protected void innerChannel_Closed(object sender, EventArgs e)
{
    Console.WriteLine("Inner request channel closed.");
    if (this.Closed != null)
    {
        this.Closed(this, e);
    }
}

Right-click on the term IRequestChannel in the declaration of the class and choose Implement Interface, Implement Interface from the context menu to create stubs for the methods of the System.ServiceModel.Channels.IRequestChannel interface.

Replace the stub for the State property defined by the System.ServiceModel.Channels.ICommunicationObject interface from which the System.ServiceModel.Channels.IRequestChannel interface ultimately derives. That interface defines the Windows Communication Foundation communication state machine, and its State property is for retrieving the current state of such a state machine.

public CommunicationState State
{
    get
    {
        Console.WriteLine("Retrieving request channel state.");
        return this.innerChannel.State;
    }
}

Replace the stub for the Open() method of the System.ServiceModel.Channels.ICommunicationObject interface, by which a Windows Communication Foundation communication state machine can be instructed to transition into the Opened state. Recall that a channel like the one being programmed here is responsible for passing on state transition instructions from the Windows Communication Foundation to subordinate channels.

public void Open(TimeSpan timeout)
{
    Console.WriteLine("Request channel Open");
    this.innerChannel.Open(timeout);
}

Replace the stub for the Close() method of the System.ServiceModel.Channels.ICommunicationObject interface, by which a Windows Communication Foundation communication state machine can be instructed to transition into the Closed state.

public void Close(TimeSpan timeout)
{
    Console.WriteLine("Request channel Close");
    this.innerChannel.Close(timeout);
}

Replace the stub for the Request() method of the System.ServiceModel.Channels.IRequestChannel interface. It is by implementing this method that the channel will be able to serve its function of implementing some communication protocol. The method is passed an outbound message as a parameter and is able to transform the message as the protocol dictates.

public Message Request(Message message, TimeSpan timeout)
{
    Console.WriteLine("Request channel request.");
    Console.WriteLine("This is where I can implement my protocol.");
    return this.innerChannel.Request(message,timeout);
}

Now that the coding of the channel has been finished, the channel factory can be completed by having it construct an instance of the channel on cue. The channel factory must have the next channel factory in the stack create a channel that can then be passed to its own channel as the subordinate channel to which messages and instructions must be passed on. Replace the stub for the OnCreateChannel() method of the Extensibility.MyCustomChannelFactory class in the MyCustomChannelFactory.cs file:

protected override IRequestChannel OnCreateChannel(
        EndpointAddress address,
        Uri via)
{
    Console.WriteLine("Channel factory OnCreateChannel event.");
    IRequestChannel innerChannel =
                (IRequestChannel)this.innerChannelFactory.CreateChannel(
                        address,
                        via);
    return new MyCustomRequestChannel(innerChannel);
}

With the channel factory finished, the binding element can be completed by providing an override of the important BuildChannelFactory<T>() method. That is the method by which it will be able to respond to an instruction to create the channel factory that will provide channels to participate in outbound communications. So, add this override to the Extensibility.MyCustomBindingElement class in the MyCustomBindingElement.cs file:

public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(
        BindingContext context)
{
    Console.WriteLine(
"Asking the binding element for a channel factory of type {0}.",
                typeof(TChannel).Name);
    return (IChannelFactory<TChannel>)
                (object)new MyCustomChannelFactory<TChannel>(
                        this,context);
}

The binding element is now fully capable of supporting outbound communications. Choose Build, Build Solution from the Visual Studio 2005 menus to confirm that there are no errors in the code.

Now proceed to edit the client application to use the binding element. Specifically, edit the statement in the Program.cs file of the Client project by which the Windows Communication Foundation client is created. Have that statement add an instance of the binding element into the list of binding elements by which the binding is defined:

Client client = new Client(
    new CustomBinding(
        new BindingElement[] {
            new MyCustomBindingElement(),
            new HttpTransportBindingElement() }),
            new EndpointAddress(
            "http://localhost:8000/SimpleService/Endpoint"));

Choose Debug, Start Debugging from Visual Studio 2005’s menus.

When the console of the ServiceHost application confirms that the service is ready, enter a keystroke into the console of the client application.

When the console of the client application confirms that the Windows Communication Foundation client is open, enter a keystroke into the console of the client application. The output in both consoles should show that the service received both messages from the client and responded to each of them. Examine the output in the client application console to confirm that, this time, each message from the client passed through the Request() method of the custom channel Extensibility.MyCustomRequestChannel. That method will have output this statement to the client application’s console, confirming that it has the opportunity to transform the outbound message in accordance with some protocol:

This is where I can implement my protocol.

Enter a keystroke into both consoles to close the applications.

Start by adding this override to the binding element defined in the MyCustomBindingElement.cs file of the MyCustomBindingElement project. The override has the binding element assert that it is capable of constructing channel listeners that can provide channels that conform to the shape defined by the System.ServiceModel.Channels.IReplyChannel interface.

public override bool CanBuildChannelListener<TChannel>(
        BindingContext context)
{
    Console.WriteLine(
 "Querying if the binding element can build a listener of type {0}.",
                typeof(TChannel).Name);

    if (typeof(TChannel) == typeof(IReplyChannel))
    {
        return context.CanBuildInnerChannelListener<TChannel>();
    }
    else
    {
        return false;
    }
}

For that assertion to be valid, it will be necessary to program the channel listener. Add a class called MyChannelListener.cs to the MyCustomBindingElement project and modify the contents to look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel.Channels;
using System.Text;

namespace Extensibility
{
    class MyCustomChannelListener<TChannel> :
        ChannelListenerBase<IReplyChannel>
            where TChannel : class, IChannel
    {
    }
}

By deriving from System.ServiceModel.Channels.ChannelListenerBase<IReplyChannel>, the class declares that it is in fact a channel listener and that it provides channels that conform to the shape defined by the System.ServiceModel.Channels.IReplyChannel interface.

Give the channel listener a member by which it can maintain a reference to the next channel listener in the stack:

class MyCustomChannelListener<TChannel> :
    ChannelListenerBase<IReplyChannel>
        where TChannel : class, IChannel
{
        IChannelListener<TChannel> innerChannelListener = null;
}

Provide a constructor by which the channel listener can obtain a reference to the next channel listener from the binding element that follows its own:

public MyCustomChannelListener(
        MyCustomBindingElement bindingElement,
        BindingContext context)
    : base(context.Binding)
{
    Console.WriteLine("Constructing the channel listener.");
    this.innerChannelListener =
                context.BuildInnerChannelListener<TChannel>();
    if (this.innerChannelListener == null)
    {
        throw new InvalidOperationException(
           "MyCustomChannelListener requires an inner IChannelFactory.");
    }
}

Right-click on the term ChannelListenerBase<IReplyChannel> in the declaration of the class, and choose Implement Abstract Class from the context menu that appears. Visual Studio 2005 will create stubs for a number of abstract methods of the base class.

Replace the stub for the OnOpen() method with this implementation by which the channel listener passes on notification that the host application has transitioned into the Opened state that is defined by the Windows Communication Foundation communication state machine:

protected override void OnOpen(TimeSpan timeout)
{
    Console.WriteLine("Channel listener OnOpen.");
    this.innerChannelListener.Open(timeout);
}

Replace the stub for the OnClose() method with an implementation that does the same for notifications of transitions into the Closed state:

protected override void OnClose(TimeSpan timeout)
{
    Console.WriteLine("Channel listener OnClose.");
    this.innerChannelListener.Close(timeout);
}

Replace the stub for the Uri property with this implementation by which the Windows Communication Foundation can retrieve the URI on which the stack of listeners is listening for incoming messages:

public override Uri Uri
{
    get
    {
        Console.WriteLine("Retrieving channel listener URI.");
        return this.innerChannelListener.Uri;
    }
}

The remainder of the work to be done in programming the channel listener is to override the methods by which it provides inbound communication channels: OnBeginAcceptChannel() and OnEndAcceptChannel(). However, before those methods can be implemented, it will be necessary to define the channel itself. Begin that task now by adding a class called MyCustomReplyChannel.cs to the MyCustomBindingElement project.

Modify the contents of that class to look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;

namespace Extensibility
{
    class MyCustomReplyChannel : IReplyChannel
    {
    }
}

By implementing the System.ServiceModel.IReplyChannel interface, the channel declares that it is a channel with the shape defined by that interface.

Add a member by which the channel can maintain a reference to the next channel in the channel stack:

class MyCustomReplyChannel : IReplyChannel
{
        private IReplyChannel innerChannel = null;
}

Add a constructor by which the channel accepts a reference to the next channel in the channel stack from the channel listener and stores that reference. Also have the constructor monitor the subordinate channel’s state changes to detect that channel transitioning into the Closed state.

public MyCustomReplyChannel(IReplyChannel innerChannel)
{
    Console.WriteLine("Constructing reply channel.");
    this.innerChannel = innerChannel;
    this.innerChannel.Closed += new EventHandler(innerChannel_Closed);
}

protected void innerChannel_Closed(object sender, EventArgs e)
{
    Console.WriteLine("Inner reply channel closed.");
    if (this.Closed != null)
    {
        this.Closed(this, e);
    }
}

Right-click on the term IReplyChannel, in the declaration of the class, and choose Implement Interface, Implement Interface from the context menu that appears. Visual Studio 2005 will create stubs for the methods defined by the System.ServiceModel.Channels.IReplyChannel interface.

Replace the stub for the System.ServiceModel.Channels.ICommunicationObject’s State property with this implementation that reports the state of the channel’s state machine to be whatever state its subordinate channel is in:

public CommunicationState State
{
    get
    {
        Console.WriteLine("Retrieving reply channel state.");
        return this.innerChannel.State;
    }
}

Replace the stub for the Open() method of the System.ServiceModel.Channels.ICommunicationObject with this implementation that passes on the instruction to transition to the Opened state to the next channel in the stack:

public void Open()
{
    Console.WriteLine("Reply channel Open");
    this.innerChannel.Open();
}

Do the same for the instruction to transition to the Closed state passed on by the Close() method the System.ServiceModel.Channels.ICommuncationObject interface:

public void Close(TimeSpan timeout)
{
    Console.WriteLine("Reply channel Close.");
    this.innerChannel.Close(timeout);
}

Replace the stubs for the important BeginTryReceiveRequest() and EndTryReceiveRequest() methods defined by the System.ServiceModel.Channels.IReplyChannel interface. The BeginTryReceiveRequest() method is the asynchronous method by which the channel will wait on an inbound message to be passed on by its subordinate channel. That EndTryReceiveRequest() method will execute when that happens, providing the channel with the opportunity to apply whatever protocol it implements to the inbound message. That message is available via the RequestMessage property of the context parameter.

public IAsyncResult BeginTryReceiveRequest(
        TimeSpan timeout,
        AsyncCallback callback,
        object state)
{
    Console.WriteLine("Reply channel BeginTryReceiveRequest.");
    return this.innerChannel.BeginTryReceiveRequest(
                timeout,
                callback,
                state);
}

public bool EndTryReceiveRequest(
        IAsyncResult result,
        out RequestContext context)
{
    Console.WriteLine("Reply channel EndTryReceiveRequest.");

    bool outcome = this.innerChannel.EndTryReceiveRequest(
                result,
                out context);

    Console.WriteLine(
"This is where I can apply my protocol to the inbound message.");
    return outcome;
}

Now that the coding of the channel has been finished, the channel listener can be completed by programming the methods by which it will provide the channel. In the MyChannelListener.cs file of the MyCustomBindingElement project, replace the stubs for OnBeginAcceptChannel() and OnEndAcceptChannel() with these implementations. The channel listener retrieves a channel from the next listener in the stack, which is then passed to the listener’s own channel as the subordinate channel, the channel to which it is responsible for passing on instructions and from which it will receive incoming messages:

protected override IAsyncResult OnBeginAcceptChannel(
        TimeSpan timeout,
        AsyncCallback callback,
        object state)
{
    Console.WriteLine("Channel listener BeginAcceptChannel.");
    return this.innerChannelListener.BeginAcceptChannel(
                timeout,
                callback,

                state);
}

protected override IReplyChannel OnEndAcceptChannel(
        IAsyncResult result)
{
    Console.WriteLine("Channel listener EndAcceptChannel.");
    IReplyChannel replyChannel =
                ((IReplyChannel)this.innerChannelListener.EndAcceptChannel(
                        result));

    if (replyChannel == null)
    {
        return null;
    }
    return new MyCustomReplyChannel(replyChannel);
}

The channel listener is now complete, which allows one to add the method to the binding element by which it will create instances of the channel listener. Go to the MyCustomBindingElement.cs file of the MyCustomBindingElement project, and provide this override of the BuildChannelListener<T>() method:

public override IChannelListener<TChannel> BuildChannelListener<TChannel>(
        BindingContext context)
{
    Console.WriteLine(
                "Asking the binding element for a listener of type {0}.",
                        typeof(TChannel).Name);
    return (IChannelListener<TChannel>)
                (object)new MyCustomChannelListener<TChannel>(this, context);
}

Choose Build, Build Solution from the Visual Studio 2005 menus to ensure that no syntactical errors have been made.

Examine the current configuration of the service in the App.config file of the ServiceHost project of the CustomChannels solution. It is reproduced in Listing 14.1. The configuration defines a custom binding that has the arbitrary name, MyCustomBinding. That binding has a single binding element, System.ServiceModel.Channel.HttpTransportBindingElement, which is referred to by the element httpTransport in the configuration.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <services>
            <service name="Extensibility.Service">
                      <host>
                              <baseAddresses>
                                      <add

baseAddress="http://localhost:8000/SimpleService"/>
                              </baseAddresses>
                      </host>
                <endpoint address="Endpoint"
                    binding="customBinding"
                                       bindingConfiguration="MyCustomBinding"
                                       contract="Extensibility.ISimple" />
            </service>
        </services>
                <bindings>
                        <customBinding>
                                <binding name="MyCustomBinding">
                                        <httpTransport/>
                                </binding>
                        </customBinding>
                </bindings>
    </system.serviceModel>
</configuration>

Add a class called MyBindingExtensionElement.cs to the MyCustomBindingElement project.

Modify its contents to look like this:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.Text;

namespace Extensibility
{
    public class MyBindingElementExtension : BindingElementExtensionElement
    {
        public override Type BindingElementType
        {
            get
            {
                 return typeof(MyCustomBindingElement);
            }
        }

        protected override BindingElement CreateBindingElement()
        {
            return new MyCustomBindingElement();
        }
    }
}

Having the class derive from System.ServiceModel.Configuration.BindingElementExtensionElement signifies that it is a class that can be referred to by a custom configuration element in a Windows Communication Foundation configuration, a custom configuration element that can be used to signify a binding element. The class overrides the CreateBindingElement() method. When the Windows Communication Foundation parses the configuration and finds the custom configuration element, it will invoke that method to retrieve an instance of the binding element to which the custom configuration element is meant to refer.

Now modify the App.config file of the ServiceHost project so that it looks like the configuration shown in Listing 14.2. That configuration uses a bindingElementExtension element to define a new configuration element with the arbitrary name myElement. That new configuration element is associated with the System.ServiceModel.Configuration.BindingElementExtensionElement defined in the previous step, and it is used in the new definition of the service’s binding to include the custom binding in the list of binding elements.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
        <system.serviceModel>
                <services>
                        <service name="Extensibility.Service">
                                <host>
                                        <baseAddresses>
                                                <add

baseAddress="http://localhost:8000/SimpleService"/>
                                        </baseAddresses>
                                </host>
                                <endpoint address="Endpoint"
                    binding="customBinding"
                                       bindingConfiguration="MyCustomBinding"
                                       contract="Extensibility.ISimple" />
                        </service>
                </services>
                <bindings>
                        <customBinding>
                                <binding name="MyCustomBinding">
                                        <myElement/>
                                        <httpTransport/>
                                </binding>
                        </customBinding>
                </bindings>
                <extensions>
                        <bindingElementExtensions>
                                <add name="myElement"
type="Extensibility.MyBindingElementExtension, MyCustomBindingElement"/>
                        </bindingElementExtensions>
                </extensions>
        </system.serviceModel>
</configuration>

Now modify the App.config file of the ServiceHost project so that it looks like the configuration shown in Listing 14.2. That configuration uses a bindingElementExtension element to define a new configuration element with the arbitrary name myElement. That new configuration element is associated with the System.ServiceModel.Configuration.BindingElementExtensionElement defined in the previous step, and it is used in the new definition of the service’s binding to include the custom binding in the list of binding elements.

Choose Debug, Start Debugging from Visual Studio 2005’s menus.

When the console of the ServiceHost application confirms that the service is ready, enter a keystroke into the console of the client application.

When the console of the client application confirms that the Windows Communication Foundation client is open, enter a keystroke into the console of the client application. The output in both consoles should show that the service received both messages from the client and responded to each of them. Examine the output in the service host application console to confirm that, this time, each message from the client passed through the EndTryReceiveRequest() method of the custom channel, Extensibility.MyCustomReplyChannel. That method will have output this statement to the client application’s console, confirming that it has the opportunity to transform the inbound message in accordance with some protocol:

This is where I can apply my protocol to the inbound message.

Also notice that directly after that statement, and before the incoming message is actually passed to the instance of the service type, the Windows Communication Foundation has the channel go back to listening for further incoming messages.

Enter a keystroke into both consoles to close the applications.