深入剖析WCF的可靠会话[实例篇](内含美女图片,定力差者慎入)

作为一个通信基础平台,WCF必须保证通信的可靠性。由于消息交换是WCF采用的通信手段，通信可靠性的保障体现在确保消息的可靠传输。WCF本质上是一个消息处理框架，作为整个消息交换系统的两个终端，即发送端和接收端。换句话说，WCF仅仅负责对消息的发送和接收，一旦消息通过WCF的信道层进入了网络，就脱离了WCF的控制范围。但是，由于网络环境的限制，网络层不能百分之百地确保对消息的有效交付。如何克服中间环节的制约，确保从一端发送的消息能够被有效地交付给另一端，这就是可靠消息传输（Reliable Messaging）需要解决的问题。WCF通过可靠会话（Reliable Sessions）实现了种种端到端（End to End）的可靠消息传输。源代码从这里下载。

为了让读者对可靠会话的作用现有一个直观的认识，我们先来做一个很有意思的实例演示。接下来我们将要演示的实例是对可靠会话确保WCF消息传输的可靠性的一个直观的反应，也是早年微软推广WCF技术频繁使用的案例：图片传输。在客户端，我们选择一张图片，并对它进行切片，最后通过调用WCF服务将每一个切片依次传输到服务端。服务端则按照切片被接收到的顺序重新组装成一张完整的图片。如果中间有任何一张切片丢失，服务端最终组装图片将不会完整；如果服务端切片接收的次序和发送顺序不一致，将会造成组装后的图片并不能还原其发送前的模样。在这里，我们充分利用了WCF中的可靠会话提供了可靠而有序的消息交付。

不稳定的网络是造成消息丢失最主要的因素，但是在本机环境下模拟不稳定的网络是一件比较困难的事情。但是，虽然我们不能让消息在网络传输层中丢失，但是我们可以让它在WCF的信道层中丢失。如何实现这样的目的呢，相应阅读过《WCF技术剖析（卷1）》第3章的读者会很快想到可以采用自定义信道的方式。

    <system.serviceModel>
        <bindings>
            <customBinding>
                <binding name="nonReliableSession">      
                  <binaryMessageEncoding>
                    <readerQuotas maxArrayLength="2147483647 "/>
                  </binaryMessageEncoding>
                 <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
                </binding>
              <binding name="reliableSession">
                <reliableSession ordered="false"/>
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
               </binaryMessageEncoding>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
             <binding name="orderedDelivery">
                <reliableSession ordered="true" />
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
            </customBinding>
        </bindings>
        <services>
            <service name="Artech.ImageTransfer.Service.ImageTransferService">
                <endpoint address="net.tcp://127.0.0.1:7777/imagetransferservice" binding="customBinding" bindingConfiguration="nonReliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
                <endpoint address="net.tcp://127.0.0.1:8888/imagetransferservice" binding="customBinding" bindingConfiguration="reliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
                <endpoint address="net.tcp://127.0.0.1:9999/imagetransferservice" binding="customBinding" bindingConfiguration="orderedDelivery" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
            </service>
        </services>
   </system.serviceModel>

步骤一：通过自定义信道模拟不稳定的网络

为了对网络传输过程中的丢包率能够进行动态控制，我特意创建一个特殊的类型MessageInspector。MessageInspector定义如下,只读属性DropRate表示丢包率，ProcessMessage对传入的消息进行处理，如果返回为Null，意味着消息的丢失。MessageInspector定义如下。

using System;
using System.ServiceModel.Channels;
namespace Artech.ImageTransfer.Extensions
{
    public class MessageInspector
    {
        public int DropRate{ get; private set; }
        public Random Randomizer{ get; private set; }
        public MessageInspector(int dropRate)
        {
            this.DropRate = dropRate;
            this.Randomizer = new Random();
        }
        public virtual void ProcessMessage(ref Message message)
        {
            int randomNumber = this.Randomizer.Next(100);
            if (randomNumber <= this.DropRate)
            {
                message = null;
            }
        }
    }
}

接下来我们就来创建这个用于模拟不稳定网络环境的自定义信道UnreliableNetworkSimulateChannel。由于我们即将演示的实例采用TCP传输方式，所以我们让UnreliableNetworkSimulateChannel实现了IDuplexSessionChannel接口。UnreliableNetworkSimulateChannel通过MessageInspector对象对传入的消息进行加工（根据丢包率随即地丢弃）。MessageInspector在构造函数中创建，而丢包率通过参数传入。除了Send方法，几乎所有的成员都是调用InnerChannel相应的方法或者返回同名的属性。由于在《WCF技术剖析（卷1）》我们有过对如何自定义信道的专门介绍，在这里我们就不在多做重复的讲述了。

using System;
using System.ServiceModel.Channels;
namespace Artech.ImageTransfer.Extensions
{
    public class UnreliableNetworkSimulateChannel : IDuplexSessionChannel
    {
        public IDuplexSessionChannel InnerChannel{ get; private set; }
        public MessageInspector MessageInspector{ get; private set; }
        public UnreliableNetworkSimulateChannel(IDuplexSessionChannel innerChannel, int dropRate)
        {
            this.InnerChannel = innerChannel;
            this.MessageInspector = new MessageInspector(dropRate);
        }
        public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return this.InnerChannel.BeginReceive(timeout, callback, state);
        }
        public void Send(Message message, TimeSpan timeout)
        {
            this.MessageInspector.ProcessMessage(ref message);
            if(null != message)
            {
                this.InnerChannel.Send(message, timeout);
            }
        }
        public void Send(Message message)
        {
            this.MessageInspector.ProcessMessage(ref message);
            if (null != message)
            {
                this.InnerChannel.Send(message);
            }
        }
        //其他成员:直接调用InnerChannel的相应的方法或者返回同名属性
    }
}

通过上面的代码我们可以看到，在Send方法中，消息对象会先传入MessageInspector的ProcessMessage方法中，如果返回值不为空，将其递交给InnerChannel，反之意味着消息在信道层中丢失。接下来我们为该自定义信道创建信道管理器，由于该信道只在客户端使用，我们只需要为之创建信道工厂即可（Channel Factory）。UnreliableNetworkSimulateChannel对应的信道工厂UnreliableNetworkSimulateChannelFactory<TChannel>定义如下。

using System;
using System.ServiceModel.Channels;
using System.ServiceModel;
namespace Artech.ImageTransfer.Extensions
{
    public class UnreliableNetworkSimulateChannelFactory<TChannel> : ChannelFactoryBase<IDuplexSessionChannel>
    {
        public int DropRate {get; private set;}
        public IChannelFactory<TChannel> InnerChannelFactory{ get; private set; }
        public UnreliableNetworkSimulateChannelFactory(BindingContext context, int dropRate):base(context.Binding)
        {
            this.InnerChannelFactory = context.BuildInnerChannelFactory<TChannel>();
            this.DropRate = dropRate;
        }
        protected override IDuplexSessionChannel OnCreateChannel(EndpointAddress address, Uri via)
        {
            var innerChannel = (IDuplexSessionChannel)this.InnerChannelFactory.CreateChannel(address, via);
            return new UnreliableNetworkSimulateChannel(innerChannel,this.DropRate);
        }
        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return this.InnerChannelFactory.BeginOpen(timeout, callback, state);
        }
        protected override void OnEndOpen(IAsyncResult result)
        {
            this.InnerChannelFactory.EndOpen(result);
        }
        protected override void OnOpen(TimeSpan timeout)
        {
            this.InnerChannelFactory.Open(timeout);
        }
    }
}

由于WCF信道栈的缔造者为绑定，而信道管理器（信道工厂或者信道监听器）最终借助于绑定元素而发送作用。为此，我们为我们创建的信道工厂创建了如下一个绑定元素：UnreliableNetworkSimulateBindingElement。

using System.ServiceModel.Channels;
namespace Artech.ImageTransfer.Extensions
{
    public class UnreliableNetworkSimulateBindingElement : BindingElement
    {
        public int DropRate { get; set; }
        public UnreliableNetworkSimulateBindingElement(int dropRate)
        {
            this.DropRate = dropRate;
        }
        public override BindingElement Clone()
        {
            return new UnreliableNetworkSimulateBindingElement(this.DropRate);
        }
        public override T GetProperty<T>(BindingContext context)
        {
            return context.GetInnerProperty<T>();
        }
        public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
        {
            return (IChannelFactory<TChannel>)new UnreliableNetworkSimulateChannelFactory<TChannel>(context, this.DropRate);
        }
    }
}

为了使上面的绑定元素具有可配制性，我们还需要为之创建相应的配置元素。在WCF编程模型下，我们只需要集成BindingElementExtensionElement类即可。在下面定义的UnreliableNetworkSimulateExtensionElement，我们将丢包率定义成配置属性，该属性默认值为20（20%丢包率）。

using System;
using System.Configuration;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
namespace Artech.ImageTransfer.Extensions
{
    public class UnreliableNetworkSimulateExtensionElement:BindingElementExtensionElement
    {
        [ConfigurationProperty("dropRate", IsRequired = false, DefaultValue = 20)]
        public int DropRate
        {
            get
            {
                return (int)this["dropRate"];
            }
            set
            {
                this["dropRate"] = value;
            }
        }
        public override Type BindingElementType
        {
            get { return typeof(UnreliableNetworkSimulateBindingElement); }
        }
        protected override BindingElement CreateBindingElement()
        {
            return new UnreliableNetworkSimulateBindingElement(this.DropRate);
        }
    }
}

步骤二：创建图片传输服务

解决了对不稳定网络环境的模拟问题，我们现在正式来创建我们用于图片传输的WCF服务。先来看看服务契约的定义。服务契约IImageTransfer具有两个单向（One-Way）服务操作。Transfer方法用于对图片切片（以字节数组的形式）的传输，而Erase则用于通知接收端将之前接收的图片删除。

using System.ServiceModel;
namespace Artech.ImageTransfer.Service.Interface
{
    [ServiceContract(Namespace="http://www.artech.com/")]
    public interface IImageTransfer
    {
        [OperationContract(IsOneWay = true)]
        void Transfer(byte[] imageSlice);
        [OperationContract(IsOneWay = true)]
        void Erase();
    }
}

服务端需要将接收到的图片切片组装成一个完整的图片，我将图片组装的功能通过如下一个叫做ImageAssembler的静态类来提供。对应于服务契约定义的两个服务操作，ImageAssembler中定义两个静态事件ImageSliceReceived和ImageErasing。这两个事件分别通过静态方法ReceiveImageSlice和Erase出发。事件ImageSliceReceived的事件参数类型为ImageReceivedEventArgs ，它和ImageAssembler定义如下。

using System;
namespace Artech.ImageTransfer.Service
{
    public static class ImageAssembler
    {
        public static void ReceiveImageSlice(byte[] imageSlice)
        {
            if (null != ImageSliceReceived)
            {
                ImageSliceReceived(null, new ImageReceivedEventArgs(imageSlice));
            }
        }

        public static void Erase()
        {
            if (null != ImageErasing)
            {
                ImageErasing(null,  EventArgs.Empty);
            }
        }

        public static event EventHandler<ImageReceivedEventArgs> ImageSliceReceived;
        public static event EventHandler ImageErasing;
    }

    public class ImageReceivedEventArgs : EventArgs
    {
        public byte[] ImageSlice
        { get; private set; }

        public ImageReceivedEventArgs(byte[] imageSlice)
        {
            this.ImageSlice = imageSlice;
        }
    }
}

接下来是服务传输服务的实现，该服务定义在如下的ImageTransferService类中。对于两个服务操作，我们分别调用ImageAssembler的两个对应的静态方法提供实现。

using System.ServiceModel;
using Artech.ImageTransfer.Service.Interface;
namespace Artech.ImageTransfer.Service
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class ImageTransferService : IImageTransfer
    {
        public void Transfer(byte[] imageSlice)
        {
            ImageAssembler.ReceiveImageSlice(imageSlice);
        }
        public void Erase()
        {
            ImageAssembler.Erase();
        }
    }
}

步骤三：服务寄宿和图片接收程序实现

图片传输服务ImageTransferService最终被寄宿于一个Windows Forms应用中，该应用同时作为图片接收程序使用。我们先来看看服务寄宿端的配置：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <customBinding>
                <binding name="nonReliableSession">
                  <binaryMessageEncoding>
                    <readerQuotas maxArrayLength="2147483647 "/>
                  </binaryMessageEncoding>
                  <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
                </binding>
              <binding name="reliableSession">
                <reliableSession ordered="false"/>
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
              <binding name="orderedDelivery">
                <reliableSession ordered="true" />
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
            </customBinding>
        </bindings>
        <services>
            <service name="Artech.ImageTransfer.Service.ImageTransferService">
                <endpoint address="net.tcp://127.0.0.1:7777/imagetransferservice" binding="customBinding" bindingConfiguration="nonReliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
                <endpoint address="net.tcp://127.0.0.1:8888/imagetransferservice" binding="customBinding" bindingConfiguration="reliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
                <endpoint address="net.tcp://127.0.0.1:9999/imagetransferservice" binding="customBinding" bindingConfiguration="orderedDelivery" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer" />
            </service>
        </services>
    </system.serviceModel>
</configuration>

通过上面的配置我们会发现，我们为ImageTransferService配置了三个终结点，它们均采用自定义绑定，并且采用TCP传输方式和二进制消息编码。考虑到对较大尺寸图片的支持，我们将BinaryMessageEncodingElement的MaxArrayLength属性，以及TcpTransportElement的MaxBufferSize和MaxReceivedMessageSize都设置成最大。对于这三个终结点的绑定配置，具有如下不一致的地方。reliableSession和orderedDelivery终结点对应的绑定比nonReliableSession多了一个ReliableSessionElement绑定元素。相信你已经猜到了，ReliableSessionElement是为了实现可靠会话而存在的。进一步地，oreliableSession和orderedDelivery终结点绑定的ReliableSessionElement的Ordered属性分别为False和True。也就是意味着orderedDelivery终结点能够实现对消息的有序交付，而reliableSession终结点则不能。

图片的接收窗口如图1所示，其中每一个方格是一个PictureBox，用户显示接收到的图片切片。对于这些PictureBox的ID，从上到下，从左到右依次是pictureBox11、pictureBox12、...、pictureBox15、...、pictureBox55。整个服务寄宿和图片接收实现在如下的代码中。值得注意的一点是，ImageAssembler_ImageCliceReceived方法将接收到的字节数组转化成位图，依次显示到上述的25个PictureBox上。在方法上面应用了一个MethodImplAttribute特性并指定MethodImplOptions.Synchronized作为参数，所以该方法是同步执行的。也就是说，该方法处理的消息次序就是消息被交付的次序。

using System;
using System.Drawing;
using System.IO;
using System.Runtime.CompilerServices;
using System.ServiceModel;
using System.Threading;
using System.Windows.Forms;
namespace Artech.ImageTransfer.Service
{
    public partial class Recevier : Form
    {
        private PictureBox[] _pictureBoxes;
        private SynchronizationContext _synchronizationContext = null;
        private int _index = 0;
        private ServiceHost _serviceHost = null;
        public Recevier()
        {
            InitializeComponent();
            _pictureBoxes = new PictureBox[]{
                this.pictureBox11,this.pictureBox12,this.pictureBox13,this.pictureBox14,this.pictureBox15,                this.pictureBox21,this.pictureBox22,this.pictureBox23,this.pictureBox24,this.pictureBox25,                this.pictureBox31,this.pictureBox32,this.pictureBox33,this.pictureBox34,this.pictureBox35,                this.pictureBox41,this.pictureBox42,this.pictureBox43,this.pictureBox44,this.pictureBox45,                this.pictureBox51,this.pictureBox52,this.pictureBox53,this.pictureBox54,this.pictureBox55};
            ImageAssembler.ImageSliceReceived += ImageAssembler_ImageCliceReceived;
            ImageAssembler.ImageErasing += ImageAssembler_ImageErasing;
        }
        [MethodImpl(MethodImplOptions.Synchronized)]
        private void ImageAssembler_ImageCliceReceived(object sender, ImageReceivedEventArgs args)
        {
            Bitmap bitmap = null;
            using (MemoryStream stream = new MemoryStream(args.ImageSlice))
            {
                bitmap = new Bitmap(stream);
                _synchronizationContext.Send(state => _pictureBoxes[_index++].Image = bitmap, null);
            }
        }
        private void ImageAssembler_ImageErasing(object sender, EventArgs args)
        {
            _index = 0;
            foreach (var pictureBox in _pictureBoxes)
            {
                pictureBox.Image = null;
            }
        }
        private void Recevier_Load(object sender, EventArgs e)
        {
            _synchronizationContext = SynchronizationContext.Current;
            _serviceHost = new ServiceHost(typeof(ImageTransferService));
            _serviceHost.Open();
        }
    }
}

图1 图片接收窗口

步骤四：创建图片发送程序

最后我们来编写我们的图片发送端程序，即如果对图片进行切片，并通过调用图片传输服务对切片进行发送。我们照例先来看看WCF在客户端的配置：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <customBinding>
              <binding name="nonReliableSession">
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <unreliabeNetworkSimulate dropRate ="10"/>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
              <binding name="reliableSession">
                <reliableSession ordered="false" />
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <unreliabeNetworkSimulate dropRate ="10"/>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
              <binding name="orderedDelivery">
                <reliableSession ordered="true" />
                <binaryMessageEncoding>
                  <readerQuotas maxArrayLength="2147483647 "/>
                </binaryMessageEncoding>
                <unreliabeNetworkSimulate dropRate ="10"/>
                <tcpTransport maxBufferSize="2147483647 " maxReceivedMessageSize="2147483647" />
              </binding>
            </customBinding>
        </bindings>
        <client>
            <endpoint name="nonReliableSession" address="net.tcp://127.0.0.1:7777/imagetransferservice" binding="customBinding" bindingConfiguration="nonReliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer"/>
            <endpoint name="reliableSession" address="net.tcp://127.0.0.1:8888/imagetransferservice" binding="customBinding" bindingConfiguration="reliableSession" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer"/>
            <endpoint name="orderedDelivery" address="net.tcp://127.0.0.1:9999/imagetransferservice" binding="customBinding" bindingConfiguration="orderedDelivery" contract="Artech.ImageTransfer.Service.Interface.IImageTransfer"/>
        </client>
        <extensions>
            <bindingElementExtensions>
                <add name="unreliabeNetworkSimulate" type="Artech.ImageTransfer.Extensions.UnreliableNetworkSimulateExtensionElement, Artech.ImageTransfer.Extensions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
            </bindingElementExtensions>
        </extensions>
    </system.serviceModel>
</configuration>

同服务寄宿端的配置一样，客户端也配置了三种自定义绑定。所不同的是，它们均多了一个额外的绑定元素UnreliableNetworkSimulateBindingElement，即我们之前创建的用于模拟不稳定网络环境的邦定元素。

图2是图片发送窗口，上边部分一个Picture，会显示通过点击Browse按钮选择的图片。当成功选择某一张用于发送的图片后，点击Send按钮将其发送。Reliable Session和Ordered Delivery两个CheckBox供用户决定是否采用可靠会话，以及有序交付机制进行图片的发送。默认情况下，并不采用可靠会话机制进行图片发送。图片的选择、切片和发送通过下面的代码实现。

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.ServiceModel;
using System.Windows.Forms;
using Artech.ImageTransfer.Service.Interface;
namespace Artech.ImageTransfer.Client
{
    public partial class Sender : Form
    {
        private string _imageSource = string.Empty;
        private IImageTransfer _nonReliableSessionProxy = null;
        private IImageTransfer _reliableSessionProxy = null;
        private IImageTransfer _orderedDeliveryProxy = null;
        ChannelFactory<IImageTransfer> _nonReliableSessionFactory = new ChannelFactory<IImageTransfer>("nonReliableSession");
        ChannelFactory<IImageTransfer> _reliableSessionFactory = new ChannelFactory<IImageTransfer>("reliableSession");
        ChannelFactory<IImageTransfer> _orderedDeliveryFactory = new ChannelFactory<IImageTransfer>("orderedDelivery");

        public Sender()
        {
            InitializeComponent();
        }
        private IImageTransfer GetProxy()
        {
            if(null != _nonReliableSessionProxy)
            {
                (_nonReliableSessionProxy as ICommunicationObject).Close();
            }
             if(null != _reliableSessionProxy)
            {
                (_reliableSessionProxy as ICommunicationObject).Close();
            }
             if(null != _orderedDeliveryProxy)
            {
                (_orderedDeliveryProxy as ICommunicationObject).Close();
            }
             if (!this.checkBoxReliableSession.Checked)
             {
                 _nonReliableSessionProxy = _nonReliableSessionFactory.CreateChannel();
                 (_nonReliableSessionProxy as ICommunicationObject).Open();
                 return _nonReliableSessionProxy;
             }
             else if (!this.checkBoxOrdered.Checked)
             {
                 _reliableSessionProxy = _reliableSessionFactory.CreateChannel();
                 (_reliableSessionProxy as ICommunicationObject).Open();
                 return _reliableSessionProxy;
             }
             else
             {
                 _orderedDeliveryProxy = _orderedDeliveryFactory.CreateChannel();
                 (_orderedDeliveryProxy as ICommunicationObject).Open();
                 return _orderedDeliveryProxy;
             }
        }
        private void buttonOpen_Click(object sender, EventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            if (openFileDialog.ShowDialog()== DialogResult.OK)
            {
                _imageSource = openFileDialog.FileName;
                this.pictureBox1.Load(_imageSource);
            }
            this.buttonSend.Enabled = true;
        }
        private byte[] BitmapToBytes(Bitmap bitmap)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                bitmap.Save(ms, ImageFormat.Bmp);
                byte[] data = new byte[ms.Length];
                ms.Seek(0, SeekOrigin.Begin);
                ms.Read(data, 0, Convert.ToInt32(ms.Length));
                return data;
            }
        }

        private void buttonSend_Click(object sender, EventArgs e)
        {
            this.buttonSend.Enabled = false;
            IList<byte[]> imageSlices = new List<byte[]>();
            Bitmap bmp = new Bitmap(this._imageSource);
            double width = (double)bmp.Width / 5;
            double height = (double)bmp.Height / 5;
            for (int y = 0; y < 5; y++)
            {
                for (int x = 0; x < 5; x++)
                {
                    Rectangle rect = new Rectangle(Convert.ToInt32(x * width), Convert.ToInt32(y * height),
                        Convert.ToInt32(width), Convert.ToInt32(height));
                    byte[] data = BitmapToBytes(bmp.Clone(rect, PixelFormat.DontCare));
                    imageSlices.Add(data);
                }
            }
            IImageTransfer proxy = GetProxy();
            proxy.Erase();
            for (int i = 0; i < imageSlices.Count; i++)
            {
                proxy.Transfer(imageSlices[i]);
            }
            this.buttonSend.Enabled = true;
        }
    }
}

通过上面的代码我们可以发现，我们通过GetProxy()方法选择相应终结点对应的ChannelFactory<IImageTransfer>对象，并创建服务代理。在buttonSend_Click方法中，被选择的图片被均分成25个切片，并按照从上到下、从左至右的顺旬转化成字节数据，最终利用创建的服务代理发送出去。在发送之前，调用Erase服务操作通知接收端擦除已经接收到的切片。

图2  图片发送端窗口

所有的编程工作完成后，我们来运行我们的程序。图3表示的是没有采用可靠会话时的图片传输情况。从中我们可以看到两接收方组装后的图片不完整，有四个切片缺失。此外，接收方组装后的切片完全是错位的。

图3 没有采用可靠会话图片传输情况

图4表示的是选择了可靠会话选项，但是没有选择有序交付选项时图片传输的情况。我们可以看出，这一次解决了切片丢失的问题，但是错位的情况下依然存在。

图4 选择可靠会话但不选择有序交付时图片传输情况

最后，我们同是选择可靠会话和有序交付两个选项，你在接收端将会得到一张完完整整地图片，既不会有切片丢失，也不会出现切片错位的情况。最终的结果如图5所示，这才是我们希望的。

图5  同时选择可靠会话和有序交付时图片传输情况

实际上，WCF的可靠会话涉及到WS中一个重要的概念——可靠消息传输（RM：Reliable Messaging）。如果想对可靠会话有一个深入的认识，对可靠消息传输的了解是必须的。《概念篇》中将会对RM的基本概念进行基本的讲述。

作者：Artech 
出处：http://artech.cnblogs.com 
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。