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
  • 相关阅读:
    基于element-ui图片封装组件
    计算时间间隔具体每一天
    C语言学习笔记 —— 函数作为参数
    AtCoder Beginner Contest 049 题解
    AtCoder Beginner Contest 048 题解
    AtCoder Beginner Contest 047 题解
    AtCoder Beginner Contest 046 题解
    AtCoder Beginner Contest 045 题解
    AtCoder Beginner Contest 044 题解
    AtCoder Beginner Contest 043 题解
  • 原文地址：https://www.cnblogs.com/aaa6818162/p/4370810.html
Copyright © 2011-2022 走看看