C#网络编程:5接收文件

这篇文章将完成Part.4中剩余的部分，它们本来是一篇完整的文章，但是因为上一篇比较长，合并起来页数太多，浏览起来可能会比较不方便，我就将它拆为两篇了，本文便是它的后半部分。我们继续进行上一篇没有完成的步骤：客户端接收来自服务端的文件。

4.客户端接收文件

4.1服务端的实现

对于服务端，我们只需要实现上一章遗留的sendFile()方法就可以了，它起初在handleProtocol中是注释掉的。另外，由于创建连接、获取流等操作与receiveFile()是没有区别的，所以我们将它提出来作为一个公共方法getStreamToClient()。下面是服务端的代码，只包含新增改过的代码，对于原有方法我只给出了签名：

  1. class Server { 
  3. static void Main(string[] args) { 
  5.         Console.WriteLine("Server is running ... "); 
  7.         IPAddress ip = IPAddress.Parse("127.0.0.1"); 
  9.         TcpListener listener = new TcpListener(ip, 8500); 
  11.         listener.Start();           // 开启对控制端口 8500 的侦听
  13.         Console.WriteLine("Start Listening ..."); 
  15. while (true) { 
  17. // 获取一个连接，同步方法，在此处中断
  19.             TcpClient client = listener.AcceptTcpClient(); 
  21.             RemoteClient wapper = new RemoteClient(client); 
  23.             wapper.BeginRead(); 
  25.         } 
  27.     } 
  29. } 
  31. public class RemoteClient { 
  33. // 字段 略
  35. public RemoteClient(TcpClient client) {} 
  37. // 开始进行读取
  39. public void BeginRead() { } 
  41. // 再读取完成时进行回调
  43. private void OnReadComplete(IAsyncResult ar) { } 
  45. // 处理protocol
  47. private void handleProtocol(object obj) { 
  49. string pro = obj as string; 
  51.         ProtocolHelper helper = new ProtocolHelper(pro); 
  53.         FileProtocol protocol = helper.GetProtocol(); 
  55. if (protocol.Mode == FileRequestMode.Send) { 
  57. // 客户端发送文件，对服务端来说则是接收文件
  59.             receiveFile(protocol); 
  61.         } else if (protocol.Mode == FileRequestMode.Receive) { 
  63. // 客户端接收文件，对服务端来说则是发送文件
  65.             sendFile(protocol); 
  67.         } 
  69.     } 
  71. // 发送文件
  73. private void sendFile(FileProtocol protocol) { 
  75.         TcpClient localClient; 
  77.         NetworkStream streamToClient = getStreamToClient(protocol, out localClient); 
  79. // 获得文件的路径
  81. string filePath = Environment.CurrentDirectory + "/" + protocol.FileName; 
  83. // 创建文件流
  85.         FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read); 
  87. byte[] fileBuffer = new byte[1024];     // 每次传1KB
  89. int bytesRead; 
  91. int totalBytes = 0; 
  93. // 创建获取文件发送状态的类
  95.         SendStatus status = new SendStatus(filePath); 
  97. // 将文件流转写入网络流
  99. try { 
  101. do { 
  103.                 Thread.Sleep(10);           // 为了更好的视觉效果，暂停10毫秒:-)
  105.                 bytesRead = fs.Read(fileBuffer, 0, fileBuffer.Length); 
  107.                 streamToClient.Write(fileBuffer, 0, bytesRead); 
  109.                 totalBytes += bytesRead;            // 发送了的字节数
  111.                 status.PrintStatus(totalBytes); // 打印发送状态
  113.             } while (bytesRead > 0); 
  115.             Console.WriteLine("Total {0} bytes sent, Done!", totalBytes); 
  117.         } catch { 
  119.             Console.WriteLine("Server has lost..."); 
  121.         } 
  123.         streamToClient.Dispose(); 
  125.         fs.Dispose(); 
  127.         localClient.Close(); 
  129.     } 
  131. // 接收文件
  133. private void receiveFile(FileProtocol protocol) { } 
  135. // 获取连接到远程的流 -- 公共方法
  137. private NetworkStream getStreamToClient(FileProtocol protocol, out TcpClient localClient) { 
  139. // 获取远程客户端的位置
  141.         IPEndPoint endpoint = client.Client.RemoteEndPoint as IPEndPoint; 
  143.         IPAddress ip = endpoint.Address; 
  145. // 使用新端口号，获得远程用于接收文件的端口
  147.         endpoint = new IPEndPoint(ip, protocol.Port); 
  149. // 连接到远程客户端
  151. try { 
  153.             localClient = new TcpClient(); 
  155.             localClient.Connect(endpoint); 
  157.         } catch { 
  159.             Console.WriteLine("无法连接到客户端 --> {0}", endpoint); 
  161.             localClient = null; 
  163. return null; 
  165.         } 
  167. // 获取发送文件的流
  169.         NetworkStream streamToClient = localClient.GetStream(); 
  171. return streamToClient; 
  173.     } 
  175. // 随机获取一个图片名称
  177. private string generateFileName(string fileName) {} 
  179. } 

服务端的sendFile方法和客户端的SendFile()方法完全类似，上面的代码几乎是一次编写成功的。另外注意我将客户端使用的SendStatus类也拷贝到了服务端。接下来我们看下客户端。

4.2客户端的实现

首先要注意的是客户端的SendFile()接收的参数是文件全路径，但是在写入到协议时只获取了路径中的文件名称。这是因为服务端不需要知道文件在客户端的路径，所以协议中只写文件名；而为了使客户端的SendFile()方法更通用，所以它接收本地文件的全路径。

客户端的ReceiveFile()的实现也和服务端的receiveFile()方法类似，同样，由于要保存到本地，为了避免文件名重复，我将服务端的generateFileName()方法复制了过来。

  1. public class ServerClient :IDisposable { 
  3. // 字段略
  5. public ServerClient() {} 
  7. // 发送消息到服务端
  9. public void SendMessage(string msg) {} 
  11. // 发送文件 - 异步方法
  13. public void BeginSendFile(string filePath) {    } 
  15. private void SendFile(object obj) { } 
  19. // 发送文件 -- 同步方法
  21. public void SendFile(string filePath) {} 
  25. // 接收文件 -- 异步方法
  27. public void BeginReceiveFile(string fileName) { 
  29.         ParameterizedThreadStart start = 
  31. new ParameterizedThreadStart(ReceiveFile); 
  33.         start.BeginInvoke(fileName, null, null); 
  35.     } 
  37. public void ReceiveFile(object obj) { 
  39. string fileName = obj as string; 
  41.         ReceiveFile(fileName); 
  43.     } 
  45. // 接收文件 -- 同步方法
  47. public void ReceiveFile(string fileName) { 
  49.         IPAddress ip = IPAddress.Parse("127.0.0.1"); 
  51.         TcpListener listener = new TcpListener(ip, 0); 
  53.         listener.Start(); 
  55. // 获取本地侦听的端口号
  57.         IPEndPoint endPoint = listener.LocalEndpoint as IPEndPoint; 
  59. int listeningPort = endPoint.Port; 
  61. // 获取发送的协议字符串
  63.         FileProtocol protocol = 
  65. new FileProtocol(FileRequestMode.Receive, listeningPort, fileName); 
  67. string pro = protocol.ToString(); 
  69.         SendMessage(pro);       // 发送协议到服务端
  71. // 中断，等待远程连接
  73.         TcpClient localClient = listener.AcceptTcpClient(); 
  75.         Console.WriteLine("Start sending file..."); 
  77.         NetworkStream stream = localClient.GetStream(); 
  79. // 获取文件保存的路劲
  81. string filePath = 
  83.             Environment.CurrentDirectory + "/" + generateFileName(fileName); 
  85. // 创建文件流
  87.         FileStream fs = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write); 
  89. byte[] fileBuffer = new byte[1024];     // 每次传1KB
  91. int bytesRead; 
  93. int totalBytes = 0; 
  95. // 从缓存buffer中读入到文件流中
  97. do { 
  99.             bytesRead = stream.Read(buffer, 0, BufferSize); 
  101.             fs.Write(buffer, 0, bytesRead); 
  103.             totalBytes += bytesRead; 
  105.             Console.WriteLine("Receiving {0} bytes ...", totalBytes); 
  107.         } while (bytesRead > 0); 
  109.         Console.WriteLine("Total {0} bytes received, Done!", totalBytes); 
  111.         fs.Dispose();          
  113.         stream.Dispose(); 
  115.         localClient.Close(); 
  117.         listener.Stop(); 
  119.     } 
  121. // 随机获取一个图片名称
  123. private string generateFileName(string fileName) {} 
  125. public void Dispose() { 
  127. if (streamToServer != null) 
  129.             streamToServer.Dispose(); 
  131. if (client != null) 
  133.             client.Close(); 
  135.     } 
  137. } 

上面关键的一句就是创建协议那句，注意到将mode由Send改为了Receive，同时传去了想要接收的服务端的文件名称。

4.3程序测试

现在我们已经完成了所有收发文件的步骤，可以看到服务端的所有操作都是被动的，接下来我们修改客户端的Main()程序，创建一个菜单，然后根据用户输入发送或者接收文件。

  1. class Program { 
  3. static void Main(string[] args) { 
  5.         ServerClient client = new ServerClient(); 
  7. string input; 
  9. string path = Environment.CurrentDirectory + "/"; 
  11. do { 
  13.             Console.WriteLine("Send File:    S1 - Client01.jpg, S2 - Client02.jpg, S3 - Client03.jpg"); 
  15.             Console.WriteLine("Receive File: R1 - Server01.jpg, R1 - Server02.jpg, R3- Server03.jpg"); 
  17.             Console.WriteLine("Press 'Q' to exit. \n"); 
  19.             Console.Write("Enter your choice: "); 
  21.             input = Console.ReadLine(); 
  23. switch(input.ToUpper()){ 
  25. case "S1": 
  27.                     client.BeginSendFile(path + "Client01.jpg"); 
  29. break; 
  31. case "S2": 
  33.                     client.BeginSendFile(path + "Client02.jpg"); 
  35. break; 
  37. case "S3": 
  39.                     client.BeginSendFile(path + "Client02.jpg"); 
  41. break; 
  43. case "R1": 
  45.                     client.BeginReceiveFile("Server01.jpg"); 
  47. break; 
  49. case "R2": 
  51.                     client.BeginReceiveFile("Server01.jpg"); 
  53. break; 
  55. case "R3": 
  57.                     client.BeginReceiveFile("Server01.jpg"); 
  59. break; 
  61.             }              
  63.         } while (input.ToUpper() != "Q"); 
  65.         client.Dispose(); 
  67.     } 
  69. } 

由于这是一个控制台应用程序，并且采用了异步操作，所以这个菜单的出现顺序有点混乱。我这里描述起来比较困难，你将代码下载下来后运行一下就知道了:-)

程序的运行结果和上一节类似，这里我就不再贴图了。接下来是本系列的最后一篇，将发送字符串与传输文件的功能结合起来，创建一个可以发送消息并能收发文件的聊天程序，至于语音聊天嘛...等我学习了再告诉你 >_<、

posted @ 2010-07-24 13:31  大漠银狐  阅读(333)  评论(0)  编辑  收藏  举报