[DataContract]
public partial class Address
{
    [DataMember("Company")]
    private string company;
    [DataMember("RecipientName")]
    private string recipientName;
    [DataMember("AddressLine1")]
    private string addressLine1;

    ... more fields ...

    public string Company
    {
        get { return company; }
        set { company = value; }
    }
   
    public string RecipientName
    {
        get { return recipientName; }
        set { recipientName = value; }
    }
   
    public string AddressLine1
    {
        get { return addressLine1; }
        set { addressLine1 = value; }
    }

    ... more properties and methods and stuff ...
}

[DataContract]
public partial class Address
{
    private string company;
    private string recipientName;
    private string addressLine1;

    ... more fields ...

    [DataMember("Company")]
    public string Company
    {
        get { return company; }
        set { company = value; }
    }

    [DataMember("RecipientName")]
    public string RecipientName
    {
        get { return recipientName; }
        set { recipientName = value; }
    }
    [DataMember("AddressLine1")]
    public string AddressLine1
    {
        get { return addressLine1; }
        set { addressLine1 = value; }
    }

    ... more properties and methods and stuff ...
}

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Serialization;

namespace DuplexMessagingConversation
{
    [XmlRoot(Namespace = PurchaseProcessHeader.NamespaceURI)]
    [XmlType(Namespace = PurchaseProcessHeader.NamespaceURI)]
    public class PurchaseProcessHeader
    {
        public const string NamespaceURI="urn:newtelligence-com:indigosamples:purchasing";
        public const string ElementName="PurchaseOrder";

        private string orderIdentifier;
       
        public string OrderIdentifier
        {
            get { return orderIdentifier; }
            set { orderIdentifier = value; }
        }
    }

    [ServiceContract(Namespace = "urn:newtelligence-com:indigosamples:seller",
                     Session = false,
                     CallbackContract = typeof(IBuyer),
                     FormatMode = ContractFormatMode.XmlSerializer)]
    interface ISeller
    {
        [OperationContract(IsOneWay=true,IsInitiating=true,
                           Style=ServiceOperationStyle.DocumentBare)]
        void HandlePurchaseOrder(
            [MessageHeader(Name=PurchaseProcessHeader.ElementName,
                           Namespace=PurchaseProcessHeader.NamespaceURI)]
            PurchaseProcessHeader process,
            [MessageBody(Name="PurchaseOrderMessage")]
            XmlNode purchaseOrder);

        [OperationContract(IsOneWay = true, IsInitiating = false,
                           Style = ServiceOperationStyle.DocumentBare)]
        void HandlePaymentNotification(
            [MessageHeader(Name = PurchaseProcessHeader.ElementName,
                           Namespace = PurchaseProcessHeader.NamespaceURI)]
               PurchaseProcessHeader process,
            [MessageBody(Name = "PaymentNotificationMessage")]
               XmlNode paymentNotification);

        [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true,
                           Style = ServiceOperationStyle.DocumentBare)]
        void HandleShippingConfirmation(
            [MessageHeader(Name = PurchaseProcessHeader.ElementName,
                           Namespace = PurchaseProcessHeader.NamespaceURI)]
            PurchaseProcessHeader process,
            [MessageBody(Name = "ShippingConfirmationMessage")]
            XmlNode shippingConfirmation);
    }

    [ServiceContract(Namespace="urn:newtelligence-com:indigosamples:buyer",
                     Session = false,
                     CallbackContract = typeof(ISeller),
                     FormatMode=ContractFormatMode.XmlSerializer)]
    interface IBuyer
    {
        [OperationContract(IsOneWay = true, IsInitiating = true,
                           Style = ServiceOperationStyle.DocumentBare)]
        void HandlePurchaseOrderConfirmation(
            [MessageHeader(Name = PurchaseProcessHeader.ElementName,
                           Namespace = PurchaseProcessHeader.NamespaceURI)]
            PurchaseProcessHeader process,
            [MessageBody(Name = "PurchaseOrderConfirmationMessage")]
            XmlNode purchaseOrderConfirmation);

        [OperationContract(IsOneWay = true, IsInitiating = false,
                           Style = ServiceOperationStyle.DocumentBare)]
        void HandleInvoice(
            [MessageHeader(Name = PurchaseProcessHeader.ElementName,
                           Namespace = PurchaseProcessHeader.NamespaceURI)]
            PurchaseProcessHeader process,
            [MessageBody(Name = "InvoiceMessage")]
            XmlNode invoice);

        [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true,
                           Style = ServiceOperationStyle.DocumentBare)]
        void HandleShippingNotification(
            [MessageHeader(Name = PurchaseProcessHeader.ElementName,
                           Namespace = PurchaseProcessHeader.NamespaceURI)]
            PurchaseProcessHeader process,
            [MessageBody(Name = "ShippingNotificationMessage")]
            XmlNode shippingNotification);
    }
}

<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"
            xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing"
            xmlns:r="http://schemas.xmlsoap.org/ws/2005/01/rm">
    <s:Header>
        <a:Action s:mustUnderstand="1">
            urn:newtelligence-com:indigosamples:seller/ISeller/HandlePurchaseOrder
        </a:Action>
        <h:PurchaseOrder xmlns="urn:newtelligence-com:indigosamples:purchasing"
                         xmlns:h="urn:newtelligence-com:indigosamples:purchasing"
                         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                         xmlns:xsd="http://www.w3.org/2001/XMLSchema">
            <OrderIdentifier>1234567890</OrderIdentifier>
        </h:PurchaseOrder>
        <r:Sequence s:mustUnderstand="1">
            <r:Identifier>uuid:b99041bf-fab8-45dd-9235-0909d9c61d04;id=2</r:Identifier>
            <r:MessageNumber>1</r:MessageNumber>
        </r:Sequence>
        <a:From>
            <a:Address>net.tcp://localhost/buyer/reply/e01289a8-424f-4e1a-bba5-b3fb7c92a023</a:Address>
        </a:From>
        <a:To s:mustUnderstand="1">net.tcp://localhost/seller</a:To>
    </s:Header>
    <s:Body>
        <PurchaseOrderMessage xmlns="urn:newtelligence-com:indigosamples:seller">
            <Order xmlns="">...</Order>
        </PurchaseOrderMessage>
    </s:Body>
</s:Envelope>

using System;
using System.Xml;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace DuplexMessagingConversation
{
    [ServiceBehavior(InstanceMode = InstanceMode.PrivateSession)]
    class SellerService : ISeller
    {
        Guid instanceId = Guid.NewGuid();

        public void HandlePurchaseOrder(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Seller: Purchase Order Received\n\t{0}\n\tInstance {1}",
                              data.OuterXml, instanceId);
            IBuyer buyer = OperationContext.Current.GetCallbackChannel<IBuyer>();

            XmlDocument orderConfirmation = new XmlDocument();
            orderConfirmation.LoadXml("<OrderConfirmation>...</OrderConfirmation>");
            buyer.HandlePurchaseOrderConfirmation(process, orderConfirmation);

            XmlDocument invoice = new XmlDocument();
            invoice.LoadXml("<Invoice>...</Invoice>");
            buyer.HandleInvoice(process, invoice);
        }

        public void HandlePaymentNotification(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Seller: Payment Notification Received\n\t{0}\n\tInstance {1}",
                              data.OuterXml, instanceId);
            IBuyer buyer = OperationContext.Current.GetCallbackChannel<IBuyer>();

            XmlDocument shippingNotification = new XmlDocument();
            shippingNotification.LoadXml("<Shipped>...</Shipped>");
            buyer.HandleShippingNotification(process, shippingNotification);
        }

        public void HandleShippingConfirmation(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Seller: Shipping Confirmation Received\n\t{0}\n\tInstance {1}",
                              data.OuterXml, instanceId);
        }
    }

    class Seller
    {
        ServiceHost<SellerService> serviceHost;

        public void Open()
        {
            serviceHost = new ServiceHost<SellerService>();
            serviceHost.Open();
        }

        public void Close()
        {
            serviceHost.Close();
        }
    }
}

Using System;
using System.Xml;
using System.ServiceModel;
using System.Threading;

namespace DuplexMessagingConversation
{
    class BuyerService : IBuyer
    {
        Guid instanceId = Guid.NewGuid();
        ManualResetEvent waitHandle;

        public BuyerService(ManualResetEvent waitHandle)
        {
            this.waitHandle = waitHandle;
        }

        public void HandlePurchaseOrderConfirmation(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Buyer: Purchase Order Confirmation Received\n\t{0}\n\tInstance {1}",
                               data.OuterXml, instanceId);
            return;
        }

        public void HandleInvoice(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Buyer: Invoice Received\n\t{0}\n\tInstance {1}",
                               data.OuterXml, instanceId);
            ISeller seller = OperationContext.Current.GetCallbackChannel<ISeller>();

            XmlDocument paymentNotification = new XmlDocument();
            paymentNotification.LoadXml("<Payment>...</Payment>");
            seller.HandlePaymentNotification(process, paymentNotification);
        }

        public void HandleShippingNotification(PurchaseProcessHeader process, XmlNode data)
        {
            Console.WriteLine("Buyer: Shipping Notification Received\n\t{0}\n\tInstance {1}",
                               data.OuterXml, instanceId);
            ISeller seller = OperationContext.Current.GetCallbackChannel<ISeller>();

            XmlDocument shippingConfirmation = new XmlDocument();
            shippingConfirmation.LoadXml("<ShipmentReceived>...</ShipmentReceived>");
            seller.HandleShippingConfirmation(process, shippingConfirmation);
            waitHandle.Set();
        }
    }

    class Buyer
    {
        public void InitiatePurchase()
        {
            ServiceHost<BuyerService> buyerHost = new ServiceHost<BuyerService>();
            using (ChannelFactory<ISeller> channelFactory = new ChannelFactory<ISeller>("clientChannel"))
            {
                ManualResetEvent conversationDone = new ManualResetEvent(false);
                using (ServiceSite replyTarget = new ServiceSite(buyerHost, new BuyerService(conversationDone)))
                {
                    ISeller channel = channelFactory.CreateDuplexChannel(replyTarget);

                    PurchaseProcessHeader header = new PurchaseProcessHeader();
                    header.OrderIdentifier = "1234567890";

                    XmlDocument purchaseOrderDocument = new XmlDocument();
                    purchaseOrderDocument.LoadXml("<Order>...</Order>");
                    channel.HandlePurchaseOrder(header, purchaseOrderDocument);

                    conversationDone.WaitOne();
                    replyTarget.Close();
                }
                channelFactory.Close();
            }
            buyerHost.Close();
        }
   }
}

using System;

namespace DuplexMessagingConversation
{
    class Program
    {
        static void Main(string[] args)
        {
            Seller server = new Seller();
            server.Open();

            Buyer client = new Buyer();
            client.InitiatePurchase();

            Console.WriteLine("Press ENTER to quit");
            Console.ReadLine();
            server.Close();
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
    <system.serviceModel>
        <bindings>
            <customBinding>
                <binding configurationName="sellerBinding">
                    <reliableSession/>
                    <compositeDuplex/>
                    <tcpTransport/>
                </binding>
                <binding configurationName="buyerClientBinding">
                    <reliableSession/>
                    <compositeDuplex clientBaseAddress="net.tcp://localhost/buyer/reply"/>
                    <tcpTransport/>
                </binding>
            </customBinding>
        </bindings>
        <client>
            <endpoint address="net.tcp://localhost/seller"
                      bindingConfiguration="buyerClientBinding"
                      bindingType="customBinding"
                      configurationName="clientChannel"
                      contractType="DuplexMessagingConversation.ISeller, DuplexMessagingConversation"/>
        </client>
        <services>
            <service serviceType="DuplexMessagingConversation.SellerService, DuplexMessagingConversation">
                <endpoint contractType="DuplexMessagingConversation.ISeller, DuplexMessagingConversation"
                     address="net.tcp://localhost/seller"
                     bindingType="customBinding"
                     bindingConfiguration="sellerBinding" />
            </service>
        </services>
    </system.serviceModel>
</configuration>

Seller: Purchase Order Received

        <Order xmlns="">...</Order>

        Instance eb628fce-ac56-43af-9326-5bfc62a101dc

Buyer: Purchase Order Confirmation Received

        <OrderConfirmation xmlns="">...</OrderConfirmation>

        Instance c1ce0c0f-fb98-4432-86fb-c81ac7243295

Buyer: Invoice Received

        <Invoice xmlns="">...</Invoice>

        Instance c1ce0c0f-fb98-4432-86fb-c81ac7243295

Seller: Payment Notification Received

        <Payment xmlns="">...</Payment>

        Instance eb628fce-ac56-43af-9326-5bfc62a101dc

Buyer: Shipping Notification Received

        <Shipped xmlns="">...</Shipped>

        Instance c1ce0c0f-fb98-4432-86fb-c81ac7243295

Seller: Shipping Confirmation Received

        <ShipmentReceived xmlns="">...</ShipmentReceived>

        Instance eb628fce-ac56-43af-9326-5bfc62a101dc

Press ENTER to quit

using System;
using System.Xml;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace SimpleAddressing
{
    [ServiceContract]
    interface IGenericMessageEndpoint
    {
        [OperationContract(IsOneWay = true, Action = "*")]
        void Receive(Message msg);
    }

    [ServiceContract]
    interface IGenericReplyChannel
    {
        [OperationContract(IsOneWay = true, Action = "*")]
        void Send(Message msg);
    }

    class GenericMessageEndpoint : IGenericMessageEndpoint
    {
        public void Receive(Message msg)
        {
            using (ChannelFactory<IGenericReplyChannel> channelFactory =
                new ChannelFactory<IGenericReplyChannel>(msg.Headers.ReplyTo, "replyChannel"))
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(msg.GetBodyReader());

                // There is a msg.CreateReplyMessage(...), but that is missing the XmlReader ctor overload
                using (Message reply = Message.CreateMessage("urn:some-action-reply", new XmlNodeReader(doc)))
                {
                    reply.Headers.RelatesTo.Reply = msg.Headers.MessageID;
                    IGenericReplyChannel replyChannel = channelFactory.CreateChannel();
                    replyChannel.Send(reply);
                }
                channelFactory.Close();
            }
        }
    }

    class Server
    {
        ServiceHost<GenericMessageEndpoint> serviceHost;

        public void Open()
        {
            serviceHost = new ServiceHost<GenericMessageEndpoint>();
            serviceHost.Open();
        }

        public void Close()
        {
            serviceHost.Close();
        }
    }
}

using System;
using System.Xml;
using System.ServiceModel;
using System.Threading;

namespace SimpleAddressing
{
    [ServiceContract]
    interface IGenericMessageChannel
    {
        [OperationContract(IsOneWay = true, Action = "*")]
        void Send(Message msg);
    }

    [ServiceContract]
    interface IGenericReplyEndpoint
    {
        [OperationContract(IsOneWay = true, Action = "*")]
        void ReceiveReply(Message msg);
    }

    class GenericReplyEndpoint : IGenericReplyEndpoint
    {
        Client client;
        string epName;

        public GenericReplyEndpoint(Client client, string epName)
        {
            epName = epName;
            client = client;
        }

        public void ReceiveReply(Message msg)
        {
            XmlDictionaryReader xdr = msg.GetBodyReader();
            Console.Write("{0}: ", epName);
            Console.WriteLine(xdr.ReadOuterXml());
            client.MessageReceived();
        }
    }

    class ReplyEndpointA : GenericReplyEndpoint
    {
        public ReplyEndpointA(Client client):base(client, "A")
        {
        }
    }

    class ReplyEndpointB : GenericReplyEndpoint
    {
        public ReplyEndpointB(Client client)
            : base(client, "B")
        {
        }
    }

    … continued below …

    … continuation from above …

    class Client
    {
        const int numMessages = 15;
        int messagesReceived;
        ManualResetEvent allReceived;
        UniqueIDGenerator messageIdGenerator;
        XmlDocument contentDocument;

        public Client()
        {
            messagesReceived = 0;
            allReceived = new ManualResetEvent(false);
            messageIdGenerator = new UniqueIDGenerator();
            contentDocument = new XmlDocument();
            contentDocument.LoadXml("<rose>is a</rose>");
        }

        void SendMessage(ChannelFactory<IGenericMessageChannel> channelFactory,
                         ServiceHost replyService)
        {
            XmlNodeReader content = new XmlNodeReader( contentDocument.DocumentElement);
            using (Message msg = Message.CreateMessage("urn:some-action", content))
            {
                msg.Headers.To = channelFactory.Description.Endpoint.Address;
                msg.Headers.MessageID = messageIdGenerator.Next();
                msg.Headers.ReplyTo = replyService.EndpointListeners[0].GetEndpointAddress();
                IGenericMessageChannel channel = channelFactory.CreateChannel();
                channel.Send(msg);
            }
        }

        public void SendLoop()
        {
            ServiceHost<ReplyEndpointA> replyServiceA = new ServiceHost<ReplyEndpointA>(new ReplyEndpointA(this));
            replyServiceA.Open();
            ServiceHost<ReplyEndpointB> replyServiceB = new ServiceHost<ReplyEndpointB>(new ReplyEndpointB(this));
            replyServiceB.Open();

            using (ChannelFactory<IGenericMessageChannel> channelFactory =
                        new ChannelFactory<IGenericMessageChannel>("clientChannel"))
            {
                channelFactory.Open();
               
                for (int i = 0; i < numMessages; i++)
                {
                    if (i % 2 == 0)
                    {
                        SendMessage(channelFactory, replyServiceB);
                    }
                    else
                    {
                        SendMessage(channelFactory, replyServiceA);
                    }
                }
                channelFactory.Close();
            }
            allReceived.WaitOne();
            replyServiceA.Close();
            replyServiceB.Close();
        }

        public void MessageReceived()
        {
            if (++ messagesReceived >= numMessages)
            {
                allReceived.Set();
            }
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
    <system.serviceModel>
        <bindings>
            <customBinding>
                <binding configurationName="defaultBinding">
                    <httpTransport/>
                </binding>
            </customBinding>
        </bindings>
        <client>
            <endpoint address="http://localhost/genericep"
                bindingConfiguration="defaultBinding"
                bindingType="customBinding"
                configurationName="clientChannel"
                contractType="SimpleAddressing.IGenericMessageChannel, SimpleAddressing"/>
            <endpoint
                bindingConfiguration="defaultBinding"
                bindingType="customBinding"
                configurationName="replyChannel"
                contractType="SimpleAddressing.IGenericReplyChannel, SimpleAddressing"/>
        </client>
        <services>
            <service serviceType="SimpleAddressing.GenericMessageEndpoint, SimpleAddressing">
                <endpoint contractType="SimpleAddressing.IGenericMessageEndpoint, SimpleAddressing"
                                    address="http://localhost/genericep"
                                    bindingType="customBinding"
                                    bindingConfiguration="defaultBinding" />
            </service>
            <service serviceType="SimpleAddressing.ReplyEndpointA, SimpleAddressing">
                <endpoint contractType="SimpleAddressing.IGenericReplyEndpoint, SimpleAddressing"
                                    address="http://localhost/genericreplyA"
                                    bindingType="customBinding"
                                    bindingConfiguration="defaultBinding" />
            </service>
            <service serviceType="SimpleAddressing.ReplyEndpointB, SimpleAddressing">
                <endpoint contractType