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 plain  copy

 

 print ?

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 plain  copy

 

 print ?

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 plain  copy

 

 print ?

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 plain  copy

 

 print ?

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. }