O proprietate utilă a obiectelor de tip delegat este aceea că mai multe obiecte pot fi atribuite unei singure instanțe delegat folosind operatorul +, proces numit înlănțuire de delegați sau delegați înlănțuiți.
Înlănțuirea delegaților nu este cu adevărat utilă până când nu vom ajunge la evenimente și abonații evenimentelor, care vor veni într-o lecție viitoare, dar este mai bine să descriu comportamentul lor acum, după ce ați văzut un pic modul de funcționare al delegaților. Așadar, să creăm un delegat, așa cum am făcut în lecțiile anterioare:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = Foo; _delegat(); _delegat = Goo; _delegat(); Console.Read(); } static void Foo() { Console.WriteLine("Foo()"); } static void Goo() { Console.WriteLine("Goo()"); } static void Sue() { Console.WriteLine("Soo()"); } } } |
Am declarat un delegat, UnDelegat și trei metode care i se pot atribui, deoarece au aceeași semnătură: Foo(), Goo() și Sue(). Apoi, am creat o instanță a UnDelegat, numită _delegat și i-am atribuit Foo. Apoi, am invocat _delegat, i-am atribuit Goo și l-am invocat din nou, cu acest rezultat:
Nimic nou până acum, dar modul de executare, cu atribuire, invocare, apoi reatribuire și iar invocare, nu este foarte elegant. De altfel, ce se întâmplă dacă vrem să apelăm două metode în același timp, atunci când invocăm delegatul? De îndată ce îi atribuim o nouă metodă, atribuirea inițială se pierde.
Soluția acestor probleme sunt delegații înlănțuiți. Putem atribui mai multe metode aceluiași delegat, fără a suprascrie metodele atribuite anterior, creând în mod efectiv un lanț de metode atribuite acestuia, care sunt executate toate atunci când invocăm delegatul:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = Foo; _delegat += Goo; _delegat += Sue; _delegat(); Console.Read(); } static void Foo() { Console.WriteLine("Foo()"); } static void Goo() { Console.WriteLine("Goo()"); } static void Sue() { Console.WriteLine("Soo()"); } } } |
Este foarte ușor. Am folosit operatorul += pentru a adăuga mai multe metode la metodele deja alocate delegatului meu. Desigur, așa cum am explicat în lecția operatori, x += y este doar o formă prescurtată de a scrie x = x + y. Cu alte cuvinte, _delegat = _delegat + OMetoda. Acesta este rezultatul:
Așadar, lucrul important de reținut este faptul că un delegat nu face referire neapărat la o singură metodă. Putem adăuga mai multe metode, putem elimina din metodele adăugate și chiar putem adăuga o metodă de mai multe ori:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = Foo; _delegat += Goo; _delegat += Sue; _delegat += Foo; _delegat -= Foo; _delegat(); Console.Read(); } static void Foo() { Console.WriteLine("Foo()"); } static void Goo() { Console.WriteLine("Goo()"); } static void Sue() { Console.WriteLine("Soo()"); } } } |
Vă puteți da seama care dintre metodele Foo vor fi eliminate atunci când instrucțiunea _delegat -= Foo va fi executată? După cum observați, Foo este atribuit delegatului de două ori, deci, care va fi eliminată, prima, ultima sau ambele?
Dacă executați codul, veți obține această imagine:
deci, ultima metodă atribuită cu acest nume este eliminată.
Să analizăm în continuare ce se întâmplă în culise atunci când compilatorul vede o operațiune de combinare a delegaților. Avem această expresie:
|
1 2 |
UnDelegat _delegat = Foo; _delegat += Goo; |
care de fapt înseamnă asta:
|
1 2 |
UnDelegat _delegat = Foo; _delegat = _delegat + Goo; |
În acest caz, atunci când compilatorul întâlnește operatorul +, acesta nu efectuează de fapt adunare între delegați, ci îi combină, ceea ce înseamnă că face referire la o metodă statică numită Delegate.Combine(), care are ca argument un array de tip params Delegate, sau, în cazul nostru, preia _delegat ca prim parametru (delegatul cu care să se combine) și Goo (metoda de combinat cu) ca al doilea parametru:
|
1 2 |
UnDelegat _delegat = Foo; _delegat = Delegate.Combine(_delegat, Goo); |
În acest moment, veți primi o eroare în Visual Studio, deoarece compilatorul nu știe cu adevărat ce să facă cu Goo: tipul la timpul de compilare este Delegate (deoarece Delegate este clasa de bază a tuturor tipurilor de delegați, într-un lanț de moștenire care urmează această ierarhie: Delegate -> MulticastDelegate -> UnDelegat), iar eu îi ofer o metodă. Trebuie să-i ofer un delegat, prin urmare este convertit în acest lucru:
|
1 2 |
UnDelegat _delegat = Foo; _delegat = Delegate.Combine(_delegat, new UnDelegat(Goo)); |
Cu alte cuvinte, preia un UnDelegat nou și îl combină cu _delegat, care este de asemenea de tip UnDelegat. Din nou, veți primi în continuare o eroare, iar aceasta se datorează faptului că Delegate.Combine() returnează un Delegate și încercăm să îl alocăm unei variabile de tip UnDelegat. Prin urmare, trebuie să facem un casting:
|
1 2 |
UnDelegat _delegat = Foo; _delegat = (UnDelegate)Delegate.Combine(_delegat, new UnDelegat(Goo)); |
Ca o concluzie, compilatorul face destul de multe modificări asupra codului pentru ca noi să putem folosi direct operatorul +=, în loc să scriem toată instrucțiunea respectivă.
Ați putea să vă întrebați dacă e posibil să atribuiți în mod direct mai multe metode unui delegat, într-o singură atribuire, așa cum putem cu tipurile primitive. De exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = Foo + Goo + Sue; _delegat(); Console.Read(); } public static void Foo() { Console.WriteLine("Foo"); } public static void Goo() { Console.WriteLine("Goo"); } public static void Sue() { Console.WriteLine("Sue"); } } } |
În acest caz, veți primi o eroare în Visual Studio, deoarece compilatorul crede că doriți să adunați două metode împreună, ceea ce este imposibil, nu să creați o alocare a lanțului delegat. Dacă doriți să înțeleagă că dorim o înlănțuire de delegați, putem înfășura prima metodă într-un delegat:
|
1 |
UnDelegat _delegat = new UnDelegat(Foo) + Goo + Sue; |
În acest caz, compilatorul vede că declarăm un UnDelegat nou, inițializat cu Foo, iar acest delegat îl adunăm cu Goo, ceea ce ne este permis. Adăugarea ar avea de asemenea, un rezultat de tip UnDelegat, care, atunci când este adăugat la Sue, repetă procesul. În sfârșit, putem ajunge la același rezultat și efectuând castinf asupra primului operand:
|
1 |
UnDelegat _delegat = (UnDelegat)Foo + Goo + Sue; |
În sfârșit, ce s-ar întâmpla dacă una dintre metodele înlănțate ar arunca o excepție? Cum ar proceda programul cu metodele înlănțuite rămase? Vor fi executate? Să vedem:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = (UnDelegat)Foo + Goo + Sue; _delegat(); Console.Read(); } public static void Foo() { Console.WriteLine("Foo"); } public static void Goo() { throw new Exception(); } public static void Sue() { Console.WriteLine("Sue"); } } } |
În acest caz, am modificat Goo pentru a arunca o excepție la executare. Să vedem rezultatul atunci când rulați programul:
Deci, de fiecare dată când o metodă din lanțul de metode aruncă o excepție, toate metodele rămase nu vor fi executate. Pentru a preveni acest lucru, trebuie să modific un pic programul, ca să pot gestiona excepțiile cu un bloc Try…Catch:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
using System; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { UnDelegat _delegat = (UnDelegat)Foo + Goo + Sue; foreach (UnDelegat item in _delegat.GetInvocationList()) { try { item(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } } Console.Read(); } public static void Foo() { Console.WriteLine("Foo"); } public static void Goo() { throw new Exception(); } public static void Sue() { Console.WriteLine("Sue"); } } } |
Și acum totul funcționează bine și sunt de asemenea capabilă să văd mesajele de excepție, pentru că am solicitat lista de invocare a lui _delegate, iar apoi am invocat fiecare dintre aceste metode în cadrul unui bloc Try…Catch:
Delegații înlănțuiți sunt imuabili, la fel ca șirurile de caractere, ceea ce înseamnă că puteți crea delegați noi oricât doriți, dar nu îi puteți modifica pe cei existenți. Acest lucru înseamnă că atunci când creați un delegat și atribuiți o metodă, compilatorul creează un obiect în memoria Stack, care indică spre adresa acelei metode, localizată în memoria Heap. Dacă atribuiți o altă metodă delegatului, compilatorul creează de fapt un obiect nou în Stack, care indică spre metoda originală din Heap, dar indică și spre un al doilea obiect delegat, care, la rândul său, indică spre noua metoda adăugată, în timp ce obiectul delegat original din stivă este șters de colectorul de gunoi. Deci, procesul de înlănțuire al delegaților este destul de complex, în fundal.
Înlănțuirea delegaților este de obicei folosită pentru un principiu de programare numit tiparul observatorului, despre care vom învăța în viitor.
Tags: delegați, delegați înlănțuiți, imuabil, tiparul observatorului
