Gewusst wie: veröffentlichen und abonnieren von events in verschiedenen Klassen

Ziel: Zu ändern, ein Bild auf einem Formular, wenn entweder udp oder tcp verwendet die send-Methode

Problem: ich habe keine Ahnung, wie man das event, Event-Handler und die Delegierten ordnungsgemäß eingerichtet

Senden-Schnittstelle

interface ISendData
{
  void Send();
}

Tcp-Verbindung-Klasse

//Need some type of delegate??

public class TCPconnection : ISendData
{
   void Send()
   {
     //how invoke/fire a send Event?
   }
}

UDP-Verbindung-Klasse

//Need some type of delegate??

public class UDPConnection : ISendData
{
   void Send()
   {
     //how invoke/fire a send event?
   }
}

der winform -, die 'sollte' abonnieren, um zu sehen, die gefeuerten events

public class myForm
{
   private DataWatcher datawatcher = new DataWatcher();
   private Image statusIndicator = null;

   public myform()
   {
     initComponents();

     datawatcher.DataSendActive += new DataWatcherSendHandler(DataSending);
     datawatcher.DataSendInactive += new DataWatcherSendHandler(NoDataSending);
   }

   public void DataSending(object sender, DataWatcherArgs e)
   {
      statusIndicator = Properties.resources.greenLight;
   }

   public void NoDataSending(object sender, DataWatcherArgs e)
   {
      statusIndicator = Properties.resources.redLight;
   }

}

Das Event/Event-handler?? Aber ich habe wirklich keine Ahnung, was ich hier mache diese Arbeit zu machen

 public delegate void EventHandler(object sender, EventArgs e);

    class DataWatcher
    {
        public event EventHandler DataSendActive;
        public event EventHandler DataSendInactive;

        protected virtual void onDataSendActive(System.EventArgs e)
        {
            if (DataSendActive != null)
            {
                DataSendActive(this, e);
            }
        }
        protected virtual void onDataSendInactive(System.EventArgs e)
        {
            if (DataSendInactive != null)
            {
                DataSendInactive(this, e);
            }
        }
     }

Können Sie das bitte erklären ? Als ich es gelesen habe, Sie wollen, um das Bild zu ändern, wenn irgendein Teil der Anwendung beginnt mit dem senden/hochladen von Daten. Ist das richtig ?
Ja, dass ist genau das richtige.

InformationsquelleAutor stackoverflow | 2013-03-17

c#delegates events

Gibt es viele Konventionen, dies zu tun. Hier ist meine kleine Umsetzung.

public enum ActivityState
{
    Sending,
    Receiving,
    Idle
}

public interface IDataTransferManager
{
    //This event will fire when the activity state changes.
    //note that Action<T> is introduced in .NET 3.5
    //if you're using .NET 2.0, you can use a delegate.
    event Action<ActivityState> DataActivityStateChange;


    void Send(byte[] data);
    //byte[] Receive(); 
    //... more methods ... //

}

Nun die TcpConnection-Klasse implementieren diese.

public class TcpConnection : IDataTransferManager
{
    public event Action<ActivityState> DataActivityStateChange;

    public void Send(byte[] data)
    {
        //we're sending data. fire the change event
        FireDataActivityStateChange(ActivityState.Sending);

        //TODO: send the data

        //we're done sending. Fire the change event
        FireDataActivityStateChange(ActivityState.Idle);
    }



    private void FireDataActivityStateChange(ActivityState state)
    {
        //helper method, so I don't have to check the event 
        //to avoid null reference exceptions.
        if (DataActivityStateChange != null)
            DataActivityStateChange(state);
    }

}

Hier ist das setup für Ihre Form.

class MyForm //:Form
{
    IDataTransferManager dataManager;

    public MyForm()
    {   //here, usually an instance will be passed in, 
        //so there's only one instance throughout the application.
        //let's new up an instance for explanation purposes.
        dataManager = new TcpConnection();

        dataManager.DataActivityStateChange += (state) => 
        {
            //NOTE: if you don't like inline, 
            //you can point this labda to a method.

            switch (state)
            {
                case ActivityState.Sending:
                    //change the image to the spinning toilet ball
                    break;
                case ActivityState.Receiving:
                    //change the image to the spinning toilet ball, but reverse :P
                    break;
                case ActivityState.Idle:
                    //hide it ?
                    break;
            }
        };
    }
}

Hoffe, das hilft.

In der Realität, die Umsetzung der IDataTransferManager unterstützt queuing mehrere senden/empfangen von Anfragen, aber die Entlassung der Veranstaltung nur, wenn der Staat sich seit dem letzten Ereignis. Es würde auch die send/receive-Operationen außerhalb der UI-thread. Aber ich hoffe, daß dieses Beispiel erläutert die Grundlagen.
Dies scheint ein guter Ansatz, aber es gibt ein problem. Meine Klasse (die winform abonnieren/hören für diese Ereignisse geschehen) ist nicht der Instanziierung entweder von verbindungen dieser Klassen (UDP, TCP) Diese classses werden Instanzen in anderen Klassen. Ich muss nur in der Lage sein zu hören, die Ereignisse, wenn Sie off gehen. Ich denke, ich bräuchte sometype der event-broker
Wie ich bereits in den Kommentaren des Form Konstruktor wird die Instanz der IDataTransferManager übergeben werden sollen, in den Konstruktor. Ich schrieb das Beispiel mit Dependency Injection-Muster in den Sinn. Obwohl Sie sind frei, alle anderen Muster. Wie Sie sagen, Ihre Form 'hängt' auf, die jemals erzeugt es eine Instanz der IDataTransferManager. So haben Sie die Entwicklung der Anwendung in einer Weise, so dass der Aufrufer der Form Konstruktor kennt und liefert die Instanz.
Was ist, wenn ich wurden, um sowohl UDP-und TCP-Klasse statische Methoden? Dies würde eleviate die Klasse aus, die zu instanziieren eine Instanz. Wie würde dieser Effekt der Veranstaltung Herausgeber-und Abonnenten-Interaktion ?
Ja, obwohl diese Klassen static bedeutet auch, dass die Form hat, zu entscheiden, welche ist im Einsatz. Auch, Sie erhalten nicht den Vorteil der Verwendung einer Schnittstelle oder erbschaft, mit denen Sie die Funktionalität erweitern, mit einer Unterklasse in der Zukunft. Es ist bis zu Ihnen, aber ich empfehle, haben Sie einen Blick auf dependency-injection-Muster, die hilft, Sie zu überwinden diese Probleme.

InformationsquelleAutor Madushan

Hier ist ein einfaches Beispiel, wie Sie umsetzen konnte ein Ereignis für das senden und nicht senden, abonnieren und es

public class Connection
{
    //Set up an event
    public event EventHandler DataSending;
    public event EventHandler DataNotSending

    //This method will trigger the event for sending
    private void OnDataSending()
    {
        if (DataSending!= null) { DataSending(this, EventArgs.Empty); }
    }

    //this method will trigger the event for finished sending
    private void OnDataNotSending()
    {
        if (DataNotSending!= null) { DataNotSending(this, EventArgs.Empty); }
    }

    //This method performs your send logic
    public void Send()
    {
         //Call your method that tells the event to be raised
         OnDataSending();
         //Then put your send code
         OnDataNotSending(); //we're done!

    }
}

Dies ist, wie Sie es in einer Konsum-Programm

public class myForm
{
     //This method is the one that sets up the 
     //instance and subscribes to the event
     public myForm()
     {
         Connection con = new Connection();

         con.DataSending += new EventHandler(con_DataSending);
         con.DataNotSending += new EventHander(con_DataNotSending);

     }

     void con_DataSending(object sender, EventArgs e)
     {
         //Put your subscription logic here.
         //Whatever you want to do in response to a send
     }

     void con_DataNotSending(object sender, EventArgs e)
     {
         //Put your subscription logic here.
         //Respond to it not sending
     }
}

InformationsquelleAutor Bill

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.