转：wcf大文件传输解决之道（1）

首先声明，文章思路源于MSDN中徐长龙老师的课程整理，加上自己的一些心得体会，先总结如下：

      在应对与大文件传输的情况下，因为wcf默认采用的是缓存加载对象，也就是说将文件包一次性接受至缓存中，然后生成对象，显然对于大文件的传输，这种方式是不可取的，一般我们采用流传输或者更优秀的本本编码方式，在文本编码这一块我们一般采用w3c提出的MTOM传输机制，MTOM（Message Transmission Optimization Mechanism），是W3C的MTOM的消息传输优化机制，有效地发送的二进制数据和从Web服务方法。将消息传输优化机制 (MTOM) 消息编码与WSHttpBinding 一起使用。MTOM是一种机制，用来以原始字节形式传输包含SOAP消息的较大二进制附件，从而使所传输的消息较小。也就是说它对于文件的编码采取的文件头和文件包得传输方式，文件头定义文件格式，文件包采用SOAP原始的二进制信息，实现信息的优化，但这种方式在文件较小的时候相对于普通的文本编辑方式也是有耗损的，下面通过一个案例比较下：

新建方法，实现文本编码方式和MTOM方式编码的比较

　　　　 ///<summary>
        /// 新建函数，用于测试moto方式对数据进行编码所生成的对象长度比较
        ///</summary>
        ///<param name="dataSize"></param>
        static void CompareMessageSize(int dataSize)
       {
           byte[] binaryData = new byte[dataSize];

            Message message = Message.CreateMessage(MessageVersion.Soap12WSAddressing10, "消息说明", binaryData);//创建一个soap消息

            MessageBuffer buffer = message.CreateBufferedCopy(int.MaxValue);//新建一个消息缓存区域并将消息传入

            int size = SizeofTextMessage(buffer.CreateMessage());
            Console.WriteLine("text  endcoding with a {0} byte playod:{1}", binaryData.Length, size);

            size = sizeofMotoMessage(buffer.CreateMessage());
            Console.WriteLine("MTMO  endcoding with a {0} byte playod:{1}", binaryData.Length, size);
            Console.WriteLine();

            message.Close();//关闭流
        }

新建方法，实现MTOM方式编码

        private static int sizeofMotoMessage(Message message)
        {
            //创建一个文本编码器
            MessageEncodingBindingElement element = new MtomMessageEncodingBindingElement();
            MessageEncoderFactory factory = element.CreateMessageEncoderFactory();
            MessageEncoder encoder = factory.Encoder;

            MemoryStream sream = new MemoryStream(); //创建内存
            encoder.WriteMessage(message, sream); //通过文本编辑器将消息写到内存中

            int size = (int)sream.Length;
            message.Close();
            sream.Close();
            return size;
        }

新建另一个方法，实现默认文本方式编码

        private static int SizeofTextMessage(Message message)
        {
            //创建一个Mtom编码器
            MessageEncodingBindingElement element = new TextMessageEncodingBindingElement();
            MessageEncoderFactory factory = element.CreateMessageEncoderFactory();
            MessageEncoder encoder = factory.Encoder;

            MemoryStream sream = new MemoryStream(); //创建内存
            encoder.WriteMessage(message, sream); //通过文本编辑器将消息写到内存中

            int size = (int)sream.Length;
            message.Close();
            sream.Close();
            return size;
           
        }

调用方式比较传输：

          ///比较文本编码方式和Moto方式两者编码的不同，两者都适用于Http协议传输，在1Mb下文本编辑方式为
            ///最佳选择，Moto适合大文件传输，在跨平台上无疑这是最好的选择
            CompareMessageSize(100);
            CompareMessageSize(1000);
            CompareMessageSize(10000);
            CompareMessageSize(100000);
            CompareMessageSize(1000000);

            Console.ReadLine();

看运行结果：

显然在字节大于2000字节的时候MOTO方式的编码长度小于普通编码方式，而在小于2000字节的时候普通文本编辑要优于MTOM编码方式

所以在我们定义Binding的时候我们要分情况对待。

我们在wcf中应用MTOM的方式是通过定义Binding的方式进行的，看配置代码

   <!--定义bangings-->
    <bindings>
      <!--文本编码方式是Mtom方式，传输协议是wsHttpBinding-->
      <wsHttpBinding>
        <binding name="wsHttpBing_IUpload" messageEncoding="Mtom" />       
      </wsHttpBinding>

      <!--流编码方式transferMode启动流模式，设置流模式类型-->
      <basicHttpBinding>
        <binding name="myBinding" transferMode="Streamed" />
      </basicHttpBinding>
    </bindings>

这里面定义了两种Binding编码方式，一个是采取Mtom方式、另一个是采取流媒体；其实两者是有区别的：

1、BasicHttpBinding发送的是明文数据，而WsHttpBinding发送的是加密和更加安全的数据

2、如果你希望有向后兼容的能力，并且支持更多的客户端，你可以选择basicHttpBinding，如果你确定你的客户端使用的  是.NET   3.0甚至更高的话，你可以选择wsHttpBinding

也就是说 basicHttpBinding扩展性好，而wshttpBinding必须给予.3.0以上版本 当然流媒体传输的速度相对会优于文本传输，但流开启的条件是有约束的：

有于stream的限制，只能对流模式使用传输级别的安全选项，并且无法打开 可靠会话，因此，流模式仅在下列系统定义的绑定中使用

  BasicHttpBinding

  NetTcpBinding

  NetNamedPipeBinding

并且流模式传输时只能定义一个参数，如果添加多个参数，则自动转换成文本编码方式，用缓存来实现

不同的应用环境分情况对待，我们看上面的配置我们如何应用，客户端定数据契约和方法：

namespace service
{
    [ServiceContract(Namespace = "http://localhost/Server")]
    public  interface IUplod
    {
        [OperationContract]
        int Upload(Stream data);
    }
    public class UploadService : IUplod
    {
        public int Upload(Stream data)
        {
            int size = 0;
            int bytesRead = 0;
            byte[] buffer = new byte[1024]; //新建字节数组

              //从流中读取信息存储到字节数组中
            do
            {
                bytesRead = data.Read(buffer, 0, buffer.Length); //
                size += bytesRead;

            }
            while (bytesRead > 0);
            data.Close();
            return size;
        }
    }
}

采用自托管的方式：

namespace service
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(UploadService)))
            {
                host.Opened += delegate
                {
                    Console.WriteLine("服务已经启动");
                };
                host.Open();
                Console.ReadLine();
            }
        }
    }
}

客户端实现流传输：

            byte[] binaryData = new byte[1000];
            //定义1000长度的字节数组            
            MemoryStream sream = new MemoryStream(binaryData);
            //生成内存里流.MemorySteam继承自sream,是stream的实例            
            ServiceUplod.UplodClient client = new ServiceUplod.UplodClient();            
            Console.WriteLine(client.Upload(sream)); 
            //调用服务传入1000个字节            
            sream.Close();//关闭流

运行结果：

呵呵...这种方式只应用于http协议传输，通过MTOM或者流媒体传输实现，流媒体的传输，在使用TCP协议的情况下我们能更大限度的使用流媒体传输，当然既然优越就有它的限制性，下一篇我们分析，基于此种协议进行大文件传输
来自：http://www.cnblogs.com/zhijianliutang/archive/2011/11/28/2265858.html