在网络中传输数据(II)

原文地址：http://www.cnblogs.com/Pierce/archive/2005/06/22/178841.html

发送复合型数据：
    除了传输数值型数据，我们更多的是传输复合型数据，如字符，数值，bool等等。是否存在简单办法发送复合型数据呢？
   可以建立一个类，

class  Employee
{
public int EmployeeID;
public int LastNameSize;
public string LastName;
public int FirstNameSize;
public string FirstName;
public int YearsService;
public double Salary;
public int size;
}

   可以把Employee看作是一个数据类型，它包括很多子类型。可以将Empolyee中的字段赋值后，转换为字节数组,因为数值型数据长度固定，如Int32 需要占用4个字节，int16占用2个字节，而字符型数据，长度是不固定的，所以要加入说明字段，标示字符长度。
建立如下方法：

public   byte [] GetBytes()
{
//字节数组，将Empolyee转换为字节数组的容器
byte[] data = new byte[1024];
//位置标示
int place = 0;
//转换Int32 类型的数据为Byte[]，加入到data中
Buffer.BlockCopy(BitConverter.GetBytes(EmployeeID), 0, data, place, 4);
//位移+4
place += 4;
//将字符LastName的长度转换为字节数组，加入到data
Buffer.BlockCopy(BitConverter.GetBytes(LastName.Length), 0, data, place, 4);
//增加位移
place += 4;
//把字符转换为字节数组，加入到Data
Buffer.BlockCopy(Encoding.ASCII.GetBytes(LastName), 0,data, place, LastName.Length);
//增加相应位移
place += LastName.Length;
//将字符FirstName的长度转换为字节数组，加入到Data
Buffer.BlockCopy(BitConverter.GetBytes(FirstName.Length),0, data, place, 4);
//增加位移
place += 4;
//把字符转换为字节数组，加入到data
Buffer.BlockCopy(Encoding.ASCII.GetBytes(FirstName), 0,data, place, FirstName.Length);
//增加位移
place += FirstName.Length;
//转换YearService为byte[]，加入到data
Buffer.BlockCopy(BitConverter.GetBytes(YearsService), 0, data, place, 4);
//增加位移
place += 4;
//转换类型为double的Salary为Byte[]，加入到data
Buffer.BlockCopy(BitConverter.GetBytes(Salary), 0, data, place, 8);
//增加位移
place += 8;
//获取Employee类转换为字节数组的实际长度
size = place;
return data;
}

GetBytes（）由3个作用：
1.将类中的每个字段转换为字节数组；
2.将每个字节数组都放入相同的总的字节数组中；
3.获取了总字节数组的长度。
    关于Buffer.BlockCopy（），是将目的数组copy到原数组的特定位置；
BlockCopy(byte[] array1, int start, byte[] array2, int offset, int size);
    我们的目的就是把不同的数组放入到统一数组的特定位置。这个做好了，那么可以通过网络传送了。

     可以这样理解网络中传输的字节数组，网络就像是有2条铁轨的道路，允许2列火车同时运行，而火车由车头，车厢组成，车厢又分为硬座车型，软座车箱，硬卧车厢，软卧车厢，餐车，邮件车厢等，每个数据类型的字节数组，对应上面的车箱，因为特定乘客要到特定车厢，所以特定的数组也要在发送的总的数组的特定位置。

   通过网络，我们说到了这个数组，怎样还原呢？
   首先，我们要知道Employee 类的结构，然后，可以

public  Employee( byte [] data)
{
int place = 0;
EmployeeID = BitConverter.ToInt32(data, place);
place += 4;
LastNameSize = BitConverter.ToInt32(data, place);
place += 4;
LastName = Encoding.ASCII.GetString(data, place, LastNameSize);
place = place + LastNameSize;
FirstNameSize = BitConverter.ToInt32(data, place);
place += 4;
FirstName = Encoding.ASCII.GetString(data, place, FirstNameSize);
place += FirstNameSize;
YearsService = BitConverter.ToInt32(data, place);
place += 4;
Salary = BitConverter.ToDouble(data, place);
}

    是不是想起了什么，觉得很熟悉，对了，序列化，同使用序列化类，通过网络传输，然后再反序列化，获取类中的字段的值，非常相似，是不是可以这样说，序列化的原理就是这样？

完整发送、接收代码：
Client:

using  System;
using  System.Net;
using  System.Net.Sockets;
class  EmployeeClient
{
public static void Main()
{
Employee emp1 = new Employee();
Employee emp2 = new Employee();
TcpClient client;
emp1.EmployeeID = 1;
emp1.LastName = "Blum";
emp1.FirstName = "Katie Jane";
emp1.YearsService = 12;
emp1.Salary = 35000.50;
emp2.EmployeeID = 2;
emp2.LastName = "Blum";
emp2.FirstName = "Jessica";
emp2.YearsService = 9;
emp2.Salary = 23700.30;
try
{
client = new TcpClient("127.0.0.1", 9050);
} catch (SocketException)
{
Console.WriteLine("Unable to connect to server");
return;
}
NetworkStream ns = client.GetStream();
byte[] data = emp1.GetBytes();
int size = emp1.size;
byte[] packsize = new byte[2];
Console.WriteLine("packet size = {0}", size);
packsize = BitConverter.GetBytes(size);
ns.Write(packsize, 0, 2);
ns.Write(data, 0, size);
ns.Flush();
data = emp2.GetBytes();
size = emp2.size;
packsize = new byte[2];
Console.WriteLine("packet size = {0}", size);
packsize = BitConverter.GetBytes(size);
ns.Write(packsize, 0, 2);
ns.Write(data, 0, size);
ns.Flush();
ns.Close();
client.Close();
}
}

Server:

using  System;
using  System.Net;
using  System.Net.Sockets;
class  EmployeeSrvr
{
public static void Main()
{
byte[] data = new byte[1024];
TcpListener server = new TcpListener(9050);
server.Start();
TcpClient client = server.AcceptTcpClient();
NetworkStream ns = client.GetStream();
byte[] size = new byte[2];
int recv = ns.Read(size, 0, 2);
int packsize = BitConverter.ToInt16(size, 0);
Console.WriteLine("packet size = {0}", packsize);
recv = ns.Read(data, 0, packsize);
Employee emp1 = new Employee(data);
Console.WriteLine("emp1.EmployeeID = {0}", emp1.EmployeeID);
Console.WriteLine("emp1.LastName = {0}", emp1.LastName);
Console.WriteLine("emp1.FirstName = {0}", emp1.FirstName);
Console.WriteLine("emp1.YearsService = {0}", emp1.YearsService);
Console.WriteLine("emp1.Salary = {0}/n", emp1.Salary);
size = new byte[2];
recv = ns.Read(size, 0, 2);
packsize = BitConverter.ToInt16(size, 0);
data = new byte[packsize];
Console.WriteLine("packet size = {0}", packsize);
recv = ns.Read(data, 0, packsize);
Employee emp2 = new Employee(data);
Console.WriteLine("emp2.EmployeeID = {0}", emp2.EmployeeID);
Console.WriteLine("emp2.LastName = {0}", emp2.LastName);
Console.WriteLine("emp2.FirstName = {0}", emp2.FirstName);
Console.WriteLine("emp2.YearsService = {0}", emp2.YearsService);
Console.WriteLine("emp2.Salary = {0}", emp2.Salary);
ns.Close();
client.Close();
server.Stop();
}
}

        Server 先读取2个字节，转换为数值，获取Client要发送的字节数组总长度，然后根据长度，读取数据。

       现在我们把复合类型转换为单一类型，通过网络发送到目的地，然后又重新组合起来，同前面说的搬运埃菲尔铁塔，用的是相同的道理。

        我们经常遇到的另一种情况是传送文件，文件可以方便的转换为字节数组，通过网络传输，要注意：
1.因为MTU的原因，每次传输的最大字节数组的长度为1024，不要大于这个值，如果文件较大，可以每次传输1024个字节，接收方按顺序收到后，在还原成原始文件。
2.可以使用每次发送固定长度字节的办法，在获取文件长度后，每次发送固定长度，直到发完。

  关于在网络中传输数据，就写到这里，如果有问题，请给我留言。

  谢谢浮云。
        MTU（Maximum Transmission Unit）  最大传输单元： 经网络发送的单一包可容纳的最大数据量。每种网络技术都定义一个MTU（以太网的MTU是1500个字节）。
       以太网和802.3对数据帧的长度都有一个限制，其最大值分别是1500和1492字节。链路层的这个特性称作MTU，最大传输单元。不同类型的网络大多数都有一个上限。
        如果IP层有一个数据报要传，而且数据的长度比链路层的MTU还大，那么IP层就需要进行分片（fragmentation），把数据报分成若干片，这样每一片都小于MTU。
       网络传输文件，因为在IP层作了处理，所以我们不必再做处理。可以发送大于1024字节的数据。
       关于“是不是我们就不需要关心每次发送的包大小了呢？ ”，发送文件的大小取决于内部消息缓冲区或者网络的限制，因为网络可以将数据分割，所以只需要考虑有没有传送时间的限制，如Http上传的时间限制，另外，系统的内部缓冲区的大小默认是8192字节，即8K，所以发送文件时，按照8K拆分发送。