Remplacement de Socket.ReceiveAsync par NetworkStream.ReadAsync (awaitable)

J'ai une application qui fait quelques centaines de connexions TCP en même temps, et reçoit un flux constant de données.

 private void startReceive()
    {
        SocketAsyncEventArgs e = new SocketAsyncEventArgs();
        e.Completed += receiveCompleted;
        e.SetBuffer(new byte[1024], 0, 1024);
        if (!Socket.ReceiveAsync(e)) { receiveCompleted(this, e); }  
    }

    void receiveCompleted(object sender, SocketAsyncEventArgs e)
    {
        ProcessData(e);

        if (!Socket.ReceiveAsync(e)) { receiveCompleted(this, e); }
    }

Mes tentatives ont conduit à quelque chose comme ceci:

private async void StartReceive()
    {
        byte[] Buff = new byte[1024];
        int recv = 0;
        while (Socket.Connected)
        {
            recv = await NetworkStream.ReadAsync(Buff, 0, 1024);
            ProcessData(Buff,recv);
        }
    }

Le problème que j'ai eu a été la méthode d'appel StartReceive() serait de les bloquer, et de ne pas obtenir à l'accompagnement StartSend() method called afterStartReceive(). Creating a new task forStartReceive()would just end up with 300-ish threads, and it seems to do so just by callingStartReceive()` de toute façon.

Quelle serait la bonne méthode de la mise en œuvre de la nouvelle async et await les mots clés sur mon code existant lors de l'utilisation d'un NetworkStream de sorte qu'il utilise le pool de threads que Socket.SendAsync() et Socket.ReceiveAsync() sont utilisation afin d'éviter d'avoir des centaines de threads/tâches?

Est-il un avantage de performance de l'aide networkstream de cette manière plus de i/o ports de fin avec beginreceive?

source d'informationauteur Josh

  1. 25

    Vous êtes de changer deux choses à la fois: l'asynchrone style (SocketAsyncEventArgs à Task/async) et le niveau d'abstraction (Socket à NetworkStream).

    Puisque vous êtes déjà à l'aise avec Socketje recommande simplement de changer le asynchrones style, et de continuer à utiliser le Socket classe directement.

    La Async CTP ne donne pas Socket tout asyncméthodes compatibles avec (ce qui est bizarre; je suppose qu'ils ont été laissés de côté par erreur et sera ajouté dans .NET 4.5).

    Il n'est pas difficile de créer votre propre ReceiveAsyncTask méthode d'extension (et similaires, en emballages pour d'autres opérations) si vous utilisez mon AsyncEx bibliothèque:

    public static Task<int> ReceiveAsyncTask(this Socket socket,
    byte[] buffer, int offset, int size)
{
  return AsyncFactory<int>.FromApm(socket.BeginReceive, socket.EndReceive,
      buffer, offset, size, SocketFlags.None);
}

    Une fois que vous faites cela, votre StartReceive peut être écrite comme suit:

    private async Task StartReceive()
{
  try
  {
    var buffer = new byte[1024];
    while (true)
    {
      var bytesReceived = await socket.ReceiveAsyncTask(buffer, 0, 1024)
          .ConfigureAwait(false);
      ProcessData(buffer, bytesReceived);
    }
  }
  catch (Exception ex)
  {
    //Handle errors here
  }
}

    Maintenant, pour répondre à de nombreux points mineurs:

    • await ne pas générer un nouveau thread. J'ai écrit jusqu' un async/await intro sur mon blogcomme beaucoup d'autres. async/await permet la simultanéité, mais cela n'implique pas nécessairement le multithreading.
    • Des centaines de fils peut être problématique. Des centaines de tâchescependant, ne sont pas un problème du tout; le pool de threads et de la BCL sont conçus pour gérer de nombreuses, de nombreuses tâches.
    • async/await n'est pas une marque nouvelle forme de traitement asynchrone, c'est juste une moyen plus facile à express traitement asynchrone. Il utilise toujours IOCPs dessous. async/await a légèrement plus bas que le niveau inférieur méthodes; son appel, c'est la facilité de l'écriture et de la composition de méthodes asynchrones.
    • Un de très occupé système peut voir une certaine augmentation de la GC de la pression quand il passe en async/await. Stephen Toub sur le Parallèle de l'Équipe écrit quelques exemple de socket spécifique awaitables qui peut aider avec ce problème. (Je recommande d'utiliser le modèle simple d'abord, et seulement à l'aide de la performance-approche améliorée si vous trouvez qu'il est nécessaire; encore, il est bon de savoir qu'elle est là, si vous finissez par avoir besoin d'elle).
    • Méthodes asynchrones doit retourner Task à moins que vous vraiment besoin à retourner void. Task est awaitable, de sorte que votre méthode est modulable (et plus facilement testables); void est plus comme "fire and forget".
    • Vous pouvez appeler ConfigureAwait(false) pour informer le reste de la async méthode à exécuter sur un thread du pool. - Je l'utiliser dans mon exemple ci-dessus, de sorte que ProcessData est exécutée dans un thread du pool, tout comme il l'a été lors de l'utilisation de SocketAsyncEventArgs.
    • Socket.Connected est inutile. Vous avez besoin d'envoyer des données afin de détecter si la connexion est toujours valide.