c # socket de comunicación, definiciones de mensajes datos de recepción síncronos con la longitud

Debido a que no hay carga de archivos, no hay byte grande se transmite, los datos entraría en la cola, por lo que no hay uso asíncrono, síncrono para recibir datos.

El principio es:

1. Los cuatro primeros bytes de la cabecera del mensaje, el cuerpo del mensaje definen longitud;

2. define los siguientes bytes cuerpo del mensaje;

3. El servidor recibe el mensaje, la marca de cabecera del mensaje obtenido de acuerdo con la longitud del cuerpo del mensaje, si no, continuar recibiendo; suficiente y si hay un exceso de, la cabeza adquiere de nuevo ir secuencialmente hacia abajo;

        Privada  sin efecto el (la ranura, Recibe Cadena IP) 
        { 
            Task.Factory.StartNew (() => 
            { 
                var Paquete = nueva nueva BytePkg (); 

                al mismo tiempo ( true ) 
                { 
                    try 
                    { 
                        // Si la toma está apagado, el ciclo termina 
                        SI (! socket.Connected) 
                        { 
                            _logger.Warn ($ " del IP: IP {}, zócalo se ha desconectado, deja de recibir datos; " );
                             PAUSA ; 
                        } 

                        bytes[] PrevBytes = nuevo  byte [ 1024 ];
                        int len = socket.Receive (prevBytes, prevBytes.Length, SocketFlags.None);
                        var bytes = prevBytes.Take (len) .ToArray (); 

                        este .RcvHeadData (paquete, bytes); 
                    } 
                    Catch (Exception ex) 
                    { 
                        _logger.Error ($ " IP: {IP},接收toma数据异常, mensaje: {} ex.Message, StackTrace: {} ex.StackTrace; " ); 
                    } 
                } 
            }); 
        } 
        
        ///  <summary>
        /// 消息头
         ///  </ summary> 
        ///  <param name = "paquete"> </ param> 
        ///  <param name = "bytes"> </ param> 
        privada  vacío RcvHeadData (paquete BytePkg, byte [] bytes) 
        { 
            var len = bytes.Length; 

            pack.headIndex + = len; si (pack.headIndex < pack.headLen) 
            { para ( int x = 0 ; x <len; x ++ ) 
                { 
                    pack.headBuff [pack.headIndex - len + x] =  bytes [x];
                }; 
            } 
            La otra cosa 
            { var actualHeadLen = pack.headIndex - len; // cabeza de la longitud real 
                var skipHeadLen = pack.headLen - actualHeadLen; // necesidades para hacer que la longitud; cabeza definir la longitud - longitud de la cabeza = cuerpo realmente necesita ser omitido la longitud 
                de ( int X = 0 ; X <skipHeadLen; X ++ ) 
                { 
                    pack.headBuff [actualHeadLen + X] = bytes [X]; 
                } // ★★★★★ comienza porción de procesamiento de mensajes ★★★★★ 
                var bodyLen len =; // longitud del cuerpo 
                IF (skipHeadLen> 0 )
                {
                    bodyLen = len - skipHeadLen; // primer lugar, obtener la longitud de la porción restante de 
                    pack.InitBodyBuff (); // primero tiempo requerido para inicializar cuerpo 
                } el este .RcvBodyData (Pack, bytes.Skip (skipHeadLen) .Tomar (bodyLen) .toArray ()); 
            } 
        } 

        ///  <summary> 
        /// cuerpo del mensaje
         ///  </ resumen> 
        ///  <param name = "pack"> </ param> 
        ///  <param name = "bytes "> </ param> 
        privada  vacío RcvBodyData (BytePkg paquete, byte [] bytes) 
        { 
            var len = bytes.Length;

            pack.bodyIndex + = len;
 IF (pack.bodyIndex < pack.bodyLen) 
            { para ( int X = 0 ; X <len; X ++ ) 
                { 
                    pack.bodyBuff [pack.bodyIndex - len + X] = bytes [X]; 
                }; 
            } 
            la otra cosa 
            { var actualBodyLen = pack.bodyIndex - len; // longitud real del cuerpo 
                var skipBodyLen = pack.bodyLen - actualBodyLen; // necesidad de compensar la longitud, el cuerpo define la longitud de - la longitud real del cuerpo = la necesidad de obtener la longitud del cuerpo 
                para ( int X =0 ; X <skipBodyLen; X ++ ) 
                { 
                    pack.bodyBuff [actualBodyLen + X] = bytes [X]; 
                } 
// datos de proceso recibidos 
                NetMsg ByteHelper.DeSerialize MSG = <NetMsg> (pack.bodyBuff);
                 el este .OnReceiveMsg ( MSG);
 // paquete de restablecimiento 
                pack.ResetData (); // ★★★★★ se inicia el procesamiento de la parte de cabecera del mensaje ★★★★★ 
                el este .RcvHeadData (pack, bytes.Skip (skipBodyLen) .toArray ()); 
            } 
        }

Si usted no confía, puede agregar el registro en el lugar más el registro, lógico observar el código es correcto. Descripción: Este es un dibujo de un proyecto de código abierto, llamado reforma PESocket.