Transfer large data volumes in Web Services

Transfer large data volumes in Web Services
Author: Dongdong
In vs2005, 12000 records are queried and remotingformat = serializationformat. Binary is set;
Re-serialization, transmitted through WebService, received by the client, and deserialized, is indeed much better than the direct transmission of dataset, not only in network transmission, even the local machine, performance improvement is also very obvious.

The following are the methods in WebService and the client deserialization Method for dataset.
1. Take the data on the server, fill the dataset, and convert it to the binary format.
/// <Summary>
/// Method for users data query with binaryformatter
/// </Summary>
/// <Param name = "Err"> </param>
/// <Returns> </returns>
Public byte [] binaryuserselect (ref string ERR)
{
Clearcommand ();
M_commandstringbuilder.append ("select * From t_users ;");
Dataset dsresult = new dataset ();
Byte [] barrayresult = NULL;
Try
{
Dsresult = sqlhelper. executedataset (m_currentconnectionstring, commandtype. Text, m_commandstringbuilder.tostring ());
// The above data is obtained, so you don't need to worry about it. The binary compressed dataset is the following small segment.
Dsresult. remotingformat = serializationformat. Binary;
Memorystream MS = new memorystream ();
Iformatter BF = new binaryformatter ();
BF. serialize (MS, dsresult );
Barrayresult = Ms. toarray ();
Ms. Close ();
//
}
Catch (exception ee)
{
Err = ee. tostring ();
}
Return barrayresult;
}

2. Send data in byte [] format to the client through WebService. This is what WebService is doing. We don't need to worry about it.

3. The client receives data in byte [] format, deserializes it, obtains the dataset, and performs client operations.
/// <Summary>
/// Get user data with binary format
/// </Summary>
/// <Returns> </returns>
Public dataset getbinaryuserdata ()
{
String err = "";
Byte [] buserdata = SVC. bytearrayuserselect (ref ERR );
If (Err! = "")
{
MessageBox. Show (ERR );
Err = "";
Return NULL;
}
// Deserialization Process
Memorystream MS = new memorystream (buserdata );
Iformatter BF = new binaryformatter ();
Object OBJ = BF. deserialize (MS );
Dataset dsresult = (Dataset) OBJ;
//
Ms. Close ();
Return dsresult;
}

On the same machine, 12000 pieces of data are manually generated. Data in the local WebService is read and transmitted separately, and the dataset and byte [] format are displayed on the client. The average time of the former is 2.3 seconds, the average time of the latter is 1.7 seconds. The difference is only in the format of the transmission process, as well as the serialization and deserialization time required by the latter. the difference between local WebService transmission is still the same, and the optimization of network transmission time will naturally become more obvious ..

. Net1.1 the datasetsurrogate Development Kit provided by Microsoft below: http://support.microsoft.com/default.aspx? SCID = KB; en-US; 829740 datasetsurrogate comes with. NET 2.0
The implementation method in. net1.1 is as follows:
There are two methods: You can save the serialized data in the client hard disk in the form of a file; you can also use the byte [] method to return the data back to the client. The following is the code.
Web service end (file form)
 
[Webmethod (description = "obtain remote dataset cyclically")]
Public void surrogatereadtable (string tablename)
{
// Serialize dataset to binary stream through surrogate class

Dataset Ds;
DS = sqlhelper. executedataset (CNN, commandtype. Text, "select * from" + tablename );
// Instantiate datasetsurrogate and upload the retrieved dataset to the constructor.
SDS = new datasetsurrogate (DS );
// Instantiate the binary stream
Binaryformatter BF = new binaryformatter ();
Streamwriter swdat;
// Write to a local file
Swdat = new streamwriter (@ "C: \ output_surrogate_dataset.dat ");
BF. serialize (swdat. basestream, SDS );
// The size of the serialized File
Long size = swdat. basestream. length;
Swdat. Close ();

}
 
Client
 
Private void button#click (Object sender, system. eventargs E)
{
Label1.text = datetime. Now. tostring ();
 
Button1.enabled = false;
// Deserialization binary stream can be converted to dataset through surrogate class
 
// Read method from Web Service
SVS. surrogateread ("t_busdocbase ");
Binaryformatter BF = new binaryformatter ();
Streamreader swdat;
Swdat = new streamreader (@ "C: \ output_surrogate_dataset.dat ");
Object o = BF. deserialize (swdat. basestream );
Dataset Ds;
SDS = (datasetsurrogate) O;
DS = SDS. converttodataset ();
Datagrid1.datasource = Ds. Tables [0];
Swdat. Close ();
}
 
 
 
Web service end (byte [] mode)
 
[Webmethod (description = "getting business data remote dataset")]
Public byte [] surrogateread1 ()
{
Dataset Ds;
DS = sqlhelper. executedataset (CNN, commandtype. Text, "select * From t_busdocbase ");
SDS = new datasetsurrogate (DS );
Memorystream S = new memorystream ();
Binaryformatter BF = new binaryformatter ();
BF. serialize (S, SDS );

Byte [] e = S. toarray ();
Return E;

}
 
 
Client
 
Private void button3_click (Object sender, system. eventargs E)
{
Label1.text = datetime. Now. tostring ();
 
Button3.enabled = false;
// * Deserializing binary stream can be converted to dataset through surrogate class */
 
// Read method from Web Service
 
 
Byte [] BB = SVS. surrogateread1 ();
Memorystream BR = new memorystream (bb );
Binaryformatter BF = new binaryformatter ();
Object o = BF. deserialize (BR );
SDS = (datasetsurrogate) O;
DS = SDS. converttodataset ();
Datagrid1.datasource = Ds. Tables [0];
 
BR. Close ();
 
}
 
I personally think byte [] is safer. After all, you don't have to generate files on the client, and you don't have to worry about data security.
 
 

In 2.0, we made a simple encapsulation of the serialization and deserialization methods of datasets so that they can be reused. For details, see the following class datformatter.

You can use the getbinaryformatdata method to convert a data set to binary. You can use this method on the server to convert the data set format. Send and receive data in binary format from the client. Use the retrievedataset method to deserialize the data set and perform client operations. Through these simple operations (serialization and deserialization, data compression), you can greatly reduce the time required for the remote transmission of large objects such as datasets, in addition, it can reduce the impact of network interruptions and other problems on the program.

1 using system;
2 using system. IO;
3 using system. Data;
4 using system. runtime. serialization;
5 using system. runtime. serialization. formatters. Binary;
6
7 namespace common
8 {
9 public class dataformatter
10 {
11 private dataformatter (){}
12 /// <summary>
13 // serialize the data of dataset to binary format
14 /// </Summary>
15 /// <Param name = "dsoriginal"> </param>
16 /// <returns> </returns>
17 static public byte [] getbinaryformatdata (Dataset dsoriginal)
18 {
19 byte [] binarydataresult = NULL;
20 memorystream memstream = new memorystream ();
21 iformatter brformatter = new binaryformatter ();
22 dsoriginal. remotingformat = serializationformat. Binary;
23
24 brformatter. serialize (memstream, dsoriginal );
25 binarydataresult = memstream. toarray ();
26 memstream. Close ();
27 memstream. Dispose ();
28 return binarydataresult;
29}
30 /// <summary>
31 // retrieve dataset from data of binary format
32 /// </Summary>
33 // <Param name = "binarydata"> </param>
34 /// <returns> </returns>
35 static public dataset retrievedataset (byte [] binarydata)
36 {
37 dataset datasetresult = NULL;
38 memorystream memstream = new memorystream (binarydata );
39 iformatter brformatter = new binaryformatter ();
40
41 object OBJ = brformatter. deserialize (memstream );
42 datasetresult = (Dataset) OBJ;
43 return datasetresult;
44}
45}
46}
47