Flex 4.6 Zunehmende Socket-Empfangspuffergröße

Question

Ich habe ein Problem mit Sockets, wo die Daten, die ich sende, auf der Client-Seite abgeschnitten wird (Flash/Flex). Die Daten, die von meinem Server gesendet werden, sind voll und in Takt, aber Flash wartet nicht die entsprechende Zeit, bevor ein Ereignis ausgelöst wird, das sagt, dass die Daten gelesen werden sollen. Dies führt dazu, dass die Daten nicht vollständig gelesen werden und (als solche) kann ich das Objekt danach nicht mehr analysieren. Wir untersuchen die Möglichkeit, das Objekt in kleinere Stücke zu zerlegen, aber die Idee ist, dass es so leicht wie möglich ist, also würden wir es lieber so machen, wie es soll, als in einer temporären Lösung zu patchen.

Ich bin mir nicht ganz sicher, ob es sich auf den Empfang 'Puffer' bezieht, da einige Computer alle Daten empfangen können und andere es abgeschnitten haben (was bedeutet, dass der Puffer ausreichend ist, aber Flash isn) Warten Sie nicht die angemessene Zeit, um die Veranstaltung aus welchem ​​Grund auch immer zu senden) ... Wenn jemand Ideen hat, würde ich sie sehr schätzen!

Answer 1

Ohne Code Ihrer Implementierung zu sehen, klingt es wie verfügbare Bytes oder Gesamtbytes werden nicht berücksichtigt. Hier

ist eine Implementierung ich verwendet habe:

package 
{ 
    import flash.events.Event; 
    import flash.events.EventDispatcher; 
    import flash.events.IOErrorEvent; 
    import flash.events.ProgressEvent; 
    import flash.events.SecurityErrorEvent; 
    import flash.net.Socket; 

    public class WebRequestService extends EventDispatcher 
    { 

     //------------------------------ 
     // model 
     //------------------------------ 

     protected var hostname:String; 

     protected var port:uint; 

     public var requestMessage:String; 

     public var responseMessage:String; 

     private var _socket:Socket; 


     //------------------------------ 
     // lifecycle 
     //------------------------------ 

     public function WebRequestService(hostname:String, port:uint, requestMessage:String) 
     { 
      this.hostname = hostname; 
      this.port = port; 
      this.requestMessage = requestMessage; 

      _socket = new Socket(); 
      _socket.addEventListener(Event.CONNECT, socketConnectHandler); 
      _socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler); 
      _socket.addEventListener(Event.CLOSE, socketCloseHandler); 
      _socket.addEventListener(IOErrorEvent.IO_ERROR, socketErrorHandler); 
      _socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, socketSecurityErrorHandler); 

      _socket.connect(hostname, port); 
     } 

     protected function socketConnectHandler(event:Event):void 
     { 
      responseMessage = ""; 
      _socket.writeUTFBytes(requestMessage); 
      _socket.flush(); 
     } 

     protected function socketDataHandler(event:ProgressEvent):void 
     { 
      while (_socket.bytesAvailable > 4) 
      { 
       responseMessage += _socket.readUTFBytes(_socket.bytesAvailable); 
      } 
     } 

     protected function socketCloseHandler(event:Event):void 
     { 
      dispose(); 
     } 

     protected function socketErrorHandler(event:IOErrorEvent):void 
     { 
      trace("socket error."); 
     } 

     protected function socketSecurityErrorHandler(event:SecurityErrorEvent):void 
     { 
      trace("socket security error."); 
     } 

     public function dispose():void 
     { 
      if (!_socket) 
       return; 

      if (_socket.connected) 
       _socket.close(); 

      _socket.removeEventListener(Event.CONNECT, socketConnectHandler); 
      _socket.removeEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler); 
      _socket.removeEventListener(Event.CLOSE, socketCloseHandler); 
      _socket.removeEventListener(IOErrorEvent.IO_ERROR, socketErrorHandler); 
      _socket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, socketSecurityErrorHandler); 
     } 

    } 
}