Jak używać zdarzeń i delegować do wysyłania danych między formularzami?

Question

Potrzebuję utworzyć aplikację Windows Form, która będzie w stanie wysyłać dane i odbierać dane z innej instancji Form. co oznacza, że ​​Form jest wydawcą i subskrybentem, obaj.

Niestety, byłem chory tego dnia i nie mogłem uczestniczyć w wykładzie tego dnia.

wytłumaczę jeszcze raz:

Mam małą pogawędkę Form, którzy mają: nowy przycisk przykład otrzymanych wiadomości i wyślij wiadomość.

jak widać tuż poniżej:

Kiedy wysłać wiadomość, zostanie ona pokazana w „otrzymaliśmy” tekstowym wszystkich instancji.

Sądzę, że muszę korzystać z delegatów i wydarzeń.

Jak to zrobić? dzięki!!

Answer 1

Oto szybkie rozwiązanie .. Daj mi znać, jeśli masz jakieś pytania lub jeśli okaże komentarze mylące ..

Oto klasa Form (kod tyłu). Zauważ, że gdy formularz zostanie utworzony, "zasubskrybuje" wydarzenie przez "podłączenie" programu obsługi zdarzeń do zdarzenia HandleMessage wewnątrz klasy Message. W klasie Form jest to miejsce, w którym gromadzona jest kolekcja przedmiotów ListView.

Gdy przycisk New Form kliknięciu tej samej formie get utworzony i wyświetlony (pozwala to na kodzie ponownego wykorzystania, ponieważ sama logika będą dokładnie takie same dla wszystkich instancji formularz)

public partial class Form1 : Form 
{ 
    Messages _messages = Messages.Instance; // Singleton reference to the Messages class. This contains the shared event 
              // and messages list. 

    /// <summary> 
    /// Initializes a new instance of the <see cref="Form1"/> class. 
    /// </summary> 
public Form1() 
{ 
    InitializeComponent(); 

    // Subscribe to the message event. This will allow the form to be notified whenever there's a new message. 
    // 
    _messages.HandleMessage += new EventHandler(OnHandleMessage); 

    // If there any existing messages that other forms have sent, populate list with them. 
    // 
    foreach (var messages in _messages.CurrentMessages) 
    { 
     listView1.Items.Add(messages); 
    } 
} 

/// <summary> 
/// Handles the Click event of the buttonNewForm control. 
/// </summary> 
/// <param name="sender">The source of the event.</param> 
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> 
private void buttonNewForm_Click(object sender, EventArgs e) 
{ 
    // Create a new form to display.. 
    // 
    var newForm = new Form1(); 
    newForm.Show(); 
} 

/// <summary> 
/// Handles the Click event of the buttonSend control. Adds a new message to the "central" message list. 
/// </summary> 
/// <param name="sender">The source of the event.</param> 
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> 
private void buttonSend_Click(object sender, EventArgs e) 
{ 
    string message = String.Format("{0} -- {1}", DateTime.UtcNow.ToLongTimeString(), textBox1.Text); 
    textBox1.Clear(); 
    _messages.AddMessage(message); 
} 

/// <summary> 
/// Called when [handle message]. 
/// This is called whenever a new message has been added to the "central" list. 
/// </summary> 
/// <param name="sender">The sender.</param> 
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param> 
public void OnHandleMessage(object sender, EventArgs args) 
{ 
    var messageEvent = args as MessageEventArgs; 
    if (messageEvent != null) 
    { 
     string message = messageEvent.Message; 
     listView1.Items.Add(message); 
    } 
} 

}

Oto klasa Wiadomości, którą utworzyłem, aby obsłużyć "centralną" listę wiadomości wysyłanych między formularzami. Klasa Messages jest singletonem (co oznacza, że ​​można ją utworzyć tylko raz), co pozwala zachować jedną listę we wszystkich instancjach Form. Wszystkie formularze będą udostępniać tę samą listę i otrzymywać powiadomienia za każdym razem, gdy lista zostanie zaktualizowana. Jak widać, zdarzenie "HandleMessage" jest zdarzeniem, które każdy formularz będzie subskrybować za każdym razem, gdy zostanie utworzony/wyświetlony.

Jeśli przyjrzeć się funkcji NotifyNewMessage, jest ona wywoływana przez klasę Messages w celu powiadomienia subskrybentów, że nastąpiła zmiana. Ponieważ EventArgs są używane do przekazywania danych do subskrybentów, utworzyłem specjalną EventArgs, aby przekazywać nowo dodane wiadomości do wszystkich subskrybentów.

class Messages 
{ 
    private List<string> _messages = new List<string>(); 
    private static readonly Messages _instance = new Messages(); 
    public event EventHandler HandleMessage; 

    /// <summary> 
    /// Prevents a default instance of the <see cref="Messages"/> class from being created. 
    /// </summary> 
    private Messages() 
    { 
    } 

    /// <summary> 
    /// Gets the instance of the class. 
    /// </summary> 
    public static Messages Instance 
    { 
     get 
     { 
      return _instance; 
     } 
    } 

    /// <summary> 
    /// Gets the current messages list. 
    /// </summary> 
    public List<string> CurrentMessages 
    { 
     get 
     { 
      return _messages; 
     } 
    } 

    /// <summary> 
    /// Notifies any of the subscribers that a new message has been received. 
    /// </summary> 
    /// <param name="message">The message.</param> 
    public void NotifyNewMessage(string message) 
    { 
     EventHandler handler = HandleMessage; 
     if (handler != null) 
     { 
      // This will call the any form that is currently "wired" to the event, notifying them 
      // of the new message. 
      handler(this, new MessageEventArgs(message)); 
     } 
    } 

    /// <summary> 
    /// Adds a new messages to the "central" list 
    /// </summary> 
    /// <param name="message">The message.</param> 
    public void AddMessage(string message) 
    { 
     _messages.Add(message); 
     NotifyNewMessage(message); 
    } 
} 

/// <summary> 
/// Special Event Args used to pass the message data to the subscribers. 
/// </summary> 
class MessageEventArgs : EventArgs 
{ 
    private string _message = string.Empty; 
    public MessageEventArgs(string message) 
    { 
     _message = message; 
    } 

    public String Message 
    { 
     get 
     { 
      return _message; 
     } 
    } 
} 

także .. Aby wiadomości do „wyświetlane” poprawnie, nie zapomnij ustawić „Widok” właściwość formantu ListView do „Listy”. Łatwiejszym (i preferowanym sposobem) byłoby po prostu używanie typu listy ObservableCollection, która już zapewnia wydarzenie, które można subskrybować.

Mam nadzieję, że to pomoże.