Haute performance asynchrone en attente de sockets

Je suis en train d'écrire une application qui nécessitera de faire des centaines de connexions socket tcp pour lire/écrire des données.

Vous n'avez pas besoin de "haute performance prises" pour que. Le code est beaucoup plus simple avec des régulière de la performance des sockets.

Pour commencer, ne pas utiliser la coutume awaitables à partir du lien que vous avez posté. Ils sont parfaitement bien pour certaines personnes (et complètement "robuste"), mais vous n'en avez pas besoin et votre code sera plus simple sans eux.

1. Est-il quelque chose de mal avec l'au-delà, et peut-il être optimisé?

Oui. Vous ne devriez pas mélanger blocage (Connect) et asynchrone (ReadAsync) du code. Je recommande quelque chose comme ceci:

foreach (var ip in listofIps)
{
  IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(ip), 4001);
  Socket client = new Socket(AddressFamily.InterNetwork,
                             SocketType.Stream, ProtocolType.Tcp);
  await client.ConnectTaskAsync(remoteEP);
  ...
}

Où ConnectTaskAsync est un ROBINET standard-sur-APM wrapper:

public static Task ConnectTaskAsync(this Socket socket, EndPoint endpoint)
{
  return TaskFactory.FromAsync(socket.BeginConnect, socket.EndConnect, endpoint, null);
}

Marc Gravel a souligné, ce code (et votre code d'origine) est de connecter les prises une à une. Vous pouvez utiliser Task.WhenAll pour se connecter simultanément.

2) Est-il un moyen plus efficace de faire cela?

Tout d'abord, vous devez définir un ROBINET-sur-APM ReceiveTaskAsync wrapper similaire à ci-dessus. Lorsque vous traitez avec des données binaires, j'aime aussi avoir une méthode d'extension sur des tableaux d'octets pour le dumping:

public string DumpHex(this ArraySegment<byte> data)
{
  return string.Join(" ", data.Select(b => b.ToString("X2")));
}

Alors vous pouvez avoir un code comme ceci:

while (true)
{
  int bytesRead = await socket.ReceiveTaskAsync(buffer);
  if (bytesRead == 0) break;
  var data = new ArraySegment<byte>(buffer, 0, bytesRead);
  AppendLog("RX: " + data.HexDump());
  ...
}

Si vous faites beaucoup de binaire de manipulation, vous pouvez trouver mon ArraySegments bibliothèque utile.

3) Où et comment dois-je inclure la logique pour vérifier si un ensemble de données est arrivé à l'intérieur d'une seule lecture

Oh, c'est plus complexe que cela. 🙂 Les Sockets sont un flux abstraction, pas un message l'abstraction. Donc, si vous voulez définir des "messages" dans votre protocole, vous devez inclure un préfixe de longueur ou un délimiteur octet de sorte que vous pouvez détecter les limites de message. Ensuite, vous devez écrire le code qui va analyser vos messages, en gardant à l'esprit que les blocs de données lues à partir de la prise peut contenir qu'une partie du message (si vous avez de la mémoire tampon), un message complet, plusieurs messages complets, et peut également mettre fin à une partie d'un message (encore une fois, de mise en mémoire tampon). Et vous devez également tenir compte de votre existant de la mémoire tampon lors de la réception du nouveau bloc.

J'ai un TCP/IP .NET Sockets FAQ sur mon blog qui cela concerne en particulier les adresses et a quelques exemple de code à l'aide de mon personnel de préférences par défaut pour les messages d'encadrement (4 octets de poids faible longueur de préfixe).

4) Comment dois-je inclure un writeasync méthode telle que je peut envoyer des données par le biais de la socket dans le milieu du lit.

Que l'on est étonnamment délicat:

public static Task<int> SendTaskAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags)
{
  return Task<int>.Factory.FromAsync(socket.BeginSend, socket.EndSend, buffer, offset, size, flags, null);
}
public static Task WriteAsync(this Socket socket, byte[] buffer)
{
  int bytesSent = 0;
  while (bytesSent != buffer.Length)
  {
    bytesSent += await socket.SendTaskAsync(data, bytesSent, buffer.Length - bytesSent, SocketFlags.None);
  }
}

OriginalL'auteur Stephen Cleary