Половина передачи файлов в C# через сокет?

Question

Я разрабатываю приложение передачи файлов через среднего уровень жадной маршрутизацию, в котором файл отправляет жадные и жадные отправляет файл снова маршрутизатор но проблема некоторое время клиент получает полный файл и через некоторое время он получит какую-то часть файла

Вот мой код идет сторона SERVER

IPAddress[] ipAddress = Dns.GetHostAddresses("127.0.0.1"); 
      IPEndPoint ipEnd = new IPEndPoint(ipAddress[0], 5655); 
      Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); 


      string filePath = ""; 


      fileDes = fileDes.Replace("\\", "/"); 
      while (fileDes.IndexOf("/") > -1) 
      { 
       filePath += fileDes.Substring(0, fileDes.IndexOf("/") + 1); 
       fileDes = fileDes.Substring(fileDes.IndexOf("/") + 1); 
      } 


      byte[] fileNameByte = Encoding.ASCII.GetBytes(fileDes); 

      lblError.Text = ""; 
      lblError.Text = "Buffering ..."; 
      byte[] fileData = File.ReadAllBytes(filePath + fileDes); 
      byte[] clientData = new byte[4 + fileNameByte.Length + fileData.Length]; 
      byte[] fileNameLen = BitConverter.GetBytes(fileNameByte.Length); 

      fileNameLen.CopyTo(clientData, 0); 
      fileNameByte.CopyTo(clientData, 4); 
      fileData.CopyTo(clientData, 4 + fileNameByte.Length); 

      lblError.Text = ""; 
      lblError.Text = "Connection to server ..."; 
      clientSock.Connect(ipEnd); 

      lblError.Text = ""; 
      lblError.Text = "File sending..."; 
     // System.Threading.Thread.Sleep(1000); 
      clientSock.Send(clientData); 
      label3.Text = clientData.Length.ToString(); 

      lblError.Text = ""; 
      lblError.Text = "Disconnecting..."; 
      clientSock.Close(); 

      lblError.Text = ""; 
      lblError.Text = "File transferred."; 

В клиенте

class DestCode 
{ 
    IPEndPoint ipEnd; 
    Socket sock; 
    public DestCode() 
    { 
     ipEnd = new IPEndPoint(IPAddress.Any, 5656); 
     sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); 
     sock.Bind(ipEnd); 
    } 
    public static string receivedPath; 
    public static string curMsg = "Stopped"; 
    public static int res; 
    public void StartServer() 
    { 
     try 
     { 
      curMsg = "Starting..."; 
      sock.Listen(100); 

      curMsg = "Running and waiting to receive file."; 
      Socket clientSock = sock.Accept(); 

      byte[] clientData = new byte[1024 * 5000]; 

      int receivedBytesLen = clientSock.Receive(clientData); 

      curMsg = "Receiving data..."; 

      int fileNameLen = BitConverter.ToInt32(clientData, 0); 
      string fileName = Encoding.ASCII.GetString(clientData, 4, fileNameLen); 

      BinaryWriter bWrite = new BinaryWriter(File.Open(receivedPath +"/"+ fileName, FileMode.Append)); ; 
      bWrite.Write(clientData,4 + fileNameLen, receivedBytesLen - 4 - fileNameLen); 
      res = receivedBytesLen; 
      if (receivedPath == "") 
      { 
       MessageBox.Show("No Path was selected to Save the File"); 
      } 
      curMsg = "Saving file..."; 

      bWrite.Close(); 
      clientSock.Close(); 
      curMsg = "File Received ..."; 

      StartServer(); 

     } 
     catch (Exception ex) 
     { 
      curMsg = "File Receving error."; 
     } 
    } 
} 

В жадного

class ReceiverCode 
{ 
    IPEndPoint ipEnd; 
    Socket sock; 
    public ReceiverCode() 
    { 
     ipEnd = new IPEndPoint(IPAddress.Any, 5655); 
     sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); 
     sock.Bind(ipEnd); 
    } 
    public static string receivedPath; 
    public static string curMsg = "Stopped"; 
    public static string Rout = ""; 
    public static int rlength = 0; 
    public static string MsgStatus = ""; 
    public static byte[] send; 
    public void StartServer() 
    { 
     try 
     { 
      curMsg = "Starting..."; 
      sock.Listen(100); 

      curMsg = "Running and waiting to receive file."; 
      Socket clientSock = sock.Accept(); 

      byte[] clientData = new byte[1024 * 5000]; 

      int receivedBytesLen = clientSock.Receive(clientData); 
      System.Threading.Thread.Sleep(5000); 
      rlength = receivedBytesLen; 
      curMsg = "Receiving data..."; 

      int receive = clientSock.Receive(clientData); 


      send = new byte[receivedBytesLen]; 
      Array.Copy(clientData, send, receivedBytesLen); 
      Rout = "Start"; 
      clientSock.Close(); 
      curMsg = "Reeived & Saved file; Server Stopped."; 
      StartServer(); 

     } 
     catch (Exception ex) 
     { 
      curMsg = "File Receving error."; 
     } 
    } 


} 

Пожалуйста, кто-нибудь помочь мне

Answer 1

Проблема заключается в том, что Socket.Receive не гарантирует, что вы получите все байты вы просили. Таким образом, вы пишете:

int receivedBytesLen = clientSock.Receive(clientData); 

documentation говорит:

Если вы используете ориентированную на соединение сокета, получающего метод будет читать столько данных, сколько есть в наличии, до размера буфера ,

Звонок в Receive получает все доступные байты. Возможно, отправитель еще не отправил все байты, или ваш сетевой стек не получил их и сделал их доступными.

Чтобы надежно отправлять и принимать данные, приемник должен знать одну из двух вещей: либо сколько байтов оно ожидает, либо что есть какое-то оценочное значение, которое говорит «вот и все, люди». Вы не можете рассчитывать на один звонок Receive, чтобы получить все.

При передаче файлов отправитель обычно включает в себя размер файла в качестве первых четырех байтов отправляемых данных. Затем ваш код считывает первые четыре байта (удостоверяясь, что вы получаете все четыре байта), чтобы определить размер, а затем вращает цикл, считывая данные из сокета, пока не будут получены все ожидаемые байты.

Что-то вроде:

const int MaximumSize = 1000000; 
// read the first four bytes 
var sizeBytes = ReadBytesFromSocket(socket, 4); 
int size = BitConverter.ToInt32(sizeBytes); 

var dataBuffer = ReadBytesFromSocket(socket, size); 
// you now have your data 

byte[] ReadBytesFromSocket(Socket socket, int size) 
{ 
    var buff = new byte[size]; 
    int totalBytesRead = 0; 

    while (totalBytesRead < size) 
    { 
     int bytesRead = socket.Receive(buff, totalBytesRead, size-totalBytesRead, SocketFlags.None); 
     if (bytesRead == 0) 
     { 
      // nothing received. The socket has been closed. 
      // maybe an error. 
      break; 
     } 
     totalBytesRead += bytesRead 
    } 
    return buff; 
} 

Смотрите мой блог на reading streams (и связанные части 1 и 2) для получения дополнительной информации. В блогах рассказывается о потоках, но понятия одинаковы с сокетами.