C# SocketAsyncEventArgs gestione ricezione e invio dati

Question

Sto cercando di capire la classe 'SocketAsyncEventArgs' in C#. http://msdn.microsoft.com/en-us/library/system.net.sockets.socketasynceventargs.aspx

Sto seguendo questo tutorial: http://www.codeproject.com/Articles/83102/C-SocketAsyncEventArgs-High-Performance-Socket-Cod

Ora mi sono bloccato sul modo in cui ho esattamente dovrei elaborare i dati con il mio server. Quello che sto cercando di fare è usare un SocketAsyncEventArgs per un client connesso con uno spazio Buffer allocato di 512 byte nel BufferManager. Quindi quello che voglio fare è decodificare i dati byte [] nella mia propria classe personalizzata (ClientPacket) che contiene il byte [] per la decodifica e la lettura.

Questo è perfetto ma il mio server non sempre risponde con i dati la domanda è:

posso utilizzare 1 SocketAsyncEventArgs per la ricezione e anello intorno per elaborare ricevere i dati, quindi allocare un SocketAsyncEventArgs dalla piscina ogni volta Devo inviare quindi restituirlo al completamento?

E come sa SocketAsyncEventArgs quando la lettura è completa? (quando ha finito con il buffer byte [] prima di sovrascriverlo con nuovi dati) come quando viene restituito al pool quando viene eseguito se non rispondo?

Answer 1

Io uso solo un'istanza SocketAsyncEventArgs per tutte le mie esigenze. Ho semplicemente resettato il buffer tra ogni richiesta (impostandolo su un nuovo Byte []).

volta ho collegato e avere un riferimento alla presa, inizio ascoltando simili:

public void StartListening(SocketAsyncEventArgs e) 
{ 
    ResetBuffer(e); 
    e.Completed += SocketReceive; 

    socket.ReceiveAsync(e); 
} 

Ho una funzione di supporto che resetta il buffer:

private void ResetBuffer(SocketAsyncEventArgs e) 
{ 
    var buffer = new Byte[SocketBufferSize]; 

    e.SetBuffer(buffer, 0, SocketBufferSize); 
} 

Elaboro dati come:

private void SocketReceive(Object sender, SocketAsyncEventArgs e) 
{ 
    ProcessData(e.Buffer, 0, e.BytesTransferred); 

    ResetBuffer(e); 

    socket.ReceiveAsync(e); 
} 

In ProcessData, è possibile utilizzare l'array di byte necessario per inserire i dati . Io lo uso per creare un MemoryStream che ho poi deserializzare nella mia classe (simile a ClientPacket), come segue:

private void ProcessData(Byte[] data, Int32 count) 
{ 
    using (var stream = new MemoryStream(data, 0, count)) 
    { 
     var serializer = new XmlSerializer(typeof(ClientPacket)); 

     var packet = serializer.Deserialize(stream); 

     // Do something with the packet 
    } 
} 

quanto riguarda la tua ultima domanda. Il framework gestisce tutto ciò che ha a che fare con il protocollo TCP sottostante, ecc., Così puoi contare sul fatto che il gestore eventi venga chiamato ogni volta che ci sono dati da elaborare. Utilizza il valore e.BytesTransferred per indicare la quantità di dati effettivamente ricevuti che potrebbe essere inferiore ma non supererà mai la dimensione del buffer (SocketBufferSize nel mio codice). Se il messaggio era più grande della dimensione del buffer, l'infrastruttura TCP bufferizzerà i messaggi e li invierà in blocchi basati su SocketBufferSize (sollevando l'evento una volta per ogni blocco). Se si tratta di una preoccupazione, è sufficiente aumentare SocketBufferSize fino a quando la maggior parte del messaggio viene ricevuta in un blocco.

Lo svantaggio del chunking è che i messaggi possono essere uniti dall'infrastruttura, il che significa che potrebbe essere necessario un modo per dire quando il primo messaggio è terminato. Gli approcci tipici includono la prefazione del messaggio con un intero di 4 byte che indica la lunghezza del messaggio. Posso elaborare di più se necessario.

Spero che questo aiuti.