MyCodeSchool

Pasul 1 din 5

C#

Pasul 1 din 5 · Ce construiești

  • C#
  • Avansat
  • 15 minute

Design patterns în C#: Observer și Factory Method

O seră are un senzor de temperatură. La fiecare măsurătoare, afișajul arată valoarea, iar peste 30 °C pleacă o alarmă pe SMS și pe email. Senzorul nu știe cine îl ascultă și nici cum se trimit mesajele. Rezultatul:

sera, în terminal
Afișaj: 24.5 °C
Afișaj: 31 °C
  SMS: Seră: 31 °C, peste 30
  Email: Seră: 31 °C, peste 30
Afișaj: 35 °C

La 35 °C nu mai pleacă nicio alarmă: între timp, alarma s-a dezabonat. Prima parte a lecției, cu Strategy și Decorator, e utilă, dar nu obligatorie.

Pasul 2 din 5

Un eveniment, doi ascultători

Sera are un eveniment, Schimbare. Doi ascultători se abonează la el: un afișaj și un ventilator. Urmărește ordinea în care rulează liniile după fiecare măsurătoare.

Program.cs
var sera = new Sera();sera.Schimbare += t =>    Console.WriteLine($"Afișaj: {t} °C");sera.Schimbare += t =>{    if (t > 30)        Console.WriteLine("Pornesc ventilatorul");};sera.Masoara(24);sera.Masoara(33);class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare?.Invoke(t);}

Variabile

Ce apare pe ecran


      

  1. Linia 1. Sera e creată. Evenimentul ei nu are încă niciun abonat.
  2. Linia 2. += adaugă o funcție în lista abonaților. Lambda nu rulează acum, doar e ținută minte.
  3. Linia 4. Al doilea abonat, ventilatorul. Abonații sunt păstrați în ordinea abonării.
  4. Linia 9. Senzorul măsoară 24. Programul intră în Masoara.
  5. Linia 16. Invoke cheamă pe rând fiecare abonat, cu aceeași valoare. ?. sare apelul dacă nu există niciun abonat.
  6. Linia 3. Primul abonat afișează temperatura.
  7. Linia 6. Al doilea abonat verifică pragul. 24 nu e peste 30, deci nu face nimic.
  8. Linia 10. A doua măsurătoare: 33.
  9. Linia 16. Din nou, toți abonații, în ordine.
  10. Linia 3. Afișajul arată 33.
  11. Linia 6. 33 > 30, deci ventilatorul reacționează.
  12. Linia 7. Se afișează mesajul ventilatorului.
  13. Gata. Clasa Sera are 5 linii și nu știe nimic despre afișaje sau ventilatoare. Poți adăuga oricâți ascultători fără s-o modifici.

Prezice ieșirea

Muți linia sera.Masoara(24); chiar după linia 1, înainte de orice abonare. Ce se schimbă pe ecran?

Răspuns: lipsește „Afișaj: 24 °C”.

Un eveniment anunță doar abonații din acel moment. Fără abonați, Schimbare e null, iar ?. sare apelul în siguranță. Măsurătorile de dinainte nu sunt păstrate pentru cine vine mai târziu.

Pasul 3 din 5

Cine anunță și cine creează

Observer desparte sursa de reacții. Fabricile despart codul care folosește obiecte de codul care alege ce obiect să creeze.

Dezabonarea are nevoie de aceeași funcție

Program.cs
var sera = new Sera();Action<double> jurnal = t =>    Console.WriteLine($"Jurnal: {t}");sera.Schimbare += jurnal;sera.Masoara(20);sera.Schimbare -= jurnal;sera.Masoara(21);Console.WriteLine("gata");class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare?.Invoke(t);}

Ce apare pe ecran

Jurnal: 20
gata

-= scoate din listă exact funcția primită. De aceea lambda e păstrată într-o variabilă, jurnal, folosită și la abonare, și la dezabonare.

Dezabonarea contează: cât timp sera ține referința către abonat, obiectul abonat nu poate fi eliberat din memorie. Un formular închis, dar încă abonat, rămâne în memorie și continuă să reacționeze.

O fabrică: new într-un singur loc

Program.cs
INotificare n = Notificari.Creeaza("sms");n.Trimite("Ușa serei e deschisă");n = Notificari.Creeaza("email");n.Trimite("Ușa serei e deschisă");interface INotificare{    void Trimite(string text);}class Sms : INotificare{    public void Trimite(string text)        => Console.WriteLine($"SMS: {text}");}class Email : INotificare{    public void Trimite(string text)        => Console.WriteLine(            $"Email, subiect „Seră”: {text}");}static class Notificari{    public static INotificare Creeaza(string canal)        => canal switch        {            "sms" => new Sms(),            "email" => new Email(),            _ => throw new ArgumentException(                $"Canal necunoscut: {canal}")        };}

Ce apare pe ecran

SMS: Ușa serei e deschisă
Email, subiect „Seră”: Ușa serei e deschisă

Codul care trimite lucrează doar cu INotificare. Alegerea clasei concrete stă într-o singură metodă, ușor de găsit și de extins. Expresia switch întoarce direct o valoare, iar _ prinde orice alt caz.

Varianta aceasta, cu o metodă statică, se numește Simple Factory. E cea pe care o vei scrie cel mai des.

Factory Method: subclasa decide

Program.cs
Senzor[] senzori ={    new SenzorTemperatura(),    new SenzorUmiditate()};foreach (var s in senzori)    s.Raporteaza(31);abstract class Senzor{    protected abstract INotificare        CreeazaNotificare();    public void Raporteaza(double valoare)    {        var n = CreeazaNotificare();        n.Trimite($"valoare citită: {valoare}");    }}class SenzorTemperatura : Senzor{    protected override INotificare        CreeazaNotificare() => new Sms();}class SenzorUmiditate : Senzor{    protected override INotificare        CreeazaNotificare() => new Email();}interface INotificare{    void Trimite(string text);}class Sms : INotificare{    public void Trimite(string text)        => Console.WriteLine($"SMS: {text}");}class Email : INotificare{    public void Trimite(string text)        => Console.WriteLine($"Email: {text}");}

Ce apare pe ecran

SMS: valoare citită: 31
Email: valoare citită: 31

Clasa de bază, Senzor, scrie tot algoritmul din Raporteaza, dar lasă un singur pas abstract: ce notificare creează. Fiecare subclasă răspunde altfel. Metoda care creează obiectul e „metoda fabrică”.

Îl folosești când familia de clase crește și fiecare membru vine cu obiectul lui potrivit. Pentru o alegere după un text din configurare, Simple Factory ajunge.

Capcană: evenimentul fără abonați

Un eveniment fără niciun abonat e null. Apelat direct, oprește programul. Compilatorul te avertizează, dar codul rulează:

Program.cs
var sera = new Sera();sera.Masoara(25);class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare(t);}
Program.cs(8,12): warning CS8602: Dereference of a possibly null reference.
Unhandled exception. System.NullReferenceException: Object reference not set to an instance of an object.
   at Sera.Masoara(Double t) in Program.cs:line 8
   at Program.<Main>$(String[] args) in Program.cs:line 2

Repară cu Schimbare?.Invoke(t): dacă nu e nimeni abonat, apelul e sărit.

Capcană: declanșezi evenimentul din afară

Cuvântul event face ca doar clasa care îl declară să-l poată declanșa. Din afară poți doar să te abonezi sau să te dezabonezi:

Program.cs
var sera = new Sera();sera.Schimbare(40);class Sera{    public event Action<double>? Schimbare;}
Program.cs(2,6): error CS0070: The event 'Sera.Schimbare' can only appear on the left hand side of += or -= (except when used from within the type 'Sera')

Repară adăugând în Sera o metodă publică, ca Masoara, care declanșează evenimentul. Așa nimeni nu poate inventa o măsurătoare în locul senzorului.

Pasul 4 din 5

Verifică-te

Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.

1 din 5 · Prezice ieșirea

Ce afișează programul?

Program.cs
var sera = new Sera();sera.Schimbare += t => Console.Write("A");sera.Schimbare += t => Console.Write("B");sera.Schimbare += t => Console.Write("C");sera.Masoara(1);sera.Masoara(2);class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare?.Invoke(t);}

Răspuns: „ABCABC”.

Fiecare Masoara cheamă toți abonații, în ordinea abonării. Întâi A, B, C pentru prima măsurătoare, apoi iar A, B, C.

2 din 5 · Prezice ieșirea

Te abonezi și te dezabonezi cu două lambda identice ca text. Ce afișează programul?

Program.cs
var sera = new Sera();sera.Schimbare += t => Console.WriteLine(t);sera.Schimbare -= t => Console.WriteLine(t);sera.Masoara(22);class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare?.Invoke(t);}

Răspuns: „22”.

Fiecare lambda scrisă în cod creează altă funcție, chiar dacă textul e identic. -= nu o găsește pe cea abonată și nu scoate nimic, fără nicio eroare. Păstrează funcția într-o variabilă.

3 din 5 · Alege varianta

De ce declari public event Action<double>? Schimbare și nu doar public Action<double>? Schimbare?

Răspuns: ca doar sera să-l poată declanșa.

Fără event, oricine ar putea scrie sera.Schimbare(99) sau chiar sera.Schimbare = null, ștergând toți abonații. += merge și pe un delegat simplu, iar abonații rulează tot pe rând.

4 din 5 · Alege varianta

Adaugi un canal nou, notificările push. Unde schimbi codul, dacă folosești fabrica Notificari?

Răspuns: o clasă nouă și un rând nou în switch.

Tot rostul fabricii e că decizia „ce clasă creez” stă într-un singur loc. Codul care trimite vede doar interfața, care rămâne neschimbată.

5 din 5 · Prezice ieșirea

Fabrica știe doar canalul „sms”. Ce se întâmplă la Notificari.Creeaza("fax")?

Răspuns: se oprește cu ArgumentException.

Ramura _ aruncă excepția cu mesajul construit din canal. E mai bine să afli imediat de o greșeală de configurare decât să trimiți notificări pe un canal greșit.

Pasul 5 din 5

Ce ai învățat

Programul complet

Alarma primește canalele create de fabrică, iar metoda ei Verifica e abonată direct la eveniment. Fiind o metodă, nu o lambda, se poate dezabona cu -=. params permite oricâte canale, despărțite prin virgulă.

Program.cs
var sera = new Sera();var alarma = new Alarma(30,    Notificari.Creeaza("sms"),    Notificari.Creeaza("email"));sera.Schimbare += t =>    Console.WriteLine($"Afișaj: {t} °C");sera.Schimbare += alarma.Verifica;foreach (double t in new[] { 24.5, 31.0 })    sera.Masoara(t);sera.Schimbare -= alarma.Verifica;sera.Masoara(35.0);class Sera{    public event Action<double>? Schimbare;    public void Masoara(double t)        => Schimbare?.Invoke(t);}class Alarma(double prag,    params INotificare[] canale){    public void Verifica(double t)    {        if (t <= prag) return;        foreach (var c in canale)            c.Trimite($"Seră: {t} °C, peste {prag}");    }}interface INotificare{    void Trimite(string text);}class Sms : INotificare{    public void Trimite(string text)        => Console.WriteLine($"  SMS: {text}");}class Email : INotificare{    public void Trimite(string text)        => Console.WriteLine($"  Email: {text}");}static class Notificari{    public static INotificare Creeaza(string canal)        => canal switch        {            "sms" => new Sms(),            "email" => new Email(),            _ => throw new ArgumentException(                $"Canal necunoscut: {canal}")        };}

Ce apare pe ecran

Afișaj: 24.5 °C
Afișaj: 31 °C
  SMS: Seră: 31 °C, peste 30
  Email: Seră: 31 °C, peste 30
Afișaj: 35 °C

Continuă cu