Partea I

Elementele
de baz ale platformei
Microsoft .NET Framework
Capitolul 1
r!itectura platformei
de dez"oltare .NET Framework
Platforma Microsoft .NET Framework introduce multe concepte, tehnologii i termeni roi. Scopul
acestui capitol este de a realiza o prezentare a arhitecturii platformei .NET Framework, a prezenta
cte!a dintre noile tehnologii incluse "n acest cadru de lucru i a defini mul#i dintre termenii pe care$i !om
"ntlni atunci cnd !om "ncepe utilizarea sa. %e asemenea, !om parcurge procesul de construire a codului
surs& ca o aplica#ie sau un set de componente 'tipuri( care pot fi redistri)uite, dup& care !om e*plica
modul "n care sunt e*ecutate aceste componente.
Compilarea codului surs #n module administrate
Ei )ine, deci !$a#i decis s& utiliza#i .NET Framework drept platform& de dez!oltare Foarte )ine+
Primul pas const& "n a sta)ili ce tip de aplica#ie sau componente inten#iona#i s& construi#i. ,om presupune c&
a#i sta)ilit acest detaliu minor, c& totul este conceput specifica#iile sunt scrise, iar dumnea!oastr& sunte#i
gata de a "ncepe dez!oltarea.
-cum, tre)uie s& decide#i ce lim)a. de programare !e#i folosi. %e o)icei, aceast& sarcin& este dificil&,
deoarece di!ersele lim)a.e pun la dispozi#ie capacit&#i diferite. %e e*emplu, "n lim)a.ele /0/11
neadministrate a!em un control destul de sc&zut asupra sistemului Putem administra memoria e*act aa
cum dorim, crea cu uurin#& fire, dac& este necesar, i aa mai departe. Pe de alt& parte, lim)a.ul ,isual 2asic
permite construirea foarte rapid& a aplica#iilor 34 i faciliteaz& controlul o)iectelor /5M i )azelor de date.
6ularea "n lim)a. comun '/76( "nseamn& e*act ceea ce sugereaz& denumirea sa8 este un mod de rulare
care poate fi utilizat de c&tre di!erse lim)a.e de programare diferite /aracteristicile rul&rii /76 sunt
disponi)ile pentru toate lim)a.ele de programare care o ai "n !edere $ punct. %ac& rularea folosete
e*cep#iile pentru a raporta erorile, atunci toate lim)a.ele !or raporta erorile prin intermediul e*cep#iilor.
%ac& rularea permite crearea unui fir, atunci oricare dintre lim)a.e "l poate crea.
%e fapt, "n momentul e*ecu#iei, rularea /76 nu 9tie: ce lim)a. de programare a folosit realizatorul de
aplica#ii pentru a scrie codul surs&. -ceasta "nseamn& c& putem alege orice lim)a. de programare care
permite e*primarea cea mai simpl& a inten#iilor noastre. Putem dez!olta codul "n orice lim)a. de
programare dorim, atta !reme ct compilatorul folosit pentru a compila codul are "n !edere rularea
/76.
%eci, dac& ceea ce am afirmat mai sus este ade!&rat, care este a!anta.ul utiliz&rii unui lim)a. de
programare fa#& de altul; Ei )ine, considera#i compilatoarele ca pe nite !erificatoare de sinta*& i
analizatoare de 9cod corect:. Ele analizeaz& codul surs&, se asigur& c& ceea ce a#i scris dumnea!oastr& are
un sens oarecare i apoi trimit la ieire un cod care descrie inten#iile dumnea!oastr&. %i!ersele lim)a.e
de programare permit dez!oltarea folosind di!erse sinta*e.
<
,aloarea acestor op#iuni nu tre)uie su)estimat&. Pentru aplica#iile matematice sau financiare,
e*primarea inten#iilor dumnea!oastr& folosind sinta*a -P7 poate duce la economisirea multor zile de
dez!oltare, comparati! cu e*primarea acelorai inten#ii cu a.utorul sinta*ei Perl, de e*emplu.
/ompania Microsoft a creat o serie de compilatoare de lim)a.e care au "n !edere momentul
e*ecu#iei8 /11 cu e*tensii administrate, /= 'pronun#at 9/ sharp:(, ,isual 2asic, >Script, >= 'un
compilator de lim)a. >a!a( i un asam)lor de lim)a. intermediar '47(. 4n afar& de Microsoft, o serie de alte
companii creeaz& compilatoare care produc coduri ce au "n !edere rularea /76. "n ceea ce m& pri!ete,
cunosc compilatoare pentru -lice, -P7, /5257, /omponent Pascal, Eiffel, Fortran, ?askell, Mercur@,
M7, Mondrian, 5)eron, Perl, P@thon, 6PA, Scheme i Smalltalk.
"n Figura <.< este prezentat procesul de compilare a fiierelor de cod surs&. %up& cum se poate o)ser!a
aici, pute#i crea fiiere de cod surs& folosind orice lim)a. de programare care accept& rularea /76. -poi
se utilizeaz& compilatorul corespunz&tor, pentru a !erifica sinta*a i a analiza codul surs&. 4ndiferent de
compilatorul folosit, rezultatul este un modul administrat. 3n modul administrat este un fiier e*ecuta)il
Bindows standard porta)il 'PE
<<
(, care necesit& rularea /76 pentru a fi e*ecutat. "n !iitor, i alte sisteme
de operare ar putea utiliza formatul de fiier PE.

Figura 1-1 /ompilarea codului surs&, "n !ederea o)#inerii unui modul administrat.
Tabelul 1-1 /omponentele unui modul administrat
/omponenta %escriere
-ntetul PE -ntetul de fiier PE standard din Bindows, care este similar cu
antetul /ommon 5).ect File Format
C
'/5FF(. -cest antet indic& tipul de fiier $
A34, /34 sau %77 $ i are o marc& de timp care arat& cnd a fost construit
fiierul. Pentru modulele care con#in numai cod 47, informa#iile masi!e din
antetul PE sunt ignorate. Pentru modulele care con#in cod /P3 nati!, antetul
con#ine informa#ii despre acesta.
-ntetul /76 /on#ine informa#iile 'interpretate de /76 i programele
utilitare( care fac ca acesta s& fie un modul administrat. -ntetul cuprinde
!ersiunea /76 necesar&, cte!a indicatoare, token$ul de metadate Method%ef al
metodei punctului de intrare 'metoda Main( din modulul administrat i
loca#ia0dimensiunea metadatelor modulului, resursele, numele tare, cte!a
indicatoare i alte informa#ii mai pu#in interesante.
Metadatele Fiecare modul administrat con#ine ta)ele de metadate. E*ist&
dou& tipuri principale de ta)ele8 ta)elele care descriu tipurile i mem)rii defini#i
"n codul surs& i ta)elele care descriu tipurile i mem)rii la care se face referire "n
codul surs&.
/odul "n lim)a. /odul pe care <$a produs compilatorul atunci cnd a compilat
intermediar '47( codul surs&. 3lterior, componenta /76 compileaz& lim)a.ul 47
"n instruc#iuni /P3 nati!e.
<
-cronim pentru porta)le e*ecuta)le 'file(, 'n.t.(
C
Formatul de fiiere comun pentru o)iecte, 'n.t.(
C
Ma.oritatea compilatoarelor din trecut produceau coduri care a!eau ca #int& o anumit& arhitectur& /P3,
cum ar fi *DE, 4-EF, -lpha sau PowerP/. "n schim), toate compilatoarele care se conformeaz& rul&rii
/76 produc cod 47. 'Mai trziu "n cadrul acestui capitol, !om intra "n detalii despre codul 47.( /odul 47
este numit uneori cod administrat, deoarece componenta /76 "i administreaz& timpul de !ia#& i e*ecu#ia.
4n afar& de crearea codului 47, este necesar ca fiecare compilator care are ca #int& rularea /76 s& emit&
metadate complete "n fiecare modul administrat. Pe scurt, metadatele reprezint& pur i simplu un set de
ta)ele care descriu ceea ce este definit "n modul, cum ar fi tipurile i mem)rii lor. 4n plus, metadatele au de
asemenea ta)ele care indic& la ce se refer& modulul administrat, cum ar fi tipurile importate i mem)rii lor.
Metadatele reprezint& un superset de tehnologii mai !echi, cum ar fi )i)liotecile de tipuri i fiierele
lim)a.ului de defini#ie a interfe#ei '4%7
G
(. 4mportant de remarcat este c& metadatele /76 sunt cu mult
mai complete. Hi, spre deose)ire de )i)liotecile de tipuri i fiierele 4%7, metadatele sunt "ntotdeauna
asociate cu fiierul care con#ine codul 47. %e fapt, metadatele sunt "ntotdeauna "nglo)ate "n acelai fiier
EIE0%77 ca i codul, ceea ce face imposi)il& separarea celor dou&. %eoarece compilatorul produce
metadatele i codul "n acelai timp i le leag& "n modulul administrat rezultant, metadatele i codul 47 care
le descrie nu sunt niciodat& nesincronizate.
Metadatele au multe utiliz&ri. Mai .os sunt enumerate cte!a dintre ele8
J Metadatele elimin& necesitatea fiierelor antet i de )i)liotec& la compilare, din moment ce toate
informa#iile despre tipurile0mem)rii la care se face referire sunt con#inute "n cadrul fiierului care
con#ine codul 47 ce implementeaz& tipurile0mem)rii. /ompilatoarele pot citi metadatele direct din
modulele administrate.
J Mediul ,isual Studio .NET utilizeaz& metadatele, pentru a a.uta la scrierea codului. /aracteristica sa
4ntelliSense analizeaz& datele, pentru a ar&ta ce metode ofer& un tip i ce parametri ateapt& metoda
respecti!&.
J Procesul de !erificare a codului la rularea /76 utilizeaz& metadatele, pentru a garanta c& "n cod se
efectueaz& numai opera#ii 9sigure:. ',om analiza "n curnd !erificarea.(
J Metadatele permit serializarea cmpurilor unui o)iect "ntr$un )loc de memorie, plasarea lor la distan#&
pe un alt calculator i apoi deserializarea lor, crend din nou o)iectul i starea sa pe calculatorul
"ndep&rtat.
J Metadatele permit colectorului de gunoaie s& urm&reasc& timpul de !ia#& al o)iectelor.
Pentru orice o)iect, colectorul de gunoaie poate determina tipul de o)iect i, din metadate, poate afla
ce cmpuri din o)iectul respecti! se refer& la alte o)iecte.
Kn /apitolul C !om descrie mai detaliat metadatele.
7im)a.ele /=, ,isual 2asic, >Script, >= i 47 -ssem)ler de la Microsoft produc "ntotdeauna module
administrate, care necesit& rularea /76 pentru a fi e*ecutate. 3tilizatorii finali tre)uie s& ai)& instalat&
componenta /76 pe calculatoarele lor pentru a e*ecuta orice fel de modul administrat, tot aa cum tre)uie s&
ai)& )i)lioteca Microsoft Foundation /lass 'MF/( sau fiierele %77 din ,isual 2asic, pentru a rula aplica#ii
MF/ sau ,isual 2asic.
/ompilatorul /11 de la Microsoft construiete implicit module neadministrate8 fiierele EIE sau %77,
cu care suntem o)inui#i. -ceste module nu necesit& componenta /76 pentru a putea fi e*ecutate. %ar,
prin specificarea "n linia de comand& a unui nou comutator, compilatorul /11 poate realiza module
administrate, care necesit& componenta /76 pentru a putea fi e*ecutate. %intre toate compilatoarele
Microsoft men#ionate, /11 este unic, prin faptul c& este singurul lim)a. care permite realizatorilor s& scrie
att cod administrat, ct i neadministrat, care s& poat& fi emis "ntr$un singur modul. -ceasta poate
reprezenta un mare a!anta., deoarece permite realizatorilor de aplica#ii s& scrie partea masi!& a aplica#iei
"n cod administrat 'pentru siguran#a tipurilor i interopera)ilitatea componentelor(, continund s&
acceseze codul /11 neadministrat e*istent.
C ombi nare a mod ulel or admin istrate #n as ambla $e
/omponenta /76 nu lucreaz& efecti! cu module, ci cu asamblaje. 3n asam)la. este un concept a)stract,
care poate fi dificil de "n#eles ini#ial. Mai "nti, un asam)la. este o grupare logic& de unul sau mai multe
module administrate sau fiiere de resurse.
G
-cronim pentru 4nterface %efinition 7anguage. 'n.t.(
G
Kn al doilea rnd, un asam)la. este cea mai mic& unitate pentru reutilizare, securitate i realizarea de
!ersiuni, "n func#ie de op#iunile alese pentru compilatoare sau instrumente, putem produce un asam)la.
format dintr$un singur fiier sau din mai multe.
Kn /apitolul C !om trata detaliat asam)la.ele, aa c& acum nu !om mai z&)o!i asupra lor. Tot ceea ce
dorim acum este s& !& atragem aten#ia asupra faptului c& e*ist& o no#iune conceptual& suplimentar&, care
ofer& o modalitate groza!& de a trata un grup de fiiere ca pe o singur& entitate.
4lustrarea din Figura <$C !& !a a.uta s& "n#elege#i ce sunt asam)la.ele. "n aceast& figur&, cte!a module
administrate i fiiere de resurse 'sau date( sunt prelucrate cu a.utorul unui instrument. -cesta produce un
singur fiier PE, care reprezint& gruparea logic& a fiierelor. -cest fiier PE con#ine un )loc de date numit
declaraie. %eclara#ia reprezint& pur i simplu un alt set de ta)ele de metadate. -ceste ta)ele descriu
fiierele din care se compune asam)la.ul, tipurile e*portate pu)lic implementate de c&tre fiierele din
cadrul asam)la.ului i fiierele de resurse sau date asociate acestuia.

Figura 1-2 Combinarea modulelor administrate n asamblaje.
4mplicit, compilatoarele efectueaz&, de fapt, transformarea modului administrat emis "ntr$un
asam)la.L cu alte cu!inte, compilatorul /= emite un modul administrat care con#ine o declara#ie.
%eclara#ia arat& c& asam)la.ul este format dintr$un singur fiier. -stfel, pentru proiectele care au un
singur modul administrat i nici un fiier de resurse 'sau date(, asam)la.ul !a fi modulul administrat, iar
dumnea!oastr& nu !a mai tre)ui s& face#i nimic suplimentar "n timpul procesului de construc#ie. %ac&
dori#i s& grupa#i un set de fiiere "ntr$un asam)la., !a tre)ui s& a!e#i "n !edere mai multe instrumente
'cum ar fi programul de leg&turi de asam)lare, -7.e*e( i op#iunile lor din linia de comand&. ,om
e*plica aceste instrumente i op#iuni "n /apitolul C.
3n asam)la. permite decuplarea no#iunilor logice i fizice ale unei componente reutili$za)ile, care
accept& desf&urarea i realizarea de !ersiuni. Modul de parti#ionare a codului i resurselor "n di!erse fiiere
este "n "ntregime la latitudinea dumnea!oastr&. %e e*emplu, a#i putea plasa tipurile de resurse rar utilizate
"n fiiere separate, care fac parte dintr$un asam)la.. Fiierele separate ar putea fi desc&rcate de pe Be),
dup& cum este necesar. %ac& fiierele nu sunt niciodat& necesare, atunci nu sunt niciodat& desc&rcate, prin
aceasta economisindu$se spa#iul de pe disc i reducnd timpul de instalare. -sam)la.ele permit
fragmentarea desf&ur&rii fiierelor, tratnd "n continuare toate fiierele ca pe o singur& colec#ie. Modulele
unui asam)la. cuprind i informa#ii M inclusi! num&rul !ersiunii M despre asam)la.ele la care se face
referire. -ceste informa#ii fac ca asam)la.ul s& fie cu autodescriere. /u alte cu!inte, componenta /76 tie tot
ceea ce este necesar pentru ca un asam)la. s& fie e*ecutat. Nu mai sunt necesare informa#ii suplimentare "n
registru sau "n -cti!e %irector@.
% n cr c a r e a c o m p o n e n t e i C o m m o n & a n ' u a ' e ( u n t im e
Fiecare asam)la. construit poate fi ori o aplica#ie e*ecuta)il&, ori o )i)liotec& %77, care con#ine un set de
tipuri 'componente( care !or fi utilizate de c&tre aplica#ia e*ecuta)il&. %esigur c& rularea /76 este
responsa)il& de administrarea e*ecu#iei codului con#inut "n cadrul acestor asam)la.e. -ceasta "nseamn& c&
platforma .NET Framework tre)uie instalat& pe calculatorul gazd&.
F
/ompania Microsoft a creat un pachet de redistri)uire, care poate fi li!rat gratuit, pentru a instala
platforma .NET Framework pe calculatoarele clien#ilor. "n cele din urm&, platforma .NET Framework !a
face parte din pachetul de !ersiuni Bindows !iitoare, astfel "nct nu !a mai tre)ui li!rat "mpreun& cu
asam)la.ele.
Pute#i !edea dac& platforma .NET Framework a fost instalat& c&utnd fiierul MS/orEE.dll "n directorul
NwindirNOs@stemGC. E*isten#a acestui fiier arat& c& platforma .NET Framework este instalat&. Totui, pe un
singur calculator pot fi instalate simultan mai multe !ersiuni ale platformei .NET Framework. %ac& dori#i
s& sta)ili#i e*act ce !ersiuni .NET Framework sunt instalate, analiza#i su)cheile aflate su) urm&toarea cheie
din registru8 ?PEQR75/-7RM-/?4NEOS5FTB-6EOMicrosoftO.NETFrameworkOpolic@
-tunci cnd construi#i un asam)la. EIE, compilatorul0programul de leg&turi emite cte!a informa#ii
speciale "n antetul fiierului PE al asam)la.ului rezultant i "n por#iunea .te*t a fiierului. -tunci cnd este
in!ocat fiierul EIE, aceste informa#ii speciale determin& "nc&rcarea i ini#ializarea componentei /76.
-poi aceasta localizeaz& metoda din punctul de intrare al aplica#iei i permite "nceperea e*ecu#iei acesteia.
Similar, dac& o aplica#ie neadministrat& apeleaz& metoda LoadLibrary pentru a "nc&rca un asam)la.
administrat, atunci func#ia din punctul de intrare tie c& tre)uie s& "ncarce componenta /76, pentru a
prelucra codul con#inut "n cadrul asam)la.ului.
"n cea mai mare parte, nu este necesar ca dumnea!oastr& s& ti#i sau s& "n#elege#i cum este "nc&rcat&
componenta /76. Pentru ma.oritatea programatorilor, aceste informa#ii speciale permit pur i simplu
e*ecu#ia aplica#iei i nu mai tre)uie s& se gndeasc& la ele. %ar, pentru cei curioi, !om dedica ceea ce a mai
r&mas din acest paragraf e*plic&rii modului "n care aplica#ia EIE sau %77 administrat& pornete rularea
/76. %ac& nu !& intereseaz& acest su)iect, pute#i s& s&ri#i la urm&torul paragraf. %e asemenea, dac& !&
intereseaz& construirea unei aplica#ii neadministrate care g&zduiete componenta /76, consulta#i
/apitolul CS.
"n Figura <$G este prezentat schematic modul "n care o aplica#ie EIE administrat& "ncarc& si
ini#ializeaz& rularea /76.

Fi'ura 1)* ncrcarea i iniializarea componentei CLR.
-tunci cnd compilatorul0programul de leg&turi creeaz, un asam)la. e*ecuta)il, "n por#iunea .text a
fiierului PE este emis& urm&toarea func#ie de racordare de E octe#i *DE8
!" #Cor$%e!ain
%eoarece func#ia _CorExeMain este importat& din )i)lioteca de leg&turi dinamice Microsoft MS/orEE.dll,
fiierul MS/orEE.dll este referen#iat "n por#iunea de import '.idata( a fiierului de asam)lare.
MS/orEE.dll !ine de la Microsoft Component Object Runtime Execution Engine.
T
-tunci cnd este in!ocat fiierul EIE administrat, sistemul de operare Bindows "l trateaz& ca pe orice
fiier EIE normal 'neadministrat(8 "nc&rc&torul Bindows "ncarc& fiierul i analizeaz& por#iunea . idata,
pentru a !edea dac& "n spa#iul de adrese tre)uie "nc&rcat& )i)lioteca MS/orEE.dll. -poi "nc&rc&torul o)#ine
adresa func#iei _CorExeMain din interiorul )i)liotecii MS/orEE.dll i sta)ilete instruc#iunea JMP a
func#iei "n fiierul EIE administrat.
Firul primar al procesului "ncepe e*ecu#ia acestei func#ii de racordare *DE, care sare imediat la func#ia
_CorExeMain din )i)lioteca MS/orEE.dll. Func#ia _CorExeMain ini#ializeaz& rularea /76 i apoi caut& "n
antetul /76 al asam)la.ului e*ecuta)il,$ pentru a determina ce metod& administrat& din punctul de intrare
tre)uie s& e*ecute. /odul 47 pentru aceast& metod& este apoi compilat "n instruc#iuni /P3 nati!e, iar rularea
/76 trece la codul nati! 'utiliznd firul primar al procesului(. "n acest punct, este rulat codul aplica#iei
administrate.
Pentru o aplica#ie %77 administrat&, situa#ia este similar&. -tunci cnd se construiete o aplica#ie %77
administrat&, compilatorul0programul de leg&turi emite o func#ie de racordare de E octe#i *DE similar&,
"n por#iunea .text corespunz&toare asam)la.ului %778
!" #Cor&ll!ain
Func#ia R/or%llMain este de asemenea importat& din )i)lioteca MS/orEE.dll, f&cnd ca por#iunea .idata a
aplica#iei %77 s& se refere la fiierul MS/orEE.dll. -tunci cnd sistemul de operare Bindows "ncarc&
aplica#ia %77, !a "nc&rca automat i )i)lioteca MS/orEE.dll 'dac& nu este de.a "nc&rcat&(, !a o)#ine adresa
func#iei R/or%llMain i !a corecta racordul >MP *DE de E octe#i din aplica#ia %77 administrat&. Firul care a
apelat metoda 7oad7i)rar@ pentru a "nc&rca aplica#ia %77 administrat& !a trece acum la racordul *DE din
asam)la.ul %77 administrat, care !a s&ri imediat la func#ia R/or%llMain din )i)lioteca MS/orEE.dll.
Func#ia R/or%llMain ini#ializeaz& rularea /76 'dac& nu a fost de.a ini#ializat& pentru proces( i apoi re!ine,
astfel "nct aplica#ia "i poate continua e*ecu#ia normal&.
Func#iile de racordare *DE de E octe#i sunt necesare pentru a rula asam)la.e administrate pe sistemele
de operare Bindows UD, Bindows UD Second Edition, Bindows Me, Bindows NT F i Bindows CSSS,
deoarece toate acestea au fost li!rate cu mult "nainte de a fi disponi)il& componenta /76. 5)ser!a#i c&
func#ia de racordare de E octe#i este construit& special pentru calculatoarele *DE. -cest racord nu
func#ioneaz& corespunz&tor "n cazul "n care componenta /76 este portat& astfel "nct s& func#ioneze pe
alte arhitecturi /P3. %eoarece sistemele de operare Bindows IP i Bindows .NET Ser!er Famil@
accept& att arhitectura *DE, ct i 4-EF, "nc&rc&toarele acestora au fost modificate astfel "nct s& caute
tocmai asam)la.e administrate.
Pe sistemele de operare Bindows IP i Bindows .NET Ser!er Famil@, atunci cnd este in!ocat un
asam)la. administrat 'de regul&, prin intermediul metodei /reateProcess sau 7oad7i)rar@(, "nc&rc&torul
5S
<
detecteaz& faptul c& fiierul con#ine un cod administrat, analiznd intrarea directoare <F din antetul
fiierului PE. '- se !edea 4M-AER%46E/T56QR ENT6QR/SMR%ES/64PTS6 din antetul BinNT.h.( %ac& aceast&
intrare directoare e*ist& i nu este S, atunci "nc&rc&torul ignor& por#iunea de import a fiierului '.idata( i
"ncarc& automat )i)lioteca MS/orEE.dll "n spa#iul de adres& al procesului. 5 dat& "nc&rcat&, "nc&rc&torul
5S face ca firul procesului s& treac& direct la func#ia corect& din )i)lioteca MS/orEE.dll. Func#iile de
racordare *DE de E octe#i sunt ignorate pe calculatoarele care ruleaz& sistemele de operare Bindows IP i
Bindows .NET Ser!er Famil@.
5 ultim& o)ser!a#ie referitoare la fiierele PE8 acestea utilizeaz& "ntotdeauna formatul de fiier PE de GC
de )i#i, nu cel de 6 de )i#i. Pe sistemele Bindows de EF de )i#i, "nc&rc&torul 5S detecteaz& fiierul PE
administrat de GC de )i#i i tie automat s& creeze un spa#iu de adres& de EF de )i#i.
E+e cuta rea codului din asam bla$
%up& cum am men#ionat mai de!reme, modulele administrate pot con#ine att metadate, ct i lim)a.
intermediar '47(. 47 este un lim)a. main& independent de /P3, creat de compania Microsoft, dup&
consult&ri cu o serie de realizatori e*terni de lim)a.e0compilatoare comerciale. Este de un ni!el mult mai
"nalt dect ma.oritatea lim)a.elor main& /P3. 7im)a.ul 47 "n#elege tipurile de o)iecte i are instruc#iuni
care creeaz& i ini#ializeaz& o)iecte, apeleaz& metode !irtuale pentru o)iecte i manipuleaz& direct
elementele ta)lourilor. -re chiar i instruc#iuni care introduc i detecteaz& e*cep#ii pentru tratarea erorilor.
47 poate fi considerat un lim)a. main& orientat spre o)iecte.
%e regul&, realizatorii de aplica#ii !or programa "ntr$un lim)a. de ni!el "nalt, cum ar fi /= sau ,isual
<
-cronim pentru 5perating S@stem, 'n.t.(
E
2asic. /ompilatoarele pentru aceste lim)a.e de ni!el "nalt produc cod 47. Totui, ca orice alt lim)a.
main&, 47 poate fi scris "n lim)a. de asam)lare, iar compania Microsoft pune la dispozi#ie un program de
asam)lare 47 -ssem)ler, 47-sm.e*e. %e asemenea, compania Microsoft ofer& i un program de
dezasam)lare 47 %isassem)ler, 47%asm.e*e.
&imba$ul I& ,i prote$area propriet-ii intelectuale .........
3nele persoane sunt preocupate de faptul c& lim)a.ul 47 nu ofer& suficient& protec#ie a propriet&#ii
intelectuale pentru algoritmi. /u alte cu!inte, ei cred ca am putea construi un modul administrat, iar
altcine!a ar putea utiliza un instrument, cum ar fi 47 %isassem)ler, pentru a reproduce tehnologia e*act& a
ceea ce face codul aplica#iei.
%a, este ade!&rat c& lim)a.ul 47 este de ni!el mai "nalt dect ma.oritatea celorlalte lim)a.e de
asam)lare i c&, "n general, reproducerea tehnologiei codului 47 este relati! simpl&. %ar, atunci cnd se
implementeaz& un ser!iciu Be) IM7 sau o aplica#ie Be) Forms, modulul administrat se afl& pe ser!er.
%eoarece nimeni din afara companiei nu poate accesa modulul, nimeni din afara companiei nu poate
utiliza un instrument pentru a !edea codul 47 $ iar proprietatea intelectual& este "n perfect& siguran#&.
%ac& !& preocup& modulele administrate pe care le distri)ui#i, pute#i o)#ine un program utilitar de
eclipsare de la o ter#& partid&. -ceste utilitare 9amestec&: numele tuturor sim)olurilor pri!ate din
metadatele modului administrat. ,a fi dificil pentru cine!a s& 9descurce: numele i s& "n#eleag& scopul
fiec&rei metode. 5)ser!a#i c& aceste programe de eclipsare pot oferi doar o mic& protec#ie, din moment ce
codul 47 tre)uie s& fie "ntr$o oarecare m&sur& disponi)il, pentru ca rularea /76 s& "l poat& prelucra.
%ac& nu crede#i c& un program de eclipsare ofer& un tip adec!at de protec#ie a propriet&#ii
intelectuale, pute#i a!ea "n !edere implementarea algoritmilor mai sensi)ili "ntr$un modul oarecare
neadministrat, care !a con#ine instruc#iuni nati!e /P3, "n loc de cod 47 i metadate. -poi pute#i folosi
caracteristicile de interopera)ilitate ale componentei /76 pentru a comunica "ntre por#iunile
administrate i cele neadministrate din aplica#ia dumnea!oastr&. %esigur c& aceasta presupune c& nu !&
"ngri.oreaz& posi)ilitatea de reproducere a tehnologiei prin interpretarea instruc#iunilor nati!e /P3 din
codul neadministrat.
6e#ine#i c& orice lim)a. de ni!el "nalt !a e*pune, pro)a)il, doar un su)set din facilit&#ile oferite de
componenta /76. Totui, utilizarea lim)a.ului de asam)lare 47 permite realizatorului s& acceseze toate
facilit&#ile /76. -stfel, "n cazul "n care lim)a.ul de programare ales nu con#ine o facilitate pe care
componenta /76 o ofer& i de care dori#i s& profita#i, atunci pute#i alege s& scrie#i respecti!a por#iune de
cod "n lim)a.ul de asam)lare 47 $ sau e!entual un alt lim)a. de programare care pune la dispozi#ie
caracteristica /76 c&utat&.
Singura modalitate prin care pute#i afla ce facilit&#i ofer& componenta /76 este de a citi documenta#ia
specific& acesteia. "n aceast& carte, !om "ncerca s& ne concentr&m asupra caracteristicilor /76 i a
modului "n care acestea sunt re!elate sau nu "n lim)a.ul /=.
Presupun c& ma.oritatea celorlalte c&r#i i articole !or prezenta componenta /76 "ntr$o perspecti!&
legat& de lim)a., iar ma.oritatea realizatorilor de aplica#ii !or a.unge la concluzia c& rularea /76 ofer& doar
ceea ce e*pune lim)a.ul de programare ales de realizator. -tta !reme ct lim)a.ul de programare ales
permite realizarea a ceea ce inten#iona#i, aceast& perspecti!& ne)uloas& nu este prea rea.

3n alt aspect important care tre)uie re#inut despre lim)a.ul 47 se refer& la faptul c& nu este legat
V
de !reo anumit& platform& /P3. -ceasta "nseamn& c& un modul administrat care con#ine cod 47
poate fi rulat pe orice platform& /P3, atta !reme ct sistemul de operare rulat pe aceasta
g&zduiete o !ersiune a componentei /76. %ei !ersiunea /76 ini#ial& este rulat& doar pe
platforme Bindows de GC de )i#i, dez!oltarea unei aplica#ii care s& utilizeze cod 47 confer&
realizatorului o mai mare independen#& de arhitectura /P3 aflat& la )az&.
/tandardizarea platformei .NET Framework ...............
4n octom)rie CSSS, compania Microsoft '"mpreun& cu 4ntel i ?ewlett$Packard, toate ca sponsori(
a propus asocia#iei E/M- 'European /omputer ManufacturerWs -ssociation( un su)set larg al
platformei .NET Framework, cu scopul de a o standardiza. E/M- a acceptat aceast& propunere i a
creat un comitet tehnic 'T/GU(, care s& supra!egheze procesul de standardizare. /omitetul tehnic
are urm&toarea structur& i sarcin&8
J Technical Group 1 tre)uie s& dez!olte un standard pentru un lim)a. de scriptare dinamic
'E/M-Script(. 4mplementarea Microsoft a standardului E/M-Script este >ScriptL
J Technical Group tre)uie s& realizeze o !ersiune standardizat& a lim)a.ului de programare
/=L
Technical Group ! tre)uie s& realizeze o infrastructur& /ommon 7anguage 4nfrastructure
<
'/74(, pe
)aza unui su)set de func#ionalit&#i oferite de componenta /76 a platformei .NET Framework i
)i)liotecii de clase. Mai e*act, /74 !a defini un format de fiiere, un sistem de tipuri comun, un sistem
de metadate e*tensi)il, un lim)a. intermediar '47( i accesul la platforma aflat& la )az& 'P04n!oke(. "n
plus, /74 !a defini o )i)liotec& intermediar& de clase de )az& 'pentru a permite mici dispoziti!e
hardware(, conceput& pentru a fi utilizat& de mai multe lim)a.e de programare.
5 dat& ce standardizarea !a fi "ncheiat&, aceste standarde !or fi introduse "n standardul 4S504E/ >T/ <
'4nformation Technolog@(. -tunci, comitetul tehnic !a analiza i direc#iile !iitoare ale infrastructurii
/74, lim)a.ului /= i standardului E/M-Script i !a sus#ine propuneri de tehnologii complementare
sau suplimentare. Pentru mai multe informa#ii despre E/M-, consulta#i siturile Be) aflate la adresele8
http800 www.E/M-.ch i http800MS%N.Microsoft.eom0.NET0E/M-.
5 dat& cu standardizarea infrastructurii /74, a lim)a.ului /= i standardului E/M-Script, compania
Microsoft nu !a 9poseda: nici una dintre aceste tehnologii. Microsoft !a fi pur i simplu una dintre multele
'sper&m( companii care produc implement&ri ale acestor tehnologii. %esigur c& cei de la Microsoft sper&
c& implementarea lor !a fi cea mai )un&, "n termeni de performan#e i caracteristici realizate la cererea
utilizatorilor. -ceasta !a a.uta la !nzarea sistemului de operare Bindows, deoarece cea mai )un&
implementare Microsoft !a fi rulat& numai su) Bindows. Totui, alte companii ar putea implementa aceste
standarde, intra "n competi#ie cu Microsoft i, posi)il, ctiga.
---------------------------------------------------------------------------------------------------
%ei unit&#ile /P3 din zilele noastre nu pot e*ecuta direct instruc#iunile 47, este posi)il ca cele !iitoare
s& ai)& aceast& capacitate. Pentru a e*ecuta o metod&, este necesar ca instruc#iunile 47 corespunz&toare s&
fie transformate "n instruc#iuni nati!e /P3. -ceasta este sarcina compilatorului >4T '.ust$in$time
C
( al
componentei /76.
"n Figura <$F se ilustreaz& ceea ce are loc atunci cnd este apelat& pentru prima dat& o metod&.
/hiar "nainte de e*ecu#ia metodei Main, componenta /76 detecteaz& toate tipurile la care se face
referire "n codul acesteia. -ceasta face ca /76 s& aloce o structur& de date intern&, care este folosit&
pentru a administra accesul la tipul la care se face referire. "n Figura <$F, metoda Main se refer& la un
singur tip, /onsole, ceea ce face ca rularea /76 s& aloce o singur& structur& intern&. Structura de date
intern& con#ine o intrare pentru fiecare metod& definit& de c&tre tip. Fiecare intrare con#ine adresa la care
poate fi g&sit& implementarea metodei. 7a ini#ializarea acestei structuri, componenta /76 atri)uie
fiecare intrare unei func#ii interne nedocumentate, con#inut& "n componenta /76 "ns&i. -m numit
aceast& func#ie >4T/ompiler.
-tunci cnd metoda Main face prima apelare a metodei Brite7ine, este apelat& func#ia >4T/ompiler.
Func#ia >4T/ompiler este responsa)il& de compilarea codului 47 al unei metode "n instruc#iuni nati!e
<
4nfrastructura comun& a lim)a.elor, 'n.t.(
C
Tocmai la timp. 'n.t.(
D
/P3. %eoarece codul 47 este compilat 9.ust in time:, aceast& component& /76 este numit& "n mod
frec!ent !"#er sau compilator !"#.
-tunci cnd este apelat&, func#ia >4T/ompiler tie ce metod& este apelat& i ce tip o definete. -poi
func#ia >4T/ompiler caut& metadatele asam)la.ului de defini#ie pentru codul 47 al metodei apelate. "n
etapa urm&toare, func#ia >4T/ompiler !erific& i compileaz& codul 47 "n instruc#iuni nati!e /P3. -cestea
sunt sal!ate "ntr$un )loc de memorie alocat dinamic. -poi, func#ia >4T/ompiler merge "napoi la
structura de date intern& a tipului i "nlocuiete adresa metodei apelate cu adresa )locului de memorie
care con#ine instruc#iunile nati!e /P3. 4n final, func#ia >4T/ompiler trece la codul din )locul de
memorie. -cest cod reprezint& implementarea metodei Brite7ine '!ersiunea care are un parametru de
tip string(. -tunci cnd acest cod efectueaz& returnarea, se re!ine la codul din metoda Main, care
continu& e*ecu#ia "n mod normal.
Fi'ura 1)0 'pelarea unei metode pentru prima dat.
-cum metoda Main apeleaz& a doua oar& metoda Brite7ine. %e aceast& dat&, codul pentru metoda
Brite7ine a fost de.a !erificat i compilat. -stfel, apelarea merge direct la )locul de memorie, s&rind cu
totul peste func#ia >4T/ompiler. %up& e*ecu#ia metodei Brite7ine, se re!ine la metoda Main. 4n Figura
<$T se arat& care este situa#ia atunci cnd metoda Brite7ine este apelat& a doua oar&.
4mpactul negati! asupra performan#elor apare doar prima dat& cnd este apelat& metoda. Toate
apel&rile ulterioare ale acesteia sunt e*ecutate la !iteza ma*im& a codului nati!8 !erificarea i compilarea
"n cod nati! nu sunt efectuate din nou.
/ompilatorul >4T stocheaz& instruc#iunile nati!e /P3 "n memoria dinamic&. -ceasta "nseamn& c&,
la terminarea aplica#iei, codul compilat este "nl&turat. -stfel, dac& aplica#ia !a fi rulat& din nou "n !iitor
sau dac& sunt rulate simultan dou& instan#e ale acesteia '"n dou& procese diferite ale sistemului de
operare(, atunci compilatorul >4T !a tre)ui s& efectueze din nou compilarea codului 47 "n instruc#iuni
nati!e.
U
Fi'ura 1)1 'pelarea unei metode a doua oar.
Pentru ma.oritatea aplica#iilor, impactul asupra performan#elor datorat compil&rii >4T nu este
semnificati!. Ma.oritatea aplica#iilor au tendin#a de a apela "n mod repetat aceleai metode. -ceste
metode !or a!ea un impact negati! asupra performan#elor numai o dat&, pentru o e*ecu#ie a
aplica#iei. %e asemenea, este mai pro)a)il s& fie necesar un timp mai mare pentru e*ecu#ia din
interiorul metodei dect pentru apelarea acesteia.
%e asemenea, tre)uie a!ut "n !edere faptul c& "n compilatorul >4T al componentei /76 se
efectueaz& optimizarea codului nati!, tot la fel cum face i compilatorul )ack$end /11 neadministrat.
%in nou, s$ar putea s& fie necesar un timp mai "ndelungat pentru a realiza codul optimizat, dar acesta
!a fi e*ecutat cu performan#e mult mai )une dect dac& nu ar fi fost optimizat.
6ealizatorii de aplica#ii care au un fond de cunotin#e / sau /11, f&r& a fi la curent cu administrarea,
pro)a)il c& se gndesc la implica#iile tuturor acestor considera#ii "n ceea ce pri!ete performan#ele. "n fond,
codul neadministrat este compilat pentru o anumit& platform& /P3 i, atunci cnd este in!ocat, el poate
fi e*ecutat pur i simplu. "n acest mediu administrat, compilarea codului se realizeaz& "n dou& faze. Mai
"nti, compilatorul parcurge codul surs&, f&cnd ct mai mult posi)il pentru a realiza codul 47. %ar, pentru
a e*ecuta codul, "nsui codul 47 tre)uie compilat "n momentul e*ecu#iei "n instruc#iuni nati!e /P3, ceea
ce necesit& o alocare de memorie mai mare i timp /P3 suplimentar pentru realizare.
Pute#i s& m& crede#i c&, atunci cnd am a)ordat componenta /76, pornind de la un fond de cunotin#e
/0/11, am fost destul de sceptic i preocupat de aceast& suprasarcin& suplimentar&. -de!&rul este c& acest
al doilea stadiu al compil&rii, care apare "n timpul e*ecu#iei, afecteaz& performan#ele i aloc& memorie
dinamic&. %ar cei de la Microsoft s$au str&duit mult pentru a reduce la minimum aceast& suprasarcin&.
%ac& i dumnea!oastr& sunte#i sceptic, atunci !a tre)ui s& construi#i cte!a aplica#ii i s& testa#i singur
performan#ele. "n plus, !a tre)ui s& rula#i cte!a aplica#ii administrate, care nu sunt uzuale $ realizate de
Microsoft sau de altcine!a $ i s& le m&sura#i performan#ele. /red c& !e#i fi surprins de ct de )une sunt,
"n realitate, performan#ele.
%e fapt, pro)a)il c& !i se pare greu de crezut, dar multe persoane 'inclusi! eu( sunt de p&rere c&
aplica#iile administrate le$ar putea dep&i efecti! pe cele neadministrate, "n ceea ce pri!ete performan#ele.
E*ist& mai multe ra#iuni "n fa!oarea acestei afirma#ii. %e e*emplu, "n timpul e*ecu#iei, atunci cnd
compilatorul >4T efectueaz& compilarea codului 47 "n cod nati!, el tie mai multe despre mediul de
e*ecu#ie dect ar putea ti un compilator neadministrat. Mai .os sunt enumerate cte!a modalit&#i prin
care codul administrat ar putea a!ea performan#e superioare fa#& de cel neadministrat8
<S
J 3n compilator >4T poate detecta c& aplica#ia este rulat& pe un calculator Pentium F, producnd un cod
nati! care s& profite de orice instruc#iuni speciale ar putea fi oferite de acesta. %e o)icei, aplica#iile
neadministrate sunt compilate pentru o unitate /P3 de ni!elul 9celui$mai$mic$numitor$comun:,
e!itndu$se utilizarea instruc#iunilor speciale, care ar putea oferi o cretere a performan#elor aplica#iei
pentru noile unit&#i /P3.
J 3n compilator >4T poate detecta c& un anumit test returneaz& "ntotdeauna !aloarea de ade!&r false pe
calculatorul pe care este rulat. %e e*emplu, !om considera o metod& cu codul urm&tor8
if (numberOfCPUs > 1) {
}
-cest cod ar putea determina compilatorul >4T s& nu genereze instruc#iuni /P3, "n cazul "n care
calculatorul gazd& are o singur& unitate /P3. "n acest caz, codul nati! este reglat pentru calculatorul
gazd&8 este mai mic i este e*ecutat mai repede.
J /omponenta /76 ar putea schi#a e*ecu#ia codului, recompilnd codul 47 "n cod nati!, "n timpul
rul&rii aplica#iei. /odul recompilat ar putea fi reorganizat, pentru a reduce ipotezele incorecte din
ramifica#ii, "n func#ie de tiparele de e*ecu#ie o)ser!ate.
-cestea sunt numai cte!a dintre moti!ele pentru care este de ateptat ca !iitoarele coduri
administrate s& fie e*ecutate mai )ine dect cele neadministrate, din zilele noastre. %up& cum am spus,
performan#ele sunt, la ora actual&, destul de )une i se !or "m)un&t&#i, pe m&sur& ce !a trece timpul.
%ac& e*perimentele dumnea!oastr& demonstreaz& c& performan#ele aplica#iilor o)#inute cu compilatorul
>4T nu sunt de un ni!el adec!at, a#i putea profita de a!anta.ele oferite de instrumentul Ngen.e*e, care este
li!rat "mpreun& cu setul S%P .NET Framework. -cest instrument realizeaz& compilarea "ntregului cod 47
dintr$un asam)la. "n cod nati!, pe care "l sal!eaz& "ntr$un fiier de pe disc. "n timpul e*ecu#iei, atunci
cnd este "nc&rcat un asam)la., componenta /76 !erific& automat dac& e*ist& i o !ersiune precompilat&
a asam)la.ului i, "n acest caz, "ncarc& acest cod precompilat, astfel "nct nu mai este necesar& nici o
compilare "n timpul e*ecu#iei.
C o d u l " L #i $ er i% i c are a
7im)a.ul 47 se )azeaz& pe sti!e, ceea ce "nseamn& c& toate instruc#iunile sale 9"mping: operanzii "ntr$o
sti!& de e*ecu#ie i 9e*trag: rezultatele din aceasta. %eoarece lim)a.ul 47 nu ofer& instruc#iuni de
manipulare a registrelor, realizatorii de compilatoare pot produce mai uor codul 47L nu mai este necesar s&
se mai gndeasc& la administrarea registrelor i sunt necesare mai pu#ine instruc#iuni 47 'din moment ce
nu e*ist& nici una pentru manipularea registrelor(.
%e asemenea, instruc#iunile 47 nu depind de tip. %e e*emplu, lim)a.ul 47 pune la dispozi#ie o
instruc#iune add, care efectueaz& sumarea ultimilor doi operanzi introdui "n sti!&L nu e*ist& instruc#iuni
add separate pentru GC de )i#i i EF de )i#i. -tunci cnd este e*ecutat& instruc#iunea add, aceasta determin&
tipurile operanzilor din sti!& i efectueaz& opera#ia corespunz&toare.
%up& p&rerea mea, cel mai mare )eneficiu al lim)a.ului 47 const& "n faptul c& nu a)stractizeaz&
unitatea /P3 aflat& la )az&. /el mai mare a!anta. este ro)uste#ea aplica#iilor, "n timpul compil&rii codului
47 "n instruc#iuni nati!e /P3, componenta /76 efectueaz& un proces numit $erificare. "n timpul !erific&rii,
se e*amineaz& codul 47, de ni!el "nalt, i se !erific& dac& tot ceea ce face acesta este 9sigur:. %e e*emplu, se
!erific& s& nu se citeasc& din memorie f&r& ca, "n preala)il, s& se fi scris "n aceasta, ca fiecare metod& s& fie
apelat& cu num&rul corect de parametri i ca fiecare parametru s& fie de tipul corect, ca !aloarea de
returnare a fiec&rei metode s& fie utilizat& adec!at, ca fiecare metod& s& ai)& o instruc#iune de returnare i
aa mai departe.
Metadatele modului administrat cuprind toate informa#iile despre metod& i tip utilizate "n procesul de
!erificare. "n cazul "n care codul 47 este considerat a fi 9nesigur:, este introdus& o e*cep#ie
&y'te(.&ecurity.)eri% ierException* care "mpiedic& e*ecutarea metodei.
C o d u l d u ( n e a $ o a ' t r + e ' t e ' i g u r , _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
4mplicit, compilatoarele Microsoft /= i ,isual 2asic produc coduri sigure. /odul sigur poate fi !erificat
ca a!nd aceast& calitate. Totui, este posi)il& utilizarea cu!ntului cheie un'a%e
1
"n lim)a.ul /= sau alte
lim)a.e 'cum ar fi /11 with Managed E*tensions sau lim)a.ul de asam)lare 47( pentru a produce un cod
care nu se poate !erifica drept fiind sigur.
/odul poate fi, de fapt, sigur, dar aceasta nu se poate demonstra prin !erificarea sa.
<
Nesigur, 'n.t.(
<<
Pentru a garanta c& toate metodele modulului administrat con#in cod 47 care poate fi !erificat ca fiind
sigur, se poate utiliza programul utilitar PE,erif@ 'PE,erif@.e*e(, li!rat "mpreun& cu pachetul .NET
Framework S%P. -tunci cnd cei de la Microsoft testeaz& compilatoarele /= i ,isual 2asic, ei ruleaz&
modulul rezultant "n programul PE,erif@, pentru a garanta c& "ntotdeauna compilatorul produce un cod
sigur, care poate fi !erificat.
%ac& programul PE,erif@ detecteaz& un cod care nu este sigur, atunci cei de la Microsoft remediaz&
compilatorul.
Pute#i "ncerca rularea programului PE,erif@ pe propriile dumnea!oastr& module, "nainte de a le
"mpacheta i li!ra. %ac& programul PE,erif@ detecteaz& o pro)lem&, atunci "n compilator e*ist& o hi)&, iar
dumnea!oastr& ar tre)ui s$o anun#a#i companiei Microsoft 'sau celei care a produs compilatorul pe care "l
utiliza#i(. %ac& programul PE,erif@ nu detecteaz& un cod care nu poate fi !erificat, atunci ti#i c& acesta !a
putea fi rulat f&r& a introduce o e*cep#ie ,erif ierE*ception pe calculatorul utilizatorului final.
Tre)uie s& ti#i c& !erificarea necesit& accesul la metadatele con#inute "n orice asam)la.e independente.
-stfel, atunci cnd se utilizeaz& programul PE,erif@ pentru a !erifica un asam)la., acesta tre)uie s& poat&
localiza i "nc&rca toate asam)la.ele referen#iate. %eoarece programul PE,erif@ utilizeaz& componenta
/76 pentru a localiza asam)la.ele dependente, amplasarea acestora este detectat& folosind aceleai reguli
de asociere i pro)are care ar fi utilizate "n mod normal la e*ecu#ia asam)la.ului respecti!. ',om analiza
aceste reguli de asociere i pro)are "n capitolele C i G.(
5)ser!a#i c& un administrator poate opta pentru dezacti!area !erific&rii 'folosind instrumentul
administrati! Microsoft .NET Framework /onfiguration(. -tunci cnd !erificarea este dezacti!at&,
compilatorul >4T !a compila un lim)a. 47 ne!erifica)il "n instruc#iuni nati!e /P3L dar administratorul "i
asum& "ntreaga responsa)ilitate pentru comportamentul codului.
"n sistemul de operare Bindows, fiecare proces are propriul s&u spa#iu de adrese !irtual. Sunt necesare
spa#ii de adrese separate, deoarece nu se poate a!ea "ncredere "n codul aplica#iei. Este cu totul posi)il 'i,
din p&cate, foarte o)inuit( ca o aplica#ie s& citeasc& i s& scrie "ntr$o adres& de memorie care nu este !ala)il&.
Prin plasarea fiec&rui proces Bindows "ntr$un spa#iu de adres& separat, se o)#ine o mai mare ro)uste#e8 un
proces nu poate afecta "n sens negati! un alt proces.
Prin !erificarea codului administrat, tim c& acesta nu acceseaz& necorespunz&tor memoria care nu
tre)uie i c& nu poate afecta "n sens negati! codul altei aplica#ii. -ceasta "nseamn& ca putem rula mai multe
aplica#ii administrate, "n cadrul unui singur spa#iu de adrese !irtual.
%eoarece procesele Bindows necesit& o mul#ime de resurse ale sistemului de operare, multitudinea
acestora poate afecta performan#ele i limita resursele disponi)ile. 6educerea num&rului de procese prin
rularea mai multor aplica#ii "n cadrul unui singur proces 5S poate duce la "m)un&t&#irea performan#elor
i necesit& mai pu#ine resurse, totodat& fiind la fel de ro)ust. -cesta este un alt a!anta. al codului
administrat, fa#& de cel neadministrat.
%e fapt, componenta /76 ofer& capacitatea de a e*ecuta mai multe aplica#ii administrate "n cadrul unui
singur proces 5S. Fiecare aplica#ie administrat& se numete %pp&omain. 4mplicit, fiecare fiier EIE
administrat !a fi rulat "n propriul s&u spa#iu de adrese separat, care are o singur& aplica#ie -pp%omain.
Totui, un proces care g&zduiete componenta /76 'cum ar fi ser!iciile 4nternet 4nformation Ser!ices,
44S, sau o !ersiune !iitoare a lim)a.ului SX7 Ser!er( poate hot&r" s& ruleze aplica#iile -pp%omain "n
cadrul unui singur proces 5S. 5 parte din /apitolul CS este dedicat& unei analize a aplica#iilor
-pp%omain.
2 ib l i o te c a de c la s e .N ET Fram ew o r k
"n cadrul platformei .NET Framework este inclus un set de asam)la.e .NET Framework /lass 7i)rar@
'F/7(, care con#ine cte!a mii de defini#ii de tipuri, fiecare tip oferind o anumit& func#ionalitate. Pe scurt,
componenta /76 i )i)lioteca F/7 permit realizatorilor de aplica#ii s& construiasc& urm&toarele feluri de
aplica#ii8
J &er$icii -eb .ML Metode care pot fi accesate foarte uor prin 4nternet, ser!iciile IM7 Be)
reprezint&, desigur, elementul esen#ial al ini#iati!ei .NET a companiei Microsoft.
J -eb For(' Sunt aplica#ii )azate pe lim)a.ul ?TM7 'situri Be)(. %e regul&, aplica#iile Be) Forms
<C
!or efectua interog&ri de )aze de date i apel&ri ale ser!iciilor Be), !or com)ina i filtra informa#iile
returnate, pe care le !or prezenta apoi "n cadrul unui )rowser, folosind o interfa#& cu utilizatorul
)ogat&, )azat& pe ?TM7. -plica#iile Be) Forms ofer& un mediu de dez!oltare "n stil ,isual 2asic E i
,isual 4nter%e! pentru aplica#iile Be) scrise "n orice lim)a. din componenta /76.
J -indo/' For(' Sunt aplica#ii Bindows A34 )ogate. "n loc de a utiliza o pagin& Be) Forms
pentru a crea interfa#a 34 a aplica#iei, se poate folosi func#ionalitatea mai puternic&, cu performan#e
mai ridicate, oferit& de suprafa#a de lucru Bindows. -plica#iile Bindows Forms pot profita de
controalele, meniurile i e!enimentele declanate de mouse i tastatur& i pot trata direct cu sistemul de
operare aflat la )az&. /a i aplica#iile Be) Forms, i acestea efectueaz& interog&ri ale )azelor de date i
apel&ri ale ser!iciilor IM7 Be). -plica#iile Bindows Forms ofer& un mediu de dez!oltare asem&n&tor
cu ,isual 2asic E pentru aplica#iile A34 scrise "n orice lim)a. /76.
J 0plica1ii -indo/' de con'ol+ Pentru aplica#iile cu cerin#e 34 foarte simple, o aplica#ie de consol&
reprezint& o modalitate rapid& i facil& de a construi o aplica#ie. /ompilatoarele, utilitarele i
instrumentele sunt implementate, de regul&, ca aplica#ii de consol&.
J &er$icii -indo/' %a, folosind platforma .NET Framework, este posi)il s& se construiasc& aplica#ii
de ser!iciu, controla)ile prin intermediul facilit&#ii Bindows Ser!ice /ontrol Manager 'S/M(.
J 2iblioteca de co(ponente Platforma .NET Framework permite construirea de componente 'tipuri(
autonome, care pot fi cu uurin#& "ncorporate "n oricare dintre tipurile de aplica#ii men#ionate mai sus.
%eoarece )i)lioteca F/7 con#ine efecti! mii de tipuri, realizatorului de aplica#ii "i este prezentat un set de
tipuri "nrudite "n cadrul unui singur spa#iu de nume. %e e*emplu, spa#iul de nume S@stem 'cu care !e#i
a.unge ct se poate de familiarizat( con#ine tipul de )az& 3b4ect* din care deri!&, "n ultim& instan#&, toate
celelalte tipuri. "n plus, spa#iul de nume S@stem con#ine tipuri pentru numere "ntregi, caractere, iruri,
tratarea e*cep#iilor i opera#ii 405 de la consol&, ca i un set de tipuri utilitare care efectueaz& "n siguran#&
transform&ri "ntre tipurile de date, formateaza tipurile de date, genereaz& numere aleatorii i efectueaz&
di!erse func#ii matematice. Toate aplica#iile !or utiliza tipuri din spa#iul de nume S@stem.
Pentru a accesa oricare dintre caracteristicile platformei, este necesar s& tim ce spa#iu de nume con#ine
tipurile care ofer& facilit&#ile c&utate. %ac& dorim s& personaliz&m compor tamentul oric&ruia dintre tipuri,
putem pur i simplu deri!a propriul tip din tipul F/7 dorit. Modul "n care platforma .NET Framework
prezint& realizatorilor de software o paradigm& de programare coerent& este prin natura orientat& spre
o)iecte a acesteia. %e asemenea, realizatorii "i pot crea cu uurin#& propriile spa#ii de nume, care s&
con#in& propriile tipuri. Spa#iile de nume i tipurile se "m)in& impeca)il "n paradigma program&rii.
/omparati! cu paradigma program&rii BinGC, aceast& nou& a)ordare simplific& su)stan #ial dez!oltarea de
software.
Ma.oritatea spa#iilor de nume din )i)lioteca F/7 prezint& tipuri care pot fi utilizate pentru orice fel de
aplica#ie. "n Ta)elul <$C sunt prezentate cte!a dintre spa#iile de nume generale, "mpreun& cu o scurt&
descriere a utiliz&rii tipurilor din cadrul acestora.
Tabelul 1- /te!a spa#ii de nume generale di n )i)lioteca F/7
&pa1iul de nu(e 5e'crierea con1inutului
&y'te( Toate tipurile de )az&, folosite de fiecare aplica#ie.
&y'te(.Collection' Tipurile pentru administrarea colec#iilor de o)iecteL
cuprinde tipurile de colec#ii uzuale, cum ar fi sti!ele, cozile, ta)elele
hash i aa mai departe.
&y'te(. 5iagno'tic' Tipurile care a.ut& la instrumentarea i depanarea
aplica#iilor.
&y'te(.5ra/ing Tipurile pentru manipularea graficelor C$%L sunt utilizate,
de regul&, pentru aplica#iile Bindows Forms i pentru crearea de imagini
care !or ap&rea "n pagina Be) Forms.
&y'te(.Enterpri'e&er$ice' Tipurile pentru gestionarea tranzac#iilor, componentelor
plasate "n cozi, crearea de rezer!oare de o)iecte, acti!area >4T, securitatea i
alte caracteristici, care fac ca utilizarea codului administrat s& fie mai
eficient& pe ser!er.
&y'te(.Globali6ation Tipurile pentru suportul National 7anguage Support 'N7S(,
<G
cum ar fi compar&rile de iruri, format&rile i calendarele.
&y'te(. 17 Tipurile pentru realizarea opera#iilor 405 cu derulare
continu&, parcurgerea directoarelor i fiierelor.
&y'te(.Manage(ent Tipurile utilizate pentru gestionarea altor calculatoare din
cadrul "ntreprinderii, prin intermediul facilit&#ii Bindows Management
4nstrumentation 'BM4(.
&y'te(.8ET Tipurile care permit comunica#iile prin re#ea.
&y'te(.9e%lection Tipurile care permit inspectarea metadatelor i asocierea
ulterioar& cu tipuri i mem)rii acestora.
&pa1iul de nu(e 5e'crierea con1inutului
&y'te(.9e'ource' Tipurile pentru manipularea resurselor de date e*terne.
&y'te(. 9unti(e. "nterop&er Tipurile care permit codului administrat s& acceseze
$ice' facilit&#ile platformei 5S, cum ar fi componentele /5M
i func#iile din )i)liotecile %77 din BinGC.
&y'te(. 9unti(e. 9e(otlng Tipurile care permit accesarea de la distan#& a tipurilor.
&y'te(.9unti(e.&eriali6at Tipurile care permit ca instan#ele o)iectelor s& fie
ion persistente i s& poat& fi regenerate dintr$un flu*.
&y'te(.&ecurity Tipurile utilizate pentru prote.area datelor i resurselor.
&y'te(.Text Tipurile necesare pentru a lucra cu te*t "n di!erse
codific&ri, cum ar fi -S/44 sau 3nicode.
&y'te(.Threading Tipurile utilizate pentru opera#iile asincrone i
sincronizarea accesului la resurse.
&y'te(..(l Tipurile utilizate pentru prelucrarea schemelor i datelor
IM7.
-ceast& carte are ca su)iect componenta /76 i tipurile generale care interac#ioneaz& cu aceasta 'care
reprezint& ma.oritatea spa#iilor de nume enumerate "n Ta)elul <$C(. -stfel, con#inutul acestei c&r#i este util
pentru to#i programatorii .NET Framework, indiferent de tipul de aplica#ie pe care o realizeaz&.
4n afar& de spa#iile de nume generale, componenta /76 pune la dispozi#ie i spa#ii de nume ale c&ror
tipuri sunt utilizate pentru construirea de tipuri de aplica#ii specifice. "n Ta)elul <$G sunt enumerate
cte!a dintre spa#iile de nume specifice aplica#iilor din )i)lioteca F/7.
Tabelul 1)* C(te)a spaii de nume speci*ice aplicaiilor+ din biblioteca FCL
&pa1iul de nu(e Tipul de aplica1ie
&y'te(.-eb.&er$ice' Tipurile utilizate pentru a construi ser!icii IM7 Be).
&y'te(.-eb.:" Tipurile utilizate pentru a construi aplica#ii Be) Forms.
&y'te(.-indo/'.For(' Tipurile utilizate pentru a construi aplica#ii Bindows A34.
&y'te(.&er$iceProce'' Tipurile utilizate pentru a construi un ser!iciu Bindows,
care poate fi controlat de facilitatea S/M.
Este de ateptat s& apar& multe c&r#i )une, care s& e*plice cum se construiesc tipuri specifice de aplica#ii
'cum ar fi ser!iciile Bindows, aplica#iile Be) Forms i Bindows Forms(. -ceste c&r#i !& !or oferi un
e*celent punct de plecare pentru a !& a.uta la construirea aplica#iilor dumnea!oastr&. Sunt "nclinat s&
cred c& aceste c&r#i specifice aplica#iilor !& !or a.uta s& "n!&#a#i de sus "n .os, deoarece ele se concentreaz&
asupra tipului de aplica#ie, nu asupra platformei de dez!oltare. 4n aceast& carte !om oferi informa#ii care !&
!or a.uta s& "n!&#a#i de .os "n sus. %up& parcurgerea acestei c&r#i i a uneia specifice aplica#iilor, !e#i
putea construi cu uurin#& i eficient orice tip de aplica#ie .NET Framework dori#i.
<F
/pecifica -ia Common T3pe /3stem
Pn& acum tre)uie s& fi de!enit e!ident c&, "n totalitate, componenta /76 se ocup& de tipuri. Tipurile
ofer& func#ionalitate aplica#iilor i componentelor acestora. Tipurile reprezint& mecanismul prin care codul
scris "ntr$un lim)a. de programare poate comunica cu cel scris "n alt lim)a. de programare. %eoarece
tipurile reprezint& )aza componentei /76, compania Microsoft a creat o specifica#ie formal& M /ommon
T@pe S@stem
<
'/TS( M care descrie modul "n care sunt definite i se comport& tipurile.
Specifica#ia /TS sta)ilete c& un tip poate con#ine zero sau mai mul#i mem)ri. "n Partea a 4l4$a ne !om
ocupa detaliat de aceti mem)ri. Pentru moment, !om oferi doar o scurt& prezentare a lor8
J c;(pul 5 !aria)il& de date, care face parte din starea o)iectului. /mpurile sunt identificate prin
nume i tipL
J (etoda 5 func#ie care efectueaz& o opera#ie asupra o)iectului, adeseori modificnd starea acestuia.
Metodele au un nume, o semn&tur& i modificatori. Semn&tura arat& con!en#ia de apelare, num&rul de
parametri 'i sec!en#a lor(, tipurile de parametri i tipul de !aloare returnat& de c&tre metod&L
J proprietatea Pentru apelant, acest mem)ru arat& ca un cmp. %ar pentru imple mentatorul tipului,
arat& ca o metod& 'sau dou&(. Propriet&#ile permit unui imple mentator s& !alideze parametrii de
intrare i starea o)iectului, "nainte de a accesa !a loarea i0sau calcula o !aloare numai atunci cnd este
necesar. %e asemenea, ele permit unui utilizator al tipului respecti! s& foloseasc& o sinta*& simplificat&.
"n sfrit, propriet&#ile permit crearea de 9cmpuri: numai pentru citire sau numai pentru scriereL
J e$eni(entul 3n e!eniment permite e*isten#a un mecanism de notificare "ntre un o)iect i alte
o)iecte interesate. %e e*emplu, un )uton ar putea reprezenta un e!eniment care s& anun#e alte o)iecte
atunci cnd se efectueaz& clic pe el.
%e asemenea, specifica#ia /TS arat& regulile pentru !izi)ilitatea tipurilor i pentru accesul la mem)rii
unui tip. %e e*emplu, prin marcarea unui tip capublic 'numit pu)lic(, acesta este e*portat, f&cndu$<
!izi)il i accesi)il pentru orice asam)la.. Pe de alt& parte, prin marcarea unui tip ca assembl' 'numit
internai "n /=(, acesta este f&cut !izi)il i accesi)il numai pentru codul din acelai asam)la.. -stfel,
specifica#ia /TS sta)ilete regulile prin care asam)la.ele formeaz& o limit& de !izi)ilitate pentru un tip,
iar componenta /76 "nt&rete regulile de !izi)ilitate.
4ndiferent dac& un tip este !izi)il pentru un apelant, el reuete s& controleze dac& apelantul are acces
la mem)rii s&i. "n lista urm&toare sunt prezentate op#iunile !ala)ile pentru controlul accesului la o
metod& sau un cmp8
J Pri$ate Metoda poate fi apelat& numai de c&tre alte metode din acelai tip de clas&.
J Fa(ily Metoda poate fi apelat& de c&tre tipurile deri!ate, indiferent dac& ele se afla "n acelai
asam)la. sau nu. %e remarcat c& multe lim)a.e de programare 'cum ar fi /11 i /=( se refer& la op#iunea
famil@ ca protected.
J Famil@ and assem)l@ Metoda poate fi apelat& de c&tre tipurile deri!ate, dar numai
dac& tipul deri!at este definit "n acelai asam)la.. Multe lim)a.e de programare 'cum
ar fi /= i ,isual 2asic( nu ofer& acest control al accesului. %esigur c& lim)a.ul 47
-ssem)l@ "l pune la dispozi#ieL
J -ssem)l@ Metoda poate fi apelat& de c&tre orice cod din acelai asam)la.. Multe
lim)a.e de programare se refer& la op#iunea assembl' ca internai.
J Famil@ or assem)l@ Metoda poate fi apelat& de c&tre tipurile deri!ate din orice
asam)la.. %e asemenea, metoda poate fi apelat& de c&tre orice tipuri din acelai asam)la.,
"n lim)a.ul /= c'pmne.(. famil' or assembl' este considerat& ca protected internai.
J Pu)lic Metoda poate fi apelat& de c&tre orice cod, din orice asam)la..
"n plus, specifica#ia /TS definete regulile care gu!erneaz& motenirea tipurilor, func#iile !irtuale,
timpul de !ia#& al o)iectului i aa mai departe. -ceste reguli au fost concepute pentru a cuprinde semantica
ce poate fi e*primat& "n lim)a.ele de programare din epoca modern&. %e fapt, nici nu !a fi necesar s&
"n!&#a#i regulile /TS per se, deoarece lim)a.ul pe care "l !e#i alege !a dez!&lui propria sa sinta*& i regulile
referitoare la tipuri, "n acelai mod cu care sunte#i familiarizat acum, i !a potri!i sinta*a specific& lim)a.ului
dup& 9lim)a.ul: componentei /76, atunci cnd !a emite modulul administrat.
-tunci cnd am "nceput s& lucrez prima dat& cu componenta /76, mi$am dat seama repede c& cel mai
)ine este s& consider&m lim)a.ul i comportamentul codului ca dou& lucruri separate i diferite. Folosind
lim)a.ul /11, putem defini propriile tipuri, cu propriii mem)ri.
%esigur c& am fi putut utiliza i lim)a.ul /= sau ,isual 2asic pentru a defini acelai tip, cu aceiai
<
Sistemul de tipuri comun, 'n.t.(
<T
mem)ri. /u siguran#& c& sinta*a folosit& pentru a defini acest tip este diferit&, depinznd de lim)a.ul ales,
dar comportamentul tipului !a fi a)solut identic, indiferent de lim)a., deoarece specifica#ia /TS a
componentei /76 este cea care definete comportamentul tipului.
Pentru a a.uta la clarificarea acestei idei, !om da un e*emplu. Specifica#ia /TS accept& numai
motenirea unic&. -stfel, dac& lim)a.ul /11 accept& tipuri care motenesc mai multe tipuri de )az&,
specifica#ia /TS nu poate accepta i opera cu astfel de tipuri. Pentru a a.uta realizatorul de aplica#ii,
compilatorul ,isual /11 raporteaz& o eroare, dac& detecteaz& c& se "ncearc& crearea unui cod administrat,
care s& includ& un tip care motenete de la mai multe tipuri de )az&.
Mai e*ist& "nc& o regul& a specifica#iei /TS. Toate tipurile tre)uie '"n cele din urm&( s& moteneasc& un
tip predefinit8 S@stem.5).ect. %up& cum pute#i !edea, 5).ect este numele unui tip definit "n spa#iul de
nume S@stem. Tipul 5).ect este r&d&cina tuturor celorlalte tipuri i, prin urmare, garanteaz& c& fiecare
apari#ie a tipului are un set minim de comportamente. Mai e*act, tipul S@stem.5).ect permite s& se
efectueze urm&toarele8
J compararea egalit&#ii a dou& instan#eL
J o)#inerea codului hash corespunz&tor instan#ei respecti!eL
J interogarea ade!&ratului tip al unei instan#eL
J efectuarea unei copii superficiale 'dup& )i#i( a instan#eiL
J o)#inerea unei reprezent&ri su) form& de ir a st&rii curente a o)iectului.
/pecifica -ia Common &an'ua'e /pecification
Specifica#ia /5M permite o)iectelor create "n di!erse lim)a.e de programare s& comunice unele cu
altele. Pe de alt& parte, componenta /76 integreaz& acum toate lim)a.ele i permite ca o)iectele create
"ntr$un lim)a. s& fie tratate "n mod egal de c&tre codul scris "ntr$un lim)a. complet diferit. -ceast& integrare
este posi)il& datorit& setului de tipuri standard al componentei /76, informa#iilor cu autodescriere
'metadatelor( i mediului de e*ecu#ie comun.
%ei aceast& integrare a lim)a.elor reprezint& un scop e*traordinar, ade!&rul este c& lim)a.ele de
programare sunt foarte diferite unele de altele. %e e*emplu, unele lim)a.e nu trateaz& sim)olurile ca fiind
dependente de tipul de litere sau nu permit tipuri de numere "ntregi f&r& semn, supra"nc&rcarea
operatorilor sau metode care s& accepte un num&r !aria)il de parametri.
%ac& inten#iona#i s& crea#i tipuri care s& fie uor accesi)ile din alte lim)a.e de programare, atunci este
necesar s& utiliza#i numai caracteristicile din lim)a.ul de programare care este sigur c& sunt disponi)ile i
"n toate celelalte lim)a.e. Pentru a !& a.uta, compania Microsoft a definit o specifica#ie numit& Common
)anguage *pecification
+
'/7S(, care prezint& detaliat pentru produc&torii de compilatoare setul minim
de caracteristici pe care tre)uie s& le accepte produsele lor, "n cazul "n care compilatoarele au ca #int&
componenta /76.
Specifica#ia /760/TS accept& mult mai multe caracteristici dect
su)setul definit de c&tre specifica#ia /7S, astfel "nct, dac& nu #ine#i la
opera)ilitatea dintre lim)a.e, atunci pute#i realiza tipuri foarte )ogate,
limitate doar de c&tre setul de caracteristici al lim)a.ului respecti!.
Mai e*act, specifica#ia /TS definete regulile pe care tre)uie s& le
respecte tipurile i metodele !izi)ile e*tern, pentru a fi accesi)ile din
orice lim)a. de programare compati)il /76. %e remarcat c& regulile
/7S nu se aplic& pentru codurile care sunt accesi)ile numai "n cadrul
asam)la.ului de defini#ie. "n Figura <$E este prezentat un rezumat al
ideilor e*primate "n acest paragraf.
%up& cum se poate o)ser!a "n Figura <$E, specifica#ia /760/TS ofer& un
set de caracteristici. 3nele lim)a.e e*pun o su)mul#ime cuprinz&toare din
specifica#ia /760/TS. %e e*emplu, un programator care dorete s& scrie
codul "n lim)a.ul de asam)lare 47 poate utiliza toate caracteristicile oferite de
specifica#ia /760/TS.
Ma.oritatea celorlalte lim)a.e, cum ar fi /=, ,isual 2asic i Fortran, ofer& programatorului un su)set
<
Specifica#ia comun& pentru lim)a.e, 'n.t.(
Fi'ura 1)4 Limbajele o*er o
submulime din speci*icaia
CLR,C-. i includ speci*icaia
CL. /dar limbajele nu reprezint
neaprat aceeai mulime0.
<E
al caracteristicilor /760/TS. Specifica#ia /7S definete setul minim de caracteristici pe care tre)uie s& le
accepte toate lim)a.ele.
Kn cazul "n care proiecta#i un tip "ntr$un lim)a. i inten#iona#i ca acesta s& fie utilizat de un alt lim)a., nu
tre)uie s& utiliza#i !reuna dintre caracteristicile din afara specifica#iei /7S. -ceasta ar "nsemna c& s$ar
putea ca mem)rii tipului dumnea!oastr& s& nu fie accesi)ili pentru programatorii care scriu coduri "n alte
lim)a.e de programare.
"n codul de mai .os este definit un tip compati)il cu specifica#ia /7S, "n lim)a.ul /=. Totui, tipul are
cte!a construc#ii care nu sunt compati)ile cu specifica#ia /7S, ceea ce determin& compilatorul /= s&
emit& mesa.e de eroare. using S@stemL
,,Cere compilatorului sa )eri*ice compatibilitatea CL..
1assembl23CL.Compliant/true04
,,$rorile care urmeaz apar deoarece clasa este de tip public.
public class 'pp 5
,,$roare3 tipul de returnare pentru 6'pp.'bc*0
1
nu e compatibil CL..
public 78nt92 'bc/0 5 return :; <
,,$roare3 identi*icatorul 6'pp.abc=6 di*er .
,,numai in cazul in care nu este compatibil CL.
public )oid abc/0 5 <
,,>u e%ista nici o eroare3 metoda este de tip pri)ate.
pri)ate 78nt92 '?C/0 5 return :; <
<
Kn acest cod, atri)utul Yassem)l@8/7S/ompliant'true(Z este aplicat asam)la.ului. -cest atri)ut "i cere
compilatorului s& se asigure c& orice tip e*pus pu)lic nu are !reo construc#ie care s&$< "mpiedice de a fi
accesat din alte lim)a.e de programare. -tunci cnd acest cod este compilat, compilatorul /= emite dou&
erori. Prima este raportat& deoarece metoda -)c returneaz& un num&r "ntreg f&r& semnL ,isual 2asic i alte
cte!a lim)a.e de programare nu pot manipula !alori "ntregi f&r& semn. /ea de$a doua eroare apare
pentru c& acest tip e*pune dou& metode pu)lice care difer& doar prin tipul de litere8 -)c i a)c. ,isual 2asic
i alte cte!a lim)a.e nu pot apela am)ele metode.
4nteresant este c&, dac& tergem op#iunea pu)lic de dinaintea clasei W class -ppW i efectu&m din nou
compilarea, am)ele erori !or disp&rea. Moti!ul este c& tipul -)c !a fi sta)ilit implicit ca internai i, prin
urmare, nu !a mai fi e*pus "n afara asam)la.ului. Pentru o list& complet& a regulilor specifica#iei /7S,
consulta#i sec#iunea 9/ross$7anguage 4nterope$ra)ilit@
<
:, din documenta#ia .NET Framework S%P.
,om distila regulile /7S "n ce!a foarte simplu. "n componenta /76, fiecare mem)ru al unui tip este fie un
cmp 'date(, fie o metod& 'comportament(. -ceasta "nseamn& c& fiecare lim)a. de programare tre)uie s&
poat& accesa cmpuri i s& apeleze metode. -numite cmpuri i metode sunt utilizate "n moduri speciale
i comune. Pentru a facilita programarea, lim)a.ele ofer& de regul& a)stractiz&ri suplimentare, care
uureaz& codificarea acestor structuri de programare uzuale. %e e*emplu, lim)a.ele etaleaz& concepte cum
ar fi enumer&rile, ta)lourile, propriet&#ile, inde*atorii, delega#ii, e!enimentele, constructorii, destructorii,
supra"nc&rc&rile de operatori, operatorii de con!ersie i aa mai departe. -tunci cnd un compilator
"ntlnete "n codul surs& una dintre aceste construc#ii, el tre)uie s& o traduc& "n cmpuri i metode, astfel
"nct componenta /76 i alte lim)a.e de programare s& o poat& accesa.
,om considera urm&toarea defini#ie a unui tip, care con#ine un constructor, un destructor,
c#i!a operatori supra"nc&rca#i, o proprietate, un inde*ator i un e!eniment. /odul prezentat este doar
pentru a permite compilareaL nu reprezint& o modalitate corect& de implementare a unui tip.
using S@stemL
class Test { //Constructor public
Test() {}
//Destructor
-Test() {}
//Supra nc!rcarea unor operatori"
<
4nteropera)ilitatea "ntre lim)a.e, 'n.t.(
<V
public static #oolean operator $$ (Test t1% Test t&) {
return true'
}
public static #oolean operator ($ (Test t1% Test t&) {
return false' }
//O supraincarcare )e operator"
public static Test operator * (Test t1% Test t&) { return null' }
// + proprietate"
public Strin, -propert. {
,et { return nuli' }
set { } }
//Un in)e/ator"
public Strin, t0is12nt3& /4 {
,et { return nuli' }
set { }
}
//Un e5eniment"
e5ent 65ent7an)ler -n65ent'
}
-tunci cnd compilatorul compileaz& acest cod, rezultatul este un tip care are un num&r de cmpuri i
metode definite "n cadrul s&u. Pute#i o)ser!a cu uurin#& aceasta, utiliznd instrumentul 47 %isassem)ler
'47%asm.e*e( din cadrul setului .NET Framework S%P, pentru a analiza modulul administrat rezultant,
care este prezentat "n Figura <$V.
"n Ta)elul <$F se arat& cum s$a realizat coresponden#a dintre construc#iile lim)a.ului de programare i
cmpurile i metodele echi!alente din specifica#ia /76.
Fi'ura 1)5 Cu ajutorul instrumentului 8L&asm sunt a*iate c(mpurile i metodele tipului -est /obinute din
metadate0.
Tabelul 1)0 C(mpurile i metodele tipului -est /obinute din metadate0.
Mem)rul tipului Tipul de mem)ru /onstruc#ia echi!alent& din lim)a.ul
de programare
0nE$ent
/mp
E!enimentL numele cmpului este -nE!ent,
iar tipul '+u e'te &y'te(.E$ent<andler.
.ctor Metod& /onstructor.
Finali6e Metod& %estructor.
add_0nE$ent Metod& Metoda accesorie add a e!enimentului.
get_0Property Metod& Metoda accesorie get a propriet&#ii.
get_"te( Metod& Metoda accesorie get a inde*atorului.
op_0ddition Metod& 5peratorul 1.
op_E=uality Metod& 5peratorul [[.
op_"ne=uality Metod& 5peratorul +[.
<D
re(o$e_0nE$ent Metod& Metoda accesorie remo!e a e!enimentului.
'et_0Property Metod& Metoda accesorie set a propriet&#ii.
'et_"te( Metod& Metoda accesorie set a inde*atorului.
Nodurile suplimentare de su) tipul Test, care nu sunt men#ionate "n Ta)elul <$F $ .class, .custom,
-nE!ent, -Propert@ i 4tem $ identific& metadate suplimentare despre tip. -ceste noduri nu corespund
cmpurilor sau metodelorL ele nu fac dect s& ofere o serie de informa#ii suplimentare despre tipul la care
poate a!ea acces componenta /76, lim)a.ele de programare sau instrumentele. %e e*emplu, un
instrument poate !edea c& tipul Test pune la dispozi#ie un e!eniment numit -nE!ent, care este e*pus prin
intermediul celor dou& metode, addR-nE!ent i remo!eR-nE!ent.
Interoperabilitatea cu codul neadministrat
Platforma .NET Framework ofer& o ton& de a!anta.e, fa#& de alte platforme de dez!oltare. Totui,
foarte pu#ine companii "i pot permite s& reproiecteze i s& reimplementeze toate codurile e*istente.
/ompania Microsoft "i d& seama de aceasta i a construit componenta /76 astfel "nct s& ofere mecanisme
care permit ca o aplica#ie s& fie format& att din p&r#i administrate, ct i din p&r#i neadministrate. Mai
e*act, componenta /76 accept& trei ipoteze de interopera)ilitate8
J /odul administrat poate apela o func#ie neadministrat& dintr$o )i)liotec& %77.
/odul administrat poate apela cu uurin#& func#iile con#inute "ntr$o )i)liotec& %77, folosind un
mecanism numit P04n!oke 'de la Platform 4n!oke
<
(. "n fond, multe dintre tipurile definite intern "n
)i)lioteca F/7 apeleaz& func#ii e*portate din fiierele PernelGC.dll, 3serGC.dll i aa mai departe.
Multe lim)a.e de programare !or prezenta un mecanism care faciliteaz& apelarea func#iilor
neadministrate con#inute "n fiierele %77 de c&tre codul administrat. %e e*emplu, o aplica#ie /= sau
,isual 2asic poate apela func#ia /reateSemaphore, e*portat& din fiierul PernelGC.dll.
J /odul administrat poate folosi o component& /5M e*istent& 'ser!er(. Multe companii au
implementat de.a un num&r de componente /5M neadministrate. Prin utilizarea )i)liotecii de tipuri
din aceste componente, poate fi creat un asam)la. administrat, care s& descrie componenta /5M.
/odul administrat poate accesa tipul din asam)la.ul administrat, la fel ca orice alt tip administrat.
Pentru mai multe informa#ii, folosi#i instrumentul Tl)lmp.e*e, care este li!rat "mpreun& cu setul .NET\
Framework S%P. 3neori, este posi)il s& nu e*iste o )i)liotec& de tipuri sau este necesar un control mai
mare asupra a ceea ce produce programul Tl)lmp.e*e. "n aceste situa#ii, se poate construi manual "n
codul surs& un tip, pe care componenta /76 "l poate utiliza pentru a realiza interopera)ilitatea
adec!at&. %e e*emplu, se pot folosi componentele %irectI /5M dintr$o aplica#ie /= sau ,isual
2asic.
J /odul neadministrat poate utiliza un tip administrat 'ser!er(. 5 mare cantitate de cod
neadministrat e*istent necesit& furnizarea unei componente /5M, pentru a func#iona corect. Este
mult mai uor s& se implementeze aceste componente folosind un cod administrat, astfel "nct se pot
e!ita toate codurile referitoare la numerotarea referin#elor i interfe#e. %e e*emplu, s$ar putea crea un
control -cti!eI sau o e*tensie shell "n lim)a.ul /= sau ,isual 2asic. Pentru mai multe informa#ii, folosi#i
instrumentele Tl)E*p.e*e i 6eg-sm.e*e, care sunt li!rate "mpreun& cu setul .NET Framework S%P.
Kn afar& de aceste trei situa#ii, compilatorul Microsoft ,isual /11 '!ersiunea <G( accept& un nou
comutator de la linia de comand&, 0cir. -cest comutator "i cere compilatorului s& emit& cod 47, "n loc de
instruc#iuni nati!e *DE. %ac& a!e#i o cantitate mare de cod /11 e*istent, pute#i s&$< recompila#i folosind
acest nou comutator de compilare. Pentru a fi e*ecutat, noul cod !a necesita componenta /76, iar acum
codul poate fi modificat "n timp, astfel "nct s& se profite de a!anta.ele caracteristicilor specifice
componentei /76.
/u a.utorul comutatorului 0cir nu se poate efectua compilarea "n lim)a.ul 47 pentru metodele care
con#in un lim)a. de asam)lare inline 'prin intermediul cu!ntului cheie Rasm(, accept& un num&r de
argumente !aria)il, apel&ri set.mp sau care con#in rutine intrinsece /cum ar *i enable6 disable6
.(eturnddress ,i .ddress7f(eturnddress8.
Pentru o list& complet& a construc#iilor pe care compilatorul /11 nu le poate compila "n lim)a.ul 47,
consulta#i documenta#ia compilatorului ,isual /11. -tunci cnd compilatorul nu poate efectua
<
4n!ocarea platformei, 'n.t.(
<U
compilarea metodei "n lim)a.ul 47, el o realizeaz& "n *DE, astfel "nct aplica#ia este totui rulat&.
6e#ine#i c&, dei codul 47 produs este administrat, datele nu suntL adic& o)iectele de tip date nu sunt
alocate din memoria heap administrat& i nu se realizeaz& colectarea gunoaielor pentru ele. %e fapt,
tipurile de date nu au metadate produse pentru ele, iar numele metodelor tipurilor sunt denaturate.
Kn urm&torul cod / se apeleaz& func#ia printf din )i)lioteca de rulare / standard i metoda
S@stem./onsoleBrite7ine. Tipul S@stem./onsole este definit "n cadrul )i)liotecii F/7. -stfel, "n codul
/0/11 se pot utiliza )i)liotecile disponi)ile pentru lim)a.ele /0/11, ca i tipurile administrate.
=include ]stdio.h^ 00Pentru printf
@using Amscorlib.dllB ,,"entru tipurile administrate de*inite in
,,acest asamblaj
using namespace .2stem; ,,'cceseaz cu u urin a tipurile din
,,spa iul de nume .2stem
,,8mplementeaz o *unc ie main C,CCC normala
)oid main/0 5
,,'peleaz *unc ia print* din biblioteca de rulare C
print*/D'*i at de print*. E r E nD 0;
,,'peleaz metoda FriteLine a tipului .2stem.Console din biblioteca FCL.
Console33FriteLine/D'*i at de Console33FriteLine. D 0 ;
<
/ompilarea acestui cod este ct se poate de uoar&. %ac& acest cod s$ar afla "ntr$un fiier Mgd/-pp.cpp,
l$am compila folosind "n promptul de comand& urm&toarea linie8
ci ,cir !gdC'pp.cpp
6ezultatul este un fiier de asam)lare Mgd/-pp.e*e. %ac& rul&m fiierul Mgd/-pp.e*e, !om o)#ine
urm&toarea ieire8
C3EB!gdC'pp
'*i at de print*.
'*i at de Console33FriteLine.
%ac& folosim utilitarul 47%asm.e*e pentru a analiza acest fiier, !om o)#ine ieirea prezentat& "n Figura
<$D.
"n Figura <$D se o)ser!& c& programul utilitar 47%asm arat& toate func#iile i cmpurile glo)ale definite
"n cadrul asam)la.ului. Este e!ident c& o mul#ime de materiale au fost generate automat de c&tre
compilator. %ac& se efectueaz& de dou& ori clic pe metoda Main, programul utilitar 47%asm !a prezenta
codul 478
.metGod public static int92
modopt/1mscorlib4.2stem.Runtime.Compiler.er)ices.CallCon)Cdecl0
main/0 cil managed
5
Fi'ura 1)9 7tilitarul 8L&asm prezint metadatele din asamblajul !gsC'pp.e%e.
.)tentr2 1 3 1
,,Code size
1
2H /:%1c0
.ma%stacI 1
<
%imensiunea codului, 'n.t.(
CS
8L#::::3 lds*lda )aluet2pe
J'rra2-2peJ:%:*aedHHK 6L':%MMd2N*OM.unnamed-global-:6
8L#:::K3 caii )ararg int92
modopt 1rascorlib4.2stem.Runtime.Compiler.er)ices.CallCon)Cdecl0
print*/intH
modopt/1!icroso*t.PisualC4!icroso*t.PisualC.>o.ign.peci*ied!odi*ier0
modopt/1!icroso*t.PisualC4!icroso*t.PisualC.8sConst!odi*ier0Q0
8L#:::a3 pop
8L#:::b3 lds*lda )aluet2pe
J'rra2-2peJ:%:eOcb2b2 6L':%MMd2N*OM.unnamed-global-16
8L#::1:3 neRobj instance )oid 1mscorlib4.2stem..tring33.ctor/intHQ0
8L#::1K3 caii )oid 1mscorlib4.2stem.Console33FriteLine/string0
8L#::1a3 ldc.iM.: 8L#==1b3 ret
< ,,end o* metGod
2
6Slobal Functions6 3 3main
/eea ce se !ede aici nu arat& prea frumos, deoarece compilatorul genereaz& o cantitate mare de cod
special, pentru a face ca toate acestea s& func#ioneze. Totui, din acest cod 47 se poate !edea c& este apelat&
att metoda printf, ct i /onsole.Brite7ine.
C
Sfritul metodei, 'n.t.(
C<