Discussion :

[simaxe25]

Bonjour à tous !

je développe actuellement sous Visual C++ .NET (VC2008 orcas b2)
et je suis confronté a un problème quasi-existentiel

je suis entrain de développer une classe/librairie (dll), qui me permettra (peut être un jour),
d'envoyer des bêtes messages UDP à travers un réseau...
l'envoi de paquets UDP s'éffectue dans une boucle interminable.

ma question est la suivante :
est-il possible de déclancher un evenement lors du passage dans cette boucle,
pour ensuite, exploiter cet evenement dans un Winform quelconque ?

si oui, comment ?

si vous avez besoin de plus de détail n'hésitez pas à me le demander.
merci d'avance

[Merlin]

la réponse est oui. Il suffit que ta classe expose un event.. et que ton code le déclenche au bon moment.
Dès lors il n'y a aucune difficulté mais si tu poses la question c'est qu'un truc t'échappe. Essaye d'expliquer ce qui te fait coincer dans ce mécanisme pour qu'on puisse d'aider.

[simaxe25]

merci pour la réponse... et en effet, quelque chose m'échappe...
en gros voici mon code :

c'est donc une librairie C++ Managed (cli) qui a pour but d'émettre des datagrammes UDP (Namespace : LANcrawler ; Classe : Publisher)
ps : la source a été réduite, possibilité d'erreurs...

LANcrawler.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 using namespace System;
 using namespace System::Net;
 using namespace System::Net::Sockets;
 using namespace System::Threading;

namespace LANcrawler 
{
    public ref class Publisher
    {
    private:
        array<Byte>^    _DatagramArray;
        IPAddress^      _ServerIP;
        int             _ServerPort;
        IPEndPoint^     _IPEndPoint;

        Sockets::Socket^ _UDPsocket;
        Thread^          _FloodingThread;
        void Flood();
        
    public:
        Publisher(String^ _Datagram, String^ _IP, int _Port);
         void Start();
    };
}

LANcrawler.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include "stdafx.h"
#include "LANcrawler.h"

// Constructor
LANcrawler::Publisher::Publisher(String^ _Datagram, String^ _IP, int _Port)
{

    this->_ServerIP = Net::IPAddress::Parse(_IP); // Local IP
    this->_ServerPort = _Port; // Local Port
    this->_DatagramArray = Text::Encoding::ASCII->GetBytes(_Datagram); // Datagram to send

    this->_IPEndPoint = gcnew Net::IPEndPoint(this->_ServerIP, this->_ServerPort); // Building IP end Point Object
    this->_UDPsocket = gcnew Socket(AddressFamily::InterNetwork, SocketType::Dgram, ProtocolType::Udp); // Building UDP socket object
}

// Start method
// <- this method start the "flooding thread" ->
void LANcrawler::Publisher::Start()
{
    if (this->_FloodingThread == nullptr)
    {
        this->_FloodingThread = gcnew Thread(gcnew ThreadStart(this, &Publisher::Flood));
        this->_FloodingThread->Start(); // Start thread on flood method
    }
 }

// Flooding method [threaded]
void LANcrawler::Publisher::Flood()
{
    while(true)
    {
          this->_UDPsocket->SendTo(this->_DatagramArray, this->_IPEndPoint);
          Threading::Thread::Sleep(50);
          // publier ici un evenement !
    }
}

l'idéal serait donc, dans la boucle de la fonction flood de "publier" un evenement que je pourrais donc traiter dans n'importe quel winform ou application console...
(par exemple afficher le nombre de datagrammes envoyés, dans un label sur un winform)

j'ai pas encore trouvé la logique
merci beaucoup

[genki]

Alors dans un premier temps tu déclare un délégate

ex en C# :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public void MessageAEnvoyerCallback (String msg);

puis tu déclare un attribut event :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public event MessageAEnvoyerCallback EvennementMessage;

et dans ta fonction tu l'appel ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
if(EvennementMessage != null)
EvennementMessage("message");

Dans ta form tu auras un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
private Publisher m_publisher = new Publisher();
 
Form()
{
m_publisher.EvennementMessage += new MessageAEnvoyerCallback(publisher_EvennementMessage );
}
 
private void publisher_EvennementMessage (String msg)
{
if(this.InvokeRequired)
{
this.Invoke(new InvokeHandler(delegate()
                    {
                        publisher_EvennementMessage(msg);
                    }));
}
else
{
textebox1.Text = msg;
}
}

[Merlin]

Pour compléter cette réponse, j'ajouterais qu'un event expose un delegate qui possède deux arguments, le sender de type object et "e" un objet EventArgs.
Depuis .NET 2.0 on ne déclare plus un delegate pour un event de la façon montrée dans le code du post précédent. On utilise en effet les delegate génériques en partant du type de l'argument de l'event.

Exemple :

La classe argument d'événement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class MyEventArgs : EventArgs
{
    private string msg;

    public MyEventArgs( string messageData ) {
        msg = messageData;
    }
    public string Message { 
        get { return msg; } 
        set { msg = value; }
    }
}

L'événement se déclare alors comme suit, sans passer par la définition d'un delegate :

(ici la classe qui expose et lance l'événement)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class HasEvent
{
// Declare an event of delegate type EventHandler of 
// MyEventArgs.

    public event EventHandler<MyEventArgs> SampleEvent;

    public void DemoEvent(string val)
    {
    // Copy to a temporary variable to be thread-safe.
        EventHandler<MyEventArgs> temp = SampleEvent;
        if (temp != null)
            temp(this, new MyEventArgs(val));
    }
}

J'ajouterais qu'on évite dans un code bien écrit de lancer les événements dans les traitements. On préfère créer une méthode "DoMachin" qui elle teste si le gestionnaire est alimenté (non nul), qui créée l'instance des arguments et qui lance réellement l'évément.
Cela permet une meilleure réutilisation du code, puisque si l'événement doit être déclencher à 2 endroits ou plus on ne fait qu'appeller le DoMachin.
Cette dernière peut avoir des arguments, par exemple "DoEtatChangé(bool enMarche); qui pourra être appelée DoEtatChangé(true) ou DoEtatChangé(false), par exemple à l'entrée et à la sortie d'une méthode qui modifie l'état de l'objet.

Tu peux aussi regarder la page MSDN suivante qui donne un exemple de delegate generique (dont sont puisés les bouts de code ci dessus):

http://msdn2.microsoft.com/en-us/library/db0etb8x.aspx

[simaxe25]

Merci pour tout, j'ai pris bonne note et... ça marche
max