Hai să vorbim despre un subiect pe care n-ar trebui să-l întâlniți în experiența voastră zilnică de programare, dar de care ar trebui să fiți totuși conștienți, dacă doriți să deveniți ingineri profesioniști: covarianța și contravarianța delegaților. Sunt termeni generali de programare, deci, îi veți întâlni și în alte limbaje de programare, nu doar C#.
Pentru început, să creăm o clasă de bază numită Baza, și o clasă derivată care o moștenește, numită Derivat:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
namespace BunaLume { class Baza { } class Derivat : Baza { } class Program { public static void Main() { } } } |
În continuare, să declaram două metode în interiorul clasei noastre Program, care returnează tipurile Baza și Derivat:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
namespace BunaLume { class Baza { } class Derivat : Baza { } class Program { public static Baza ReturneazaBaza() { return null; } public static Derivat ReturneazaDerivat() { return null; } public static void Main() { } } } |
În mod normal, nu am returna null în metodele noastre, dar din moment ce încerc doar să demonstrez un concept, și avem de-a face doar cu tipuri la timp de compilare, null va fi suficient.
În cele din urmă, să declarăm doi delegați care vor accepta de asemenea metode care returnează tipurile Baza și Derivat, și nu preiau niciun argument:
|
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 |
namespace BunaLume { class Baza { } class Derivat : Baza { } class Program { delegate Baza DelegatReturneazaBaza(); delegate Derivat DelegatReturneazaDerivat(); public static Baza ReturneazaBaza() { return null; } public static Derivat ReturneazaDerivat() { return null; } public static void Main() { } } } |
Acum, să atribuim acestor delegați, pe rând. Vom începe cu DelegatReturneazaBaza și îi vom atribui ambele metode:
|
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 |
namespace BunaLume { class Baza { } class Derivat : Baza { } class Program { delegate Baza DelegatReturneazaBaza(); delegate Derivat DelegatReturneazaDerivat(); public static Baza ReturneazaBaza() { return null; } public static Derivat ReturneazaDerivat() { return null; } public static void Main() { DelegatReturneazaBaza _delegat; _delegat = ReturneazaBaza; _delegat = ReturneazaDerivat; } } } |
În acest moment, nu veți observa nicio eroare, programul vostru va compila și va rula perfect. Să analizăm ce trebuie compilatorul să facă în acest caz: mai întâi de toate, rețineți că delegații acceptă doar metode care se potrivesc cu semnătura lor. În exemplul meu, DelegatReturneazaBaza returnează o Baza, deci, atunci când instanțiez acest delegat și îi atribui o metodă care returnează și ea o Baza, ReturneazaBaza(), există o potrivire perfectă, deoarece atât delegatul, cât și metoda atribuită acestuia, folosesc tipul Baza. Dar, observați că în a doua atribuire, ofer delegatului meu o metodă care returnează tipul Derivat, nu tipul Baza! De ce compilatorul nu generează o eroare? De ce putem atribui ReturneazaDerivat(), care returnează un tip Derivat, unui delegat care acceptă un tip Baza?
Dacă vă gândiți la asta, de fiecare dată când invocăm ReturneazaDerivat(), restricția la timpul de compilare este aceea că TREBUIE să returneze un tip Derivat, nu poate returna un object, nu poate returna un string, nu poate returna o Baza – poate returna doar un Derivat sau orice altceva moștenește din Derivat. Deci, compilatorul știe că nu există NICIO modalitate prin care metoda noastră ReturneazaDerivat() să poată încălca faptul că DelegatReturneazaBaza trebuie să returneze o Baza, deoarece un obiect Derivat ESTE o Baza. Întrucât Derivat moștenește din Baza, are toate proprietățile, metodele, câmpurile și orice altceva din Baza, deci este o Baza.
Și asta înseamnă covarianța: avem voie să returnăm obiecte care moștenesc din tipul pe care îl așteaptă semnătura de returnare a delegatului, chiar dacă, evident, acele obiecte nu sunt cele declarate în semnătura de returnare a delegatului. Putem spune că tipul de returnare între metoda ce returnează Derivat și delegatul a cărui semnătură returnează o Baza este covariant.
Pentru a rezuma covarianța: atunci când declarăm un delegat a cărui semnătură declară că returnează tipul a, avem voie să îi atribuim metode care returnează tipul a, dar și metode care returnează tipul b, dar numai dacă b este un tip derivat din a.
În această lumină nouă, să luăm cel de al doilea delegat al nostru, DelegatReturneazaDerivat, și să facem exact același lucru pe care l-am făcut cu primul delegat:
|
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 |
namespace BunaLume { class Baza { } class Derivat : Baza { } class Program { delegate Baza DelegatReturneazaBaza(); delegate Derivat DelegatReturneazaDerivat(); public static Baza ReturneazaBaza() { return null; } public static Derivat ReturneazaDerivat() { return null; } public static void Main() { DelegatReturneazaDerivat _delegat; _delegat = ReturneazaBaza; _delegat = ReturneazaDerivat; } } } |
Acum, veți primi o linie de eroare sub alocarea metodei ReturneazaBaza(). Puteți deduce cu ușurință cauza, dacă vă gândiți la aceasta: delegatul DelegatReturneazaDerivat spune că va returna întotdeauna ceva foarte specific, și anume, un Derivat. Cu toate acestea, metoda ReturneazaBaza() nu este obligată să returneze ceva atât de specific ca Derivat. Poate returna o Baza sau poate returna ORICE alt tip care moștenește din Baza. Din acest motiv, vom primi o eroare de compilare. Pe de altă parte, metoda ReturneazaDerivat() returnează un Derivat, care este exact tipul pe care DelegatReturneazaDerivat îl returnează. Nu există probleme, este o potrivire perfectă.
Să vorbim acum despre contravarianță. Voi modifica delegații mei pentru a accepta tipurile Derivat și Baza ca parametri și a returna void, și, de asemenea, voi modifica metodele mele pentru a returna void și a accepta și ele tipurile Baza și Derivat ca parametri:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
namespace BunaLume { class Program { delegate void DelegatPreiaBaza(Baza _baza); delegate void DelegatPreiaDerivat(Derivat _derivat); public static void PreiaBaza(Baza _baza) { } public static void PreiaDerivat(Derivat _derivat) { } public static void Main() { } } } |
Și acum, să atribuim ambele metode fiecărui delegat, așa cum am făcut prima dată. Să începem cu DelegatPreiaDerivat:
|
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 |
namespace BunaLume { class Program { delegate void DelegatPreiaBaza(Baza _baza); delegate void DelegatPreiaDerivat(Derivat _derivat); public static void PreiaBaza(Baza _baza) { } public static void PreiaDerivat(Derivat _derivat) { } public static void Main() { DelegatPreiaDerivat _delegat; _delegat = PreiaBaza; _delegat = PreiaDerivat; } } } |
În acest caz, atunci când invocăm delegatul nostru, trebuie să îi oferim un tip Derivat ca parametru, nu îi putem oferi o Baza, deoarece Baza este mai generală decât Derivat. Delegatul necesită ceva foarte specific, un tip Derivat și din această cauză, satisface cerințele ambelor metode. Dacă ne gândim la aceasta, alocarea PreiaDerivat() este o potrivire perfectă, atât delegatul cât și metoda atribuită acestuia folosesc un tip Derivat. Dar, atunci când îi oferim delegatului metoda PreiaBaza(), întrucât PreiaBaza() preia o Baza, este mai general decât ceea ce va necesita DelegatPreiaDerivat. Când invoc DelegatPreiaDerivat, nu îi pot oferi decât un Derivat ca parametru de invocare, sau orice altceva moștenește din Derivat. Aceasta înseamnă că nu există NICIO modalitate în care să ofer ceva mai general decât un Derivat și, din moment ce Derivat ESTE o Baza, îl pot transmite metodei PreiaBaza(), deoarece această metodă acceptă tipuri mai generale decât Derivat. Poate lua un Derivat, dar poate lua și alte lucruri, cum ar fi Baza, sau orice moștenire din Baza. Cu alte cuvinte, putem atribui delegatului nostru o metodă foarte relaxată, deoarece delegatul este foarte strict și nu va atribui niciodată lucruri pe care metoda nu le va accepta.
Pentru a încheia această lecție, să luăm și delegatul DelegatPreiaBaza și să-i atribuim ambele metode:
|
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 |
namespace BunaLume { class Program { delegate void DelegatPreiaBaza(Baza _baza); delegate void DelegatPreiaDerivat(Derivat _derivat); public static void PreiaBaza(Baza _baza) { } public static void PreiaDerivat(Derivat _derivat) { } public static void Main() { DelegatPreiaBaza _delegat; _delegat = PreiaBaza; _delegat = PreiaDerivat; } } } |
Vom primi acum o eroare de compilator sub alocarea metodei noastre PreiaDerivat(), la fel cum s-a întâmplat și în cazul covarianței. Evident, dacă delegatul acceptă o Baza ca parametru și îi atribuim o metodă care ia și ea tot o Baza, există o potrivire perfectă și totul funcționează bine. Pe de altă parte, când încercăm să atribuim PreiaDerivat() unui delegat care acceptă o Baza, acest lucru nu este posibil, deoarece delegatul așteaptă un tip mai general, iar noi îi oferim ceva foarte specific. Un Derivat poate fi doar Derivat, în timp ce o Baza poate fi orice moștenește din ea, inclusiv Derivat. În acest caz, putem spune că argumentul Baza nu este contravariant cu Derivat.
Tags: contravarianță, covarianță, delegați, moștenire
