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?

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.ServiceModel;

using System.Text;

///日期：2008-04-16

///作者：旋风

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

namespace WCFDataTransfers

{

[ServiceContract(Namespace = "http://DataTransfers/Demao")]

public interface IDataTransfers

{

/// <summary>

/// 获取所用压缩后字节流

/// </summary>

/// <returns></returns>

[OperationContract]

byte[] GetAllBuffer();

/// <summary>

/// 设置压缩后字节流分块，每一块的大小

/// </summary>

/// <param name="length"></param>

[OperationContract]

void SetBufferLength(int length);

/// <summary>

/// 读取压缩后字节流一块，并提升字节流的位置

/// </summary>

/// <returns></returns>

[OperationContract]

bool ReadNextBuffer();

/// <summary>

/// 获取当前块的字节流

/// </summary>

/// <returns></returns>

[OperationContract]

byte[] GetCurrentBuffer();

}

}

[c-sharp] view plaincopyprint?

using System;

using System.Data;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO;

using System.IO.Compression;

using System.Collections.Generic;

using System.Linq;

using System.ServiceModel;

using System.Text;

///日期：2008-04-16

///作者：旋风

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

namespace WCFDataTransfers

{

public class DataTransfers :IDataTransfers

{

/// <summary>

/// 无参数构造函数

/// </summary>

public DataTransfers()

{

InitBuffers(InitTestDataSet());

}

private byte[] buffer_all = null;

private byte[] buffer_currect = null;

private int  get_buffer_length = 1000;

private long  remain_length;

private MemoryStream stream;

/// <summary>

/// 生成一个测试的数据集

/// </summary>

/// <returns></returns>

private DataSet InitTestDataSet()

{

DataSet ds = new DataSet("test");

DataTable table = new DataTable("test");

DataColumn column = new DataColumn("test");

column.DataType = Type.GetType("System.String");

table.Columns.Add(column);

DataRow row;

for (int i = 0; i < 100000;i++ )

{

row = table.NewRow();

row["test"] = "测试数据 !";

table.Rows.Add(row);

}

ds.Tables.Add(table);

return ds;

}

/// <summary>

/// 初始化压缩字节流

/// </summary>

/// <param name="ds"></param>

private void InitBuffers(DataSet ds)

{

IFormatter formatter = new BinaryFormatter();

MemoryStream stream_ = new MemoryStream();

formatter.Serialize(stream_, ds);

buffer_all = stream_.ToArray();

stream_.Close();

byte[] bytes_c = Compression(buffer_all, CompressionMode.Compress);

stream = new MemoryStream(bytes_c);

stream.Position = 0;

remain_length = stream.Length;

}

/// <summary>

/// 提供内部使用压缩字流的方法

/// </summary>

/// <param name="data"></param>

/// <param name="mode"></param>

/// <returns></returns>

private  byte[] Compression(byte[] data, CompressionMode mode)

{

DeflateStream zip = null;

try

{

if (mode == CompressionMode.Compress)

{

MemoryStream ms = new MemoryStream();

zip = new DeflateStream(ms, mode, true);

zip.Write(data, 0, data.Length);

zip.Close();

return ms.ToArray();

}

else

{

MemoryStream ms = new MemoryStream();

ms.Write(data, 0, data.Length);

ms.Flush();

ms.Position = 0;

zip = new DeflateStream(ms, mode, true);

MemoryStream os = new MemoryStream();

int SIZE = 1024;

byte[] buf = new byte[SIZE];

int l = 0;

do

{

l = zip.Read(buf, 0, SIZE);

if (l == 0) l = zip.Read(buf, 0, SIZE);

os.Write(buf, 0, l);

} while (l != 0);

zip.Close();

return os.ToArray();

}

}

catch

{

if (zip != null) zip.Close();

return null;

}

finally

{

if (zip != null) zip.Close();

}

}

#region IDataTransfers 成员

/// <summary>

/// 获取所有字节流

/// </summary>

/// <returns></returns>

public byte[] GetAllBuffer()

{

if (buffer_all != null)

return buffer_all;

else return null;

}

/// <summary>

/// 设置压缩后字节流分块，每一块的大小

/// </summary>

/// <param name="length"></param>

public void SetBufferLength(int length)

{

this.get_buffer_length=length;

}

/// <summary>

/// 读取压缩后字节流一块，并提升字节流的位置

/// </summary>

/// <returns></returns>

public bool ReadNextBuffer()

{

bool bo;

if (remain_length > 0)

{

if (remain_length> get_buffer_length)

{

buffer_currect = new byte[get_buffer_length];

stream.Read(buffer_currect, 0, get_buffer_length);

remain_length -= get_buffer_length;

}

else

{

buffer_currect = new byte[remain_length];

stream.Read(buffer_currect, 0, (int)remain_length);

remain_length = 0;

}

bo = true;

}

else

bo = false;

return bo;

}

/// <summary>

/// 获取当前块的字节流

/// </summary>

/// <returns></returns>

public byte[] GetCurrentBuffer()

{

if (buffer_currect != null)

return buffer_currect;

else

return null;

}

#endregion

}

}

using System;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.IO.Compression;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
///日期：2008-04-16
///作者：旋风
///来自：http://cnblogs.com/xuanfeng
namespace WCFDataTransfers
{

public class DataTransfers :IDataTransfers
{
/// <summary>
/// 无参数构造函数
/// </summary>
public DataTransfers()
{

InitBuffers(InitTestDataSet());
}

private byte[] buffer_all = null;
private byte[] buffer_currect = null;
private int  get_buffer_length = 1000;
private long  remain_length;
private MemoryStream stream;
/// <summary>
/// 生成一个测试的数据集
/// </summary>
/// <returns></returns>
private DataSet InitTestDataSet()
{
DataSet ds = new DataSet("test");
DataTable table = new DataTable("test");
DataColumn column = new DataColumn("test");
column.DataType = Type.GetType("System.String");
table.Columns.Add(column);
DataRow row;
for (int i = 0; i < 100000;i++ )
{
row = table.NewRow();
row["test"] = "测试数据 !";
table.Rows.Add(row);
}

ds.Tables.Add(table);

return ds;

}
/// <summary>
/// 初始化压缩字节流
/// </summary>
/// <param name="ds"></param>
private void InitBuffers(DataSet ds)
{

IFormatter formatter = new BinaryFormatter();
MemoryStream stream_ = new MemoryStream();
formatter.Serialize(stream_, ds);
buffer_all = stream_.ToArray();
stream_.Close();
byte[] bytes_c = Compression(buffer_all, CompressionMode.Compress);
stream = new MemoryStream(bytes_c);
stream.Position = 0;
remain_length = stream.Length;

}
/// <summary>
/// 提供内部使用压缩字流的方法
/// </summary>
/// <param name="data"></param>
/// <param name="mode"></param>
/// <returns></returns>
private  byte[] Compression(byte[] data, CompressionMode mode)
{
DeflateStream zip = null;
try
{
if (mode == CompressionMode.Compress)
{
MemoryStream ms = new MemoryStream();
zip = new DeflateStream(ms, mode, true);
zip.Write(data, 0, data.Length);
zip.Close();
return ms.ToArray();
}
else
{
MemoryStream ms = new MemoryStream();
ms.Write(data, 0, data.Length);
ms.Flush();
ms.Position = 0;
zip = new DeflateStream(ms, mode, true);
MemoryStream os = new MemoryStream();
int SIZE = 1024;
byte[] buf = new byte[SIZE];
int l = 0;
do
{
l = zip.Read(buf, 0, SIZE);
if (l == 0) l = zip.Read(buf, 0, SIZE);
os.Write(buf, 0, l);
} while (l != 0);
zip.Close();
return os.ToArray();
}
}
catch
{
if (zip != null) zip.Close();
return null;
}
finally
{
if (zip != null) zip.Close();
}
}

#region IDataTransfers 成员
/// <summary>
/// 获取所有字节流
/// </summary>
/// <returns></returns>
public byte[] GetAllBuffer()
{
if (buffer_all != null)
return buffer_all;
else return null;
}
/// <summary>
/// 设置压缩后字节流分块，每一块的大小
/// </summary>
/// <param name="length"></param>
public void SetBufferLength(int length)
{
this.get_buffer_length=length;
}
/// <summary>
/// 读取压缩后字节流一块，并提升字节流的位置
/// </summary>
/// <returns></returns>
public bool ReadNextBuffer()
{
bool bo;
if (remain_length > 0)
{
if (remain_length> get_buffer_length)
{
buffer_currect = new byte[get_buffer_length];

stream.Read(buffer_currect, 0, get_buffer_length);
remain_length -= get_buffer_length;
}
else
{
buffer_currect = new byte[remain_length];
stream.Read(buffer_currect, 0, (int)remain_length);
remain_length = 0;
}

bo = true;
}
else
bo = false;
return bo;

}
/// <summary>
/// 获取当前块的字节流
/// </summary>
/// <returns></returns>
public byte[] GetCurrentBuffer()
{
if (buffer_currect != null)
return buffer_currect;
else
return null;

}

#endregion
}
}

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

[c-sharp] view plaincopyprint?

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

///日期：2008-04-16

///作者：旋风

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

namespace WCFDataTransfers

{

class RunServies

{

static void Main(string[] args)

{

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

Console.Write("服务中......");

Console.Read();

Console.Read();

}

}

}

[c-sharp] view plaincopyprint?

//实例化WCF客户端

DataTransfersClient client = new DataTransfersClient();

MemoryStream stream = new MemoryStream();

byte[] buffer;

//获取所用块压缩流，并组装

while(client.ReadNextBuffer())

{

buffer = client.GetCurrentBuffer();

stream.Write(buffer,0,buffer.Length);

}

stream.Position = 0;

buffer= new byte[stream.Length] ;

stream.Read(buffer,0,buffer.Length);

stream.Close();

//解压压缩流

byte[] bytes = Compression(buffer,CompressionMode.Decompress);

stream = new MemoryStream(bytes);

IFormatter formatter = new BinaryFormatter();

//反序列化

DataSet ds=(DataSet) formatter.Deserialize(stream);

stream.Close();

this.dataGridView1.DataSource = ds;

this.dataGridView1.DataMember="test";

this.label1.Text = ds.Tables[0].Rows.Count.ToString();

client.Close();

private byte[] Compression(byte[] data, CompressionMode mode)

{

DeflateStream zip = null;

try

{

if (mode == CompressionMode.Compress)

{

MemoryStream ms = new MemoryStream();

zip = new DeflateStream(ms, mode, true);

zip.Write(data, 0, data.Length);

zip.Close();

return ms.ToArray();

}

else

{

MemoryStream ms = new MemoryStream();

ms.Write(data, 0, data.Length);

ms.Flush();

ms.Position = 0;

zip = new DeflateStream(ms, mode, true);

MemoryStream os = new MemoryStream();

int SIZE = 1024;

byte[] buf = new byte[SIZE];

int l = 0;

do

{

l = zip.Read(buf, 0, SIZE);

if (l == 0) l = zip.Read(buf, 0, SIZE);

os.Write(buf, 0, l);

} while (l != 0);

zip.Close();

return os.ToArray();

}

}

catch

{

if (zip != null) zip.Close();

return null;

}

finally

{

if (zip != null) zip.Close();

}

}

//实例化WCF客户端
DataTransfersClient client = new DataTransfersClient();
MemoryStream stream = new MemoryStream();
byte[] buffer;
//获取所用块压缩流，并组装
while(client.ReadNextBuffer())
{
buffer = client.GetCurrentBuffer();
stream.Write(buffer,0,buffer.Length);
}
stream.Position = 0;
buffer= new byte[stream.Length] ;
stream.Read(buffer,0,buffer.Length);
stream.Close();
//解压压缩流
byte[] bytes = Compression(buffer,CompressionMode.Decompress);
stream = new MemoryStream(bytes);
IFormatter formatter = new BinaryFormatter();
//反序列化
DataSet ds=(DataSet) formatter.Deserialize(stream);
stream.Close();
this.dataGridView1.DataSource = ds;
this.dataGridView1.DataMember="test";
this.label1.Text = ds.Tables[0].Rows.Count.ToString();
client.Close();

private byte[] Compression(byte[] data, CompressionMode mode)
{
DeflateStream zip = null;
try
{
if (mode == CompressionMode.Compress)
{
MemoryStream ms = new MemoryStream();
zip = new DeflateStream(ms, mode, true);
zip.Write(data, 0, data.Length);
zip.Close();
return ms.ToArray();
}
else
{
MemoryStream ms = new MemoryStream();
ms.Write(data, 0, data.Length);
ms.Flush();
ms.Position = 0;
zip = new DeflateStream(ms, mode, true);
MemoryStream os = new MemoryStream();
int SIZE = 1024;
byte[] buf = new byte[SIZE];
int l = 0;
do
{
l = zip.Read(buf, 0, SIZE);
if (l == 0) l = zip.Read(buf, 0, SIZE);
os.Write(buf, 0, l);
} while (l != 0);
zip.Close();
return os.ToArray();
}
}
catch
{
if (zip != null) zip.Close();
return null;
}
finally
{
if (zip != null) zip.Close();
}
}

转自：/article/4847342.html