C# Academy · Lekcja

Wzorce zdarzeń i pułapki (wycieki pamięci)

Wzorce zdarzeń i pułapki (wycieki pamięci) to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Przegląd pułapek

Cel: Bezpiecznie używać zdarzeń.

Anulować subskrypcję, aby zapobiegać wyciekom pamięci
Przechowywać odwołanie do tego samego procedury obsługi, aby ją usunąć
Preferować niewielki wzorzec IDisposable do sprzątania
Unikać wbudowanych anonimowych procedur obsługi, których nie można odłączyć

Anulowanie subskrypcji zapobiega wyciekom

Zdarzenia przechowują odwołania do subskrybentów. Jeśli wydawca żyje długo i nigdy nie odłączysz subskrybenta, nie może on zostać usunięty przez moduł odśmiecania pamięci.

using System;

public class Publisher
{
  public event EventHandler Tick;
  public void Fire()
  {
    EventHandler h = Tick;
    if (h != null) h(this, EventArgs.Empty);
  }
}

public class Subscriber
{
  public void Handle(object s, EventArgs e)
  {
    Console.WriteLine("Handling tick");
  }

  public void Subscribe(Publisher p) { p.Tick += Handle; }
  public void Unsubscribe(Publisher p) { p.Tick -= Handle; } // required to avoid leaks
}

public class Program
{
  public static void Main(string[] args)
  {
    Publisher p = new Publisher();
    Subscriber s = new Subscriber();

    s.Subscribe(p);
    p.Fire();                // prints once

    s.Unsubscribe(p);        // detach when done
    s = null;                // now eligible for GC in a real app
    p.Fire();                // no output
  }
}

Zachowywanie odwołania do procedury obsługi

Aby odłączyć anonimową procedurę obsługi, zachowaj ją w zmiennej i przekaż tę samą instancję do -=.

using System;

public class Button
{
  public event EventHandler Click;
  public void Simulate()
  {
    EventHandler h = Click;
    if (h != null) h(this, EventArgs.Empty);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Button b = new Button();

    // BAD: cannot easily remove this later
    // b.Click += (s, e) => Console.WriteLine("inline");

    // GOOD: store the handler, attach, later detach the same instance
    EventHandler saved = (s, e) => Console.WriteLine("saved");
    b.Click += saved;

    b.Simulate();           // prints "saved"
    b.Click -= saved;       // can remove because we kept the reference
    b.Simulate();           // no output
  }
}

Subskrypcja z IDisposable

Zwracaj IDisposable z metody Subscribe. Używaj using, aby automatycznie anulować subskrypcję.

using System;

public class Ticker
{
  public event EventHandler Tick;

  public IDisposable Subscribe(EventHandler handler)
  {
    Tick += handler;
    return new Unsubscriber(this, handler);
  }

  private sealed class Unsubscriber : IDisposable
  {
    private Ticker _t;
    private EventHandler _h;
    private bool _done;

    public Unsubscriber(Ticker t, EventHandler h) { _t = t; _h = h; }

    public void Dispose()
    {
      if (!_done)
      {
        _t.Tick -= _h;
        _done = true;
      }
    }
  }

  public void Fire()
  {
    EventHandler h = Tick;
    if (h != null) h(this, EventArgs.Empty);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Ticker t = new Ticker();
    using (t.Subscribe((s, e) => Console.WriteLine("tick")))
    {
      t.Fire(); // prints once
    }
    t.Fire();   // nothing after disposal
  }
}

Odłączanie w try/finally

Używaj try/finally, gdy procedura obsługi musi zostać odłączona nawet w przypadku zgłoszenia wyjątku.

using System;

public class Alarm
{
  public event EventHandler Ring;
  public void Trigger()
  {
    EventHandler h = Ring;
    if (h != null) h(this, EventArgs.Empty);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Alarm a = new Alarm();
    EventHandler h = (s, e) => Console.WriteLine("ring");

    a.Ring += h;
    try
    {
      a.Trigger(); // do work with subscription active
    }
    finally
    {
      a.Ring -= h; // always detach
    }

    a.Trigger(); // no output
  }
}

Wskazówki dotyczące unikania wycieków

Wskazówki:

Subskrybenci powinni odpowiadać za anulowanie własnych subskrypcji (Dispose, finally lub jawna metoda).
Unikaj subskrybowania za pomocą wbudowanych anonimowych procedur obsługi, których nie można usunąć.
Zachowuj ostrożność w przypadku zdarzeń statycznych, ponieważ często żyją dłużej niż obiekty.
Procedury obsługi powinny być krótkie; nie blokuj wydawcy.

Przyczyna wycieku przy zdarzeniach

Szybkie sprawdzenie: Jaka jest częsta przyczyna wycieków pamięci podczas używania zdarzeń C#?

Podsumowanie

Podsumowanie: Anuluj subskrypcję, aby zapobiegać wyciekom, przechowuj odwołania do procedur obsługi, aby móc je usuwać, i preferuj wzorce sprzątania oparte na IDisposable lub finally, aby bezpiecznie zarządzać czasem życia zdarzeń.

Często zadawane pytania

Czy lekcja „Wzorce zdarzeń i pułapki (wycieki pamięci)” jest bezpłatna?

Tak — pełny tekst „Wzorce zdarzeń i pułapki (wycieki pamięci)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Wzorce zdarzeń i pułapki (wycieki pamięci)”?

Proszę rozpoznawać i naprawiać pułapki związane ze zdarzeniami: odsubskrybować się, aby uniknąć wycieków pamięci, przechowywać odwołania do delegatów w celu ich usuwania oraz stosować wzorzec subskry… Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Wzorce zdarzeń i pułapki (wycieki pamięci)”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

delegate, Action/Func, domknięcia
Zdarzenia: publikowanie/subskrypcja, słowo kluczowe event
Wzorce zdarzeń i pułapki (wycieki pamięci)

← Powrót do C# Academy