zoukankan      html  css  js  c++  java

  • WCF大数据量传输解决方案

    文章内容列表:
    1． 场景：
    2． 解决方案
    3. WCF契约与服务实现设计静态图
    4. WCF契约与服务实现设计详细说明
    6. 服务端启动服务代码:
    7. 客户端代码
    8.   WCF大数据量传输解决方案源码下载


    1． 场景：

    WCF在网络传输中，大数据量传输造成网络阻塞，宽带无法承受；

    2． 解决方案

    解决WCF在网络传输中的大数据量问题：

    A．需要把相关数据序列化成字节流，再对字节流进行压缩，再进行传输，到了客户端再做反向操作便可获得原始数据。

    B．如果压缩后的数据仍然较大时，可以再压缩流后，再对流进行拆分即可。

    3. WCF契约与服务实现设计静态图

    4. WCF契约与服务实现设计详细说明

     

    5. WCF契约与服务代码实现:

    [c-sharp] view plaincopyprint?
    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Runtime.Serialization;  
    5. using System.ServiceModel;  
    6. using System.Text;  
    7. ///日期：2008-04-16   
    8. ///作者：旋风   
    9. ///来自：http://cnblogs.com/xuanfeng   
    10. namespace WCFDataTransfers  
    11. {  
    12.   
    13.     [ServiceContract(Namespace = "http://DataTransfers/Demao")]  
    14.     public interface IDataTransfers  
    15.     {    
    16.         /// <summary>   
    17.         /// 获取所用压缩后字节流   
    18.         /// </summary>   
    19.         /// <returns></returns>   
    20.         [OperationContract]  
    21.         byte[] GetAllBuffer();  
    22.         /// <summary>   
    23.         /// 设置压缩后字节流分块，每一块的大小   
    24.         /// </summary>   
    25.         /// <param name="length"></param>   
    26.         [OperationContract]  
    27.         void SetBufferLength(int length);  
    28.         /// <summary>   
    29.         /// 读取压缩后字节流一块，并提升字节流的位置   
    30.         /// </summary>   
    31.         /// <returns></returns>   
    32.         [OperationContract]  
    33.         bool ReadNextBuffer();  
    34.         /// <summary>   
    35.         /// 获取当前块的字节流   
    36.         /// </summary>   
    37.         /// <returns></returns>   
    38.         [OperationContract]  
    39.         byte[] GetCurrentBuffer();         
    40.   
    41.          
    42.     }  
    43.   
    44.      
    45. }  

    [c-sharp] view plaincopyprint?
    1. using System;  
    2. using System.Data;  
    3. using System.Runtime.Serialization;  
    4. using System.Runtime.Serialization.Formatters.Binary;  
    5. using System.IO;  
    6. using System.IO.Compression;  
    7. using System.Collections.Generic;  
    8. using System.Linq;  
    9. using System.ServiceModel;  
    10. using System.Text;  
    11. ///日期：2008-04-16   
    12. ///作者：旋风   
    13. ///来自：http://cnblogs.com/xuanfeng   
    14. namespace WCFDataTransfers  
    15. {  
    16.       
    17.     public class DataTransfers :IDataTransfers  
    18.     {  
    19.         /// <summary>   
    20.         /// 无参数构造函数   
    21.         /// </summary>   
    22.         public DataTransfers()  
    23.         {  
    24.   
    25.             InitBuffers(InitTestDataSet());  
    26.         }  
    27.   
    28.         private byte[] buffer_all = null;  
    29.         private byte[] buffer_currect = null;  
    30.         private int  get_buffer_length = 1000;  
    31.         private long  remain_length;  
    32.         private MemoryStream stream;  
    33.         /// <summary>   
    34.         /// 生成一个测试的数据集   
    35.         /// </summary>   
    36.         /// <returns></returns>   
    37.         private DataSet InitTestDataSet()  
    38.         {  
    39.             DataSet ds = new DataSet("test");  
    40.             DataTable table = new DataTable("test");  
    41.             DataColumn column = new DataColumn("test");  
    42.             column.DataType = Type.GetType("System.String");  
    43.             table.Columns.Add(column);  
    44.             DataRow row;  
    45.             for (int i = 0; i < 100000;i++ )  
    46.             {  
    47.                 row = table.NewRow();  
    48.                 row["test"] = "测试数据 !";  
    49.                 table.Rows.Add(row);  
    50.             }  
    51.   
    52.             ds.Tables.Add(table);  
    53.   
    54.             return ds;  
    55.           
    56.         }  
    57.         /// <summary>   
    58.         /// 初始化压缩字节流   
    59.         /// </summary>   
    60.         /// <param name="ds"></param>   
    61.         private void InitBuffers(DataSet ds)  
    62.         {  
    63.               
    64.                 IFormatter formatter = new BinaryFormatter();  
    65.                 MemoryStream stream_ = new MemoryStream();  
    66.                 formatter.Serialize(stream_, ds);  
    67.                 buffer_all = stream_.ToArray();  
    68.                 stream_.Close();  
    69.                 byte[] bytes_c = Compression(buffer_all, CompressionMode.Compress);  
    70.                 stream = new MemoryStream(bytes_c);  
    71.                 stream.Position = 0;  
    72.                 remain_length = stream.Length;  
    73.   
    74.               
    75.         }  
    76.         /// <summary>   
    77.         /// 提供内部使用压缩字流的方法   
    78.         /// </summary>   
    79.         /// <param name="data"></param>   
    80.         /// <param name="mode"></param>   
    81.         /// <returns></returns>   
    82.         private  byte[] Compression(byte[] data, CompressionMode mode)  
    83.         {  
    84.             DeflateStream zip = null;  
    85.             try  
    86.             {  
    87.                 if (mode == CompressionMode.Compress)  
    88.                 {  
    89.                     MemoryStream ms = new MemoryStream();  
    90.                     zip = new DeflateStream(ms, mode, true);  
    91.                     zip.Write(data, 0, data.Length);  
    92.                     zip.Close();  
    93.                     return ms.ToArray();  
    94.                 }  
    95.                 else  
    96.                 {  
    97.                     MemoryStream ms = new MemoryStream();  
    98.                     ms.Write(data, 0, data.Length);  
    99.                     ms.Flush();  
    100.                     ms.Position = 0;  
    101.                     zip = new DeflateStream(ms, mode, true);  
    102.                     MemoryStream os = new MemoryStream();  
    103.                     int SIZE = 1024;  
    104.                     byte[] buf = new byte[SIZE];  
    105.                     int l = 0;  
    106.                     do  
    107.                     {  
    108.                         l = zip.Read(buf, 0, SIZE);  
    109.                         if (l == 0) l = zip.Read(buf, 0, SIZE);  
    110.                         os.Write(buf, 0, l);  
    111.                     } while (l != 0);  
    112.                     zip.Close();  
    113.                     return os.ToArray();  
    114.                 }  
    115.             }  
    116.             catch  
    117.             {  
    118.                 if (zip != null) zip.Close();  
    119.                 return null;  
    120.             }  
    121.             finally  
    122.             {  
    123.                 if (zip != null) zip.Close();  
    124.             }  
    125.         }  
    126.  
    127.         #region IDataTransfers 成员   
    128.         /// <summary>   
    129.         /// 获取所有字节流   
    130.         /// </summary>   
    131.         /// <returns></returns>   
    132.         public byte[] GetAllBuffer()  
    133.         {  
    134.             if (buffer_all != null)  
    135.                 return buffer_all;  
    136.             else return null;  
    137.         }  
    138.         /// <summary>   
    139.         /// 设置压缩后字节流分块，每一块的大小   
    140.         /// </summary>   
    141.         /// <param name="length"></param>   
    142.         public void SetBufferLength(int length)  
    143.         {  
    144.            this.get_buffer_length=length;  
    145.         }  
    146.         /// <summary>   
    147.         /// 读取压缩后字节流一块，并提升字节流的位置   
    148.         /// </summary>   
    149.         /// <returns></returns>   
    150.         public bool ReadNextBuffer()  
    151.         {  
    152.             bool bo;  
    153.             if (remain_length > 0)  
    154.             {  
    155.                 if (remain_length> get_buffer_length)  
    156.                 {  
    157.                     buffer_currect = new byte[get_buffer_length];  
    158.   
    159.                     stream.Read(buffer_currect, 0, get_buffer_length);  
    160.                     remain_length -= get_buffer_length;  
    161.                 }  
    162.                 else  
    163.                 {  
    164.                     buffer_currect = new byte[remain_length];  
    165.                     stream.Read(buffer_currect, 0, (int)remain_length);  
    166.                     remain_length = 0;  
    167.                 }  
    168.   
    169.                 bo = true;  
    170.             }  
    171.             else  
    172.                 bo = false;  
    173.             return bo;  
    174.              
    175.         }  
    176.         /// <summary>   
    177.         /// 获取当前块的字节流   
    178.         /// </summary>   
    179.         /// <returns></returns>   
    180.         public byte[] GetCurrentBuffer()  
    181.         {  
    182.             if (buffer_currect != null)  
    183.                 return buffer_currect;  
    184.             else  
    185.                 return null;  
    186.   
    187.         }  
    188.  
    189.         #endregion   
    190.     }  
    191. }  

    6. 服务端启动服务代码:

     

    [c-sharp] view plaincopyprint?
    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5. using System.ServiceModel;  
    6. ///日期：2008-04-16   
    7. ///作者：旋风   
    8. ///来自：http://cnblogs.com/xuanfeng   
    9. namespace WCFDataTransfers  
    10. {  
    11.     class RunServies  
    12.     {  
    13.         static void Main(string[] args)  
    14.         {  
    15.             ServiceHost host = new ServiceHost(typeof(DataTransfers));  
    16.             Console.Write("服务中......");  
    17.             Console.Read();  
    18.             Console.Read();  
    19.         }  
    20.     }  
    21. }  

     

    7. 客户端代码

    [c-sharp] view plaincopyprint?
    1.    //实例化WCF客户端   
    2.     DataTransfersClient client = new DataTransfersClient();  
    3.     MemoryStream stream = new MemoryStream();  
    4.     byte[] buffer;  
    5.     //获取所用块压缩流，并组装   
    6.     while(client.ReadNextBuffer())   
    7.     {  
    8.         buffer = client.GetCurrentBuffer();  
    9.         stream.Write(buffer,0,buffer.Length);  
    10.     }  
    11.     stream.Position = 0;  
    12.     buffer= new byte[stream.Length] ;  
    13.     stream.Read(buffer,0,buffer.Length);  
    14.     stream.Close();  
    15.     //解压压缩流   
    16.     byte[] bytes = Compression(buffer,CompressionMode.Decompress);  
    17.     stream = new MemoryStream(bytes);  
    18.     IFormatter formatter = new BinaryFormatter();  
    19.     //反序列化   
    20.     DataSet ds=(DataSet) formatter.Deserialize(stream);  
    21.     stream.Close();  
    22.     this.dataGridView1.DataSource = ds;  
    23.     this.dataGridView1.DataMember="test";  
    24.     this.label1.Text = ds.Tables[0].Rows.Count.ToString();  
    25.     client.Close();  
    26.   
    27. private byte[] Compression(byte[] data, CompressionMode mode)  
    28. {  
    29.     DeflateStream zip = null;  
    30.     try  
    31.     {  
    32.         if (mode == CompressionMode.Compress)  
    33.         {  
    34.             MemoryStream ms = new MemoryStream();  
    35.             zip = new DeflateStream(ms, mode, true);  
    36.             zip.Write(data, 0, data.Length);  
    37.             zip.Close();  
    38.             return ms.ToArray();  
    39.         }  
    40.         else  
    41.         {  
    42.             MemoryStream ms = new MemoryStream();  
    43.             ms.Write(data, 0, data.Length);  
    44.             ms.Flush();  
    45.             ms.Position = 0;  
    46.             zip = new DeflateStream(ms, mode, true);  
    47.             MemoryStream os = new MemoryStream();  
    48.             int SIZE = 1024;  
    49.             byte[] buf = new byte[SIZE];  
    50.             int l = 0;  
    51.             do  
    52.             {  
    53.                 l = zip.Read(buf, 0, SIZE);  
    54.                 if (l == 0) l = zip.Read(buf, 0, SIZE);  
    55.                 os.Write(buf, 0, l);  
    56.             } while (l != 0);  
    57.             zip.Close();  
    58.             return os.ToArray();  
    59.         }  
    60.     }  
    61.     catch  
    62.     {  
    63.         if (zip != null) zip.Close();  
    64.         return null;  
    65.     }  
    66.     finally  
    67.     {  
    68.         if (zip != null) zip.Close();  
    69.     }  
    70. }  

     

    转自：http://www.cnblogs.com/xuanfeng/archive/2008/04/16/1155700.html
  • 相关阅读:
    《团队-团队编程项目中国象棋-成员简介及分工》
    团队-编程项目 中国象棋-需求分析
    结对编程：贪吃蛇项目
    软件工程进阶
    JAVA第二次作业
    JAVA第一次作业
    JS解决重复绑定问题以及获取事件
    ECMAScript5学习笔记--第十四章 程序
    ECMAScript5学习笔记--第十三章 函数定义
    ECMAScript5学习笔记--第十二章 语句
  • 原文地址：https://www.cnblogs.com/aaa6818162/p/4370810.html
Copyright © 2011-2022 走看看