perte d'octets aléatoire lors de la diffusion de données sur le réseau

Question

Mon problème est que lorsque je diffuse un flux continu de données sur un réseau LAN LOCAL, des octets aléatoires sont parfois perdus au cours du processus.

Dans l'état actuel des choses, le code est configuré pour diffuser environ 1 027 octets environ environ 40 fois par seconde sur un réseau local et parfois (très rare) un ou plusieurs octets sont perdus.

Ce qui me déroute, c'est que l'octet réel n'est pas "perdu", il est simplement défini sur 0 quelles que soient les données d'origine.(J'utilise TCP d'ailleurs)

Voici le code d'envoi :

    public void Send(byte[] data)
    {
        if (!server)
        {
            if (CheckConnection(serv))
            {
                serv.Send(BitConverter.GetBytes(data.Length));
                serv.Receive(new byte[1]);
                serv.Send(data);
                serv.Receive(new byte[1]);
            }
        }
    }

et le code de réception :

    public byte[] Receive()
    {
        if (!server)
        {
            if (CheckConnection(serv))
            {
                byte[] TMP = new byte[4];
                serv.Receive(TMP);
                TMP = new byte[BitConverter.ToInt32(TMP, 0)];
                serv.Send(new byte[1]);
                serv.Receive(TMP);
                serv.Send(new byte[1]);
                return TMP;
            }
            else return null;
        }
        else return null;
    }

L'envoi et la réception des octets vides servent simplement à maintenir le système en quelque sorte synchronisé.Personnellement, je pense que le problème réside du côté réception du système.Je n'ai cependant pas pu prouver l'existence de ce jet.

Answer 1

Juste parce que tu donnes Receive(TMP) un tableau de 4 octets ne signifie pas qu'il va remplir ce tableau avec 4 octets.L'appel de réception est autorisé à passer n'importe où entre 1 et TMP.Length octets dans le tableau.Vous devez vérifier le retour int pour voir combien d'octets du tableau ont été remplis.

Les connexions réseau sont basées sur des flux et non sur des messages.Tous les octets que vous mettez sur le câble sont simplement concaténés dans une grande file d'attente et sont lus de l'autre côté dès qu'ils deviennent disponibles.Donc si vous avez envoyé les deux tableaux 1,1,1,1 et 2,2,2,2 il est tout à fait possible que du côté récepteur vous appeliez Receive trois fois avec un tableau de 4 octets et obtenez

• 1,1,0,0 (Recevoir retourné 2)
• 1,1,2,2 (Recevoir retourné 4)
• 2,2,0,0 (Recevoir retourné 2)

Donc, ce que vous devez faire, c'est regarder les valeurs que vous avez récupérées. Receive et continuez à boucler jusqu'à ce que votre tableau d'octets soit plein.

byte[] TMP = new byte[4];

//loop till all 4 bytes are read
int offset = 0;
while(offset < TMP.Length)
{
    offset += serv.Receive(TMP, offset, TMP.Length - offset, SocketFlags.None);
}
TMP = new byte[BitConverter.ToInt32(TMP, 0)];

//I don't understand why you are doing this, it is not necessary.
serv.Send(new byte[1]); 

//Reset the offset then loop till TMP.Length bytes are read.
offset = 0;
while(offset < TMP.Length)
{
    offset += serv.Receive(TMP, offset, TMP.Length - offset, SocketFlags.None);
}

//I don't understand why you are doing this, it is not necessary.
serv.Send(new byte[1]);

return TMP;

Enfin, vous avez dit "le flux réseau vous confond", je suis prêt à parier que le problème ci-dessus est l'une des choses qui vous ont dérouté, passer à un niveau inférieur ne supprimera pas ces complexités.Si vous souhaitez supprimer ces pièces complexes afin de ne pas avoir à les gérer, vous devrez utiliser une bibliothèque tierce qui les gérera pour vous dans la bibliothèque.