文章内容列表:

1． 场景：

2． 解决方案

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

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

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

7. 客户端代码

8.   WCF大数据量传输解决方案源码下载

1． 场景：

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

2． 解决方案

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

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

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

                   (解决方案A图)

                     (解决方案2)

 

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

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

契约接口详细说明

服务类详细说明

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

  契约代码

 1using System;

 2using System.Collections.Generic;

 3using System.Linq;

 4using System.Runtime.Serialization;

 5using System.ServiceModel;

 6using System.Text;

 7///日期：2008-04-16

 8///作者：旋风

 9///来自：http://cnblogs.com/xuanfeng

10namespace 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}

46

    实现契约服务代码

  1using System;

  2using System.Data;

  3using System.Runtime.Serialization;

  4using System.Runtime.Serialization.Formatters.Binary;

  5using System.IO;

  6using System.IO.Compression;

  7using System.Collections.Generic;

  8using System.Linq;

  9using System.ServiceModel;

 10using System.Text;

 11///日期：2008-04-16

 12///作者：旋风

 13///来自：http://cnblogs.com/xuanfeng

 14namespace 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}

192

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

static void Main(string[] args)

        

{

            ServiceHost host = new ServiceHost(typeof(DataTransfers));

            Console.Write("服务中");

            Console.Read();

            Console.Read();

        }

7. 客户端代码

 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();

8.