Comment puis-je implémenter les données de diffusion de modèles de conception d'observateur en C++?

Question

Je souhaite envoyer des données d'un serveur à un client, en continu (streaming), sans que le client doive continuellement faire une boucle et vérifier les données. Je pense que j'ai raison de croire que c'est le modèle de conception de l'observateur? Comment est-ce possible?

Quelqu'un pourrait-il me fournir une liste de choses que je peux google? Comment l'aspect du modèle d'observateur est-il mis en œuvre?

Merci

Answer 1

Le modèle de conception d'observateur est légèrement différent de ce que vous décrivez:

Notez que chaque observateur est notifié par l'objet « observable »; Donc, si vous avez un serveur qui diffuse continuellement des données, alors vous attendez-vous à ce que le serveur vous «avertisse» et que voulez-vous que le serveur vous avertisse? Chaque paquet vous envoie-t-il? Chaque morceau de paquets? En résumé: non, vous ne pouvez pas implémenter le modèle d'observateur sur une application client/serveur. Il n'y a pas de moyen (facile) pour un serveur d'invoquer une méthode de notification sur votre application client et si votre client est déconnecté, il ne se désinscrit pas de l'observable.

Retour à votre question ... vous êtes limité par l'architecture: les sockets bloquants (tcp/udp) fonctionnent tous en bloquant jusqu'à ce que vous receviez des données. Une fois que vous recevez des données, vous devez passer en boucle et appeler à nouveau pour recevoir plus de données. Une alternative consiste à utiliser des sockets asynchrones:

• http://www.nightmare.com/medusa/async_sockets.html
• Boost Asynchronous UDP (note, je ne l'ai jamais utilisé, mais il semble que c'est ce que vous voudrez peut-être)
• Ou tout simplement Google Asynchronous UDP sockets.

communication socket asynchrone est probablement aussi proche que vous obtiendrez le motif d'observateur. En outre, vous souhaitez utiliser le protocole UDP car vous disposez de données en continu et UDP est spécialement conçu pour le streaming de données. Si vous ne voulez pas manquer de paquets (en raison du manque de fiabilité d'UDP), vous pouvez utiliser reliable UDP.

Answer 2

Vous ne pouvez pas implémenter un modèle d'observateur pour le cas d'utilisation Client/Serveur car le protocole de communication est entièrement différent. (RPC peut convenir, mais vous utilisez TCP donc)

Quoi qu'il en soit, vous pouvez avoir un client TCP dédié pour recevoir des données. C'est ce client TCP et votre classe interne peut implémenter ensemble un pattern Observer. Avec cela, votre classe n'aura plus à attendre (interroger) sur les données.

Shash

Answer 3

Si je comprends bien, la principale préoccupation est l'application client ici ne doit pas être bloqué en attente de données du serveur. Pour cela, vous pouvez créer un thread qui agira sur les événements de socket. Vous pouvez enregistrer le contexte de votre classe avec ce module de threads et chaque fois que des données sont reçues, ce module de thread peut effectuer un rappel (notifier) ​​en utilisant le contexte enregistré.