[.netv2] classcom - classe de communication en réseau simplifiée gérant le multiclient, 2 en 1 client et serveur - class soc

Soyez le premier à donner votre avis sur cette source.

Snippet vu 13 127 fois - Téléchargée 20 fois

Contenu du snippet

Bonjour,

Je vous présente ici une class de communication réseau, simple et d'utilisation claire, pour tout ceux qui rencontre (ou non) des problèmes avec les sockets.

Fonctionnement :

} Connexion
- on définit grâce au constructeur si c'est un serveur qui écoute ou bien un client qui va se connecter à un serveur
- si instanciée en serveur, un évenement prévient lorsqu'une connexion arrive, et donne le socket client (qu'il suffit de passer à un constructeur de cette class)
- si instanciée en client (avec les infos de connexion en paramètre), un évenement prévient si la connexion s'est effectuée ou non

} Communication
# les messages sont des classcomm.commMessage (structure perso pour simplifier la comm réseau)
- pour envoyer un message, on utilise Send qui prend en paramètre un Ordre (string) et un Message (string)
- pour recevoir des messages, il suffit de tester de temps en temps MsgCount : si y'en a 0 c'est qu'il n'y a pas de CommMessage à consommer, sinon c'est qu'il y en a le nombre indiqué en attente d'être lu, grâce à ReadNextMsg qui renvoie le CommMessage

} L'event ProblemDetected
- renvoit ErrorType.connection_failed si un client n'a pas su se connecter à un serveur donné
- renvoit ErrorType.seems_disconnected si on est vraisemblablement déconnecté (erreur pendant une transmission par exemple)
- renvoit ErrorType.failed_to_listen si un serveur n'arrive pas à écouter sur un port donné ou tout autre erreur à l'ouverture d'un serveur

} Fermeture
- pour fermer un serveur ou déconnecter un client, utilisez la méthode Dispose
#en gros l'objet ne vit QUE connecté. Simple.

Ci-dessous la class à coller directement dans un module de class.net :

Source / Exemple :


Imports System.Net.Sockets
Imports System.Net
Imports System.Text

Public Class ClassComm
  Implements IDisposable

#Region "IDisposable Support"
  Private disposedValue As Boolean = False

  ' IDisposable
  Protected Overridable Sub Dispose(ByVal disposing As Boolean)
    If Not Me.disposedValue Then
      If disposing Then
        If Not TimerConnectionTimeOut Is Nothing Then
          TimerConnectionTimeOut.Enabled = False
          TimerConnectionTimeOut.Close()
          TimerConnectionTimeOut.Dispose()
          TimerConnectionTimeOut = Nothing
        End If
        If Not TimerSendTimeOut Is Nothing Then
          TimerSendTimeOut.Enabled = False
          TimerSendTimeOut.Close()
          TimerSendTimeOut.Dispose()
          TimerSendTimeOut = Nothing
        End If
        If Not TimerSend Is Nothing Then
          TimerSend.Enabled = False
          TimerSend.Close()
          TimerSend.Dispose()
          TimerSend = Nothing
        End If
        _bytes = Nothing
        _qrcv.Clear()
        _qrcv = Nothing
        _qsnd.Clear()
        _qsnd = Nothing
        On Error Resume Next
        _sck.Shutdown(SocketShutdown.Both)
        _sck.Close()
        On Error GoTo 0
        _sck = Nothing
      End If
      'free shared unmanaged resources
    End If
    Me.disposedValue = True
  End Sub

  Public Sub Dispose() Implements IDisposable.Dispose
    Dispose(True)
    GC.SuppressFinalize(Me)
  End Sub
#End Region

#Region "Enumeration"
  Public Enum ErrorType
    seems_disconnected
    connection_failed
    failed_to_listen
  End Enum
#End Region

#Region "Structure"
  Public Structure CommMessage
    Public Order As String
    Public Message As String
    Private _idCode As Long
    Public IsComplete As Boolean
    Public Property idCode() As Long
      Get
        If _idCode = 0 Then _idCode = Now.Ticks / ((Rnd() * 1000) + 1)
        Return _idCode
      End Get
      Set(ByVal value As Long)
        If _idCode = 0 Then _idCode = value
        _idCode = value
      End Set
    End Property
    Public ReadOnly Property MyBytes() As Byte()
      Get
        If _idCode = 0 Then _idCode = Now.Ticks / ((Rnd() * 1000) + 1)
        If Order Is Nothing Then Order = ""
        If Message Is Nothing Then Message = ""
        Dim ms As New IO.MemoryStream
        Dim bw As New IO.BinaryWriter(ms, Encoding.Unicode)
        With bw
          .Write(Order)
          .Write(Message)
          .Write(IsComplete)
          .Write(_idCode)
          .Close()
        End With
        ms.Close()
        Return ms.ToArray
        bw = Nothing
        ms.Dispose()
        ms = Nothing
      End Get
    End Property
    Public Sub SetBytes(ByRef ByteCommMessage As Byte())
      Dim ms As New IO.MemoryStream(ByteCommMessage, False)
      Dim br As New IO.BinaryReader(ms, Encoding.Unicode)
      With br
        Order = .ReadString
        Message = .ReadString
        IsComplete = .ReadBoolean
        _idCode = .ReadUInt64
        .Close()
      End With
      br = Nothing
      ms.Close()
      ms.Dispose()
      ms = Nothing
    End Sub
    Public Function ConfirmSequence() As Byte()
      Dim ms As New IO.MemoryStream
      Dim bw As New IO.BinaryWriter(ms, Encoding.Unicode)
      With bw
        .Write("")
        .Write("")
        .Write(True)
        .Write(_idCode)
        .Close()
      End With
      ms.Close()
      Return ms.ToArray
      bw = Nothing
      ms.Dispose()
      ms = Nothing
    End Function
  End Structure
#End Region

#Region "Private objects"
  Private _bytes() As Byte
  Private _qrcv As New Queue(Of CommMessage)
  Private _qsnd As New Queue(Of CommMessage)
  Private _last_send As CommMessage
  Private _last_rcv As CommMessage
  Private _sck As Socket = New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP)
  Private WithEvents TimerConnectionTimeOut As Timers.Timer
  Private WithEvents TimerSendTimeOut As Timers.Timer
  Private WithEvents TimerSend As New Timers.Timer(10)
  Private _sending As Boolean = False
#End Region

#Region "Events"
  Public Event ConnectionRequestAccepted(ByRef sck As Socket)
  Public Event Connected()
  Public Event ProblemDetected(ByVal source As ErrorType)
  Public Event NewMessage()
#End Region

#Region "Constructor New"

  Public Sub New(ByVal Port_To_Listen_If_Server As Integer)
    _last_rcv.idCode = -1
    _last_rcv.IsComplete = True
    Try
      With _sck
        .Bind(New IPEndPoint(IPAddress.Any, Port_To_Listen_If_Server))
        .Listen(10)
        .BeginAccept(AddressOf CallBackAccept, _sck)
      End With
    Catch
      RaiseEvent ProblemDetected(ErrorType.failed_to_listen)
    End Try
  End Sub
  Public Sub New(ByVal Host_To_Connect As String, ByVal Port_To_Connect As Integer, Optional ByVal Timeout_ms As Integer = 5000)
    _last_rcv.idCode = -1
    _last_rcv.IsComplete = True
    If Timeout_ms >= 0 Then
      TimerConnectionTimeOut = New Timers.Timer
      TimerConnectionTimeOut.Interval = Timeout_ms
      TimerConnectionTimeOut.Enabled = True
      TimerSendTimeOut = New Timers.Timer
      TimerSendTimeOut.Interval = Timeout_ms
      TimerSendTimeOut.Enabled = False
    End If
    Try
      _sck.BeginConnect(Host_To_Connect, Port_To_Connect, AddressOf CallBackConnect, _sck)
    Catch
      RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
    End Try
  End Sub
  Public Sub New(ByRef Sck As Socket, Optional ByVal Timeout_ms As Integer = 5000)
    _last_rcv.idCode = -1
    _last_rcv.IsComplete = True
    If Sck.Connected Then
      If Timeout_ms >= 0 Then
        TimerSendTimeOut = New Timers.Timer
        TimerSendTimeOut.Interval = Timeout_ms
        TimerSendTimeOut.Enabled = False
      End If
      Try
        _sck = Sck
        TimerSend.Enabled = True
        _bytes = New Byte(_sck.ReceiveBufferSize) {}
        _sck.BeginReceive(_bytes, 0, _sck.ReceiveBufferSize, SocketFlags.None, AddressOf CallBackReceive, _sck)
      Catch
        RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
      End Try
    Else
      RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
    End If
  End Sub

#End Region

#Region "Timers events"
  Private Sub TimerConnectionTimeOut_Elapsed(ByVal sender As Object, ByVal e As system.Timers.ElapsedEventArgs) Handles TimerConnectionTimeOut.Elapsed
    TimerConnectionTimeOut.Enabled = False
    RaiseEvent ProblemDetected(ErrorType.connection_failed)
  End Sub

  Private Sub TimerSendTimeOut_Elapsed(ByVal sender As Object, ByVal e As System.Timers.ElapsedEventArgs) Handles TimerSendTimeOut.Elapsed
    If _sending Then Sendcm(_last_send.MyBytes) Else TimerSendTimeOut.Enabled = False
  End Sub

  Private Sub TimerSend_Elapsed(ByVal sender As Object, ByVal e As System.Timers.ElapsedEventArgs) Handles TimerSend.Elapsed
    If Not _sending Then
      If _qsnd.Count > 0 Then
        Sending(True)
        _last_send = _qsnd.Dequeue
        Sendcm(_last_send.MyBytes)
      End If
    End If
  End Sub

#End Region

#Region "Public properties"
  Public ReadOnly Property ReadNextMsg() As CommMessage
    Get
      If _qrcv.Count > 0 Then Return _qrcv.Dequeue Else Return Nothing
    End Get
  End Property

  Public ReadOnly Property MsgCount() As Integer
    Get
      Return _qrcv.Count
    End Get
  End Property

  Public ReadOnly Property IsSending() As Boolean
    Get
      Return _sending
    End Get
  End Property

#End Region

#Region "Public functions"

  Public Sub Send(ByVal Order As String, ByVal Message As String)
    Dim cm As CommMessage
    Dim LenTT As Integer = (Order & Message).Length
    If LenTT > 4000 Then
      'Si supérieur à 4000 alors découpe

      'Les paquets sont basés sur 4000 car le tout sera encodé en Unicode, donc doublé,
      'la limite des paquets des sockets étant 8192, j'ai arrondi la découpe à 4000
      'pour prendre en compte les autres paramètres transmis avec les messages
      Dim i As Integer = 0
      Dim j As Integer = 0
      Dim ti As Integer
      Dim tj As Integer
      Do
        tj = 0
        ti = 0
        cm = New CommMessage
        ti = IIf(Order.Substring(i).Length > 4000, 4000, Order.Substring(i).Length)
        cm.Order = Order.Substring(i, ti)
        i += ti
        If ti < 4000 Then
          tj = IIf(Message.Substring(j).Length > (4000 - ti), (4000 - ti), Message.Substring(j).Length)
          cm.Message = Message.Substring(j, tj)
          j += tj
        End If
        cm.IsComplete = (LenTT = i + j)
        _qsnd.Enqueue(cm)
      Loop Until cm.IsComplete

    Else
      'Sinon envoie tel quel
      cm = New CommMessage
      cm.Order = Order
      cm.Message = Message
      cm.IsComplete = True
      _qsnd.Enqueue(cm)
    End If
  End Sub

#End Region

#Region "Private functions"
  Private Sub Sendcm(ByRef _b() As Byte)
    Try
      _sck.BeginSend(_b, 0, _b.Length, SocketFlags.None, AddressOf CallBackSend, _sck)
    Catch
      RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
    End Try
  End Sub
  Private Sub Sending(ByVal Flag As Boolean)
    _sending = Flag
    TimerSendTimeOut.Enabled = Flag
  End Sub
#End Region

#Region "Socket delegate CallBack"

  'en mode serveur, renvoit un socket connecté à un client
  'puis repasse en attente
  Private Sub CallBackAccept(ByVal async As IAsyncResult)
    Try
      RaiseEvent ConnectionRequestAccepted(_sck.EndAccept(async))
      _sck.BeginAccept(AddressOf CallBackAccept, _sck)
    Catch
      RaiseEvent ProblemDetected(ErrorType.failed_to_listen)
    End Try
  End Sub

  'en mode client, établit la connexion
  Private Sub CallBackConnect(ByVal async As IAsyncResult)
    If Not TimerConnectionTimeOut Is Nothing Then TimerConnectionTimeOut.Enabled = False
    Try
      _sck.EndConnect(async)
      RaiseEvent Connected()
      TimerSend.Enabled = True
      _bytes = New Byte(_sck.ReceiveBufferSize) {}
      _sck.BeginReceive(_bytes, 0, _sck.ReceiveBufferSize, SocketFlags.None, AddressOf CallBackReceive, _sck)
    Catch
      RaiseEvent ProblemDetected(ErrorType.connection_failed)
    End Try
  End Sub

  'réception de données, puis se remet en attente
  Private Sub CallBackReceive(ByVal async As IAsyncResult)
    Dim size As Integer
    Try
      size = _sck.EndReceive(async)
      If size > 0 Then
        Dim cm As New CommMessage
        cm.SetBytes(_bytes)
        If cm.Order = "" AndAlso cm.Message = "" Then
          If cm.idCode = _last_send.idCode Then Sending(False)
        Else
          If cm.idCode <> _last_rcv.idCode Then
            If Not _last_rcv.IsComplete Then
              cm.Order = cm.Order.Insert(0, _last_rcv.Order)
              cm.Message = cm.Message.Insert(0, _last_rcv.Message)
            End If
            _last_rcv = cm
            If cm.IsComplete Then
              _qrcv.Enqueue(cm)
              RaiseEvent NewMessage()
            End If
          End If
          Sendcm(cm.ConfirmSequence)
        End If
      Else
        RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
      End If
      _bytes = New Byte(_sck.ReceiveBufferSize) {}
      _sck.BeginReceive(_bytes, 0, _sck.ReceiveBufferSize, SocketFlags.None, AddressOf CallBackReceive, _sck)
    Catch
      RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
    End Try
  End Sub

  'envoi des données terminées
  Private Sub CallBackSend(ByVal async As IAsyncResult)
    Try
      _sck.EndSend(async)
    Catch
      RaiseEvent ProblemDetected(ErrorType.seems_disconnected)
    End Try
  End Sub

#End Region

End Class

Conclusion :


>>>>> Pourquoi avoir utilisé une structure perso (commMessage) pour l'envoi et la réception ?
L'utilisateur de cette classe simplifiée n'a pas à s'inquiéter de ce qu'il envoit et comment il l'envoit. Il envoit juste.
A la réception on reçoit donc un commMessage, on regarde l'ordre (par exemple avec un select case) et on interprete donc le message correctement, l'ordre nous renseignant sur ce qu'on doit faire du message (exemple : est-ce que c'est l'âge du gars, son nom ou bien son prénom ?)
Démo :

Dim cm As ClassComm.CommMessage = _comm.ReadNextMsg
Select Case cm.Order
Case "nom"
Msgbox("La personne connectée s'appelle " & cm.Message & ".")
Case "age"
Msgbox("La personne connectée a " & cm.Message & " ans.")
Case "passion"
Msgbox("La personne connectée est passionnée par " & cm.Message & ".")
End Select

>>>>> Pourquoi ne pas avoir mis en event un message arrivant ?
Parceque les sockets sont multithreads et c'est pas propre du tout : les events sont renvoyés dans un thread à part à cause des callbacks des sockets, donc on ne peut pas agir sur une interface à partir des events renvoyés par la class.
Alors j'ai jugé plus souple de mettre les messages arrivant dans une file d'attente FIFO (first in first out), qui sera par exemple checké par l'utilisateur à l'aide d'un Timer 100ms, ce qui est parfait pour de la comm réseau.
Démo :

Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
If Not _traitement Then
If _comm.MsgCount > 0 Then
_traitement = True
Dim cm As ClassComm.CommMessage = _comm.ReadNextMsg
'traitement du message ici ou renvoie sur une sub qui traitera
_traitement = False
End If
End If
End Sub

>>>>> C'est quoi idCode dans le commMessage ?
La classe est consciencieuse : quand elle envoit un message, avant de pouvoir en envoyer un nouveau, elle attend d'avoir la confirmation que le message précédent a bien été reçu (bien que le protocole TCP/IP est censé s'en occupé... mais j'ai déjà subit trop de perte en réseau pour des causes inconnues donc avec ça, c'est plus un problème). Chaque message a un idCode unique, et ce code sert d'accusé de réception. Quand la class reçoit un message, elle renvoie l'idCode à l'expéditeur pour dire OK, sinon le dit expéditeur renverra sans cesse le message au bout d'un laps de temps (timeout définit au constructeur) jusqu'à avoir la confirmation que c'est bien reçu.
Pas d'inquiétude, les messages n'arrivent pas en double, le mécanisme est bien géré, tout est vérifié.
Pas d'inquiétude non plus, les nouveaux messages demandés à être envoyé entre un envoi précédent et son propre accusé de réception sont mis en file d'attente pour être envoyé après, donc rien n'est perdu.
Au final on a une class bien aboutie qui gère bien ses comm réseau à la place de l'user.
Bref, ne pas prendre garde à l'idcode, c'est pour info seulement, au cas où on en aurait besoin pour autre chose... sinon pas touche !!
De toute façon c'est une property codée et la valeur de l'IdCode n'est redéfinissable que si elle n'a pas encore été attribuée (valeur 0).

Exemple d'utilisation complet à lire :
Public Class Form1

Private WithEvents Srv As New ClassComm(25000) 'ici on a déjà un serveur en écoute sur le port 25000
Private WithEvents Clt1 As ClassComm
Private WithEvents Clt2 As ClassComm

'en cliquant sur le Button1, on créé le client classComm CLT1 qui va tenter de se connecter au serveur (déjà ouvert juste au dessus)
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Clt1 = New ClassComm("localhost", 25000)
End Sub

'ici le serveur reçoit la demande de connexion et l'accepte en créant le client ClassComm CLT2
Private Sub Srv_ConnectionRequestAccepted(ByRef sck As System.Net.Sockets.Socket) Handles Srv.ConnectionRequestAccepted
Clt2 = New ClassComm(sck)
End Sub

'ceci est l'évenement du client ClassComm CLT1 qui confirme que la connexion a bien eu lieu
'a ce stade on a donc une communication prête et ouverte entre CLT1 et CLT2, avec en plus un serveur qui écoute toujours
'normalement c'est fait pour du multiclient donc on devrait pas avoir juste CLT1 et CLT2 mais une collection de client
'et là à ce stade de cette petite appli, vu que ses 2 clients sont pris, on devrait fermer le serveur avec Srv.dispose, mais bref....
Private Sub Clt1_Connected() Handles Clt1.Connected
MsgBox("connecté" )
End Sub

'en cliquand sur le Button2, on fait envoyer un commMessage (ordre + message) par CLT1
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Clt1.Send(InputBox("ordre" ), InputBox("mon message" ))
End Sub

'ici j'ai mis un bouton qui permet de dire si la file d'attente du CLT2 contient des messages
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
MsgBox(Clt2.MsgCount)
End Sub

'et ici un bouton qui lit les messages en attente dans CLT2
Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
Dim cm As CommMessage = Clt2.ReadNextMsg
MsgBox(cm.Order & vbCrLf & cm.Message)

'ici il faudrait (exemple) :
'SELECT CASE cm.Order
'CASE "age" : msgbox ("le type a " & cm.Message & " ans" )
'CASE "nom" : msgbox ("le type s'appelle " & cm.Message)
'CASE "profession" : msgbox ("le type travaille dans " & cm.Message)
'END SELECT

End Sub


'Les 2 subs précédentes devraient être dans un Timer avec un test sur MsgCount

'ici un exemple de l'event ProblemDetected chez CLT1
Private Sub Clt1_ProblemDetected(ByVal source As ClassComm.ErrorType) Handles Clt1.ProblemDetected
Select Case source
Case ErrorType.connection_failed : MsgBox("échec connexion" )
Case ErrorType.seems_disconnected : MsgBox("semble déconnecté" )
End Select
Clt1.Dispose()
Clt1 = Nothing
End Sub

End Class

A voir également

Ajouter un commentaire

Commentaires

celiphane
Messages postés
466
Date d'inscription
samedi 16 février 2002
Statut
Membre
Dernière intervention
20 avril 2007
-
Je n'ai pas encore pleinement exploité cette class et bien que je ne vois pas encore lesquels (car j'ai vraiment travaillé cette class pour qu'elle soit exploitable), j'attends vos déclarations de bug.

Cordialement,
Celiphane
cs_Dnx
Messages postés
16
Date d'inscription
jeudi 9 octobre 2003
Statut
Membre
Dernière intervention
16 juillet 2007
-
Hello,

ta source a l'air vachement bien faite, bien expliquée, je vais la tester un peu pour voir... mais avant, dans quel cas devrais-je utiliser ta classe? dans quand quel type d'application?

merci d'avance.
celiphane
Messages postés
466
Date d'inscription
samedi 16 février 2002
Statut
Membre
Dernière intervention
20 avril 2007
-
Merci pour ton commentaire.

Pour répondre à ta question, cette class peut s'utiliser à chaque fois que tu auras besoin de faire un application qui fonctionnera en réseau. Les usages sont donc multiples, du plus simple chat / dialogue en direct, jusqu'à la plus complexe des applications clients / serveur en entreprise par exemple.

Chaque fois que tu auras besoin de faire des applications qui devront communiquer en réseau, poste à poste ou bien architecture clients / serveur, tu peux sortir cette class de ta manche et elle t'épargnera un fastidieux codage de sockets, mais aussi le développement d'un protocole de communication perso ainsi que des tests de bonnes réceptions de tes messages réseaux. Elle gère tout cela.

Instancié en serveur, la class est dès le début orienté multiclients pour l'architecture clients / serveur. Si on ne souhaite pas faire du multiclients mais juste du poste à poste, à l'évènement ConnectionRequestAccepted de la classcomm serveur il suffit de lui faire << .Dispose >> puis de la réinstancier en passant à son constructeur le socket fourni par l'évènement. Et voilà, c'est devenu un simple poste à poste.

Je pense que tous ceux qui ont déjà l'habitude de coder en réseau appréciront ces fonctionnalités très simples.


Cordialement,
Celiphane
hvb
Messages postés
961
Date d'inscription
vendredi 25 octobre 2002
Statut
Membre
Dernière intervention
27 janvier 2009
1 -
salut, j'ai survolé un peu ton code. Je suis actuellement en train de finliser un projet semblable pour une de mes pti de fin d'année, et j'utilise la même ruse pour le multiclient.
Par contre perso j'ai opté pour une gestion d'évenement, avec la possibilité d'effectuer une synchronisation entre les threads. Je posterais d'ici quelques jours le resultat ici (d'ou ma deception quand j'ai vu ton post ^^)
celiphane
Messages postés
466
Date d'inscription
samedi 16 février 2002
Statut
Membre
Dernière intervention
20 avril 2007
-
Salut l'ami,
je suis désolé pour toi d'avoir posté cette source avant la tienne !

Est-ce que c'est le fait de renvoyer le socket fraichement connecté à un serveur dans un event pour pouvoir le passer au constructeur d'une nouvelle class (pour << transformer >> le socket en ClassComm) que tu appelles une ruse ? Car je ne dirais pas que j'ai employé une quelconque feinte dans ce code source. Tu m'expliqueras quand tu pourras ! :-)

Concernant la gestion d'évènement, c'est effectivement un choix. Comme je l'ai expliqué, je n'ai pas souhaité obligé l'utilisateur de la class à devoir se synchroniser avec son interface à chaque réception de données. Voilà pourquoi j'ai opté pour une queue FIFO, ce qui permet en outre à l'utilisateur de traiter les messages dans l'ordre, de prendre tout le temps qu'il faut avec un message et de passer au second ensuite. A l'inverse en mettant les réceptions en évènement, le risque (et c'est fréquent) est que pendant la gestion d'un message fraichement reçu, un autre message arrive et redéclenche l'évenement ce qui fait que tout se déroule en même temps, je trouve que c'est confu et selon les cas ça peut faire des conflits (si les traitements des deux messages manipulent ne serait-ce qu'une même variable ou bien un même contrôle, les résultats deviennent inattendu).

Bref c'est pour ça que j'ai garder le concept du FIFO : les messages s'enqueuent les uns à la suite des autres, et même pendant qu'un message est en cours de traitement, la classcomm continu d'enqueuer les nouveaux messages, qui seront donc traités seulement à la suite, un par un, sans conflit ni résultat inattendu.

Je ne critique absolument pas, au contraire j'ai hâte devoir comment d'autres que moi gère tout ces inévitables conflits réseaux. Je présente juste ma vision des choses, avec mon expérience.

A très bientôt,
Celiphane

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.