Dlaczego warto korzystać z wydarzeń?

Question

Rozumiem, jak działają zdarzenia w języku C# (jestem uczciwym nowicjuszem w tej dziedzinie). Próbuję zrozumieć, dlaczego używamy wydarzeń.

Czy znasz dobrze zakodowaną/zaprojektowaną aplikację, która wykorzystuje zdarzenia?

** Reszta wiadomości ucięte i umieścić w jako odpowiedź **

Answer 1

Aby zapewnić konkretny przykład normalny świat ....

mieć formę, forma ma listbox. Dla listbox jest dobra klasa. Gdy użytkownik wybierze coś z listy, chcesz wiedzieć i modyfikować inne rzeczy w formularzu.

Bez zdarzenia:

można czerpać z pola listy, zastępując wszystko, aby upewnić się, że rodzic jest formą można oczekiwać, aby być dalej. Zastępujesz metodę ListSelected lub coś, co manipuluje innymi rzeczami w formularzu nadrzędnym.

Przy zdarzeniach: Formularz nasłuchuje zdarzenia, aby wskazać użytkownika wybranego przez siebie i manipuluje innymi elementami formularza.

Różnica polega na tym, że w przypadku zdarzeń bez zdarzeń utworzyłeś klasę jednoczynnościową, a także taką, która jest ściśle związana ze środowiskiem, w którym spodziewa się być. W przypadku zdarzeń zdarzeń kod, który manipuluje twoją formularz jest zlokalizowany w twoim formularzu, a listbox to po prostu ... listbox.

Answer 2

Zawsze można zbudować swój własny sposób wysyłania/odbierania zdarzeń, subskrybowania/wypisaniem do źródeł zdarzeń. Ale język daje prosty/standardowy sposób robienia tego, więc jest to dobry powód, aby używać "zdarzeń" językowych zamiast własnych technik.

Ponadto, używanie języka "wydarzenia" pozwala na robienie najróżniejszych rzeczy za pomocą refleksji, ponieważ jest standaryzowana.

Co do tego, dlaczego w ogóle korzystasz z techniki imprezowej. Istnieją różne przykłady z życia wzięte, w których korzystanie z wydarzeń jest całkiem użyteczne i łatwiejsze. Zdarzenia są prawie podobne do ich użyteczności niż wiadomości systemu Windows.

Answer 3

Na najbardziej podstawowym poziomie koncepcyjnym, Wydarzenia pozwalają komputerowi reagować na to, co robisz, a nie na to, że musisz reagować na to, co robi komputer. Gdy siedzisz przed komputerem z kilkoma uruchomionymi aplikacjami (w tym z systemem operacyjnym) i kilkoma klikalnymi obiektami dostępnymi w każdym kontekście, z których możesz wybierać, Zdarzenia są związane z tym, co się dzieje, gdy wybierzesz jedną i wszystkie powiązane elementy mogą być właściwie zgłoszone.

Nawet przesuwanie myszy powoduje uruchomienie strumienia zdarzeń (na przykład w celu przesunięcia kursora).

Answer 4

Możesz wdrożyć Observer Pattern w języku C# za pomocą zdarzeń i delegatów.

Oto link do artykułu, który opisuje takie: http://blogs.msdn.com/bashmohandes/archive/2007/03/10/observer-pattern-in-c-events-delegates.aspx

---

alt text http://dofactory.com/Patterns/Diagrams/observer.gif

Answer 5

* to kiedyś w organizmie zapytania

Jaki byłby bardzo przydatny jest nie trywialny Przykład aplikacji, która wykorzystuje zdarzenia (chyba to naprawdę pomaga w testowaniu?)

Dotychczasowe myśli to:

Dlaczego warto korzystać z wydarzeń lub publikować/subskrybować?

Dowolna liczba klas może być powiadomiona o wydarzeniu.

sygnatariuszy klasy nie muszą wiedzieć, jak metronom (patrz kod poniżej) działa, a Metronome nie musi wiedzieć, co mają zamiar zrobić w odpowiedzi na zdarzenie

wydawcy i abonentów są oddzielone przez delegata. Jest to wysoce pożądane, ponieważ zapewnia bardziej elastyczny i odporny kod. Metronom może zmienić sposób wykrywania czasu bez zrywania żadnej z subskrybujących klas. Subskrybujące klasy mogą zmieniać sposób reagowania na zmiany czasu bez przerywania metronomu. Dwie klasy obracają się niezależnie od siebie, co sprawia, że ​​kod jest łatwiejszy w utrzymaniu.

class Program 
{ 
    static void Main() 
    { 
     // setup the metronome and make sure the EventHandler delegate is ready 
     Metronome metronome = new Metronome(); 

     // wires up the metronome_Tick method to the EventHandler delegate 
     Listener listener = new Listener(metronome); 
     ListenerB listenerB = new ListenerB(metronome); 
     metronome.Go(); 
    } 
} 

public class Metronome 
{ 
    // a delegate 
    // so every time Tick is called, the runtime calls another method 
    // in this case Listener.metronome_Tick and ListenerB.metronome_Tick 
    public event EventHandler Tick; 

    // virtual so can override default behaviour in inherited classes easily 
    protected virtual void OnTick(EventArgs e) 
    { 
     // null guard so if there are no listeners attached it wont throw an exception 
     if (Tick != null) 
      Tick(this, e); 
    } 

    public void Go() 
    { 
     while (true) 
     { 
      Thread.Sleep(2000); 
      // because using EventHandler delegate, need to include the sending object and eventargs 
      // although we are not using them 
      OnTick(EventArgs.Empty); 
     } 
    } 
} 


public class Listener 
{ 
    public Listener(Metronome metronome) 
    { 
     metronome.Tick += new EventHandler(metronome_Tick); 
    } 

    private void metronome_Tick(object sender, EventArgs e) 
    { 
     Console.WriteLine("Heard it"); 
    } 
} 

public class ListenerB 
{ 
    public ListenerB(Metronome metronome) 
    { 
     metronome.Tick += new EventHandler(metronome_Tick); 
    } 

    private void metronome_Tick(object sender, EventArgs e) 
    { 
     Console.WriteLine("ListenerB: Heard it"); 
    } 
} 

Pełny artykuł piszę na mojej stronie: http://www.programgood.net/

nb część tego tekstu jest od http://www.akadia.com/services/dotnet_delegates_and_events.html

Cheers.