Grup elaborar e suport curs: [603973]

Grup elaborar e suport curs:
Nușa Dumitriu-Lupan, Inspector General M.E.C.T .
Rodica Pintea, profesor , Liceul Grigor e Moisil, Bucur ești
Adrian Nițã, profesor , Colegiul Național Emanuil Gojdu, Oradea
Mioara Nițã, profesor , Colegiul Național Emanuil Gojdu, Oradea
Cristina Sichim, profesor , Colegiul Național Ferdinand I, Bacãu
Nicolae Olãroiu, profesor Colegiul Național "B.P . Hașdeu", Buzãu
Mihai Tãtãran, cadru didactic asociat, Universitat ea Politehnicã Timișo ara
Petru Jucovschi, Developer Community Lead, Micr osoft R omânia
Tudor -Ioan Salomie, Team Lead Micr osoft S tudent P artners,
Universitat ea Tehnicã Cluj Napoca Autori
M.E.C.T .:
MICROSOFT:Introducer e
în Pr ogramar ea
.Net Framew orkMinist erului Educație,
Cercetãrii și T iner etului

Programarea
Orientatã pe Obiecte
și
Programarea Vizualã
cu C# .Net

CUPRINS
CUPRINS……………………………………………….. ……………………………………………………… ……………………….. 1
1. PROGRAMAREA ORIENTATĂ OBIECT (POO) ……………….. …………………………………………. 3
1.1. EVOLUȚIA TEHNICILOR DE PROGRAMARE ……………………………………………………… ………………. 3
1.2. TIPURI DE DATE OBIECTUALE . ÎNCAPSULARE ……………………………………………………… …………. 3
1.3. SUPRAÎNCĂRCARE ……………………………………………………… ……………………………………………… 4
1.4. MOȘTENIRE ……………………………………………………… ……………………………………………………… .5
1.5. POLIMORFISM . METODE VIRTUALE ……………………………………………………… ………………………. 5
1.6. PROGRAMARE ORIENTATĂ OBIECT ÎN C#……………………………………………………. …………………. 6
1.7. DECLARAREA UNEI CLASE ……………………………………………………… …………………………………… 6
1.8. CONSTRUCTORI ……………………………………………………… …………………………………………………. 7
1.9. DESTRUCTOR ……………………………………………………… …………………………………………………….. 7
1.10. METODE ……………………………………………………… ……………………………………………………… …… 8
1.11. PROPRIETĂȚI ……………………………………………………… …………………………………………………….. 9
1.12. EVENIMENTE ȘI DELEGĂRI ……………………………………………………… …………………………………. 10
1.13. INTERFEȚE ……………………………………………………… ……………………………………………………… .1 1
1.14. FIRE DE EXECUȚIE ……………………………………………………… ……………………………………………. 12
2. PLATFORMA .NET…………………………………………. ……………………………………………………… ….. 13
2.1. PREZENTARE ……………………………………………………… …………………………………………………… 13
2.2. .NET FRAMEWORK ……………………………………………………… ………………………………………….. 13
2.3. COMPILAREA PROGRAMELOR ……………………………………………………… …………………………….. 14
3. LIMBAJUL C#……………………………………………. ……………………………………………………… ……….. 14
3.1. CARACTERIZARE ……………………………………………………… ……………………………………………… 14
3.2. COMPILAREA LA LINIA DE COMANDĂ ……………………………………………………… ………………….. 14
3.3. CREAREA APLICAȚIILOR CONSOLĂ ……………………………………………………… ……………………… 15
3.4. STRUCTURA UNUI PROGRAM C#……………………………………………………. …………………………… 16
3.5. SINTAXA LIMBAJULUI ……………………………………………………… ……………………………………….. 16
3.6. TIPURI DE DATE ……………………………………………………… ……………………………………………….. 17
3.7. CONVERSII ……………………………………………………… ……………………………………………………… .2 1
3.8. CONSTANTE ……………………………………………………… …………………………………………………….. 2 2
3.9. VARIABILE ……………………………………………………… ……………………………………………………… 22
3.10. EXPRESII ȘI OPERATORI ……………………………………………………… …………………………………….. 22
3.11. COLECȚII ……………………………………………………… ……………………………………………………… … 23
3.12. INSTRUCȚUNEA FOREACH ……………………………………………………… …………………………………… 23
3.13. INSTRUCȚIUNILE TRY -CATCH -FINALLY ȘI THROW ……………………………………………………… …. 23
4. PROGRAMARE VIZUALĂ ……………………………………… ………………………………………………….. 25
4.1. CONCEPTE DE BAZĂ ALE PROGRAMĂRII VIZUALE ……………………………………………………… ….. 25
4.2. MEDIUL DE DEZVOLTARE VISUAL C#……………………………………………………. ……………………. 26
4.3. FERESTRE ……………………………………………………… ……………………………………………………… .. 27
4.4. CONTROALE ……………………………………………………… ……………………………………………………. 29
4.5. SYSTEM .DRAWING ……………………………………………………… …………………………………………… 36
4.6. VALIDAREA INFORMAȚIILOR DE LA UTILIZATOR ……………………………………………………… …… 37
5. APLICAȚII ORIENTATE PE DATE……………………………… …………………………………………….. 38
5.1. STRUCTURI DE DATE ……………………………………………………… …………………………………………. 38
5.2. COLECȚII DE DATE ……………………………………………………… ……………………………………………. 38
5.3. ADO.NET……………………………………………….. ……………………………………………………… …….. 39
5.4. CONECTAREA LA O SURSĂ DE DATE ……………………………………………………… …………………….. 39
5.5. EXECUTAREA UNEI COMENZI SQL …………………………………………………… ………………………… 41
5.6. SETURI DE DATE ……………………………………………………… ………………………………………………. 42
5.7. PROIECTAREA VIZUALĂ A SETURILOR DE DATE ……………………………………………………… …….. 43

Programarea Orientată Obiect (POO) 3
1. Programarea Orientată Obiect (POO)
1.1. Evoluția tehnicilor de programare
• Programarea nestructurată (un program simplu, ce utilizează numai variabile globale);
complicațiile apar când prelucrarea devine mai amplă, iar datel e se multiplică și se diversifică.
• Programarea procedurală (program principal deservit de subprograme cu parametri
formali, variabile locale și apeluri cu parametri efectivi); se obțin avantaje privind depanarea
și reutilizarea codului și se aplică noi tehnici privind transf erul parametrilor și vizibilitatea
variabilelor; complicațiile apar atunci când la program sunt as ignați doi sau mai mulți
programatori care nu pot lucra s imultan pe un același fișier ce conține codul sursă.
• Programarea modulară (gruparea subprogramelor cu
funcționalități similare în module, implementate și depanate
separat); se obțin avantaje privind independența și încapsularea (prin separarea zonei de implementare,
păstrând vizibilitatea numai asupra zonei de interfață a
modulului) și se aplică tehnici de asociere a procedurilor cu
datele pe care le manevrează, stabilind și diferite reguli de acces la date și la subprograme. Se observă că modulele sunt ”centrate” pe proceduri, acestea gestionând și setul de date pe care le prelucrează
(date+date1 din figură). Daca, de exemplu, dorim să avem mai multe seturi diferite de date,
toate înzestrate comportamental cu procedurile din modulul module
1, această arhitectură de
aplicație nu este avantajoasă.
• Programarea orientată obiect (programe cu noi tipuri c e
integrează atât datele, cât și metodele asociate creării,
prelucrării și distrugerii acestor date); se obțin avantaje pri n
abstractizarea programării (programul nu mai este o succesiune
de prelucrări, ci un ansamblu de obiecte care prind viață, au diverse proprietăți, sunt capabile de acțiuni specifice și care
interacționează în cadrul programului); intervin tehnici noi pr ivind
instanțierea, derivarea și polimorfismul tipurilor obiectuale.
1.2. Tipuri de date obi ectuale. Încapsulare
Un tip de date abstract (ADT) este o entitate caracterizată pri ntr-o structură de date și
un ansamblu de operații aplicabile acestor date. Considerând, în rezolvarea unei probl eme
de gestiune a accesului utilizatorilor la un anumit site, tipul abstract USER , vom obseva că
sunt multe date ce caracterizează un utilizator Internet. Totuș i se va ține cont doar de datele
semnificative pentru problema dată. Astfel, ”culoarea ochilor” este irelevantă în acest caz, în
timp ce ”data nașterii” poate fi importantă. În aceeași idee, o perații specifice ca ”se
înregistrează”, ’comandă on-line” pot fi relevante, în timp ce operația ”manâncă” nu este, în
cazul nostru. Evident, nici nu se pun în discuție date sau oper ații nespecifice (”numărul de
laturi” sau acțiunea ”zboară”).
Operațiile care sunt accesibile din afara entității formează interfața acesteia. Astfel,
operații interne cum ar fi conversia datei de naștere la un num ăr standard calculat de la
01.01.1900 nu fac parte din interfața tipului de date abstract, în timp ce operația ”plasează o
comandă on-line” face parte, deoarece permite interacțiunea cu alte obiecte (SITE, STOC etc.)
O instanță a unui tip de date abstract este o ”concretizare” a tipului re spectiv, formată
din valori efective ale datelor.
Un tip de date obiectual este un tip de date care implementează un tip de date abstract .
Vom numi operațiile implementate în cadrul tipului de date abst ract metode . Spunem că
datele și metodele sunt membrii unui tip de date obiectual. Folosirea unui astfel de tip
presupune: existența definiției acestuia, apelul metodelor și a ccesul la date. program principal
date
modul_1
(date+date1 )
• subprog_1
• subprog_2
• subprog_3 modul_2
(date+date2 )
• subprog_1
• subprog_2
obiect1
• date1
•met1obiect4
• date4
• met4
obiect2
• date2
•met2obiect3
• date3
• met3

4 POO și Programare vi zuală (suport de curs)
Un exemplu de-acum clasic de tip de date abstract este STIVA. E a poate avea ca date:
numerele naturale din stivă, capacitatea stivei, vârful etc. Ia r operațiile specifice pot fi:
introducerea în stivă ( push ) și extragerea din stivă ( pop). La implementarea tipului STIVA,
vom defini o structura de date care să rețină valorile memorate în stivă și câmpuri de date
simple pentru: capacitate, număr de elemente etc. Vom mai defin i metode (subprograme)
capabile să creeze o stivă vidă, care să introducă o valoare în stivă, să extragă valoarea din
vârful stivei, să testeze dacă stiva este vidă sau dacă stiva e ste plină etc.
Crearea unei instanțe noi a unui tip obiectual, presupune opera ții specifice de
”construire” a noului obiect, metoda corespunzătoare purtând nu mele de constructor . Analog,
la desființarea unei instanțe și eliberarea spațiului de memori e aferent datelor sale, se aplică
o metodă specifică numită destructor1.
O aplicație ce utilizează tipul obiectual STIVA, va putea const rui două sau mai multe
stive (de cărți de joc, de exemplu), le va umple cu valori dist incte, va muta valori dintr-o stivă
în alta după o anumită regulă desființând orice stivă golită, p ână ce rămâne o singură stivă.
De observat că toate aceste prelucrări recurg la datele, constr uctorul, destructorul și la
metodele din interfața tipului STIVA descris mai sus.
Principalul tip obiectual întâlnit în majoritatea mediilor de d ezvoltare (Viisual Basic,
Delphi, C++, Java, C#) poartă numele de clasă ( class ). Există și alte tipuri obiectuale ( struct ,
object ). O instanță a unui tip obiectual poartă numele de obiect .
La implementare, datele și metodele asociate trebuie să fie com plet și corect definite,
astfel încât utilizatorul să nu fie nevoit să țină cont de deta lii ale acestei implementări. El va
accesa datele, prin intermediul proprietăților și va efectua op erațiile, prin intermediul
metodelor puse la dispoziție de tipul obiectual definit. Spunem că tipurile de date obiectuale
respectă principiul încapsulării . Astfel, programatorul ce utilizează un tip obiectual CONT (în
bancă) nu trebuie să poarte grija modului cum sunt reprezentate în memorie datele
referitoare la un cont sau a algoritmului prin care se realizea ză actualizarea soldului conform
operațiilor de depunere, extragere și aplicare a dobânzilor. EL va utiliza unul sau mai multe
conturi (instanțe ale tipului CONT), accesând proprietățile și metodele din interfață,
realizatorul tipului obiectual asumându-și acele griji în momen tul definirii tipului CONT.
Permițând extensia tipurilor de date abstracte, clasele pot ave a la implementare:
• date și metode caracterisitice fiecărui obiect din clasă (memb ri de tip instanță),
• date și metode specifice clasei (membri de tip clasă).
Astfel, clasa STIVA poate beneficia, în plus, și de date ale cl asei cum ar fi: numărul de
stive generate, numărul maxim s au numărul minim de componente a le stivelor existente etc.
Modificatorul static plasat la definirea unui membru al clasei face ca acela să fie un
membru de clasă, nu unul de tip instanță. Dacă în cazul membril or nestatici, există câte un
exemplar al membrului respectiv pentru fiecare instanță a clase i, membrii statici sunt unici,
fiind accesați în comun de toate instanțele clasei. Mai mult, m embrii statici pot fi referiți fără a
crea vreo instanță a clasei respective.
1.3. Supraîncărcare
Deși nu este o tehnică specifică programării orientată obiect, ea creează un anumit
context pentru metodele ce formează o clasă și modul în care ac estea pot fi (ca orice
subprogram) apelate.
Prin supraîncarcare se înțelege posibilitatea de a defini în ac elași domeniu de
vizibilitate2 mai multe funcții cu același nume, dar cu parametri diferiti c a tip și/sau ca număr.
Astfel ansamblul format din numele funcției și lista sa de para metri reprezintă o modalitate
unică de identificare numită semnătură sau amprentă. Supraîncărcarea permite obținerea
unor efecte diferite ale apelului în contexte diferite3.

1 Datorită tehnicii de supraîncăr care C++, Java și C# permit exi stența mai multor constructori
2 Noțiunile generale legate de vizibilitate se consideră cunoscu te din programarea procedurală.
Aspectele specifice și m odificatorii de acce s/vizibilitate pot fi studiați din documentațiile de referință C#.
3 Capacitatea unor limbaje (este și cazul limbajului C#) de a fo losi ca ”nume” al unui
subprogram un operator, reprezin tă supraîncărcarea operatorilor . Aceasta este o facilitate care

Programarea Orientată Obiect (POO) 5
Apelul unei funcții care beneficiază, prin supraîncărcare, de d ouă sau mai multe
semnături se realizează prin selecția funcției a cărei semnătur ă se potrivește cel mai bine cu
lista de parametri efectivi (de la apel).
Astfel, poate fi definită metoda ”comandă on-line” cu trei semn ături diferite:
comanda_online(cod_prod) cu un parametru întreg (desemnând comanda unui singur
produs identificat prin cod_prod .
comanda_online(cod_prod ,cantitate) cu primul parametru întreg și celalalt real
comanda_online(cod_prod,calitate) cu primul parametru întreg și al-II-ilea caracter.
1.4. Moștenire
Pentru tipurile de date obiectuale class este posibilă o operație de extindere sau
specializare a comportamentului unei clase existente prin defin irea unei clase noi ce
moștenește datele și metodele clasei de bază, cu această ocazie putând fi redefiniți unii
membri existenți sau adăugați unii membri noi. Operația mai poa rtă numele de derivare .
Clasa din care se moșteneștea se mai numește clasă de bază sau superclasă . Clasa
care moștenește se numește subclasă , clasă derivată sau clasă descendentă.
Ca și în Java, în C# o subclasă poate moșteni de la o singură s uperclasă, adică avem
de-a face cu moștenire simplă; aceeași superclasă însă poate fi derivată în mai multe
subclase distincte. O subclasă, la randul ei, poate fi supercla să pentru o altă clasă derivată.
O clasă de bază impreună cu toate clasele descendente (direct s au indirect) formeaza o
ierarhie de clase. În C#, toate clasele moștenesc de la clasa d e bază Object .
În contextul mecanismelor de moștenire trebuie amintiți modific atorii abstract și sealed
aplicați unei clase, modificatori ce obligă la și respectiv se opun procesului de derivare. Astfel, o
clasă abstractă trebuie obligatoriu derivată, deoarece direct d in ea nu se pot obține obiecte
prin operația de instanțiere, în timp ce o clasă sigilată ( sealed ) nu mai poate fi derivată (e un
fel de terminal în ierarhia claselor). O metodă abstractă este o metodă pentru care nu este
definită o implementare, aceasta urmând a fi realizată în clase le derivate din clasa curentă4.
O metodă sigilată nu mai poate fi redefinită în clasele derivat e din clasa curentă.
1.5. Polimorfism. Metode virtuale
Folosind o extensie a sensului etimologic, un obiect polimorfic este cel capabil să ia
diferite forme, să se afle în diferite stări, să aibă comportam ente diferite. Polimorfismul
obiectual5 se manifestă în lucrul cu obiecte din clase aparținând unei ie rarhii de clase, unde,
prin redefinirea unor date sau metode, se obțin membri diferiți având însă același nume.
Astfel, în cazul unei referiri obiectuale, se pune problema sta bilirii datei sau metodei referite.
Comportamentul polimorfic este un element de flexibilitate care permite stabilirea
contextuală, în mod dinamic6, a membrului referit.
De exemplu, dacă este definită clasa numită PIESA (de șah), cu metoda nestatică
muta(pozitie_initiala,pozitie_finala), atunci subclasele TURN și PION trebuie
să aibă metoda muta definită în mod diferit (pentru a implementa maniera specifică a
pionului de a captura o piesă ”en passant”7). Atunci, pentru un obiect T, aparținând claselor

”reduce” diferențele dintre operarea la nivel abstract (cu DTA) și apelul metodei ce realizează acestă
operație la nivel de implementare obiectuală. Deși ajută la spo rirea expresivității codului, prin
supraîncărcarea operatorilor și metodelor se pot crea și confuz ii.
4 care trebuie să fie și ea abstra ctă (virtuală pură, conform te rminologiei din C++)
5 deoarece tot aspecte polimorfice îmbracă și unele tehnici din programarea clasică sau tehnica
supraîncărcărcăr ii funcțiilor și operatorilor.
6 Este posibil doar în cazul limbajelor ce permit “legarea întâr ziată”. La limbajele cu "legare
timpurie", adresa la care se face un apel al unui subprogram se stabilește la compilare. La limbajele
cu legare întârziată, această adresa se stabileste doar in mome ntul rulării, putându-se calcula distinct,
în funcție de contextul în care apare apelul.
7 Într-o altă concepție, metoda muta poate fi implementată la nivelul clasei PIESA și redefinită
la nivelul subclasei PION, pentru a particulariza acest tip de deplasare care capturează piesa peste
care trece pionul în diagonală.

6 POO și Programare vi zuală (suport de curs)
derivate din PIESA, referirea la metoda muta pare nedefinită. Totuși mecanismele POO
permit stabilirea, în momentul apelului, a clasei proxime cărei a îi aparține obiectul T și
apelarea metodei corespunzătore (mutare de pion sau tură sau al tă piesă).
Pentru a permite acest mecanism, metodele care necesită o deciz ie contextuală (în
momentul apelului), se decalră ca metode virtuale (cu modificat orul virtual ). În mod
curent, în C# modificatorului virtual al funcției din clasa de bază, îi corespunde un
specificator override al funcției din clasa derivată ce redefinește funcția din clas a de bază.
O metodă ne-virtuală nu este polimorfică și, indiferent de clas a căreia îi aparține
obiectul, va fi invocată metoda din clasa de bază.
1.6. Programare orientată obiect în C#
C# permite utilizarea OOP respectând toate principiile enunțate anterior.
Toate componentele limbajului sunt într-un fel sau altul, asoci ate noțiunii de clasă.
Programul însuși este o clasă având metoda statică Main() ca punct de intrare, clasă ce nu
se instanțiază. Chiar și tipurile predefinite byte , int sau bool sunt clase sigilate derivate
din clasa ValueType din spațiul System . Pentru a evita unele tehnici de programare
periculoase, limbajul oferă tipuri speciale cum ar fi: interfeț e și delegări. Versiunii 2.0 a
limbajului i s-a adăugat un nou tip: clasele generice8,
1.7. Declararea unei clase
Sintaxa9: [atrib] o [modificatori] o class [nume_clasă] [:clasa_de_bază] o [corp_clasă] o
Atributele reprezintă informații declarative cu privire la enti tatea definită.
Modificatorii reprezintă o secvență de cuvinte cheie dintre: new public protected
internal private (modificatori de acces) abstract sealed (modificatori de moștenire)
Clasa de bază este clasa de la care moștenește clasa curentă și poate exista o singură
astfel de clasă de bază. Corpul clasei este un bloc de declarăr i ale membrilor clasei:
constante (valori asociate clasei), câmpuri (variabile), tipuri de date definite de utilizator,
metode (subprograme), constructori , un destructor , proprietăți (caracteristici ce pot fi
consultate sau setate), evenimente (instrumente de semnalizare), indexatori ( c e p e r m i t
indexarea instanțelor din cadrul clasei respective) și operator i.
• constructorii și destructorul au ca nume numele clasei proxime din care fac parte10
• metodele au nume care nu coincid cu numele clasei sau al altor membri (cu excepția
metodelor, conform mecanismului de supraîncărcare)
• metodele sau constructorii care au același nume trebuie să dif ere prin semnătură11
• se pot defini date și metode statice (caracteristice clasei) ș i un constructor static care se
execută la inițializarea clasei propriu-zise; ele formează un f el de ”context” al clasei
• se pot defini date și metode nestatice (de instanță) care se m ultiplică pentru fiecare
instanță în parte în cadrul operației de instanțiere; ele forme ază contextele tuturor
instanțelor clasei respective
Exemplul următor definește o ierarhie de clase (conform figurii alăturate)
public abstract class Copil
public class Fetita: Copil { } public sealed class Baiat: Copil { }
Modificatorul abstract este folosit pentru a desemna faptul că nu se pot obține
obiecte din clasa Copil, ci numai din derivatele acesteia ( Fetita , Baiat ), iar modificatorul
sealed a fost folosit pentru a desemna faptul că nu se mai pot obtine clase derivate din
clasa Baiat (de exemplu, subclasele Baiat_cuminte și Baiat_rau )

8 echivalentrul claselor template din C++
9 [] din definiția schematică se mnifică un neterminal, iar o semnifică o componentă opțională
10 având în vedere că ele pot să fa că parte dintr-o clasă interio ară altei clase
11 din semnătură nefăcând parte specificatorii ref și out asociați parametrilor Copil
Fetita Baiat

Programarea Orientată Obiect (POO) 7
1.8. Constructori
Sintaxa:
[atrib] o [modificatori] o [nume_clasă] ([listă_param_formali] o) [:inițializator] o [corp_constr] o
Modificatori: public protected internel private extern
Inițializator: base ([listă_param] o), this ([listă_param] o) ce permite invocarea unui constructor
anume12 înainte de executarea instrucțiunilor ce formează corpul const ructorului curent. Dacă
nu este precizat niciun inițializator, se asociază implicit ini țializatorul base() .
Corpul constructorului este format din instrucțiuni care se exe cută la crearea unui nou obiect al
clasei respective (sau la crear ea clasei, în cazul constructori lor cu modificatorul static ).
• pot exista mai mulți constructori care se pot diferenția prin lista lor de parametri
• constructorii nu pot fi moșteniți
• dacă o clasă nu are definit niciun constructor, se va asigna a utomat constructorul fără
parametri al clasei de bază (clasa object , dacă nu este precizată clasa de bază)
Instanțierea presupune declararea unei variabile de tipul clase i respective și inițializarea
acesteia prin apelul constructorului clasei (unul dintre ei, da că sunt definiți mai mulți)
precedat de operatorul new. Acestea se pot realiza și simultan într-o instrucțiune de fel ul:
[Nume_clasă] [nume_obiect]= new [Nume_clasă] ([listă_param] o)
¾ Utilizarea unui constructor fără parametri și a constructorulu i implicit în clasă derivată
public abstract class Copil
{ protected string nume;
public Copil() {nume = Console.ReadLine();} //la inițializarea obiectului se citește
//de la tastatură un șir de caractere ce va reprezenta numele copilului
}
class Fetita:Copil {} …
Fetita f=new Fetita();
Copil c= new Copil(); //
Pentru clasa Copil abstractă, s-ar fi obținut eroare aici
¾ Supraîncărcarea constructorilor și definirea explicită a const ructorilor în clase derivate
public class Copil
{ protected string nume; //dată acceesibilă numai în interiorul clasei și claselor deriv ate
public Copil() {nume = Console.ReadLine();}
public Copil(string s) {nume=s;}
}
class Fetita:Copil { public Fetita(string s):base(s) {nume=”Fetita ”+nume}
13
public Fetita(){} //preia constructorul fără parametri din clasa de bază14
//public Fetita(string s):base() {nume=s}
}
…
Copil c1= new Copil(); //se citeste numele de la tastatură
Copil c2= new Copil(“Codrina”);
Fetita f1=new Fetita();Fetita f2=new Fetita("Ioana”);
Există două motive pentru care definiția constructorului al tre ilea din clasa Fetita este greșită
și de aceea este comentată. Care sunt aceste motive?
1.9. Destructor
Sintaxa: [atrib] o [extern ]o ~[nume_clasă] () [corp_destructor] o
Corpul destructorului este format din instrucțiuni care se exec ută la distrugerea unui
obiect al clasei respective. Pentru orice clasă poate fi defini t un singur constructor. Destructorii

12 Din clasa de bază ( base ) sau din clasa insăși ( this )
13 Preia și specializează constru ctorul al doilea din clasa de ba ză
14 Este echivalent cu public Fetita():base(){}

8 POO și Programare vi zuală (suport de curs)
nu pot fi moșteniți. În mod normal, destructorul nu este apelat în mod explicit, deoarece
procesul de distrugere a unui obiect este invocat și gestionat automat de Garbagge Collector.
1.10. Metode
Sintaxa: [atrib] o[modificatori] o[tip_returnat] [nume] ([listă_param_formali] o) [corp_metoda] o
Modificatori: new public protected internal private static virtual abstract
sealed override extern15
Tipul rezultat poate fi un tip definit sau void . Numele poate fi un simplu identificator sau, în
cazul în care definește în mod explicit un membru al unei inter fețe, numele este de forma
[nume_interfata].[nume_metoda]
Lista de parametri formali este o succesiune de declarări despă rțite prin virgule, declararea
unui parametru având sintaxa: [atrib] o [modificator] o [tip] [nume]
Modificatorul unui parametru poate fi ref (parametru de intrare și ieșire) sau out (parametru
care este numai de ieșire). Parametrii care nu au niciun modifi cator sunt parametri de intrare.
Un parametru formal special este parametrul tablou cu sintaxa: [atrib] o params [tip][] [nume].
• Pentru metodele abstracte și externe, corpul metodei se reduce la un semn ;
• Semnătura fiecărei metode este formată din numele metodei, mod ificatorii acesteia,
numărul și tipul parametrilor16
• Numele metodei trebuie să difere de numele oricărui alt membru care nu este metodă.
• La apelul metodei, orice parametru trebuie să aibă același mod ificator ca la definire
Invocarea unei metode se realizează prin sintagma [nume_obiect] .[nume_metoda] (pentru
metodele nestatice) și respectiv [nume_clasă] .[nume_metoda] (pentru metodele statice).
¾ Definirea datelor și metodelor statice corespunzătoare unei clase
public class Copil
{ public const int nr_max = 5; //constantă
public static int nr_copii=0; //câmp simplu (variabilă)
static Copil[] copii=new Copil[nr_max]; //câmp de tip tablou (variabilă)
public static void adaug_copil(Copil c) //metodă
{ copii[nr_copii++] = c;
if (nr_copii==nr_max) throw new Exception("Prea multi copii");
}
public static void afisare() //metodă
{
Console.WriteLine("Sunt {0} copii:", nr_copii); for (int i = 0; i<nr_copii; i++) Console.WriteLine("Nr.{0}. {1}", i+1, copii[i].nume);
} …
17
} … Fetita c = new Fetita();Copil.adaug_copil(c);
referința noului obiect se memorează în tabloul static copii (caracteristic clasei) și se
incrementează data statică nr_copii
Baiat c = new Baiat(); Copil.adaug_copil(c);
Copil c = new Copil(); Copil.adaug_copil(c);
Copil.afisare(); //se afișează o listă cu numele celor 3 copii

15 Poate fi folosit cel mult unul dintre modificatorii static, vi rtual șI override ; nu pot apărea
împreună new și override, abstract nu poate să apară cu niciunu l dintre static, virtual, sealed, extern;
private nu poate să apară cu ni ciunul dintre virtual, override și abstract; seald obligă și la override
16 Din semnătură (amprentă) nu fac parte tipul returnat, numele p arametrilor formali și nici
specificatorii ref și out.
17 Se are în vedere și constructor ul fără parametri definit și pr eluat implicit în subclasele din cadrul
primului exemplu din subcapitolul 1.8: public Copil() {nume = Console.ReadLine();}

Programarea Orientată Obiect (POO) 9
¾ Definirea datelor și metodelor nestatice corespunzătoare clasei Copil și claselor derivate
public class Copil
{ … public string nume;
public virtual void se_joaca()
//virtual Æ se poate suprascrie la derivare
{Console.WriteLine("{0} se joaca.", this.nume);}
public void se_joaca(string jucaria) //nu permite redefinire18
{Console.WriteLine("{0} se joaca cu {1}.", this.nume, jucaria);}
} //supraîncărcarea metodei se_joaca
class Fetita:Copil
{ public override void se_joaca() //redefinire Æ comportament polimorfic
{Console.WriteLine("{0} leagana papusa.",this.nume);}
} class Baiat:Copil { public override void se_joaca() {Console.WriteLine("{0} chinuie pisica.",this.nume);}
}
…
Fetita c = new Fetita();c.se_joaca("pisica");c.se_joaca();
//polimorfism
Baiat c = new Baiat();c.se_joaca("calculatorul");c.se_joaca(); //polimorfism
Copil c = new Copil();c.se_joaca(); //polimorfism
Pentru a evidenția mai bine comportamentul polimorfic, propunem s e c v e n ț a
următoare în care nu se știe exact ce este obiectul copii[i] (d e tip Copil, Fetita sau Baiat?):
for (int i=0; i<nr_copii; i++) copii[i].se_joaca;
1.11. Proprietăți
Proprietatea este un membru ce permite accesul controlat la dat ele-membru ale clasei.
Sintaxa: [atrib] o [modificatori] o [tip] [nume_proprietate] {[metode_de_acces] o}
Observațiile privind modificatorii și numele metodelor sunt val abile și în cazul proprietăților.
Metodele de acces sunt două: set și get. Dacă proprietatea nu este abstractă sau externă,
poate să apară una singură dintre cele două metode de acces sau amândouă, în orice ordine.
Este o manieră de lucru recomandabilă aceea de a proteja datele membru (câmpuri) ale
clasei, definind instrumente de acces la acestea: pentru a obți ne valoarea câmpului respectiv
(get) sau de a memora o anumită valoare în câmpul respectiv ( set). Dacă metoda de acces
get este perfect asimilabilă cu o metodă ce retunează o valoare (v aloarea datei pe care
vrem s-o obținem sau valoarea ei modificată conform unei preluc rări suplimentare specifice
problemei în cauză), metoda set este asimilabilă cu o metodă care un parametru de tip
valoare (de intrare) și care atribuie (sau nu, în funcție de co ntext) valoarea respectivă
câmpului. Cum parametrul corespunzător valorii transmise nu apa re în structura sintactică a
metodei, este de stiut că el este implicit identificat prin cuv ântul value . Dacă se supune unor
condiții specifice problemei, se face o atribuire de felul câmp =value .
¾ Definirea în clasa Copil a proprietății Nume, corespunzătoare câmpului protejat ce reține,
sub forma unui șir de caractere, numele copilului respctiv. Se va observă că proprietatea
este moștenită și de clasele derivate Fetita și Băiat19.
public class Copil
{…
string nume; // este implicit protected
public string Nume //proprietatea Nume
{ get
{ if(char.IsUpper(nume[0]))return nume; else return nume.ToUpper();}
set { nume = value; }
}

18 Decât cu ajutorul modificatorului new pentru metoda respect ivă în clasa derivată
19 Desigur că proprietatea care controlează accesul la câmpul ide ntificat prin nume se poate
numi cu totul altfel (proprietatea Nume fiind ușor de confunda t cu câmpul de date nume ).

10 POO și Programare vi zuală (suport de curs)
public Copil() { Nume = Console.ReadLine();} //metoda set
}
class Fetita:Copil
{ public override void se_joaca()
{Console.WriteLine("{0} leagana papusa.",this. Nume);} //metoda get
}20
1.12. Evenimente și delegări
Evenimentele sunt membri ai unei clase ce permit clasei sau obi ectelor clasei să facă
notificări, adică să anunțe celelalte obiecte asupra unor schim bări petrecute la nivelul stării lor.
Clasa furnizoare a unui eveniment publică (pune la dispoziția altor clase) acest lucru printr-o
declarare event care asociază evenimentului un delegat , a d i c ă o r e f e r i n ț ă c ă t r e o f u n c ț i e
necunoscută căreia i se precizează doar antetul, funcția urmând a fi implementată la nivelul
claselor interesate de evenimentul respectiv. Este modul prin c are se realizează comunicarea
între obiecte. Tehnica prin care clasele implementează metode ( handler-e ) ce răspund la
evenimente generate de alte clase poartă numele de tratare a evenimentelor .
Sintaxa: [atrib] o [modificatori] o event [tip_delegat] [nume]
Modificatorii permiși sunt aceiași ca și la metode.
Tipul delegat este un tip de date ca oricare altul, derivat din c l a s a s i g i l a t ă Delegate , din
spațiul System . Definirea unui tip delegat se realizează prin declararea:
[atrib] o [modificatori] o delegate [tip_rezultat] [nume_delegat] ([listă_param_formali] o)
Un delegat se poate defini și în afara clasei generatoare de ev enimente și poate servi și altor
scopuri în afara tratării evenimentelor. Prezentăm în continuar e un exemplu.
De exemplu, dacă dorim să definim o metodă asociată unui vector de numere întregi,
metodă ce verifică dacă vectorul este o succesiune ”bine aranja tă” (orice două valori succesive
respectă o anumită regulă), o implementare ”generică” se poate realiza folosind delegări:
public delegate bool pereche_ok(object t1, object t2);
public class Vector
{ public const int nmax = 4;
public int[] v=new int[nmax];
public Vector() { Random rand = new Random(); for (int i = 0; i < nmax; i++) v[i] = rand.Next(0,5); }
public void scrie()
{ for (int i = 0; i < nmax; i++) Console.Write("{0}, ", v[i]); Console.WriteLine(); }
public bool aranj(pereche_ok ok)
//ok e o delegare către o funcție necunoscută
{ for (int i = 0; i < nmax-1; i++)
if (!ok(v[i], v[i + 1])) return false;
return true; } }
Dacă în clasa-program21 se adugă funcțiile (exprimând două “reguli de aranjare” posibi le)
public static bool f1(object t1, object t2)
{if ((int)t1 >= (int)t2) return true;else return false;} public static bool f2(object t1, object t2) {if ((int)t1 <= (int)t2) return true;else return false;}
atunci o secvență de prelucrare aplicativă ar putea fi:

20 De observat că în exemplul anterior (subcapitolul 1.10), câmpu l nume era declarat public,
pentru a permite accesul ”general” la câmpul respectiv de date. Iar metodele și constructorii foloseau
identificatorul nume și nu proprietatea Nume .
21 Independent de definiția clasei Vector

Programarea Orientată Obiect (POO) 11
static void Main(string[] args)
{ Vector x;
do { x =new Vector();x.scrie(); if (x.aranj(f1))Console.WriteLine("Monoton descrescator"); if (x.aranj(f2))Console.WriteLine("Monoton crescator");
} while (Console.ReadKey(true).KeyCar!=’\x001B’);
//Escape
}
Revenind la evenimente, descriem pe scurt un exemplu teoretic d e declarare și tratare a
unui eveniment. În clasa Vector se consideră că interschimbarea valorilor a două
componente ale unui vector e un eveniment de interes pentru alt e obiecte sau clase ale
aplicației. Se definește un tip delegat TD (să zicem) cu niște parametri de interes22 și un
eveniment care are ca asociat un delegat E (de tip TD)23. Orice obiect x din clasa Vector are
un membru E (inițial null). O clasă C interesată să fie înștiințată când se face vreo
interschimbare într-un vector pentru a genera o animație (de ex emplu), va implementa o
metodă M ce realizează animația și va adăuga pe M (prin intermediul unui delegat) la x.E24.
Cumulând mai multe astfel de referințe, x.E ajunge un fel de listă de metode ( handlere ). În
clasa Vector , în metoda sort , la interschimbarea valorilor a două componente se invocă
delegatul E. Invocarea lui E realizaeză de fapt activearea tuturor metodelor adăugate la E.
Care credeți că sunt motivele pentru care apelăm la evenimente în acest caz, când pare
mult mai simplu să apelăm direct metoda M la orice interschimbare?
1.13. Interfețe
Interfețele sunt foarte importante în programarea orientată pe obiecte, deoarece permit
utilizarea polimorfismului într-un sens mai extins.O interfață este o componentă a aplicației,
asemănătoare unei clase, ce declară prin membrii săi (metode, p roprietăți, evenimente și
indexatori) un ”comportament” unitar aplicabil mai multor clase , comportament care nu se
poate defini prin ierarhia de clase a aplicației.
De exemplu, dacă vom considera arborele din figura următoare, î n care AVERE este o
clasă abstractă, iar derivarea claselor a fost concepută urmări nd proprietățile comune ale
componentelor unei averi, atunci o clasă VENIT nu este posibilă , deoarece ea ar moșteni de
la toate clasele evidențiate, iar moștenirea multiplă nu este a dmisă în C#.

22 De exmplu indicii compon entelor interschimbate
23 A se observa că evenimentul în s ine este anonim, doar delegatu l asociat are nume
24 într-o atribuire de felul x.E+=new [tip_delegat](M) VENITURI
(din produse, din
chirii, din dobânzi,
dividende)
• c a l c ( ) AVERE
Proprietate Bani
Imobiliara Bun Depunere Investiție Credit_primit
Teren
Imobil B_inchiriat
Productiv
Neproductiv
De_folosință
I_inchiriat Mobilier
Altul Actiune
Cotă
Credit_acordat

12 POO și Programare vi zuală (suport de curs)
Pentru metodele din cadrul unei interfețe nu se dă nici o imple mentare, ci sunt pur și simplu
specificate, implementarea lor fiind furnizată de unele dintre clasele aplicației25. Nu există
instanțiere în cazul interfețelor, dar se admit derivări, inclu siv moșteniri multiple.
În exemplul nostru, se poate defini o interfață VENIT care să c onțină antetul unei
metode calc (să zicem) pentru calculul venitului obținut, fiecare dintre c lasele care
implementează interfața VENIT fiind obligată să furnizeze o imp lementare (după o formulă
de calcul specifică) pentru metoda calc din interfață. Orice clasă care dorește să adere la
interfață trebuie să implementeze toate metodele din interfață. Toate clasele care moștenesc
dintr-o clasă care implementează o interfață moștenesc, eviden t, metodele respective, dar le
pot și redefini (de exemplu, clasa Credit_acordat redefinește m etoda calc din clasa Investiție,
deoarece formula de calcul implementată acolo nu i se ”potriveș te” și ei26).
De exemplu, dacă presupunem că toate clasele subliniate impleme ntează interfața
VENIT, atunci pentru o avere cu acțiuni la două firme, un imobi l închiriat și o depunere la
bancă, putem determina venitul total:
Actiune act1 = new Actiune();Actiune act2 = new Actiune();
I_inchiriat casa = new I_inchiriat();Depunere dep=new Depunere(); Venit[] venituri = new Venit()[4]; venituri[0] = act1; venituri[1] = act2; venituri[2] = casa; venituri[3] = dep;
…
int t=0; for(i=0;i<4;i++) t+=v[i].calc();
Găsiți două motive pentru care interfața VENIT și rezovarea de mai sus oferă o soluție
mai bună decât: t=act1.calc()+act2.calc()+casa.calc()+dep.calc() .
1.14. Fire de execuție
Programarea prelucrărilor unei aplicații pe mai multe fire de e xecuție ( multithreading )
presupune ”descompunerea” ansamblului de prelucrări în secvențe , unele dintre ele
”planificându-se” a fi prelucrate paralel (cvasi-simultan) de c ătre procesor în vederea utilizării
eficiente a acestuia.
Schema alăturată este o posibilă
planificare a procesului de calcul al
expresiei a∗(b+c)-b∗b, unde a, b și c sunt
niște matrice pătrate ale căror
componente se găsesc în fișiere separate.
În orice punct al prelucrării de pe un fir de execuție se poate genera un nou fir ( thread )
căruia i se asociază un subprogram cu ajutorul unui delegat. În exemplul următor, care
utilizează spațiul System.Threading , afișarea succesivă a unor secvențe de 1 și de 2
demonstrază ”comutarea” executării de pe un fir pe altul la int ervale relativ constante de timp:
static void scrie2()
{ for (int i = 1; i <=300; i++)Console.Write('2');} static void Main(string[] args) { ThreadStart delegat = new ThreadStart(scrie2); Thread fir = new Thread(delegat);
fir.Start();
for (int i = 1; i <= 500; i++) Console.Write('1'); Console.ReadKey();}
Spațiul Threading mai oferă facilități de schimbare a priorităț ilor prelucrărilor din fire
paralele, de delimitare a secvențelor critice, de așteptare și semnalizare folosind semafoare
etc. O clasă sigilată folosită curent în aplicații ( Timer ) permite implementarea unui ceas care
funcționează pe un fir paralel cu aplicația curentă și care, la intervale de timp ce se pot seta,
generează un eveniment ( Tick) ”sesizat” și exploatat de prelucrarea din firul principal.

25 Acele clase care ”aderă” la o interfață spunem că ”implementea ză” interfața respectivă
26 Dacă în sens polimorfic spunem că Investiție este și de tip Ba ni și de tip Avere, tot așa putem
spune că o clasă care implementează interfața VENIT și clasele derivate din ea sunt și de tip VENIT citire b
citire c Xb∗bYb+c Za∗Y UZ-Xcitire a

Platforma .NET 13
2. Platforma .NET
2.1. Prezentare
.NET este un cadru ( framework ) de dezvoltare software unitară care permite realizarea,
distribuirea și rularea aplicațiilor-desktop Windows și aplicaț iilor WEB.
Tehnologia .NET pune laolaltă mai multe tehnologii (ASP, XML, O OP, SOAP, WDSL,
UDDI) și limbaje de programare (VB, C++, C#, J#) asigurând toto dată atât portabilitatea
codului compilat între diferite calculatoare cu sistem Windows, cât și reutilizarea codului în
programe, indiferent de limbajul de programare utilizat.
.NET Framework este o componentă livrată înpreună cu sistemul d e operare Windows.
De fapt, .NET 2.0 vine cu Windows Server 2003 și Windows XP SP2 și se poate instala pe
versiunile anterioare, până la Windows 98 inclusiv; .NET 3.0 vi ne instalat pe Windows Vista și
poate fi instalat pe versiunile Windows XP cu SP2 și Windows Se rver 2003 cu minimum SP1.
Pentru a dezvolta aplicatii pe platforma .NET este bine sa avem 3 componente esențiale:
• un set de limbaje (C#, Visual Basic .NET, J#, Managed C++, Sma lltalk, Perl, Fortran,
Cobol, Lisp, Pascal etc),
• un set de medii de dezvoltare (Visual Studio .NET, Visio),
• și o bibliotecă de clase pentru crearea serviciilor Web, aplic ațiilor Web și aplicațiilor
desktop Windows.
Când dezvoltăm aplicații .NET, putem utiliza:
• Servere specializate – un set de servere Enterprise .NET (din familia SQL Server 2000,
Exchange 2000 etc), care pun la dispoziție funcții de stocare a bazelor de date, email,
aplicații B2B ( Bussiness to Bussiness – comerț electronic între partenerii unei afaceri).
• Servicii Web (în special comerciale), utile în aplicații care necesită identificarea
utilizatorilor (de exemplu, .NET Passport – un mod de autentifi care folosind un singur
nume și o parolă pentru toate ste-urile vizitate)
• Servicii incluse pentru dispozitive non-PC (Pocket PC Phone Ed ition, Smartphone,
Tablet PC, Smart Display, XBox, set-top boxes, etc.)
2.2. .NET Framework
Componenta .NET Framework stă la baza tehnologiei .NET, este ul tima interfață între
aplicațiile .NET și sistemul de operare și actualmente conține:
• Limbajele C#, VB.NET, C++ și J#. Pentru a fi integrate în plat forma .NET toate aceste
limbaje respectă niște specificații OOP numite Common Type System (CTS). Ele au
ca elemente de bază: clase, interfețe, delegări, tipuri valoare și referință, iar ca
mecanisme: moștenire, polimorfism și tratarea excepțiilor.
• Platforma comună de executare a programelor numită Common Language Runtime
(CLR), utilizată de toate cele 4 limbaje.
• Ansamblul de biblioteci necesare în realizarea aplicațiilor de sktop sau Web numit
Framework Class Library (FCL).
Arhitectura ,NET Framework

Componenta .NET Framework este
formată din compilatoare, biblioteci și alte executabile utile în rularea aplicațiilor .NET. Fișierele
corespunzătoare se află, în general,
în directorul WINDOWS\Microsoft. NET\Framework\V2.0…. (corespunzător versiunii instalate) FCL
Framework Base Classes
(IO, securitate , fire de execu ție, colec ții etc. )
Common Language Runtime
(exece pții, validări de ti puri,compilatoare JIT ) Data and XML classes
(ADO.NET , SQL , XML etc. ) Servicii WEB Formulare
CLR

14 POO și Programare vi zuală (suport de curs)
2.3. Compilarea programelor
Un program scris îıntr-unul dintre limbajele .NET conform Common Language
Specification (CLS) este compilat în Microsoft Intermediate Language (MSIL sau IL). Codul
astfel obținut are extensia exe, dar nu este direct executabil, ci respectă formatul unic MSIL .
CLR include o mașină virtuală asemănătoare cu o mașină Java, ce e x e c u t ă
instrucțiunile IL rezultate în urma compilării. Mașina foloseșt e un compilator special JIT ( Just
In Time ). Compilatorul JIT analizează codul IL corespunzător apelului unei metode și
produce codul mașină adecvat și eficient. El recunoaște secvenț ele de cod pentru care s-a
obținut deja codul mașină adecvat permițând reutilizarea acestu ia fără recompilare, ceea ce
face ca, pe parcursul rulării, aplicațiile .NET să fie din ce î n ce mai rapide.
Faptul că programul IL produs de diferitele limbaje este foarte asemănător are ca
rezultat interoperabilitatea între aceste limbaje. Astfel, clas ele și obiectele create într-un
limbaj specific .NET pot fi utilizate cu succes într-un program scris în alt limbaj.
În plus, CLR se ocupă de gestionarea automată a memoriei (un me canism
implementat în platforma .NET fiind acela de eliberare automată a zonelor de memorie
asociate unor date devenite inutile – Garbage Collection ).
Ca un element de portabilitate, trebuie spus că CTS are o arhit ectură ce permite
rularea aplicațiilor .NET, în afară de Windows, și pe unele tip uri de Unix, Linux, Solaris, Mac
OS X și alte sisteme de operare ( http://www.mono-project.com/Main_Page ).

3. Limbajul C#
3.1. Caracterizare
Limbajul C# fost dezvoltat de o echipă restrânsă de ingineri de la Microsoft, echipă din
care s-a evidențiat Anders Hejlsberg (autorul limbajului Turbo Pascal și membru al echipei
care a proiectat Borland Delphi).
C# este un limbaj simplu, cu circa 80 de cuvinte cheie, și 12 t ipuri de date predefinite.
El permite programarea structurată, modulară și orientată obiec tual, conform perceptelor
moderne ale programării profesioniste.
Principiile de bază ale programării pe obiecte (INCAPSULARE, MO STENIRE,
POLIMORFISM) sunt elemente fundamentale ale programării C#. În mare, limbajul
moștenește sintaxa și principiile de programare din C++. Sunt o serie de tipuri noi de date
sau funcțiuni diferite ale datelor din C++, iar în spiritul rea lizării unor secvențe de cod sigure
(safe), unele funcțiuni au fost adăugate (de exemplu, interfețe și d elegări), diversificate (tipul
struct ), modificate (tipul string ) sau chiar eliminate (moștenirea multiplă și pointerii către
funcții). Unele funcțiuni (cum ar fi accesul direct la memorie folosind pointeri) au fost
păstrate, dar secvențele de cod corespunzătoare se consideră ”n esigure”.
3.2. Compilarea la linia de comandă
Se pot dezvolta aplicații .NET și fără a dispune de mediul de d ezvoltare Visual Studio, ci
numai de .NET SDK ( pentru 2.0 și pentru 3.0 ). În acest caz, codul se scrie în orice editor de
text, fișierele se salvează cu extensia cs, apoi se compilează la linie de comandă.
Astfel, se scrie în Notepad programul:
using System;
class primul { static void Main() { Console.WriteLine("Primul program");
Console.ReadKey(true);
} }

Limbajul C# 15
Dacă se salvează fișierul primul.cs , în directorul WINDOWS\Microsoft.NET\Framework\V2.0 ,
atunci scriind la linia de comandă: csc primul.cs se va obține fișierul primul.exe direct
executabil pe o platformă .NET.
3.3. Crearea aplicațiilor consolă
Pentru a realiza aplicații în mediul de dezvoltare Visual Studi o, trebuie să instalăm o
versiune a acestuia, eventual versiunea free Microsoft Visual C# 2005 Express Edition de
la adresa http://msdn.microsoft.com/vstudio/express/downloads/default.asp x. Pentru început,
putem realiza aplicații consolă (ca și cele din Borland Pascal sau Borland C).
După lansare, alegem
opțiunea New Project d i n
meniul File. În fereastra de
dialog (vezi figura), selectăm
pictograma Console
Application , după care, la
Name , introducem numele
aplicației noastre.
Fereastra în care scriem
programul se numește
implicit Programs.cs ș i s e
poate modifica prin salvare explicită ( Save As ). Extensia
cs provine de la C Sharp.

În scrierea programului suntem asistati
de IntelliSense , ajutorul contextual.
Compilarea programului se realizează cu
ajutorul opțiunii Build Solution (F6) din meniul
Build. Posibilele erori de compilare sunt listate
în fereastra Error List . Efectuând dublu click pe
fiecare eroare în parte, cursorul din program se poziționează pe linia conținând eroarea.
Rularea programului se poate realiza în
mai multe moduri: rapid fără asistență de
depanare ( Start Without Debugging Shift+F5 ) ,
rapid cu asistență de depanare ( Start
Debugging F5 sau cu butonul
din bara de
instrumente), rulare pas cu pas ( Step Into F11
și Step Over F12) sau rulare rapidă până la linia
marcată ca punct de întrerupere ( Toggle
Breakpoint F9 pe linia respectivă și apoi Start
Debugging F5). Încetarea urmăririi pas cu pas
(Stop Debugging Shift+F5 ) permite ieșirea din
modul depanare și revenirea la modul normal de lucru. Toate opțiunile de rulare și depanare se găsesc în meniul Debug al meniului.
Fereastra de cod și ferestrele auxiliare ce ne
ajută în etapa de editare pot fi vizualizate alegând
opțiunea corespunzătoare din meniul View .
Ferestrele auxiliare utile în etapa de depanare se pot vizualiza alegând opțiunea corespunzătoare din meniul Debug/Windows .

16 POO și Programare vi zuală (suport de curs)
3.4. Structura unui program C#
Să începem cu exemplul clasic “Hello World” adaptat la limbajul C#:
1 using System;
2
3 namespace HelloWorld
4 { 5 class Program 6 { 7 static void Main()
8 {
9 Console.WriteLine("Hello World!"); 10 } 11 } 12 }

O aplicatie C# este formată din una sau mai multe clase , grupate în spații de nume
(namespaces ). Un spațiu de nume cuprinde mai multe clase cu nume diferite având
funcționalități înrudite. Două clase pot avea același nume cu c ondiția ca ele să fie definite în
spații de nume diferite. În cadrul aceluiași spațiu de nume poa te apărea definiția unui alt
spațiu de nume, caz în care avem de-a face cu spații de nume im bricate. O clasă poate fi
identificată prin numele complet (nume precedat de numele spați ului sau spațiilor de nume
din care face parte clasa respectivă, cu separatorul punct). În exemplul nostru,
HelloWorld.Program este numele cu specificație completă al clas ei Program.
O clasă este formată din date și metode (funcții). Apelarea une i metode în cadrul clasei
în care a fost definită aceasta presupune specificarea numelui metodei. Apelul unei metode
definite în interiorul unei clase poate fi invocată și din inte riorul altei clase, caz în care este
necesară specificarea clasei și apoi a metodei separate prin pu nct. Dacă în plus, clasa
aparține unui spațiu de nume neinclus în fișierul curent, atunc i este necesară precizarea
tuturor componentelor numelui: spațiu.clasă.metodă sau spațiu.spațiu.clasă.metodă etc.
În fișierul nostru se află două spații de nume: unul definit ( HelloWorld ) și unul extern
inclus prin directiva using (System ). Console.Writeln reprezintă apelul metodei Writeln
definită în clasa Console . Cum în spațiul de nume curent este definită doar clasa Progra m,
deducem că definiția clasei Console trebuie să se găsească în spațiul System .
Pentru a facilita cooperarea mai multor programatori la realiza rea unei aplicații
complexe, există posibilitatea de a segmenta aplicația în mai m ulte fișiere numite
assemblies . Într-un assembly se pot implementa mai multe spații de nume, iar parți ale unui
aceeași spațiu de nume se pot regăsi în mai multe assembly-uri. Pentru o aplicație consolă,
ca și pentru o aplicație Windows de altfel, este obligatoriu ca una (și numai una) dintre clasele
aplicației să conțină un „punct de intrare” ( entry point ), și anume metoda (funcția) Main .
Să comentăm programul de mai sus:
linia 1: este o directivă care specifică faptul că se vor folosi clase incluse în spațiul de nume
System . În cazul nostru se va folosi clasa Console .
linia 3: spațiul nostru de nume
linia 5: orice program C# este alcătuit din una sau mai multe clase
linia 7: metoda Main , „punctul de intrare” în program
linia 9: clasa Console , amintită mai sus, este folosită pentru operațiile de intrare/ ieșire. Aici
se apelează metoda WriteLine din acestă clasă, pentru afișarea mesajului dorit pe ecran.
3.5. Sintaxa limbajului
Ca și limbajul C++ cu care se înrudește, limbajul C# are un alf abet format din litere
mari și mici ale alfabetului englez, cifre și alte semne. Vocab ularul limbajului este format din
acele ”simboluri”27 cu semnificații lexicale în scrierea programelor: cuvinte (num e), expresii,
separatori, delimitatori și comentarii.

27 Este un termen folosit un pic echivoc și provenit din traducer iea cuvântului ”token”

Limbajul C# 17
Comentarii
• comentariu pe un rând prin folosirea // Tot ce urmează după caracterele // sunt
considerate, din acel loc, până la sfârșitul rândului drept com entariu
// Acesta este un comentariu pe un singur rand
• comentariu pe mai multe rânduri prin folosirea /* ș i */ Orice text cuprins între
simbolurile menționate mai sus se consideră a fi comentariu. Si mbolurile /* reprezintă
începutul comentariului, iar */ sfârșitul respectivului comentariu.
/* Acesta este un
comentariu care se intinde pe mai multe randuri */
Nume
Prin nume dat unei variabile, clase, metode etc. înțelegem o succesiune de caractere
care îndeplinește următoarele reguli:
• numele trebuie să înceapă cu o literă sau cu unul dintre caract erele ” _” și ”@”;
• primul caracter poate fi urmat numai de litere, cifre sau un ca racter de subliniere;
• numele care reprezintă cuvinte cheie nu pot fi folosite în alt scop decât acela
pentru care au fost definite
• cuvintele cheie pot fi folosite în alt scop numai dacă sunt pre cedate de @
• două nume sunt distincte dacă diferă prin cel puțin un caracter (fie el și literă mică
ce diferă de aceeași literă majusculă)
Convenții pentru nume:
• în cazul numelor claselor, metodelor, a proprietăților, enumeră rilor, interfețelor,
spațiilor de nume, fiecare cuvânt care compune numele începe cu majusculă
• în cazul numelor variabilelor dacă numele este compus din mai m ulte cuvinte,
primul începe cu minusculă, celelalte cu majusculă
Cuvinte cheie în C#
abstract as base bool break
byte case catch char checked
class const continue decimal default
delegate do double else enum
event explicit extern false finally
fixed float for foreach goto
if implicit in int interface
internal is lock long namespace
new null object operator out
override params private protected public
readonly ref return sbyte sealed
short sizeof stackalloc static string
struct switch this throw true
try typeof uint ulong unchecked
unsafe ushort using virtual void
volatile while
Simbolurile lexicale reprezentând constante, regulile de formar e a expresiilor,
separatorii de liste, delimitatorii de instrucțiuni, de blocuri de instrucțiuni, de șiruri de
caractere etc. sunt în mare aceiași ca și în cazul limbajului C ++.
3.6. Tipuri de date
În C# există două categorii de tipuri de date:
• tipuri valoare
ƒ tipul simple: byte, char , int, float etc.
ƒ tipul enumerare – enum
ƒ tipul structură – struct

18 POO și Programare vi zuală (suport de curs)
• tipuri referință
ƒ tipul clasă – class
ƒ tipul interfață – interface
ƒ tipul delegat – delegate
ƒ tipul tablou – array
Toate tipurile de date sunt derivate din tipul System.Object
Toate tipurile valoare sunt derivate din clasa System.ValueType , derivată la rândul ei
din clasa Object (alias pentru System.Object ).
Limbajul C# conține un set de tipuri predefinite (int, bool etc.) și permite definirea
unor tipuri proprii (enum, struct, class etc.).
Tipuri simple predefinite
Tip Descriere Domeniul de valori
object rădăcina oricărui tip
string secvență de caractere Unicode
sbyte tip întreg cu semn, pe 8 biți -128; 127
short tip întreg cu semn, pe 16 biți -32768; 32767
int tip întreg cu semn pe, 32 biți -2147483648; 21447483647
long tip întreg cu semn, pe 64 de biți -9223372036854775808;
9223372036854775807
byte tip întreg fără semn, pe 8 biți 0; 255
ushort tip întreg fără semn, pe 16 biți 0; 65535
uint tip întreg fără semn, pe 32 biți 0; 4294967295
ulong tip întreg fără semn, pe 64 biți 0; 18446744073709551615
float tip cu virgulă mobilă, simplă precizie, pe
32 biți (8 pentru exponent, 24 pentru mantisă) -3.402823E+38; 3.402823E+38
double tip cu virgulă mobilă, dublă precizie, pe
64 biți (11 pentru exponent, 53 -mantisa) -1.79769313486232E+308;
1.79769313486232E+308
bool tip boolean –
79228162514264337593543950335;
79228162514264337593543950335
char tip caracter din setul Unicode, pe 16 biți
decimal tip zecimal, pe 128 biți (96 pentru
mantisă), 28 de cifre semnificative
O valoare se asignează după următoarele reguli:
Sufix Tip
nu are int, uint, long, ulong
u, U uint, ulong
L, L long, ulong
ul, lu, Ul, lU, UL, LU, Lu ulong
Exemple:
string s = “Salut!” float g = 1.234F;
long a = 10; double h = 1.234;
long b = 13L; double i = 1.234D;
ulong c = 12; bool cond1 = true;
ulong d = 15U; bool cond2 = false;
ulong e = 16L; decimal j = 1.234M;
ulong f = 17UL;

Limbajul C# 19
Tipul enumerare
Tipul enumerare este un tip de finit de utilizator. Acest tip p ermite utilizarea numelor
care, sunt asociate unor valori numerice. Toate componentele en umerate au un același tip
de bază întreg. În cazul în care, la declarare, nu se specifică tipul de bază al enumerării,
atunci acesta este considerat implicit int.
Declararea unui tip enumerare este de forma:
enum [Nume_tip] [: Tip] o
{
[identificator1][=valoare] o,
… [identificatorn][=valoare]
o
}
Observații:
• În mod implicit valoarea primului membru al enumerării este 0, iar fiecare variabilă care
urmează are valoarea (implicită) mai mare cu o unitate decât pr ecedenta.
• Valorile folosite pentru inițializări trebuie să facă parte di n domeniul de valori declarat al
tipului
• Nu se admit referințe circulare:
enum ValoriCirculare
{ a = b, b }
Exemplu:
using System; namespace tipulEnum { class Program
{
enum lunaAnului { Ianuarie = 1, Februarie, Martie, Aprilie, Mai, Iunie, Iulie,
August, Septembrie, Octombrie, Noiembrie, Decembrie
} static void Main(string[] args) { Console.WriteLine("Luna Mai este a ",
(int)lunaAnului.Mai + "a luna din an.");
Console.ReadLine(); } } }
În urma rulării programului se afișează mesajul :
Luna Mai este a 5 a luna din an.
Tablouri
Declararea unui tablou unidimensional:
Tip[] nume;
Prin aceasta, nu se alocă spațiu pentru memorare. Pentru a putea reține date în
structura de tip tablou, este necesară o operație de instanțiere :
nume = new Tip[NumarElemente];
Declararea, instanțierea și chiar inițializarea tabloului se po t face în aceeași instrucțiune:
Exemplu:
int[] v = new int[] {1,2,3}; sau
int[] v = {1,2,3}; //new este implicit

20 POO și Programare vi zuală (suport de curs)
În cazul tablourilor cu mai multe dimensiuni facem distincție î ntre tablouri regulate și
tablouri neregulate (tablouri de tablouri)
Declarare în cazul tablourilor regulate bidimensionale :
Tip[,] nume;
Intanțiere:
nume = new Tip[Linii,Coloane];
Acces:
nume[indice1,indice2]
Exemple:
int[,] mat = new int[,] {{1,2,3},{4,5,6},{7,8,9}}; sau
int[,] mat = {{1,2,3},{4,5,6},{7,8,9}};
Declarare în cazul tablourilor neregulate bidimensionale :
Tip[][] nume;
Intanțiere:
nume = new Tip[Linii],[];
nume[0]=new Tip[Coloane1] … nume[Linii-1]=new Tip[Coloane
Linii-1]
Acces:
nume[indice1][indice2]
Exemple:
int[][] mat = new int[][] {
new int[3] {1,2,3},
new int[2] {4,5},
new int[4] {7,8,9,1}
}; sau
int[][] mat={new int[3] {1,2,3},new int[2] {4,5},new int[4] {7,8,9,1}};
Șiruri de caractere
Se definesc două tipuri de șiruri:
• regulate
• de tip „ verbatim ”
Tipul regulat conține între ghilimele zero sau mai multe caract ere, inclusiv secvențe escape.
Secvențele escape permit reprezentarea caracterelor care nu au reprezentare grafică
precum și reprezentarea unor caractere speciale: backslash, car acterul apostrof, etc.

Secvență
escape Efect
\’ apostrof
\” ghilimele
\\ backslash
\0 null
\a alarmă
\b backspace
\f form feed – pagină nouă
\n new line – linie nouă
\r carriage return – început de rând
\t horizontal tab – tab orizontal
\u caracter unicode
\v vertical tab – tab vertical
\x caracter hexazecimal

Limbajul C# 21
În cazul în care folosim multe secvențe escape, putem utiliza ș irurile verbatim . Aceste șiruri
pot să conțină orice fel de caractere, inclusiv caracterul EOLN . Ele se folosesc în special în
cazul în care dorim să facem referiri la fișiere și la regiștri . Un astfel de șir începe
întotdeauna cu simbolul ’@’ înaintea ghilimelelor de început.
Exemplu:
using System;
namespace SiruriDeCaractere
{
class Program { static void Main(string[] args) {
string a = "un sir de caractere";
string b = "linia unu \nlinia doi"; string c = @"linia unu linia doi"; string d="c:\\exemple\\unu.cs";
string e = @"c:\exemple\unu.cs";
Console.WriteLine(a); Console.WriteLine(b); Console.WriteLine(c); Console.WriteLine(d); Console.WriteLine(e); Console.ReadLine(); }
}
}
Programul va avea ieșirea
un sir de caractere
linia unu
linia doi
linia unu linia doi c:\exemple\unu.cs c:\exemple\unu.cs
3.7. Conversii
Conversii numerice
În C# există două tipuri de conversii numerice:
• implicite
• explicite.
Conversia implicită se efectuează (automat) doar dacă nu este a fectată valoarea
convertită. Regulile de conversie implicită sunt descrise de tabelul următor:
din în
sbyte short, int, long, float, double, decimal
byte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
int long, float, double, decimal
uint long, ulong, float, double, decimal
long float, double, decimal
char ushort, int, uint, long, ulong, float, double, decimal
float double
ulong float, double, decimal

Conversia explicită se realizează prin intermediul unei expresii cast, atunci când nu
există posibilitatea unei conversii implicite.
Exemplu:
int i=Console.Read(); char c;
c=char(i);

22 POO și Programare vi zuală (suport de curs)
Conversii boxing și unboxing
Datorită faptului că în C# toate tipurile sunt derivate din cla sa Object
(System.Object ), prin conversiile boxing (împachetare) și unboxing (despachetare) este
permisă tratarea tipurilor valoare drept obiecte și reciproc. P rin conversia boxing a unui tip
valoare, care se păstrează pe stivă, se produce ambalarea în in teriorul unei instanțe de tip
referință, care se păstrază în memoria heap, la clasa Object . Unboxing permite convertirea
unui obiect într-un tipul valoare corespunzător.
Exemplu:
Prin boxing variabila i este asignata unui obiect ob:
int i = 13;
object ob = (object)i; //boxing explicit
sau
int i = 13;
object ob = i; //boxing implicit
Prin conversia de tip unboxing, obiectul ob poate fi asignat variabilei întregi i:
int i=13;
object ob = i; //boxing implicit
i = (int)ob; //unboxing explicit
3.8. Constante
În C# există două modalități de declarare a constantelor: folos ind const sau folosind
modificatorul readonly . Constantele declarate cu const trebuie să fie inițializate la
declararea lor.
Exemple:
const int x; //gresit, constanta nu a fost initializata
const int x = 13; //corect
3.9. Variabile
O variabilă în C# poate să conțină fie o valoare a unui tip ele mentar, fie o referință la
un obiect.
Exemple:
int Salut;
int Azi_si _maine;
char caracter ;
3.10. Expresii și operatori
Prin expresie se înțelege o secvență formată din operatori și operanzi . Un operator
este un simbol ce indică acțiunea care se efectuează, iar operandul este valoarea asupra
căreia se execută operația.
În C# sunt definiți mai mulți operatori. În cazul în care într- o expresie nu intervin
paranteze, operațiile se execută conform priorității operatoril or. În cazul în care sunt mai
mulți operatori cu aceeași prioritate, evaluarea expresiei se r ealizează de la stânga la
dreapta.

Prioritate Tip Operatori Asociativi-tate
0 Primar ( ) [ ] f() . x++ x– new typeof sizeof
checked unchecked ->
→
1 Unar + – ! ~ ++x –x (tip) true false & sizeof →
2 Multiplicativ * / % →
3 Aditiv + – →
4 De deplasare << >> →
5 Relațional < > <= >= is as →
6 De egalitate == != →

Limbajul C# 23
7 AND (SI) logic & →
8 XOR (SAU
exclusiv) logic ^ →
9 OR (SAU) logic | →
10 AND (SI)
condițional && →
11 OR (SAU)
condițional || →
12 Condițional ?: ←
13 De atribuire = *= /= %= += -= ^= &= <<= >>= |= ←
3.11. Colecții
O colecție în C# este o clasă specializată pentru memorarea și regăsirea rapidă a
informațiilor. Ea implementează metode specifice de actualizare dinamică colecției, de
căutare și de enumerare a datelor. Cel mai des folosite sunt co lecțiile de obiecte și colecțiile
generice (vezi capitolul 5.1) cum ar fi liste, stive, hash-uri. Aceste clase pot fi derivate pentru
a obține colecții specializate care se potrivesc cel mai bine n ecesităților de memorare a
datelor specifice unei aplicații. Colecțiile sunt definite în s pațiul System.Collection. Metodele
uzuale ale claselor din spațiul Collection sunt: Add, Remove , IndexOf , Sort, Reverse ,
CopyToArray , Find, Foreach etc.
3.12. Instrucțunea foreach
Cum instrucțiunile de apel, atribuire, decizie, selecție și tre i structuri repetitive coincid
ca formă și funcționalitate cu cele din C, ne oprim sumar numai unora dintre noile structuri de
control specifice limbajului C#.
Instrucțiunea foreach enumeră elementele dintr-o colecție sau dintr-un tablou,
executând un bloc de instrucțiuni pentru fiecare element al col ecției sau tabloului. La fiecare
iterație, elementul curent al colecției este de tip readonly , neputând fi modificat. Amintim că
în instrucțiunea repetitivă foreach se pot utiliza cu exact aceeași funcționalitate
instrucțiunile de salt break și continue .
instrucțiunea se utilizează curent în aplicații pentru tablour i și colecții de obiecte28.
Pentru a vedea cum acționează o vom compara cu instrucțiunea cu noscută for. Fie
vectorul nume format din șiruri de caractere:
string[] nume={“Ana”, Ionel”, “Maria”};
Să afișam acest șir folosind instrucțiunea for:
for(int i=0; i<nume.Length; i++)
{ Console.Write(“{0} ”, nume[i]); }
Același rezultat îl obținem folosind instrucțiunea foreach :
foreach (string copil in nume)
{ Console.Write(“{0} ”, copil); }
3.13. Instrucțiunile try -catch-finally și throw
Prin excepție se înțelege un obiect care încapsulează informații despre situ ații
anormale în funcționarea unui program. Ea se folosește pentru a semnala contextul în care

28 de exemplu, pentru prelucrarea sistematică a tuturor component lelor unei ferestre (butoane,
liste, casete de text etc.)

24 POO și Programare vi zuală (suport de curs)
apare o situație specială. De exemplu: erori la deschiderea uno r fișiere, împărțire la 0 etc.
Aceste erori se pot manipula astfel încât programul să nu se te rmine abrupt.
Sunt situații în care prefigurăm apariția unei erori într-o sec vență de prelucrare și atunci
integrăm secvența respectivă în blocul unei instrucțiuni try, precizând una sau mai multe
secvențe de program pentru tratarea excepțiilor apărute (blocur i catch ) și eventual o
secvență comună care se execută după terminarea normală sau dup ă ”recuperarea”
programului din starea de excepție (blocul finally ).
Exemplu:
using System;
using System.IO;
class tryCatch
{ static void Main(string[] args) { string s; Console.Write("Numele fisierului:");
Console.Readln(s);
try { File.OpenRead(s); }
catch (FileNotFoundException a)
{ Console.WriteLine(a.ToString()); } catch (PathTooLongException b)
{
Console.WriteLine(b.ToString()); } finally {
Console.WriteLine("Programul s-a sfarsit");
Console.ReadLine(); } }

Alteori putem simula prin program o stare de eroare ”aruncând” o excepție
(instrucțiunea throw ) sau putem profita de mecanismul de tratare a erorilor pentru a
implementa un sistem de validare a datelor prin generarea unei excepții proprii pe care, de
asemenea, o ”aruncăm” în momentul neîndeplinirii unor condiții puse asupra datelor.
Clasa System.Exception și derivate ale acesteia servesc la tratarea adecvată și
diversificată a excepțiilor.
Exemplu: Considerăm clasele Copil, Fetita, Baiat definite fragmentat în capitolul 1. O
posibilitate de validare la adăugara unui copil este aceea care generează o excepție proprie
la depășirea dimensiunii vectorului static copii :
public static void adaug_copil( Copil c)
{ if (nr_copii < nr_max)
copii[nr_copii++] = c;
else throw new Exception ("Prea multi copii" );
}

Programare vizuală 25
4. Programare vizuală
4.1. Concepte de bază ale programării vizuale
Programarea vizuală trebuie privită ca un mod de proiectare a unui program prin
operare directă asupra unui set de elemente grafice (de aici vi ne denumirea de programare
vizuală). Această operare are ca efect scrierea automată a unor secvențe de program,
secvențe care, împreună cu secvențele scrise textual29, vor forma programul.
Spunem că o aplicație e s t e vizuală dacă dispune de o interfață grafică sugestivă și
pune la dispoziția utilizatorului instrumente specifice de util izare ( drag, click, hint etc.)
Realizarea unei aplicații vizuale nu constă doar în desenare și aranjare de controale, ci
presupune în principal stabilirea unor decizii arhitecturale30, decizii ce au la bază unul dintre
modelele arhitecturale de bază:
a) Modelul arhitectural orientat pe date.
Acest model nu este orientat pe obiecte, timpul de dezvoltare al unei astfe l de aplicații
este foarte mic, o parte a codului este generată automat de Vis ual Stdio.Net, codul nu
este foarte ușor de întreținut și este recomandat pentru aplica ții relativ mici sau cu multe
operații de acces (in/out) la o bază de date.
b) Modelul arhitectural Model-view-controller
Este caracterizat de cele trei concepte de bază : Model ( reprezentarea datelor se
realizează într-o manieră specifică aplicației: conține obiecte le de „business”,
încapsulează accesul la date), View (sunt utilizate elemente de interfață, este format
din Form-uri), Controller ( procesează și răspunde la evenimente iar SO, clasele Form
și Control din .Net rutează evenimentul către un „handler”, eve niment tratat în codul din
spatele Form-urilor).
c) Modelul arhitectural Multi-nivel
Nivelul de prezentare ( interfața)
Se ocupă numai de afișarea informațiilor către
utilizator și captarea celor introduse de acesta. Nu cuprinde detalii despre logica aplicației, și cu atât mai mult despre baza de date sau fișierele pe care aceasta le utilizează. Cu alte cuvinte, în
cadrul interfeței cu utilizatorul, nu se vor folosi
obiecte de tipuri definite de programator, ci numai baza din .NET.
Nivelul de logică a aplicației
Se ocupă de tot ceea ce este specific aplicației
care se dezvoltă. Aici se efectuează calculele și
procesările și se lucrează cu obiecte de tipuri
definite de programator.
Nivelul de acces la date
Aici rezidă codul care se ocupă cu accesul la
baza de date, la fișiere, la alte servicii.

Această ultimă structură este foarte bună pentru a organiza apl icațiile, dar nu este ușor
de realizat. De exemplu, dacă în interfața cu utilizatorul prez entăm date sub formă ListView
și la un moment dat clientul ne cere reprezentarea datelor într -un GridView , modificările la
nivel de cod nu se pot localiza doar în interfață deoarece cele două controale au nevoie de
modele de acces la date total diferite.

29 Se utilizează ades antonimia din tre vizual (opera ții asupra un or componente grafice) și textual
(scriere de linii de co d); proiectarea oricărei aplicații ”vizu ale” îmbină ambele tehnici.
30 Deciziile arhitecturale stabilesc în principal cum se leagă in terfața de restul aplicației și cât de
ușor de întreținut este codul rezultat.

26 POO și Programare vi zuală (suport de curs)
Indiferent de modelul arhitectural ales, în realizarea aplicați ei mai trebuie respectate și
principiile proiectării interfețelor :
• Simplitatea
Interfața trebuie să fie cât mai ușor de înțeles31 și de învățat de către utilizator și să permită
acestuia să efectueze operațiile dorite în timp cât mai scurt. În acest sens, este vitală
culegerea de informații despre utilizatorii finali ai aplicație i și a modului în care aceștia sunt
obișnuiți să lucreze.
• Poziția controalelor
Locația controalelor dintr-o fereastră trebuie să reflecte impo rtanța relativă și frecvența de
utilizare. Astfel, când un utilizator trebuie să introducă nișt e informații – unele obligatorii și
altele opționale – este indicat să organizăm controalele astfel încât primele să fie cele care
preiau informații obligatorii.
• Consistența
Ferestrele și controalele trebuie să fie afișate după un design asemănător („template”) pe
parcursul utilizării aplicației. Înainte de a implementa interf ața, trebuie decidem cum va arăta
aceasta, să definim „template”-ul.
• Estetica
Intefața trebuie să fie pe cât posibil plăcută și atrăgătoare.
4.2. Mediul de dezvoltare Visual C#
Mediul de dezvoltare Microsoft Visual C# dispune de instrumente specializate de
proiectare, ceea ce permite crearea aplicațiilor în mod interac tiv, rapid și ușor.
Pentru a construi o aplicație Windows (File ÆNew Project) se selectează ca template
Windows Application .
O aplicație Windows conține cel puțin o fereastră ( Form ) în care se poate crea o
interfață cu utilizatorul aplicației.
Componentele vizuale ale aplicației pot fi prelucrate în modul Designer (Shift+F7 )
pentru a plasa noi obiecte, a le stabili proprietățile etc. Cod ul ”din spatele” unei componente
vizuale este accesibil în modul Code (F7).
În fereastra Solution Explorer s u n t a f i ș a t e
toate fișierele pe care Visual Studio.NET le-a inclus în proiect. Form1.cs este formularul creat implicit de
Visual Studio.NET ca parte a proiectului.
Fereastra Properties este utilizată pentru a
vizualiza și eventual schimba proprietățile obiectelor.
Toolbox conține controale standard drag-
and-drop și componente utilizate în crearea aplicației
Windows. Controalele sunt grupate în categoriile logice din imaginea alăturată.
Designer , Code , Solution Explorer și celelalte se află grupate în meniul View .
La crearea unei noi aplicații vizuale, Visual Studio.NET genere ază un spațiu de nume
ce conține clasa statică Program , cu metoda statică ce constituie punctul de intrare (de
lansare) a aplicației:

static void Main()
{ …
Application .Run(new Form1());
}
Clasa Application este responsabilă cu administrarea unei aplicații Windows, pun ând la
dispoziție proprietăți pentru a obține informații despre aplica ție, metode de lucru cu aplicația
și altele. Toate metodele și proprietățile clasei Application s unt statice . Metoda Run invocată

31 Întrucât mintea umană poate să p erceapă la un moment dat aproxi mativ 5-9 obiecte, o
fereastră supra-încărc ată de controale o fa ce greu de utilizat.

Programare vizuală 27
mai sus creează un formular implicit, aplicația răspunzând la m esajele utilizatorului până
când formularul va fi închis.
Compilarea modulelor aplicației și asamblarea lor într-un singu r fișier ”executabil” se
realizează cu ajutorul opțiunilor din meniul Build, uzuală fiin d Build Solution (F6).
Odată implementată, aplicația poate fi lansată, cu asistență de depanare sau nu
(opțiunile Start din meniul Debug ). Alte facilități de depanare pot fi folosite prin umărirea pa s
cu pas, urmărirea până la puncte de întrerupere etc. (celelalte opțiuni ale meniului Debug ).
Ferestre auxiliare de urmărire sunt vizualizate automat în timp ul procesului de depanare, sau
pot fi activate din submeniul Windows al meniului Debug .
4.3. Ferestre
Spațiul Forms ne oferă clase specializate pentru: creare de fer estre sau formulare
(System.Windows.Forms.Form ), elemente specifice ( controale ) cum ar fi butoane
(System.Windows.Forms.Button ), casete de text ( System.Windows.Forms.TextBox ) etc.
Proiectarea unei ferestre are la bază un cod complex, generat a utomat pe măsură ce noi
desemnăm componentele și comportamentul acesteia. În fapt, aces t cod realizează:
derivarea unei clase proprii din System.Windows.Forms.Form, clasă care este înzestrată
cu o colecție de controale (inițial vidă). Constructorul ferestrei realizază instanțieri ale
claselor Button , MenuStrip , Timer etc. (orice plasăm noi în fereastră) și adaugă referințele
acestor obiecte la colecția de controale ale ferestrei.
Dacă modelul de fereastră reprezintă ferestra principală a apli cației, atunci ea este
instanțiată automat în programul principal (metoda Main ). Dacă nu, trebuie să scriem noi
codul ce realizează instanțierea.
Clasele derivate din Form moștenesc o serie de proprietăți care determină atributele
vizuale ale ferestrei (stilul marginilor, culoare de fundal, et c.), metode care implementează
anumite comportamente ( Show , Hide, Focus etc.) și o serie de metode specifice ( handlere )
de tratare a evenimentelor ( Load, Click etc.).
O fereastră poate fi activată cu form.Show() sau cu form.ShowDialog() , metoda a
doua permițând ca revenirea în fereastra din care a fost activa t noul formular să se facă
numai după ce noul formular a fost inchis (spunem că formularul nou este deschis modal ).
Un propietar este o fereastră care contribuie la comportarea formularului d eținut.
Activarea propietarului unui formular deschis modal va determin a activarea formularului
deschis modal. Când un nou formular este activat folosind form.Show() nu va avea nici un
deținător, acesta stabilindu-se direct :
public Form Owner { get; set; }
F_nou form= new F_nou();
form.Owner = this; form.Show();
Formularul deschis modal va avea un proprietar setat pe null. Deținătorul se poate
stabili setând proprietarul înainte să apelăm Form.ShowDialog() sau apelând
From.ShowDialog() cu proprietarul ca argument.
F_nou form = new F_nou();form.ShowDialog( this);
Vizibilitatea unui formular poate fi setată folosind metodele Hide sau Show . Pentru a
ascunde un formular putem folosi :
this.Hide(); // setarea propietatii Visible indirect sau
this.Visible = false; // setarea propietatii Visible direct
Printre cele mai uzuale proprietăți ale form-urilor, reamintim:
• StartPosition determină poziția ferestrei atunci când aceasta apare prima dat ă, poziție
ce poate fi setată Manual sau poate fi centrată pe desktop ( CenterScreen ), stabilită de
Windows, formularul având dimensiunile și locația stabilite de programator
(WindowsDefaultLocation ) sau Windows-ul va stabili dimensiunea inițială și locația
pentru formular ( WindowsDefaultBounds) sau, centrat pe formularul care l-a afișat
(CenterParent ) atunci când formularul va fi afișat modal.

28 POO și Programare vi zuală (suport de curs)
• Location (X,Y) reprezintă coordonatele colțului din stânga sus al formularulu i relativ la
colțul stânga sus al containerului. (Această propietate e igno rată dacă StartPosition =
Manual).
Mișcarea formularului ( și implicit schimbarea locației) poate fi tratată în evenimentele
Move și LocationChanged .
Locația formularului poate fi stabilită relativ la deskto p astfel:
void Form_Load( object sender, EventArgs e) {
this.Location = new Point(1, 1);
this.DesktopLocation = new Point(1, 1); } //formularul in desktop
• Size (Width ș i Height ) reprezintă dimensiunea ferestrei. Când se schimbă propietățil e
Width și Height ale unui formular, acesta se va redimensiona a utomat, această
redimensionare fiind tratată în evenimentele Resize sau in SizeChanged .
Chiar dacă propietatea Size a formularului indică dimensiunea ferestrei, formularul nu est e
în totalitate responsabil pentru desenarea întregului conținut al său. Partea care este
desenată de formular mai este denumită și Client Area. Marginil e, titlul și scrollbar-ul sunt
desenate de Windows.
• MaxinumSize și MinimumSize sunt utilizate pentru a restricționa dimensiunile unui
formular.
void Form_Load( object sender, EventArgs e) {
this.MinimumSize = new Size(200, 100);…
this.MaximumSize = new Size( int.MaxValue, 100);…}
• IsMdiContainer precizează dacă form-ul reprezintă un container pentru alte fo rm-uri.
• ControlBox precizează dacă fereastra conține sau nu un icon, butonul de î nchidere al
ferestrei și meniul System (Restore,Move,Size,Maximize,Minimize ,Close).
• HelpButton -precizează dacă butonul
va apărea sau nu lângă butonul de închidere al
formularului (doar dacă MaximizeBox=false, MinimizeBox=false). Dacă utilizatorul apasă
acest buton și apoi apasă oriunde pe formular va apărea evenime ntul HelpRequested
(F1).
• Icon reprezintă un obiect de tip *.ico folosit ca icon pentru form ular.
• MaximizeBox și MinimizeBox precizează dacă fereastra are sau nu butonul Maximize și
respectiv Minimize
• Opacity indică procentul de opacitate32
• ShowInTaskbar precizează dacă fereastra apare in TaskBar atunci când formula rul este
minimizat.
• SizeGripStyle specifică tipul pentru ‘Size Grip’ (Auto, Show, Hide). Size gr ip
(în colțul
din dreapta jos) indică faptul că această fereastră poate fi re dimensionată.
• TopMost precizează dacă fereastra este afisată în fața tuturor celorlal te ferestre.
• TransparencyKey identifică o culoare care va deveni transparentă pe formă.

Definirea unei funcții de tratare a unui eveniment asociat controlului se realizează prin
selectarea grupului
Events d i n f e r e s t r a Properties a controlului respectiv și alegerea
evenimentului dorit.
Dacă nu scriem nici un nume pentru funcția de tratare, ci efect uăm dublu click în
căsuța respectivă, se generează automat un nume pentru această funcție, ținând cont de
numele controlului și de numel e evenimentului (de exemplu button1_Click).
Dacă în Designer efectuăm dublu click pe un control, se va genera automat o fun cție
de tratare pentru evenimentul implicit asociat controlului (pen tru un buton evenimentul
implicit este Click , pentru TextBox este TextChanged , pentru un formular Load etc.).
Printre evenimentele cele mai des utilizate, se numără :
• Load apare când formularul este pentru prima data încărcat în memor ie.

32 Dacă va fi setată la 10% formular ul și toate controalele sale v or fi aproape invizibile.

Programare vizuală 29
• FormClosed apare când formularul este închis.
• FormClosing apare când formularul se va inchide ca rezultat al acțiunii uti lizatorului
asupra butonului Close (Dacă se setează CancelEventArgs.Cancel =True atunci se
va opri închiderea formularului).
• Activated apare pentru formularul activ.
• Deactivate apare atunci când utilizatorul va da click pe alt formular al a plicatiei.
4.4. Controale
Unitatea de bază a unei interfețe Windows o reprezintă un contr ol. Acesta poate fi
„găzduit” de un container ce poate fi un formular sau un alt co ntrol.
Un control este o instanță a unei clase derivate din System.Win dows.Forms și este
reponsabil cu desenarea unei părți din container. Visual Studio . N E T v i n e c u o s e r i e d e
controale standard, disponibile în Toolbox. Aceste controale po t fi grupate astfel:
• Controale de actiune (de exemplu button ) care, atunci când sunt acționate, se poate
executa o prelucrare. De exemplu, cel mai important eveniment pentru Button este Click
(desemnând acțiunea click stânga pe buton).
În exemplul PV1 se adaugă pe formular două butoane și o casetă
text. Apăsarea primului buton va determina afișarea textului di n TextBox
într-un MessageBox iar apăsarea celui de-al doilea buton va înc hide
închide aplicația. După adăugarea celor două butoane și a caset ei text a
fost schimbat textul afișat pe cele două butoane au fost scris e funcțiile
de tratare a evenimentului Click pentru cele două butoane:
private void button1_Click( object sender, System. EventArgs e)
{ MessageBox .Show(textBox1.Text);}
private void button2_Click( object sender, System. EventArgs e)
{ Form1.ActiveForm.Dispose();}
• Controale valoare (label, textbox, picturebox ) care arată utilizatorului o informație
(text, imagine).
Label este folosit pentru plasarea de text pe un formular. Textul af ișat este conținut în
propietatea Text și este aliniat conform propietății TextAlign.
TextBox – permite utilizatorului să introducă un text. Prevede, prin in termediul
ContextMenu-ului asociat, un set de funcționalități de bază, ca de exemplu (Cut,
Copy, Paste, Delete, SelectAll).
PictureBox permite afișarea unei imagini.
Exemplul PV2 afișează un grup alcătuit din 3
butoane, etichetate A,B respectiv C având inițial culoarea roșie. Apăsarea unui buton determină schimbarea culorii acestuia în galben. La o nouă
apăsare butonul revine la culoare inițială. Acționarea
butonului “Starea butoanelor” determină afișarea într-o casetă text a etichetelor butoanelor galbene. Caseta text devine vizibilă atunci când apăsăm prima oară acest buton. Culoarea butonului mare (verde/portocaliu)
se schimbă atunci când mouse-ul este poziționat pe
buton.
După adăugarea butoanelor și a casetei text pe
formular, stabilim evenimentele care determină
schimbarea culoriilor și completarea casetei text.
private void button1_Click( object sender, System. EventArgs e)
{if (button1.BackColor== Color.IndianRed) button1.BackColor= Color.Yellow;
else button1.BackColor= Color.IndianRed;}

30 POO și Programare vi zuală (suport de curs)
private void button4_MouseEnter( object sender, System. EventArgs e)
{button4.BackColor= Color.YellowGreen;button4.Text= "Butoane apasate" ;}
private void button4_MouseLeave( object sender, System. EventArgs e)
{textBox1.Visible= false;button4.Text= "Starea butoanelor" ;
button4.BackColor= Color.Orange;}
private void button4_Click( object sender, System. EventArgs e)
{textBox1.Visible= true;textBox1.Text= "";
if( button1.BackColor== Color.Yellow)textBox1.Text=textBox1.Text+ 'A';
if( button2.BackColor== Color.Yellow)textBox1.Text=textBox1.Text+ 'B';
if( button3.BackColor== Color.Yellow)textBox1.Text=textBox1.Text+ 'C';
}
Exercițiu Modificați aplicația precedentă astfel încât să avem un singur eveniment
button_Click, diferențierea fiind făcută de parametrul sender.
Exercițiu ( Password) Adăugați pe un formular o casetă text în care să introduceți un
șir de caractere și apoi verificați dacă acesta coincide cu o p arolă dată. Textul introdus în
casetă nu este vizibil (fiecare caracter este înlocuit cu*). Re zultatul va fi afișat într-un
MessageBox .
• Controale de selecție (CheckBox,RadioButton) au propietatea Checked care indică
dacă am selectat controlul. După schimbarea stării unui astfel de control, se declanșează
evenimentul Checked . Dacă propietatea ThreeState este setată, atunci se schimbă
funcționalitatea acestor controale, în sensul că acestea vor permite setarea unei alte
stări. În acest caz, trebuie verificată propietatea CheckState(Checked ,
Unchecked ,Indeterminate ) pentru a vedea starea controlului.
Aplicația PV3 este un exemplu de utilizare a
acestor controale. Soluția unei probleme cu
mai multe variante de răspuns este memorată cu ajutorul unor checkbox-uri cu proprietatea ThreeState. Apăsarea butonului Verifică
determină afișarea unei etichete și a butoanelor radio DA și NU. Răspunsul este afișat într-un Messag eBox.
După adăugarea controalelor pe formular și setarea proprietățil or Text și ThreeState în
cazul checkbox-urilor stabilim e venimentele click pentru butonu l Verifica și pentru butonul
radio cu eticheta DA:
private void radioButton1_Click( object sender, System. EventArgs e)
{if (checkBox1.CheckState== CheckState .Checked &&
checkBox2.CheckState== CheckState .Checked &&
checkBox3.CheckState== CheckState .Checked &&
checkBox5.CheckState== CheckState .Checked &&
checkBox4.CheckState== CheckState .Unchecked) MessageBox .Show( "CORECT" );
else MessageBox .Show( "Indicatie> Daca punem un sac in altul…." );
label2.Visible= false;
radioButton1.Checked= false; radioButton2.Checked= false;
radioButton1.Visible= false; radioButton2.Visible= false;}
private void button1_Click( object sender, System. EventArgs e)
{label2.Visible= true;radioButton1.Visible= true;radioButton2.Visible= true;}
Exercițiu (Test grilă) Construiți un test grilă care conține 5 itemi cu câte 4 variant e de
răspuns (alegere simplă sau multiplă), memorați răspunsurile da te și afișați, după efectuarea
testului, într-o casetă text, în dreptul fiecărui item, răspuns ul corect .
• LinkLabel afișează un text cu posibilitatea ca anumite părți ale textului (LinkArea) să fie
desenate ca și hyperlink-uri. Pentru a face link-ul funcțional trebuie tratat evenimentul
LinkClicked.
În exemplul PV4, prima etichetă permite afișarea conținutului discului C:, a d oua legătură
este un link către pagina www.microsoft.com/romania și a treia accesează Notepad.

Programare vizuală 31

private void etichetaC_LinkClicked ( object sender,
LinkLabelLinkClickedEventArgs e )
{ etichetaC.LinkVisited = true;
System.Diagnostics. Process .Start( @"C:\" );}
private void etichetaI_LinkClicked( object sender,
LinkLabelLinkClickedEventArgs e )
{etichetaI.LinkVisited = true;
System.Diagnostics. Process .Start( "IExplore" ,
"http://www.microsoft.com/romania/" );}
private void etichetaN_LinkClicked( object sender,
LinkLabelLinkClickedEventArgs e )
{etichetaN.LinkVisited = true;
System.Diagnostics. Process .Start( "notepad" );}
Exercițiu (Memorator) Construiți o aplicație care să conțină patru legături către ce le
patru fișiere/ pagini care conțin rezumatul capitolelor studiat e.
• Controale pentru listare ( ListBox , CheckedListBox , ComboBox, ImageList ) ce pot fi
legate de un DataSet, de un ArrayList sau de orice tablou (oric e sursă de date ce
implementează interfața IEnumerable).
În exemplul PV5 elementele selectate din
CheckedListBox se adaugă în ListBox. După
adăugarea pe formular a CheckedListBox-ului, stabilim colecția de itemi (Properties-Items-Collection), butonul Selecție și ListBox-ul.
Evenimentul Click asociat butonului Setectie golește
mai întâi listBox-ul (
listBox1.Items.Clear();) și
după aceea adaugă în ordine fiecare element
selectat din CheckedListBox. Suplimentar se afișează o etichetă cu itemii selectați.

void button1_Click( object source, System. EventArgs e)
{ String s = "Am selectat si am adaugat itemii: " ;
listBox1.Items.Clear(); foreach ( object c in checkedListBox1.CheckedItems)
{listBox1.Items.Add(c); s = s + c.ToString();s = s + " ";}
label1.Text = s;}
Exercițiu ( Filtru) Construiți o aplicație care afișează fișierele dintr-un folder ales care
au un anumit tip ( tipul fișierelor este ales de utilizator pe baza unui CheckedListBox)
Aplicația PV6 este un exemplu de utilizare a
controlului ImageList. Apăsarea butonului Desene va
adăuga fișierele *.gif din folderul C:\Imagini în listă și va
afișa conținutul acesteia. Butonul Animate va determina
afișarea fișierelor *.gif cu ajutorul PictureBox.

32 POO și Programare vi zuală (suport de curs)
ImageList desene_animate = new System.Windows.Forms. ImageList ();
private void contruieste_lista_Click( object sender, System. EventArgs e)
{ // Configureaza lista
desene_animate.ColorDepth =System.Windows.Forms. ColorDepth .Depth8Bit;
desene_animate.ImageSize = new System.Drawing. Size(60, 60);
desene_animate.Images.Clear();
string [] gif_uri = Directory .GetFiles( "C:\\Imagini" , "*.gif" );
// se construieste un obiect Imagine pentru fiecare fisier si se adauga la ImageList.
foreach (string fisier_gif in gif_uri)
{Bitmap desen= new Bitmap (fisier_gif);
desene_animate.Images.Add(desen);pictureBox2.Image=desen;}
Graphics g = this.CreateGraphics();
// Deseneaza fiecare imagine utilizand metoda ImageList.Draw()
for (int i = 0; i < desene_animate.Images.Count; i++)
desene_animate.Draw(g, 60 + i * 60, 60, i);
g.Dispose(); }
Exercițiu (Thumbnails) Afișați într-o ferestră conținutul folder-ului curent în mod V iew-
Thumbnails.
• MonthCalendar afișează un calendar prin care se poate selecta o dată (zi, lu na, an) în
mod grafic. Proprietățile mai importante sunt: MinDate , MaxDate , TodayDate c e
reprezintă data minimă/maximă selectabilă și data curentă (care apare afișată diferențiat
sau nu în funcție de valorile proprietăților ShowToday ,ShowTodayCircle . Există 2
evenimente pe care controlul le expune: DateSelected și DateChanged . În rutinele de
tratare a acestor evenimente, programatorul are acces la un obi ect de tipul
DateRangeEventArgs care conține proprietățile Start și End (reprezentând intervalul de
timp selectat).
Formularul din aplicația PV7 conține un
calendar pentru care putem selecta un interval de maximum 30 de zile, sunt afișate săptămânile și ziua curentă. Intervalul selectat se afișează prin intermediul unei etichete. Dacă se selectează o
dată atunci aceasta va fi adăugată ca item într-un
ComboBox (orice dată poate apărea cel mult o dată în listă).
După adăugarea celor 3 controale pe formular, stabilim propriet ățile pentru
monthCalendar1 ( ShowWeekNumber -True, MaxSelectionCount -30, etc.) și precizăm ce
se execută atunci când selectăm un interval de timp:
private void monthCalendar1_DateSelected( object sender,
System.Windows.Forms. DateRangeEventArgs e)
{ this.label1.Text = "Interval selectat: Start = "
+e.Start.ToShortDateString() + " : End = "
+ e.End.ToShortDateString();
if (e.Start.ToShortDateString()==e.End.ToShortDateString())
{String x=e.Start.ToShortDateString();
if(!(comboBox1.Items.Contains(x)))
comboBox1.Items.Add(e.End.ToShortDateString());} }
• DateTimePicker este un control care (ca și MonthCalendar) se poate utiliza pe ntru a
selecta o dată. La click se afișează un control de tip MonthCal endar, prin care se poate
selecta data dorită. Fiind foarte asemănător cu MonthCalendar, proprietățile prin care se
poate modifica comportamentul controlului sunt identice cu cele ale controlului
MonthControl.

Programare vizuală 33
Exercițiu (Formular) Contruiți un formular de introducere a datelor necesare realiză rii
unei adrese de e-mail. Data nașterii va fi selectată direct uti lizând MonthCalendar.
• ListView este folosit pentru a afișa o colecție de elemente în unul din cele 4 moduri
(Text, Text+Imagini mici, Imagini mari, Detalii ). Acesta este similar grafic cu
ferestrele în care se afișează fișierele dintr-un anumit direct or din Windows Explorer.
Fiind un control complex, conține foarte multe proprietăți, pri ntre care:
View ( selectează modul de afișare (LargeIcon, SmallIcon, Details, L ist)),
LargeImageList, SmallImageList (icon-urile de afișat în modurile LargeIcon,
SmallIcon), Columns (utilizat doar în modul Details, pentru a defini coloanele de
afișat), Items( elementele de afișat).

Aplicația PV8 este un exemplu de utilizare
ListView . Se pornește de la rădăcină și se
afișează conținutul folder-ului selectat cu dublu
click. La expandare se afișează numele complet,
data ultimei accesări și, în cazul fișierelor, dimensiunea.
Controlul lista_fisiere este de tip ListView .
Funcția
ConstruiesteHeader permite
stabilirea celor trei coloane de afișat.

private void ConstruiesteHeader()
{ ColumnHeader colHead;colHead = new ColumnHeader ();
colHead.Text = "Nume fisier" ;
this.lista_fisiere.Columns.Add(colHead);
colHead = new ColumnHeader ();colHead.Text = "Dimensiune" ;
his.lista_fisiere.Columns.Add(colHead);
colHead = new ColumnHeader ();colHead.Text = "Ultima accesare" ;
this.lista_fisiere.Columns.Add(colHead);
}
Pentru item-ul selectat se afișează mai întâi folderele și după aceea fișierele. Pentru aceasta
trebuie să determinăm conținutul acestuia:
ListViewItem lvi;
ListViewItem .ListViewSubItem lvsi;
this.calea_curenta.Text = radacina + "(Doublu Click pe folder)" ;
System.IO. DirectoryInfo dir = new System.IO. DirectoryInfo (radacina);
DirectoryInfo [] dirs = dir.GetDirectories();
FileInfo [] files = dir.GetFiles();
să ștergem vechiul conținut al listei:
this.lista_fisiere.Items.Clear();
this.lista_fisiere.BeginUpdate();
și să adăugăm fiecare nou item ( coloana a doua este vidă în ca zul foldere-lor):
foreach (System.IO. DirectoryInfo fi in dirs)
{ lvi = new ListViewItem ();lvi.Text = fi.Name;
lvi.ImageIndex = 1; lvi.Tag = fi.FullName;
lvsi = new ListViewItem .ListViewSubItem ();
lvsi.Text = "";lvi.SubItems.Add(lvsi);
lvsi = new ListViewItem .ListViewSubItem ();
lvsi.Text = fi.LastAccessTime.ToString(); lvi.SubItems.Add(lvsi); this.lista_fisiere.Items.Add(lvi);
}

Exercițiu (Ordonare) Modificați aplicația anterioară astfel încât apăsarea pe numele
unei coloane să determine afișarea informațiilor ordonate după criteriul specificat (nume,
dimensiune, data).
• Controale ”de control” al executării ( Timer ) sau de dialog ( OpenFileDialog ,
SaveFileDialog , ColorDialog , FontDialog, ContextMenu ).

34 POO și Programare vi zuală (suport de curs)
• Grupuri de controale Toolbar (ToolStrip ) afișează o bară de butoane în partea de sus a
unui formular. Se pot introduce vizual butoane (printr-un desig ner, direct din Visual
Studio.NET IDE), la care se pot seta atât textul afișat sau ima ginea. Evenimentul cel mai
util al acestui control este ButtonClick (care are ca parametru un obiect de tip
ToolBarButtonClickEventArgs , prin care programatorul are acces la butonul care a fost
apasat).
În aplicația următoare PV9 cele 3 butoane ale
toolbar-ului permit modificarea proprietăților textului introdus în casetă. Toolbar-ul se poate muta fără a depăși
spațiul ferestrei. Schimbarea fontului se realizează cu
ajutorul unui control FontDialog(),iar schimbarea culorii utilizează ColorDialog()
FontDialog fd = new FontDialog ();
fd.ShowColor = true;fd.Color = Color.IndianRed;
fd.ShowApply = true;
fd.Apply += new EventHandler (ApplyFont);
if(fd.ShowDialog() !=
System.Windows.Forms. DialogResult .Cancel)
{ this.richTextBox1.Font= fd.Font;
this .richTextBox1.ForeColor=fd.Color;
} ColorDialog cd = new ColorDialog ();
cd.AllowFullOpen = true;cd.Color = Color.DarkBlue;
if(cd.ShowDialog() == System.Windows.Forms. DialogResult .OK)
this.richTextBox1.ForeColor = cd.Color;
Mutarea toolbar-ul este dirijată de evenimentele produse atunci când apăsăm butonul de
mouse și/sau ne deplasăm pe suprafața ferestrei.
private void toolBar1_MouseDown( object sender, MouseEventArgs e)
{ // am apasat butonul de mouse pe toolbar
am_apasat = true;
forma_deplasata = new Point(e.X, e.Y); toolBar1.Capture = true;}
private void toolBar1_MouseUp( object sender, MouseEventArgs e)
{ am_apasat = false;toolBar1.Capture = false;}
private void toolBar1_MouseMove( object sender, MouseEventArgs e)
{ if (am_apasat)
{ if(toolBar1.Dock == DockStyle .Top || toolBar1.Dock == DockStyle .Left)
{ // daca depaseste atunci duc in stanga sus
if (forma_deplasata.X < (e.X-20) || forma_deplasata.Y < (e.Y-20))
{ am_apasat = false;// Disconect toolbar
toolBar1.Dock = DockStyle .None;
toolBar1.Location = new Point(10, 10);
toolBar1.Size = new Size(200, 45);
toolBar1.BorderStyle = BorderStyle .FixedSingle;
}
}
else if (toolBar1.Dock == DockStyle .None)
{toolBar1.Left = e.X + toolBar1.Left – forma_deplasata.X; toolBar1.Top = e.Y + toolBar1.Top – forma_deplasata.Y; if (toolBar1.Top < 5 || toolBar1.Top> this.Size.Height-20)
{ am_apasat = false;toolBar1.Dock = DockStyle .Top;
toolBar1.BorderStyle = BorderStyle .Fixed3D;}
else if (toolBar1.Left < 5 || toolBar1.Left > this.Size.Width – 20)
{ am_apasat = false; toolBar1.Dock = DockStyle .Left;
toolBar1.BorderStyle = BorderStyle .Fixed3D;
}}}
}
Exercițiu (Editor) Realizați un editor de texte care conțină un control toolBar cu butoanele
uzuale.

Programare vizuală 35
• Controale container (GroupBox, Panel, TabControl ) sunt controale ce pot conține alte
controale.
Aplicația PV10 simulează lansarea unei
comenzi către un magazin de jucării. Se utilizează 4
pagini de Tab pentru a simula selectarea unor opțiuni ce se pot grupa pe categorii.
Exercițiu (Magazin)
Dezvoltați aplicația
precedentă astfel încât pe o pagină să se afișeze modelele disponibile (imagine+detalii) și să se
permită selectarea mai multor obiecte. Ultima pagină
reprezintă coșul de cumpărături.
• Grupuri de controale tip Meniu (MenuStrip, ContextMenuStrip etc. )
Un formular poate afișa un singur meniu principal la un moment dat, meniul asociat
inițial fiind specificat prin propietatea Form.MainMenuStrip . Meniul care este afișat de către
un formular poate fi schimbat dinamic la rulare :
switch(cond) { case cond1:this.MainMenuStrip = this.mainMenu1;break;
case cond2:this.MainMenuStrip = this.mainMenu2;
}
unde mainMenu1 și mainMenu2 sunt obiecte de tip MenuStrip . Editarea unui astfel de
obiect se poate face utilizând Menu Designer . Clasa MenuStrip are o colecție de MenuItem
care conține 0 sau mai multe obiecte de tip MenuItem . Fiecare dintre aceste obiecte de tip
MenuItem are 0 sau mai multe obiecte de tip MenuItem, care vor constitui noul nivel de itemi
(Ex: File ÆNew,Save, Open, Close, Exit).
Propietățile Checked s i RadioCheck indică itemul selectat, Enabled and Visible
determină dacă un item poate fi sau nu selectat sau vizibil, Shortcut permite asignarea unei
combinații de taste pentru selectarea unui item al meniului și Text memorează textul care va
fi afișat pentru respectivul item al meniului.
Evenimentul Click are loc când un utilizator apasă un item al meniului.
Exemplul PV11 permite, prin
intermediul unui meniu, scrierea unui fisier Notpad, afișarea continutului acestuia într-o casetă text, schimbarea fontului și culorii de afișare, ștergerea conținutului casetei,
afișarea unor informații teoretice precum și
Help dinamic. Au fost definite chei de acces rapid pentru accesarea componentelor meniului. FileÆ New permite scrierea unui fișier notepad nou
System.Diagnostics. Process .Start( "notepad" );
FileÆ Open selectează și afișează în caseta text conținutul unui fișier text.
OpenFileDialog of = new OpenFileDialog ();
of.Filter = "Text Files (*.txt)|*.txt" ;
of.Title = "Fisiere Text" ;
if (of.ShowDialog() == DialogResult .Cancel) return ;
richTextBox1.Text= "";richTextBox1.Visible= true;
FileStream strm;
try{strm = new FileStream (of.FileName, FileMode .Open, FileAccess .Read);
StreamReader rdr = new StreamReader (strm);
while (rdr.Peek() >= 0){ string str = rdr.ReadLine ();
richTextBox1.Text=richTextBox1.Text+ " "+str;}
} catch (Exception ){MessageBox .Show ( "Error opening file" , "File Error" ,
MessageBoxButtons .OK, MessageBoxIcon .Exclamation);}
FileÆ Close șterge conținutul casetei text, File Æ Exit închide aplicația

36 POO și Programare vi zuală (suport de curs)
Window Æ Font și Window ÆColor permit stabilirea fontului/culorii textului afișat.
HelpÆ DinamicHelp accesează System.Diagnostics. Process .Start( "IExplore" ,
"http://msdn2.microsoft.com/en-us/default.aspx" );
HelpÆ About PV afișează în caseta text informații despre implementar ea unui menu.
Exercițiu (Fisiere) Contruiți un menu care să permită efectuarea operațiilor uzuale cu fișiere.
4.5. System.Drawing
Spațiul System.Drawing conține tipuri care permit realizarea unor desene 2D și au
rol deosebit în proiectarea interfețelor grafice.
Un obiect de tip Point este reprezentat prin coordonatele unui punct într-un spațiul
bidimensional (exemplu: Point myPoint = new Point(1,2);)
Point este utilizat frecvent nu numai pentru desene, ci și pen tru a identifica în program
un punct dintr-un anumit spațiu. De exemplu, pentru a modifica poziția unui buton în
fereastră putem asigna un obiect de tip Point proprietății Location indicând astfel poziția
colțului din stânga-sus al butonului ( button.Location = new Point(100, 30) ). Putem
construi un obiect de tip Point pentru a redimensiona un alt obiect.
Size mySize = new Size(15, 100);
Point myPoint = new Point(mySize);
System.Console.WriteLine( "X: " + myPoint.X + ", Y: " + myPoint.Y);
Structura Color conține date, tipuri și metode utile în lucrul cu culori. Fiin d un tip
valoare ( struct ) și nu o clasă, aceasta conține date și metode, însă nu permit e instanțiere,
constructori, destructor, moștenire.
Color myColor = Color.Brown; button1.BackColor = myColor;
Substructura FromArgb a structurii Color returnează o culoare pe baza celor trei
componente ale oricărei culori (red, green, blue).
Clasa Graphics este o clasă sigilată reprezentând o arie rectangulară care p ermite
reprezentări grafice. De exemplu, o linie frântă se poate reali za astfel:
Point[] points = new Point[4];
points[0] = new Point(0, 0);points[1] = new Point(0, 120);
points[2] = new Point(20, 120);points[3] = new Point(20, 0);
Graphics g = this.CreateGraphics();
Pen pen = new Pen(Color.Yellow, 2);
g.DrawLines(pen, points);

Aplicația PV12 este un exercițiu care desenează cercuri de raze și
culori aleatoare și emite sunete cu frecvență aleatoare.
Random x = new Random ();
Console .Beep(300 + x.Next(1000), 150);
Graphics g = e.Graphics;
i = 1 + x.Next(30);
p=new Pen(System.Drawing. Color.FromArgb(x.Next(256),x.Next(256),x.Next(256)))
g.DrawEllipse(p, x.Next(100), x.Next(100), i, i); Console.Sleep(200);
În exemplul PV13 se construiește o pictogramă pe baza unei imagini.
Image thumbnail;
private void Thumbnails_Load( object sender, EventArgs e)
{ try{Image img = Image.FromFile( "C:\\Imagini\\catel.jpg" );
int latime=100, inaltime=100;
thumbnail=img.GetThumbnailImage(latime, inaltime, null,
IntPtr .Zero);}
catch{MessageBox .Show( "Nu exista fisierul" );}
} private void Thumbnails_Paint( object sender, PaintEventArgs e)
{e.Graphics.DrawImage(thumbnail, 10, 10);}

Programare vizuală 37
4.6. Validarea informațiilor de la utilizator
Înainte ca informațiile de la utilizator să fie preluate și tra nsmise către alte clase, este
necesar să fie validate. Acest aspect este important, pentru a preveni posibilele erori. Astfel,
dacă utilizatorul introduce o valoare reală ( float) când aplicația așteaptă un întreg ( int), este
posibil ca aceasta să se comporte neprevăzut abia câteva secund e mai târziu, și după multe
apeluri de metode, fiind foarte greu de identificat cauza prima ră a problemei.
Validarea la nivel de câmp
Datele pot fi validate pe măsură ce sunt introduse, asociind o prelucrare unuia dintre
handlerele asociate evenimentelor la nivel de control ( Leave , Textchanged , MouseUp etc.)
private void textBox1_KeyUp( object sender,
System.Windows.Forms.KeeyEventArgs e) {if(e.Alt== true) MessageBox.Show ( "Tasta Alt e apasata" ); // sau
if(Char.IsDigit(e.KeyChar)== true) MessageBox.Show( "Ati apasat o cifra" );
}
Validarea la nivel de utilizator
În unele situații (de exemplu atunci când valorile introduse tr ebuie să se afle într-o
anumită relație între ele), validarea se face la sfârșitul intr oducerii tuturor datelor la nivelul
unui buton final sau la închiderea ferestrei de date.
private void btnValidate_Click( object sender, System.EventArgs e)
{ foreach (System.Windows.Forms.Control a in this.Controls)
{ if( a is System.Windows.Forms.TextBox & a.Text== "")
{ a.Focus(); return ;}
} }
ErrorProvider
O manieră simplă de a semnala erori de validare este aceea de a seta un mesaj de
eroare pentru fiecare control .
myErrorProvider.SetError(txtName, " Numele nu are spatii in stanga" );
Aplicatii recapitulative.
Urmăriți aplicațiile și precizați pentru fiecare dintre ele con troalele utilizate,
evenimentele tratate: Forma poloneza (PV14), Triunghi (PV15), O rdonare vector(PV16),
Subsir crescător de lungime max imă(PV17), Jocul de Nim (PV18)
Exercițiu (Test grila) Realizați un generator de teste grilă (întrebările sunt preluat e
dintr-un fisier text, pentru fiecare item se precizează punctaj ul, enunțul, răspunsul corect,
distractorii și o imagine asociată enunțului (dacă există). Dup ă efectuarea testului se
afișează rezultatul obținut și statistica răspunsurilor.

38 POO și Programare vi zuală (suport de curs)
5. Aplicații orientate pe date
5.1. Structuri de date
Construirea unei aplicații ce gestionează un volum mare de date necesită o atenție
particulară privind organizarea acestor date. Sursele de date t rebuie și ele integrate
corespunzător într-o aplicație OOP. Faptul că o stivă din clasa Stack este implementată ca
vector sau nu, este de mică importanță pentru programatorul pe platformă .NET. Dar pentru
operațiile executate de o aplicație ce monitorizează traficul d intr-o gară de triaj, este
important de știut dacă trebuie memorat sau nu un istoric al ac estor operații, dacă sunt
folosite informațiile de acest tip în prelucrări ulterioare sau sunt doar listate sub formă de
rapoarte periodice, etc. Dacă datele trebuie exportate către al te aplicații, atunci se pune
problema formatului în care vor fi salvate. Pentru colecțiile c onsistente de date care suferă
prelucrări ample și frecvente se pune problema suportului de me morare astfel încât să
suporte tehnici de acces rapide etc.
5.2. Colecții de date
Colecția, în general, reprezintă un ansamblu bine structurat de componente de același
tip, ansamblu ce permite identificarea rapidă a oricărei compon ente din colecție. Definiția
este aplicabilă și colecțiilor de date. Uneori, cloecțiile de d ate sunt percepute ca date externe
(aflate pe harddisc sau alte suporturi de memorare), dar asta n u exclude posibilitatea
organizării datelor interne sub forma unor colecții. În C#, colecțiile sunt clase special izate
aparținând spațiului System.Collection. Despre colecții am mai vorbit în cadrul capitolului 3.11.
Aducem unele completări în cele ce urmează vorbind despre structuri generice de date .
Atributul ”generic” se referă la proprietatea de a referi o înt reagă categorie de obiecte.
Clasele, structurile, metodele, interfețele, delegații și metod ele pot fi generice, adică pot fi
concepute astfel încât să depindă de unul sau mai multe tipuri de date pe care acestea le
memorează sau manipulează.
De exemplu, la declararea unei clase obișnuite, noi stabilim el ementele fixe ale
acesteia: numele și tipurile datelor, numele metodelor33 și altor componente ce formează
clasa respectivă. Pentru o funcție (metodă) obișnuită sunt defi nite atât numele, cât și tipul
parametrilor funcției34.
C# introduce, începând de la versiunea 2.0, parametrizarea tipu rilor, adică posibilitatea
declarării unor clase, metode etc. în care tipul datelor manevr ate nu este cunoscut decât la
apel. Acest tip de date constituie un parametru al clasei, meto dei etc.
Vom defini în mod obișnuit și, paralel, în mod generic clasa St iva (amintită și în
capitolul 1.1) pentru a pune în evidență diferențele induse de modul de lucru … generic:
class Stiva
{
int[] st = new int[10]; int vf;
public Stiva() { vf = -1; } public void Push(int x)
{ st[++vf] = x; }
public int Pop() { return st[vf–]; }
35
public void scrie() {for (int i = 0; i <= vf; i++)
Console.Write(st[i]);
Console.WriteLine();
}
} class Stiva<T>
{
T[] st = new T[10]; int vf;
public Stiva() { vf = -1; } public void Push(T x)
{ st[++vf] = x; }
public T Pop()
35
{ return st[vf–]; } public void scrie() {for (int i = 0; i <= vf; i++)
Console.Write(st[i]);
Console.WriteLine();
}
}

33 A nu se confunda capacitatea de a defini mai multe metode cu a celași nume cu faptul că
numele este bine determinat. A spune că numele nu este definit ar presupune un fel de declarare cu
numele … și abia la apel să se stabilească ce nume este scris în loc de … ☺
34 Numărul parametrilor este și el bine definit, deși funcțiile c are au definit un parametru de tip
tablou, permit apelul cu un număr variabil de parametri efectiv i.
35 Versiuni mai vechi de C nu execu tă conform așteptărilor returu l valorii cu pos tincrementare.

Aplicații orientate pe date 39
…
static void Main(string[] args)
{ Stiva s = new Stiva(); s.Push(7);s.Push(5); s.scrie(); Console.WriteLine(„Ex{0},s.Pop());
s.scrie();
s.Push(7); s.scrie(); Console.WriteLine("Ex{0}",s.Pop()); s.scrie(); } …
static void Main(string[] args)
{ Stiva<int> s = new Stiva<int>(); s.Push(7); s.Push(5); s.scrie(); Console.WriteLine("Ex{0}",s.Pop());
s.scrie();
s.Push(7); s.scrie(); Console.WriteLine("Ex{0}",s.Pop()); s.scrie(); }
Dintre clasele generice ”predefinite”, cele mai des utilizate s unt colecțiile generice.
Astfel, clasele și interfețele din spațiul System.Collection.Generic permit organizarea
datelor proprii, indiferent de tipul acestora, în structuri spe cifice cum ar fi: liste ( List), liste
dublu înlănțuite ( LinkedList ), stive ( Stack ), cozi ( Queue ), dicționare ( Dictionary ) etc.
De exemplu, dorim să gestionăm un ansamblu de ferestre asemănăt oare, instanțiate
dintr-o aceeași clasă MyForm (să zicem) derivată din System.Windows.Forms.Form .
Putem memora în program sau ca element static al clasei MyForm o structură de tip listă:
List<MyForm> fer=new List<MyForm>()
La crearea oricărei ferestre f de tipul MyForm ( MyForm f=new MyForm(); f.Show(); )
se adaugă referința ferestrei în lista fer (fer.Add(f) ). Analog, la închiderea ferestrei, se va
elimina referința acesteia din listă ( fer.Remove(f) ).
Exercițiu: Presupunem că implementăm o aplicație în care se completează d atele
unui pacient într-o fereastră. Pentru a nu încărca ferestra cur entă, aceasta este proiectată să
conțină butoane ce permit deschiderea unor ferestre secundare p entru completarea unor
subcategorii de date (istoricul suferințelor cronice, analize e fectuate, adresa detaliată etc.).
De exemplu, în fereastră se completează numele pacientului, iar apoi, apăsând pe butonul
Adresa, se deschide o fereastră ce permite completarea câmpuril or ce formează adresa, la
închiderea ferestrei revenind la fereastra principală. Desigur, și o fereastră secundară poate
avea la rândul ei butoane pentru alte ferestre secundare în rap ort cu aceasta. Stabiliți ce tip
de structură generică se poate utiliza pentru gestiunea ferestr elor deschise la un moment
dat36.
5.3. ADO.NET
ADO.NET ( ActiveX Data Objects ) reprezintă o parte componentă a nucleului .NET
Framework ce permite accesarea și manipularea datelor. Amintim că o sursă de date poate
fi: un fișier text, un fișier Excel sau XML, o bază de date Dba se, Access, SQL etc. Lucrul cu o
sursă de date se poate face fie conectat, fie deconectat de la sursa de date. ADO.NET
implementează clase ce oferă servicii atât pentru lucrul în sti l deconectat cât și conectat,
oferă instrumentele de utilizare și reprezentare XML, de combin are a datelor din diferite
surse și de diferite tipuri (pe bază mecanismenlor de reprezent are comună implementate de
.NET. Maniera de lucru deconectată recomandă metoda ca fiind ma i eficientă în proiectarea
aplicațiilor pentru Internet decât alte tehnologii cum ar fi AD O sau ODBC.
Deoarece există mai multe tipuri de baze de date e nevoie de câ t e o b i b l i o t e c ă
specializată de clase și interfețe care să implementeze un ”pro tocol” specific pentru fiecare.
5.4. Conectarea la o sursă de date
Înainte de orice operație cu o sursă de date externă, trebuie r ealizată o conexiune
(legătură) cu acea sursă. Clasele din categoria Connection ( SQLConnection ,
OleDbConnection etc.) conțin date referitoare la sursa de date (locația, numel e și parola
contului de acces, etc.), metode pentru deschiderea/închiderea conexiunii, pornirea unei
tranzacții etc. Aceste clase se găsesc în subspații ( SqlClient , OleDb e t c . ) a l e s p a ț i u l u i
System.Data . În plus, ele implementează interfața IDbConnection .

36 punem accentul pe faptul că ferestrele sunt modale

40 POO și Programare vi zuală (suport de curs)
Pentru deschiderea unei conexiuni prin program se poate instanț ia un obiect de tip
conexiune, precizându-i ca parametru un șir de caractere conțin ând date despre conexiune.
Dăm două exemple de conectare la o sursă de date SQL respectiv Access:
using System.Data.SqlClient;
… SqlConnection co = new SqlConnection(@"Data Source=serverBD; Database=scoala;User ID=elev;Password=madonna");
co.Open();
… using System.Data.OleDb; … OleDbConnection con =
new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;
Data Source=C:\Date\scoala.mdb"); cn.Open(); …
Proprietățile unei conexiuni
ConnectionString (String): conține un string cu o succesiune de parametri de fo rma
parametru=valoare, despărțiți prin ;. Parametrii pot fi:
• provider : specifică furnizorul de date pentru conectarea la sursa de da te. Acest furnizor
trebuie precizat doar dacă se folosește OLE DB .NET Data Provid er, și nu se specifică
pentru conectare la SQL Server
• Data Source : se specifică numele serverului de baze de date sau numele fiș ierului de date
• Initial Catalog (Database): specifică numele bazei de date. Baza de date trebu ie să se
găsească pe serverul dat în Data Source.
• User ID : specifica un nume de cont de utilizator care are acces de log are la server.
• Password : specifică parola contului de mai sus.
ConnectionTimeout (int): specifică numărul de secunde pentru ca re un obiect de
conexiune poate să aștepre pentru realizarea conectării la serv er înainte de a se genera o
excepție. (implicit 15). Se poate specifica o valoare diferită de 15 în ConnectionString
folosind parametrul Connect Timeout, Valoarea Timeout=0 specifi că așteptare nelimitată.
SqlConnection cn = new SqlConnection("Data Source=serverBD;
Database=scoala;User ID=elev;Password=madonna; Connect Timeout=30");
Database (string): returnează numele bazei de date la care s–a făcut co nectarea. Este
necesară pentru a arăta unui utilizator care este baza de date pe care se face operarea
Provider (string): returnează furnizorul
ServerVersion (string): returnează versiunea de server la care s–a făcut con ectarea.
State (enumerare de componente ConnectionState ): returnează starea curentă a conexiunii.
Valorile posibile: Broken , Closed , Connecting , Executing , Fetching , Open .
Metodele unei conexiuni
Open() : deschide o conexiune la baza de date
Close() și Dispose() : închid conexiunea și eliberează toate resursele alocate pentr u ea
BeginTransaction() : pentru executarea unei tranzacții pe baza de date; la sfârșit s e
apelează Commit() sau Rollback() .
ChangeDatabase() : se modifică baza de date la care se vor face conexiunile. Nou a bază
de date trebuie să existe pe același server ca și precedenta.
CreateCommand() : creează o comandă (un obiect de tip Command ) validă asociată
conexiunii curente.
Evenimentele unei conexiuni
StateChange : apare atunci când se schimbă s tarea conexiunii. Handlerul cor espunzător (de
tipul delegat StateChangeEventHandler ) spune între ce stări s-a făcut tranziția.
InfoMessage : apare când furnizorul trimite un avertisment sau un mesaj căt re client.

Aplicații orientate pe date 41
5.5. Executarea unei comenzi SQL
Clasele din categoria Command ( SQLCommand , OleDbCommand e t c . ) c o n ț i n d a t e
referitoare la o comandă SQL (SELECT, INSERT, DELETE, UPDATE) ș i metode pentru
executarea unei comenzi sau a unor proceduri stocate. Aceste cl ase implementează
interfața IDbCommand . Ca urmare a interogării unei baze de date se obțin obiecte di n
categoriile DataReader sau DataSet . O comandă se poate executa numai după ce s-a
stabilit o conxiune cu baza de date corespunzătoare.
SqlConnection co = new SqlConnection(@"Data Source=serverBD;
Database=scoala;User ID=elev;Password=madonna");
co.Open();
SqlCommand cmd = new SqlCommand("SELECT * FROM ELEVI", con);
Proprietățile unei comenzi
CommandText (String): conține comanda SQL sau numele procedurii stocate ca re se
execută pe sursa de date.
CommandTimeout (int): reprezintă numărul de secunde care trebuie să fie aștep tat pentru
executarea comenzii. Dacă se depășeste acest timp, atunci se ge nerează o excepție.
CommandType (enumerare de componente de tip CommandType ): reprezintă tipul de
comandă care se execută pe sursa de date. Valorile pot fi: Stor edProcedure (apel de
procedură stocată), Text (comandă SQL obișnuită), TableDirect ( numai pentru OleDb)
Connection (System. Data. [Provider].PrefixConnection): conține obiectul de tip conexiune
folosit pentru legarea la sursa de date.
Parameters (System.Data.[Provider].PrefixParameterCollection): returnează o colecție de
parametri care s-au transmis comenzii;
Transaction (System.Data.[Provider].PrefixTransaction): permite accesul la obiectul de tip
tranzacție care se cere a fi executat pe sursa de date.
Metodele unei comenzi
Constructori: SqlCommand() sau SqlCommand(string CommandText) sau
SqlCommand(string CommandText, SqlConnection con ) sau
SqlCommand(string CommandText,SqlConnection con,SqlTransaction trans)
Cancel() oprește o comandă aflată în executare.
Dispose() distruge obiectul comandă.
ExecuteNonQuery() execută o comandă care nu returnează un set de date din baza de
date; dacă comanda a fost de tip INSERT, UPDATE, DELETE, se ret urnează numărul de
înregistrări afectate.
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "DELETE FROM elevi WHERE nume = ’BARBU’";
cmd.Connection = con;
Console.WriteLine(cmd.ExecuteNonQuery().ToString()); //câte înreg.s-au șters
ExecuteReader() execută comanda și returnează un obiect de tip DataReader
SqlCommand cmd = new SqlCommand("SELECT * FROM elevi",con);
SqlDataReader reader = cmd.ExecuteReader(); while(reader.Read()) { Console.WriteLine("{0} – {1}",
reader.GetString(0),reader.GetString(1));
} reader.Close();
Metoda ExecuteReader() mai are un argument opțional, CommandBehavior care descrie
rezultatele și efectul asupra bazei de date: CloseConnection (conexiunea este închisă atunci
când obiectul DataReader este închis), KeyInfo (returneză informație despre coloane și cheia
primară), SchemaOnly (returneză doar informație despre coloane), SequentialAccess (pentru
manevrarea valorilor binare cu GetChars() sau GetBytes()), SingleResult (se returnează un
singur set de rezultate), SingleRow (se returnează o singură li nie).

42 POO și Programare vi zuală (suport de curs)
ExecuteScalar() execută comanda și returnează valoarea primei coloane de pe p rimul
rând a setului de date rezultat; folosit pentru obținerea unor rezultate statistice
SqlCommand cmd = new SqlCommand("SELECT COUNT(*) FROM elevi",con);
SqlDataReader reader = cmd.ExecuteScalar(); Console.WriteLine(reader.GetString(0));
ExecuteXmlReader() returnează un obiect de tipul XmlReader obținut prin interoga re
SqlCommand CMD=
new SqlCommand("SELECT * FROM elevi FOR XML MATE,EXAMEN", con); System.Xml.XmlReader myXR = CMD.ExecuteXmlReader();
5.6. Seturi de date
Datele pot fi explorate în mod conectat (cu ajutorul unor obiec te din categoria
DataReader ), sau pot fi preluate de la sursă (dintr-un obiect din categor ia DataAdapter ) și
înglobate în aplicația curentă (sub forma unui obiect din categ oria DataSet ).
Clasele DataReader permit parcurgerea într-un singur sens a sursei de date, fără
posibilitate de modificare a datelor la sursă. Dacă se dorește modificarea datelor la sursă, se
va utiliza ansamblul DataAdapter + DataSet .
Un obiect DeatReader nu are constructor, ci se obține cu ajutorul unui obiect de ti p
Command și prin apelul metodei ExecuteReader() (vezi exemplul de la pa gina 41, jos).
Evident, pe toată durata lucrului cu un obiect de tip DataReader , conexiunea trebuie să fie
activă. Toate clasele DataReader (SqlDataReader , OleDbDataReader etc.) implementează
interfața IDataReader .
Proprietăți :
IsClosed , HasRows , Item (indexator de câmpuri) și FieldCount
Metode :
Close() închidere obiectului și eliberarea resurselor; trebuie să prec eadă închiderea conxiunii
GetBoolean() , GetByte() , GetChar() , GetDateTime() , GetDecimal() ,
GetDouble() , GetFloat() , GetInt16() , GetInt32() , GetInt64() , GetValue() ,
GetString() returnează valoarea unui câmp specificat, din înergistrarea cu rentă
GetBytes() , GetChars() citirea unor octeți/caractere dintr–un câmp de date binar
GetDataTypeName() , GetName() returnează tipul/numele câmpului specificat
IsDBNull() returnează true dacă în câmpul specificat prin index este o va loare NULL
NextResult() determină trecerea la următorul rezultat stocat în obiect (vezi exemplul)
Read() determină trecerea la următoarea înregistrare, returnând false numai dacă aceasta
nu există; de reținut că inițial poziția curentă este înaintea primei întrgistrări.
SqlCommand cmd=new SqlCommand("select * from elevi;select * from profi", conn );
conn.Open ();
SqlDataReader reader = cmd.ExecuteReader ();
do { while ( reader.Read () ) {Console.WriteLine ( "{0}\t\t{1}", reader[0], reader[1] );} } while ( reader.NextResult () );
Folosirea combinată a obiectelor DataAdapter și DataSet permite operații de selectare,
ștergere, modificare și adăugare la baza de date. Clasele DataAdapter generează obiecte
care funcționează ca o interfață între sursa de date și obiecte le DataSet interne aplicației,
permițând prelucrări pe baza de date. Ele gestionează automat c onexiunea cu baza de date
astfel încât conexiunea să se facă numai atunci când este imper ios necesar.
Un obiect DataSet este de fapt un set de tabele relaționate. Folosește serviciil e unui
obiect DataAdapter pentru a-și procura datele și trimite modificările înapoi cătr e baza de date.
Datele sunt stocate de un DataSet în format XML, același folosit și pentru transferul datelor.
În exemplul următor se preiau datele din tablele elevi și profi :
SqlDataAdapter de=new SqlDataAdapter("SELECT nume,clasa FROM elevi, conn);
de.Fill(ds,"Elevi"); //transferă datele în datasetul ds sub forma unei tabele locale numite elevi
SqlDataAdapter dp=new SqlDataAdapter("SELECT nume, clasdir FROM profi,conn);
dp.Fill(ds,"Profi"); //transferă datele în datasetul ds sub forma unei tabele locale numite profi

Aplicații orientate pe date 43
Proprietățile unui DataAdapter
DeleteCommand, InsertCommand , SelectCommand , UpdateCommand (Command),
conțin comenzile ce se execută pentru selectarea sau modificare a datelor în sursa de date.
MissingSchemaAction (enumerare) determină ce se face atunci când datele aduse nu s e
potrivesc peste schema tablei în care sunt depuse. Poate avea u rmătoarele valori:
• Add – implicit, DataAdapter adaugă coloana la schema tablei
• AddWithKey – se adugă coloana și informații relativ la cheia primară
• Ignore – se ignoră lipsa coloanei respective, ceea ce duce la pierder e de date
• Error – se generează o excepție de tipul InvalidOperationException .
Metodele unui DataAdapter
Constructoril: SqlDataAdapter(); sau SqlDataAdapter(obiect_comanda); sau
SqlDataAdapter(string_comanda, conexiune);
Fill() permite umplerea unei tabele dintr–un obiect DataSet cu date. Permite specificarea
obiectului DataSet în care se depun datele, eventual a numelui tablei din acest DataSet ,
numărul de înregistrare cu care să se înceapă popularea (prima având indicele 0) și numărul
de înregistrări care urmează a fi aduse.
Update() permite transmiterea modificărilor efectuate într–un DataSet către baza de date.
Structura unui DataSet
Un DataSet este format din Tables (colecție formată din obiecte de tip DataTable ; DataTable
este compus la rândul lui dintr-o colecție de DataRow și DataColumn ), Relations (colecție de
obiecte de tip DataRelation pentru memorarea legăturilor părinte–copil) și ExtendedProperties
ce conține proprietăți definite de utilizator. Scenariul uzual de lucru cu datele dintr-o tabelă conține următ oarele etape:
• popularea succesivă a unui DataSet prin intermediul unuia sau mai multor obiecte
DataAdapter , apelând metoda Fill (vezi exemplul de mai sus)
• procesarea datelor din DataSet folosind numele tabelelor stabilite la umplere,
ds.Tables["elevi"] , sau indexarea acestora, ds.Tables[0] , ds.Tables[1]
• actualizarea datelor prin obiecte comandă corespunzătoare ope rațiilor INSERT,
UPDATE și DELETE. Un obiect CommandBuilder poate construi automat o
combinație de comenzi ce reflectă modificările efectuate.
5.7. Proiectarea vizual ă a seturilor de date
Mediul de dezvoltare Visual Studio dispune de instrumente puter nice și sugestive
pentru utilizarea bazelor de date în aplicații. Conceptual, în spatele unei ferestre în care
lucrăm cu date preluate dintr-una sau mai mlte tabele ale unei baze de date se află obiectele
din categoriile Connection , Command , DataAdapter ș i DataSet prezentate. ”La vedere” se
află controale de tip DataGridView , sau TableGridView , BindingNavigator etc.
Meniul Data și fereastra auxiliară Data Sources ne sunt foarte utile în lucrul cu surse de
date externe.
Să urmărim un scenariu de realizare a unei aplicații simple cu o
fereastră în care putem vizualiza date dintr-o tabelă, putem na viga,
putem modifica sau șterge înregistrări.
• Inițiem adăugarea unei surse de date ( Add New Source )
• Configurăm cu atenție (asistați de ”vrăjitor”) conexiunea cu o
sursă de tip SQL sau Access; figura surprinde elemente de
conectare la o bază de date Access, numită Authors, bază stocată pe harddiscul local.
• Selectăm tabelele care ne interesează din baza de date și
câmpurile din cadrul tabelei ce vor fi reținute în TableAdapter
(din categoria DataAdapter )
• Când operațiunea se încheie, date relative la baza de date la
care ne-am conectat sunt integrate în proiect și pictograma, c a
și structura bazei de date apar în fereastra Data Source

44 POO și Programare vi zuală (suport de curs)

• Prin "tragerea" unor obiecte din
fereastra Data Sources în ferea-
stra noastră nouă, se creează automat obiecte specifice. În partea de jos a figurii se pot observa obiectele de tip Dataset , TableAdapter , Binding-
Source , BindingNavigator și, în
fereastră, TableGridView
BindingNavigator este un tip ce permite, prin instanțiere, construirea barei de navigare ce permite
operații de deplasare, editare,
ștergere și adăugare în tabel.

Să observăm că reprezentarea vizuală a fiecărui obiect este înzestrată cu o săgetă în partea de sus, în dreapta. Un click pe această săgeată activează un meniu contextual cu lista
principalelor operații ce se pot efectua cu obiectul respectiv.
Meniul contextual asociat grilei în care vor fi vizualizate dat ele
permite configurarea modului de lucru cu grila (sursa de date, operațiile permise și altele).

În timpul rulării aplicației,
bara de navigare și elementele vizuale ale grilei permit operațiile de bază cu înregistrările bazei de date. Operațiile care modifică
baza de date trebuie să fie
definitivate prin salvarea noilor
date
.

Programarea Web
cu ASP .Net 2.0

CUPRINS
CUPRINS ……………………………………………….. ……………………………………………………… …………………….. 49
1. ARHITECTURI SOFTWARE ……………………………………. ………………………………………………… 51
1.1. MODELUL CLIENT – SERVER ……………………………………………………… ……………………………………. 51
1.2. MODELUL MULTI -STRAT ……………………………………………………… ……………………………………….. 52
1.3. APLICAȚII ORIENTATE SPRE SERVICII ……………………………………………………… ………………………. 54
2. PROTOCOALE DE REȚEA …………………………………….. ………………………………………………….. 57
2.1. MODELUL DE REFERINȚĂ TCP/IP………………………………………………… ………………………………… 57
2.2. PROTOCOLUL HTTP ………………………………………………….. ………………………………………………… 58
3. PROGRAMAREA CLIENT – SIDE……………………………….. ……………………………………………… 62
3.1. ELEMENTE AVANSATE DE HTML………………………………………………….. ………………………………. 62
3.1.1. Tabele………………………………………………… ……………………………………………………… ……… 62
3.1.2. Frames (cadre) în HTML………………………………….. …………………………………………………. 65
3.1.3. Formulare ……………………………………………… ……………………………………………………… ….. 68
3.2. XML …………………………………………………… ……………………………………………………… ……………. 72
3.3. CSS – CASCADING STYLE SHEETS (FOI DE STIL IN CASCADA ) ……………………………………………… 73
4. PROGRAMAREA SERVER – SIDE CU ASP.NET……………………… ………………………………… 76
4.1. SERVERUL IIS…………………………………………………… ……………………………………………………… … 76
4.2. CARACTERISTICI ALE ASP SI ASP .NET………………………………………………….. …………………….. 76
4.3. CREAREA DE APLICAȚII WEB FOLOSIND ASP.NET……………………………………………….. …………. 78
4.3.1. Configurarea masinii de lucru pentru proiecte ASP.NET………. …………………………………. 78
4.3.2. Proiectele ASP.NET in Vis ual Studio .NET cu C# …………….. …………………………………….. 78
4.3.3. Formulare în ASP.NET ……………………………………. ………………………………………………….. 79
4.3.4. Controale în ASP.NET ……………………………………. …………………………………………………… 80
4.3.5. Pastrarea in formatiilor …………………………………. …………………………………………………….. 8 1
4.3.6. Navigarea intre Forms cu pastrarea informatiilor …………… ……………………………………… 81
4.3.7. Securitatea în ASP.NET ………………………………….. …………………………………………………… 82
4.4. ADO.NET……………………………………………….. ……………………………………………………… ………… 83
4.4.1. Obiectele ADO.Net………………………………………. ……………………………………………………… 85
4.4.2. Configurare, mentenanta …………………………………. ………………………………………………….. 86
5. REFERINTE ……………………………………………… ……………………………………………………… ………… 88

Arhitecturi Software 51
1. Arhitecturi Software
Dezvoltarea de aplicatii / programe software implica mai multe etape, programarea
(scrierea de cod propriu-zisa) fiind doar una dintre ele si poa te să insemne doar aproximatv
25% din timpul total de dezvoltare. Etapele sunt:
• Analiza cerintelor • Proiectarea de nivel inalt (arhitectura)
• Proiectarea componentelor
• Implementarea • Testarea si validarea • Punerea in functiune • Intretinerea

Proiectarea la nivel inalt, sau stabilirea arhitecturii are o i mportanta deosebita in acest
proces, deoarece alegerile facute aici determina derularea viit oarelor etape, implicit limitele
intre care se va programa efectiv aplicatia. Arhitectura este u n model scris al unui sistem,
care poate fi utilizat la construirea sistemului propriu-zis, ș i este formata din:
• Definirea scopului sistemului.
• Modelul de date.
• Diagrame de flux de date.
• Fluxul interfetei cu utilizatorul.
Exista mai multe modele arhitecturale, dintre care putem aminti :
• Modelul client-server
• Multi-strat
Aplicatii orientate pe servicii

1.1. Modelul client- server
Termenul client-server este folosit prima data in 1980, legat d e calculatoarele dîntr-o
rețea. Arhitectura software client-server este o infrastructură modulară, bazată pe mesaje.
Un client este definit ca un solicitant de servicii, iar server ul ca un prestator de servicii. O
masină (un calculator) poate fi in același timp atât client cât și server în funcție de aplicațiile
rulate.
Precursoare ale modelului client-server au fost arhitecturile d e tip mainframe si file
sharing . Propozitia precedenta nu e prea corecta, pentru ca se refera strict la modul in care
erau utilizate calculatoarele in trecut.
Urmatoarele paragrafe nu prea au legatura cu modelul arhitectur al client-server, ci tot
cu modul in care erau utilizate calculatoarele. In plus, sunt s i niste erori in exprimare, cum ar
fi „Comunicarea între client și server se realizează prin inter mediul interogarilor SQL sau a
RPC (Remote Procedure Calls)”. Una este SQL si cu totul altceva este RPC – nu prea au
legatura.
În arhitectura mainframe aplicațiile rulau pe un computer princ ipal, iar utilizatorii
interacționau cu acesta prîntr-un terminal (blind terminal) car e trimitea informațiile tastate.
Limitarile acestui tip de arhitectură constau în faptul că nu a sigurau o interfată grafica cu
utilizatorul (GUI) si nu puteau accesa baze de date distribuite in diferite locații.
Rețelele de calculatoare inițiale se bazau pe arhitectura de ti p partajare de fisiere
(file-sharing) , în care serverul download-a fisiere (dîntr-o l ocație partajata) pe calculatorul
gazda. Aici se rulau aplicațiile (datele si procesarea lor). V iteza de lucru era scazută, iar
numarul maxim de utilizatori, car e accesa simultan resursele pa rtajate, era mic.
Ca urmare a limitărilor arhitecturii de tip file-sharing, a apa rut modelul client – server,
în care serverul de fisiere a fost inlocuit de un server de baz e de date. Prin utilizarea unui
sistem de gestiune a bazelor de date (SGBD) se raspundea in mod direct cererilor
utilizatorului. De asemenea se reduce traficul in retea prin re turnarea unui raspuns la o
interogare, față de returnarea unui întreg fisier. Apar si int erfatele grafice (GUI) pentru

52 Programare Web (suport de curs)
accesul la baza de date partajata (interfețe numite și front-en d). Comunicarea între client și
server se realizează prin intermediul interogarilor SQL sau a R PC (Remote Procedure Calls).

Mecanismul RPC a aparut cu mai bine de doua decenii in urma in lumea Unix si este
folosit in construcția de aplicații distribuite pe sisteme eter ogene, avand la baza tehnologiile
Internet. O aplicatie RPC va consta dintr-un client si un serve r, serverul fiind localizat pe
mașina care execută procedura. Aplicația client comunica prin r ețea – via TCP/IP – cu
procedura de pe calculatorul aflat la distanță, transmițând arg umentele și recepționând
rezultatele. Clientul și serverul se execută ca două procese se parate care pot rula pe
calculatoare diferite din rețea.
In loc de ultimele 4 paragrafe, as insista mai mult pe niste mo dele client-server foarte
cunoscute, cum ar fi:
• Windows Live Messenger. In acest caz, clientul este programul pe care il
avem instalat pe calculatorul personal cei care dorim să comuni cam prin
acest serviciu. Server-ul (in ac est caz programul server este i nstalat de fapt
mai multe masini) este programul „central” care:
o Are baza de date a utilizatorilor, adica a celor care au contu ri de
Windows Live.
o Primeste mesaje de la clienti si le „ruteaza”, adica le trimit e mai
departe catre clientul / clientii (in cazul unei conferinte) de stinatari.
o Tine evidenta sesiunilor clientilor, adica „stie” tot timpul c and cineva
este logged in, cu Live Messenger pornit, respectiv cand iese.
o Etc.
Solutiile de email, cum ar fi de exemplu serverul Exchange + Ou tlook.

1.2. Modelul multi-strat
Arhitecturile multi-strat sunt acelea in care fiecare strat log ic:
• Are un scop precis.
• Isi vede numai de propriile responsabilitati.
• Stie exact modul de comunicare / interactiune cu straturile ad iacente.

In astfel de arhitecturi, este usor de separat anumite function alitati care nu ar trebui
să depinda unele de altele. De exemplu, interfata cu utilizator ul, sau mai bine spus clasele /
paginile care formeaza aceasta interfata, nu trebuie să „stie” cum anume se realizeaza
accesul la baza de date. Cu alte cuvinte, in clasele / paginile in care se afiseaza informatii, Modelul
client-
serve r

Arhitecturi Software 53
nu este nevoie să avem cod care lucreaza cu baza de date. Astfe l, se realizeaza o separare
logica benefica pentru intelegerea mai usoara si intretinerea m ai eficienta a software-ului.
De exemplu, putem avea arhitecturi multi-strat pe 2 nivele (tw o tier architecture), in
care să spunem ca interfața cu utilizatorul este situată pe cal culatorul utilizatorului sub forma
unei aplicatii Windows (deci instalata pe calculator), iar sist emul de gestiune a bazelor de
date pe un calculator mai puternic (server) care deserveste mai multi clienti
O alta arhitectura pe 2 nivele poate fi o aplicatie web in care interfata propriu-zisa
(paginile, codul de afisare a informatiilor si de captare a dat elor introduse de utilizator) este
instalata pe un server, iar baza de date pe un alt server.
În arhitectura multi-strat pe 3 nivele (three tier architecture ) se introduce un nou strat
intre interfață și SGBD. Interfața cu utilizatorul , procesarea , stocarea si accesarea datelor
sunt module separate, care se pot situa pe platforme diferite. Acest model asigură o
flexibilitate sporita, fiecare modul putand fi modificat indepe ndent de celelalte. Spre exemplu
schimbarea sistemului de operare din Windows în Linux poate afe cta doar modulul de
interfață.
De obicei, interfața cu utilizatorul rulează pe un alt calculat or și folosește o interfață
grafica standard (GUI), procesarea logica poate consta din unul sau mai multe module care
ruleaza pe un server de aplicatii, iar SGBD-ul ruleaza pe un se rver de baze de date sau
mainframe. Stratul de mijloc poate fi format la randul lui din mai multe nivele, caz in care
arhitectura este numită multi strat cu n nivele (n-tier archite cture).

Cele 3 nivele sunt:

54 Programare Web (suport de curs)
• Nivelul de prezentare (presentation tier) sau interfața cu uti lizatorul:
prezentarea rezultatelor sistemului catre utilizator si preluar ea de informatii de
la utilizator
• Nivelul logic de procesare (logic tier / business logic tier/ transaction tier) :
funcționalitatea specifică aplicației.
Nivelul de date (data tier): Interactiunea cu suportul datelor (baze de date, fisiere,
servicii web, etc).

1.3. Aplicații orientate spre servicii
Pentru a discuta despre Arhitecturi Orientate pe Servicii (SOA) , ar trebui să plecam
mai intai de la definitia acestora. Din pacate nu exista o defi nitie universal acceptat pentru
SOA. Ceea ce se poate spune in schimb despre acest mode este ca prin intermediul lui se
incearca descrierea unor arhitecturi bazate pe servicii slab in terconectate care suporta
modelarea proceselor de business si a necesitatilor utilizatori lor. Resursele aflate într-o
„retea” sunt expuse ca servicii independente care pot fi accesa te fara cunostiinte apriori
despre ceea ce rezida in spatele lor: platforma, implementare, algoritmi, etc.
Aceste concepte generice sunt valabile fie ca se vorbeste despr e business-uri,
software sau alte tipuri de sisteme de tip consumator-producato r.
Dupa cum mentionam anterior, arhitecturile de tip SOA nu impun utilizare unei
anumite tehnologii [precum REST, RPC, DCOM, CORBA sau Servicii Web]. Conceptul cheie
care permite acest lucru este faptul ca serviciile sunt indepen dente, si pot fi apelate într-un
mod standardizat pentru a-si indeplini sarcinile pentru care au fost proiectate si
implementate, fara ca serviciul s ă fie nevoit să stie in preala bil nimic despre aplicatia care il
invoca, sau ca aplicatia care invoca serviciul să aibă nevoie s ă inteleaga mecanismele
interne prin care serviciul isi duce la bun sfarsit rolul pentr u care a fost definit.
Putem astfel incerca să definim SOA ca fiind: o paradigma pentr u organizarea si
utilizarea capabilitatilor distribuite care pot să fie sub cont rolul unor entitati diferite. Aceasta
paradigma ofera o modalitate uniforma de descoperire si interac tioanre.
Conceptul de baza al SOA este aceala de interconectare slaba, r ealizat prin
constrangeri arhitecturale precum:
– Fiecare serviciu ofera un set de interfete simple si care ofera doar o semantica
generala, si care este accesibila de catre orice producator sau consumator interesat.
– Intre interfetele diferitelor servicii se schimba doar mesaje c are respecta o schema
predefinita, dar extensibila, prin intermediul carora se trimit e doar continut si nu
descriere comportamentala a sistemului. Cu alte cuvinte mesajul trebuie să aibă o
mare putere de descriere si nu una de „comanda”/instruire.
Pe langa conceptul de interconectare slaba, mai exista si urmat orele concepte
referitoare la principiile unei arhitecturi de tip SOA:
– Incapsularea Serviciului
– Contractul Serviciului – se refera la faptul ca serviciile sunt de acord să comunice pe
baza unui agreement stipulat de catre unul sau mai multe servic ii prin intermediul
unor documente descriptive
– Abstractizarea Serviciului – un serviciu expune ceea ce face si nu cum o face
– Refolosirea Serviciului – in sine conceptul se serviciu implica reutilizare. Serviciile au
fost concepte pentru a putea să fie reutilizate.
– Compunerea Serviciilor – colectii de servicii pot să fie coordo nate si asambalte astfel
in cat să formeza un nou serviciu, numit un serviciu compus.
– Autonomia Serviciului – un serviciu are control total asupra lo gicii pe care o
incapsuleaza
– Descoperirea Serviciilor – serviciile sunt concepute astfel inc at să isi descrie
functionalitatea catre „exterior”, astfel incat să poata fi gas ite si folosite prin
intermediul unor mecanisme de descoperire.
Avand bazele puse pentru conceptul de SOA, in cele ce urmeaza s e va incerca
definirea Serviciilor Web pe baza acestor concepte. Serviciile Web nu sunt altceva decât o

Arhitecturi Software 55
modalitate prin care o arhitectura SOA este realizate, folosind un anumit set de protocoale si
restrictii. In cazul concret al Serviciilor Web, urmatoarele do ua restrictii sunt impuse:
– Interfetele serviciilor trebuie să fie construite peste protoco ale din Internet, precum
HTTP, FTP sau SMTP.
– Exceptand atasamentele binare alea unor mesaje, toata comunicar ea intre servicii
trebuie să fie făcută prin mesaje in format XML.
In momentul de fata exista doua mari clase de Servicii Web, si anume: SOAP si
REST. In cele ce urmeaza vom discuta despre Servicii Web de tip SOAP si infrastructuri
oferite de platforma .NET pentru implementarea/dezvoltarea, gaz duira, rularea si
mentenanta unor Servicii Web de tip SOAP. Decizia de a descrie mai indetaliu Serviciile
Web de tip SOAP este aceea ca ele sunt recunoscute de piata ca un standard defacto, fapt
vizibil si prin adoptia majoritara a acestora.
SOAP este un acronim pentru Simple Object Access Protocol. Clas a de Servicii Web
de tip SOAP aduce urmatoarele constrangeri fata de cele mention ate mai sus:
– Cu exceptia atasamentelor binare, toate mesajele trebuie să fie transportate prin
intermediul SOAP.
– Descrierea unui Serviciu Web se va face folosind un limbaj de m arkup numit WSDL –
Web Service Description Language.
– Existenta registrelor UDDI (Universal Description Discovery and Integration) care au
ca scop indexarea Serviciilor Web. UDDI-ul permite interogarea să prin intermediul
SOAP si faciliteaza accesul la WSDL-ul Serviciilor Web pe care le indexeaza.
SOAP nu face altceva decât să defineasca un format pentru mesaj e care pot fi
trimise intre servicii web deasupra unui numar de protocoale in ternet. Cu alte cuvinte, SOAP
se comporta ca un plic care muta continut dintr-un punct in alt ul.
Pentru exemplificare, mai jos este un mesaj SOAP: <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/enve lope/">
<soap:Body> <obtineDetaliiCursant xmlns="http://www.example.com/WebSer vice">
<IDCursant>C010030</IDCursant >
</obtineDetaliiCursant > </soap:Body> </soap:Envelope> Se poate observa in exemplul de mai sus structura unui mesaj de tip SOAP:
– Plicul: <soap:Envelope>
– Continutul acestui delimitat de: <soap:Body>
Odata cu dezvoltarea standardelor pentru Servicii Web de tip SO AP (de acum incolo
numit simplu Servicii Web) si cu adoptia lor pe piata, s-a facu t simtita nevoia unor standarde
suplimentare pentru a putea exprima concepte precum securitatea , increderea si tranzactiile.
O serie de firme din industria software au dezvoltat in conseci nta o suita de standarde
numite colectiv WS-* care trateaza aceste probleme. Telul acest or specificatii este acela de
a oferi sabloane pentru functionalitati avansate ale Serviciilo r Web, totodata pastrand
simplitatea nativa a Serviciilor Web. Cea mai importanta trasat ura a specificatiilor WS-* este
posibilitatea lor de a fi compuse. Compunearea protocoalelor as ociate acestor specificatii
permite o dezvoltare incrementala a Serviciilor Web, pe masura ce functionalitatea lor o cere
(securitate, incredere, atasamente, tranzactii, descoperire, et c.). Individual fiecare
specificatie rezolva o problema izolta, dar ca un compus, ele r ezolva probleme de
functionalitate ridicata adesea intalnite in aplicatii distribu ite.
Modelul acesta poate fi exprimat schematic astfel:

56 Programare Web (suport de curs)

In cele ce urmeaza se vor prezenta succint produsele din platf orma Microsoft care
compun ecosistemul pentru construirea si mentenanta sistemlor d istribuite implementate
folosing Servicii Web.
Constructia de Servicii Web se poate realiza
– folosind Microsoft Visual Studio 2005 in colaborare cu platform a .NET 2.0, prin
intermediul carora se pot implementa servicii web care sunt in conformitate cu
standardul WS-Interoperability [WS-I]. Crearea serviciului este facila, partea de
contract fiind generata automat pe partea serviciului, iar part e a d e p r o x y f i i n d
deasemenea generata automat pe partea de client. Suportul pentr u descoperire este
deasemenea integrat prin suportarea protocolului UDDI.
– folosind Web Service Enhancements 3.0 [WSE 3.0] in colaborare c u VS2005 si .NET
2.0, se pot realiza Servicii Web care sunt in conformitate cu u ltimele specificatii ale
WS-*. WSE 3.0 este oferit ca un pachet care se integreaza perfe ct cu suita de
dezvoltare VS 2005. WSE 3.0 aduce suport in cadrul platformei . NET 2.0 pentru
XML, SOAP, WSDL, WS-Security, WS-Trust, WS-SecureConversation, WS-
Addressing si MTOM
– folosind platforma .NET 3.0 care aduce un set nou de API-uri p rintre care si Windows
Communication Foundation, API care permite un model unificat de programare si
rulare a Serviciilor Web folosind limbaje managed, precum C#. W CF aduce suport
integral pentru toate standardele recunoscute cat si cele mai p opulare adoptate de
piata, numarand astfel urmatoarele:
o pentru trimiterea mesajelor: XML, SOAP, WS-Addressing
o pentru descrierea interfetelor (asa numita MetaData): WSDL, WS –
MetadataExchange, WS-Policy, WS-SecurityPolicy
o pentru securitate: WS-Trust, WS-Security, WS-SecureConversatio n
o pentru incredere: WS-ReliableMessaging
pentru tranzactii: WS-Coordination si WS-AtomicTransactions

Protocoale de rețea 57
2. Protocoale de rețea
2.1. Modelul de referință TCP/IP
Pana în anii 60, comunicarea între computere se realiza greoi p rin intermediul liniilor
telefonice. În 1962 Paul Baran și Donald Davies propun – indepe ndent – ideea unui sistem
de comunicare între rețele bazat pe comutarea de pachete – pack et switching. Această
arhitectura a fost implementată de ARPANET, o rețea de calculat oare sponsorizată de DoD
(Department of Defence). Arhitectura a devenit cuoscută mai târ ziu sub denumirea de
modelul de referință TCP/IP , după numele celor două protocoale fundamentale utilizate.
Protocolul TCP (Transfer Control Protocol) se refera la modalit atea de transmitere a
informatiei, iar protocolul IP (Internet Protocol) se refera la modealitatea de adresare.
Dată fiind îngrijorarea DoD că o parte din gazde, routere și po rți de interconectare ar
putea fi distruse la un moment dat, un obiectiv major a fost ca rețeaua să poată supraviețui
pierderii echipamentelor din subrețea, fără a întrerupe convers ațiile existente. Cu alte
cuvinte, DoD dorea ca, atâta timp cât funcționau mașina sursă ș i mașina destinație,
conexiunile să rămână intacte, chiar dacă o parte din mașini sa u din liniile de transmisie erau
brusc scoase din funcțiune. Mai mult, era nevoie de o arhitectu ră flexibilă, deoarece se
aveau în vedere aplicații cu cerințe divergente, mergând de la transferul de fișiere până la
transmiterea vorbirii în timp real.
Toate aceste cerințe au condus la alegerea unei rețele cu comut are de pachete
bazată pe un nivel inter-rețea fără conexiuni. Acest nivel, nu mit nivelul internet (IP), este
axul pe care se centrează întreaga arhitectură. Rolul său este de a permite gazdelor să
emită pachete în orice rețea și face ca pachetele să circule in dependent până la destinație.
Pachetele pot chiar să sosească într-o ordine diferită față de cea în care au fost trimise, caz
în care rearanjarea cade în sarcina nivelurilor de mai sus (ace le nivele ce urmeaza să
proceseze pachetele primite).

Fiecare computer conectat la internet are o adresa de IP unică. Adresele IP sunt sub
forma nnn.nnn.nnn.nnn , unde nnn trebuie să fie un număr între 0 și 255. Spre exemplu, la
momentul redactarii acestui document, www.microsoft.com a r e i p – u l 207.46.192.254 .
Fiecarui calculator îi este asociată o adresă de loopback 127.0 .0.1, care înseamna “acest
calculator”. 127.0.0.1 se mai numește și localhost. În anii `80 au fost conectate la Arpanet un
număr foarte mare de rețele. Această situație a determinat, în 1984, crearea sistemului DNS
(Domain Name System), prin intermediul căruia calculatoarele er au organizate în domenii,
punându-se în corespondență adresele IP cu numele gazdelor.
Nivelul de transport sau TCP atașează pachetelor trimise un num ăr de port al
serviciului destinatar și direcționează pachetele care ajung, c ătre o anumită aplicație. Fiecare
serviciu comunică pe un anumit port. Porturile sunt numere într egi care permit unui computer
să facă diferența între comunicațiile internet ce au loc la un anumit moment dat. Numerele
porturilor sunt cuprinse intre 0 si 65535 si sunt impartite in doua clase: cele pana la 1024
sunt rezervate pentru sistemul de operare, iar cele peste 1024 sunt disponibile
dezvoltatorilor. Prin prezenta porturilor si deoarece aplicatii le care deservesc diferite servicii
pe un sistem ruleaza pe porturi diferite, putem avea servicii c are ruleaza concomitent pe

58 Programare Web (suport de curs)
acelasi calculator. Astfel, pe un sistem (server) pot rula conc omitent aplicatii server si pentru
protocolul HTTP cat si pentru protocolul FTP. Un server poate d eservi clienti atat ai
serviciului sau HTTP cat si a celui FTP, deoarece poate deosebi pachetele adresate celor
doua servicii pe baza portului catre care sunt trimise. Cele ma i comune porturi sunt: FTP :
20/21, Telnet: 23, HTTP: 80, Microsoft SQL Server:1433.
Printre protocoalele de nivel aplicatie, enumeram cateva din ce le mai cunoscute:
HTTP, FTP, Telnet, SMTP, SSL, POP3, IMAP, SSH etc.
HTTP (Hyper Text Transfer Protocol) este un protocol client – s erver în care clienții
(browserele web) trimit o cerere unui server web. După ce serve rul returnează elementele
cerute (imagini, text etc.) conexiunea dintre client și server este întreruptă. Acest lucru
înseamnă că după ce elementele cerute sunt descarcate pe calcul atorul utilizatorului, iar
browserul descoperă ca are nevoie de o alta resursa de pe serve r, se realizează o nouă
cerere către acesta. Acest lucru înseamnă că HTTP nu este orien tate pe conexiune
(connection-oriented).
FTP (File Transfer Protocol) facilitează transferul de fișiere între două calculatoare din
internet.
SMTP (Simple Mail Transfer Protocol) este un protocol folosit p entru schimbul de
mesaje de poștă electronică.
Telnet este un protocol care permite unui utilizator să se cone cteze de la un calculator
la altul.
SSL (Secure Socket Layer) este un protocol folosit pentru trans miterea de date text
criptate in internet.
Modelul TCP/IP este înrudit cu modelul de referință OSI (Open S ystems
Interconnection). Modelul OSI este format din 7 straturi asigur ând astfel mai multă
flexibilitate. Acest model nu este folosit însa în practică, ră mânând mai mult un model
teoretic. In figura de mai jos se poate vedea sitva de comunica re propusa de modelul
ISO/OSI cu cele 7 nivele ale sale. Nivelul cel mai de jos repre zinta nivelul fizic al retelei, iar
nivelul cel mai de sus reprezinta nivelul aplicatie. In aceasta arhitectura multi-nivel, fiecare
nivel comunica doar cu nivelele adiacente: la transmiterea de d ate, datele pleaca din nivelul
aplicatiei, iar fiecare nivel comunica doar cu nivelul imediat de sub el; la primirea de date,
fiecare nivel comunica doar cu nivelul imediat de deasupra lui.

2.2. Protocolul HTTP
Unul dintre cele mai importante și de succes servicii ale Inter netului, World-Wide
Web -ul – mai pe scurt Web sau spațiul WWW , a fost instituit la CERN (Centre Européen

Protocoale de rețea 59
pour la Recherche Nucléaire – Centrul European de Cercetări Nucleare de la Geneva) în
anul 1989. Web – ul a apărut din necesitatea de a permite cerc etătorilor răspândiți în lume
să colaboreze utilizând colecții de rapoarte, planuri, desene, fotografii și alte tipuri de
documente aflate într-o continuă dezvoltare.
Comunicația dintre clientul web (browserul) și serverul web ar e loc în felul următor:
procesul server Web (spre exemplu Microsoft IIS – Internet Info rmation Services) „ascultă”
portul TCP 80 al mașinii gazde pentru a răspunde eventualelor c ereri de conexiune venite de
la clienți. După stabilirea conexiunii TCP, clientul care a ini țiat conexiunea trimite o cerere
(de exemplu un document HTML), la care serverul trimite un răsp uns (documentul cerut sau
un mesaj de eroare). După trimiterea răspunsului conexiunea din tre client și server se
încheie. Cererile clientului și răspunsurile serverului Web sun t descrise de protocolul HTTP
(Hyper Text Transfer Protocol).
Etapele care se parcurg între cerere și răspuns sunt:
1. Browserul determina URL – ul cerut de utilizator. 2. Browserul întreabă serverul local DNS adresa IP a mașinii pe care se află pagina
cu URL-ul selectat.
3. Serverul DNS comunică browserului adresa IP cerută. 4. Browserul stabilește o conexiune TCP cu portul 80 al serveru lui cu IP – ul obținut
anterior.
5. Utilizând conexiunea TCP, browserul trimite o comandă GET. 6. Serverul web răspunde trimițând un fișier HTML. 7. Serverul Web închide conexiunea TCP. 8. Browserul afișează textul din fișierul HTML trimis.
9. Browserul cere și afișează și celelalte elemente necesare în pagină (de exemplu
imaginile).
Exemplu de cerere din partea clientului:
GET / HTTP/1.1
Host: www.live.com
Exemplu de răspuns al serverului:
HTTP/1.1 200 OK
Date: Wed, 15 Aug 2007 09 :49:56 GMT
Server: Microsoft-IIS/6.0 P3P:CP="BUS CUR CONo FIN IVDo ONL OUR PHY SAMo TELo"
S:WEBA12
X-Powered-By: ASP.NET X-AspNet-Version: 2.0 .50727
Set-Cookie: mktstate=E=&P= &B=; domain=live.com; path=/
Set-Cookie: mkt1=norm=-ro ; domain=live.com; path=/
Set-Cookie: mkt2=ui=ro-ro; domain=www.live.com; path=/
Set-Cookie: lastMarket=ro-ro; domain=.live.com; path=/
Set-Cookie: lastMktPath=ro/ro; domain=.live.com; path=/ Set-Cookie: frm=true; domai n=.live.com; expires=Mon,
04-Oct-2021 19:00:00 GMT; path=/
Set-Cookie: frm=true; domai n=.live.com; expires=Mon,
04-Oct-2021 19:00:00 GMT; path=/
Cache-Control: no-cache
Pragma: no-cache Expires: -1
Content-Type: text/html ; charset=utf-8
Content-Length: 5939

Metodele puse la dispoziție de protocolul HTTP sunt:
• HEAD – clientul cere numai antetul paginii

60 Programare Web (suport de curs)
• GET – clientul cere serverului să trimită pagina specificată
• POST – trimite date pentru a fi procesate pe server
• PUT – inlocuiește conținutul paginii specificate cu datele tri mise de client
• DELETE – solicită ștergerea paginii specificate
• TRACE – permite clientului să vadă cum sunt prelucrate mesajel e
• OPTIONS – returnează metodele HTTP suportate de server
• CONNECT – convertește conexiunea de tip cerere într-un tunel TCP/IP , de
obicei pentru a facilita comunicații securizate prin SSL (HTTPS ).

Formularele HTML sunt folosite pentru ca utilizatorii să introd ucă date în câmpurile
acestora și să le transmită serverului Web (utilizând browserul , o conexiune TCP și
protocolul HTTP).
Cele mai răspândite servere Web sunt :
• IIS (Internet Information Server) de la Microsoft. Este inclus ca parte
componentă a sistemelor de operare Microsoft (Windows NT Server ,
Windows 2000 Server și Windows Server 2003).
Apache (open source). Pentru a transmite date serverului se poa te folosi metoda
GET sau metoda POST. Metoda implicită este GET.
Dacă se utilizează GET, datele transmise serverului pot fi vizu alizate în bara de
adrese a browserului, ele urmând după URL-ul fișierului ce conț ine scriptul care le va
prelucra. Datele introduse de utilizator vor fi sub forma de pe rechi nume=valoare. Caracterul
? semnifică faptul că se transmit date către server, iar perech ile nume=valoare pot fi
separate prin caracterul &. De exemplu pentru a cauta informaț ii referitoare la ASP.NET în
Live Search, se poate folosi url-ul: http://search.live.com/results.aspx?q=ASP.NET .
Metoda POST permite ca transmiterea datelor către server să se facă în flux,
putându-se transmite cantități mari de date. De asemenea, datel e trimise nu mai sunt afișate
în bara de adrese a browserului, lucru util când se transmit in formații confidențiale.
La nivelul serverului, datele primite de la browser (via HTTP) sunt prelucrate de un
script, o aplicatie sau chiar un framework:
• CGI (Common Gateway Interface). Reprezinta o serie de script-u ri executate
pe serverul web. Acestea pot fi scrise in orice limbaj de prog ramare (interpretat sau compilat)
cu respectarea urmatoarelor restrictii: programul scrie datele la iesirea standard si genereaza
antete care permit serverului Web să interpreteze corect iesire a scriptului, conform
specificatiilor HTTP.
• PHP (inițial Personal Home Page apoi PHP: Hypertext Preprocessor ) și ASP
(Active Server Pages ). ASP ( Active Server Pages ) este o platformă de programare Web
creată de Miscrosoft. Lucrează bine cu serverul IIS, dar există versiuni și pentru alte servere
Web.
Desi difera din punct de vedere al sintaxei, atat PHP cat si A SP sunt interpretate,
codul lor fiind stocat in fisiere externe cu extensia .php/.asp . De fapt, ASP nu ofera un limbaj
nou, ci se bazeaza pe limbajele VBScript si JScript. Un fisier PHP/ASP poate fi combinat cu
date de tip text, marcatori HTML si comenzi script. in momentul executiei, in urma cererii
unui client Web, fisierul este procesat, fiecare script din cad rul lui este interpretat si rezultatul
executiei este introdus inapoi in fisierul static HTML inainte ca rezultatul să fie trimis catre
client (browser web). Aceste modele completeaza destul de bine suportul dezvoltarii
aplicatiilor Web, insa aduc unele limitari: sunt lente deoarece la fiecare accesare fisierele
sunt procesate si interpretate (in loc să fie compilate), nu su nt capabile să construiasca
controale reutilizabile care să incapsuleze functionalitati com plexe pentru interactiunea cu
utilizatorul
• P e r l ( Practical Extraction and Report Language ) este un limbaj de programare
complex, precursor al PHP
• JSP ( JavaServer Pages ) este o platformă de programare Web creată de Sun
Microsystems și face parte din specificația Java 2 Entreprise E dition (J2EE).

Protocoale de rețea 61
JSP utilizează sintaxa XML și o serie de clase și funcții Java. Codul JSP este
compilat de servlet -uri binare pentru o procesare rapidă.
Server-side scripting reprezintă „programarea” comportamentului serverului, iar client-side
scripting se refera la „programarea” comportamentului browserul ui de pe client. Programarea
la nivel de client se realizează în special prin JavaScript.

62 Programare Web (suport de curs)

3. Programarea client – side
Unul din primele elemente fundamentale ale WWW ( World Wide Web ) este HTML
(Hypertext Markup Language), care descrie formatul primar in ca re documentele sint
distribuite si vazute pe Web. Multe din trasaturile lui, cum ar fi independenta fata de
platforma, structurarea formatarii si legaturile hipertext, fac din el un foarte bun format pentru
documentele Internet si Web.
Standardul oficial HTML este stabilit de World Wide Web Consort ium (W3C), care este
afiliat la Internet Engineering Task Force (IETF). W3C a enunta t cateva versiuni ale
specificatiei HTML, printre care si HTML 2.0, HTML 3.0,HTML 3.2 , H T M L 4 . 0 s i , c e l m a i
recent, HTML 4.01. In acelasi timp, autorii de browsere, cum ar fi Netscape si Microsoft, au
dezvoltat adesea propriile "extensii" HTML in afara procesului standard si le-au incorporat in
browserele lor. In unele cazuri, cum ar fi tagul Netscape , ace ste extensii au devenit
standarde de facto adoptate de autorii de browsere.

3.1. Elemente avansate de HTML
3.1.1. Tabele
Tabelele ne permit să cream o retea dreptunghiulara de domenii, fiecare domeniu
avand propriile optiuni pentru culoarea fondului, culoarea text ului, alinierea textului etc.
Pentru a insera un tabel se folosesc etichetele corespondente <table>…</table> . Un tabel
este format din randuri. Pentru a insera un rand într-un tabel se folosesc etichetele
<tr>…</tr> ("table row "= rand de tabel ).
Un rand este format din mai multe celule ce contin date. O celu la de date se
introduce cu eticheta <td>..</td> .

<html>
<head>
<title> tabel </title>
</head>
<body>
<h1 align=center> Un tabel simplu format din 4 linii si 2 coloane </h1>
<hr>
<table>
<tr>
<td> c11</td>
<td>c 11</td>
</tr>
<tr>
<td>c 21</td>
<td>c 22</td>
</tr>
<tr>
<td> c31</td>
<td>c 32</td>
</tr>
<tr>
<td> c41</td>
<td> c42</td>
</tr>
</table>
</body>
</html>

Programarea client – side 63

In mod prestabilit, un tabel nu are chenar. Pentru a adauga un chenar unui tabel, se
utilizeaza un atribut al etichetei <tabel> numit border. Acest atribut poate primi ca valoare
orice numar intreg ( inclusiv 0 ) si reprezinta grosimea in pix eli a chenarului tabelului. Daca
atributul border nu este urmata de o valoare atunci tabelul va avea o grosime prestabilita
egala cu 1 pixel, o valoare egala cu 0 a grosimii semnifica abs enta chenarului. Cand atributul
border are o valoare nenula chenarul unui tabel are un aspect t ridimensional.

<table border="2"> <tr>
<td> c11</td>
<td> c11</td>
</tr>
</table>

Pentru a alinia un tabel într-o pagina Web se utilizeaza atribu tul align al etichetei
<table>, cu urmatoarele valori posibile: " left " ( valoarea pr estabilita ), " center " si "right ".
Alinierea este importanta pentru textul ce inconjoara tabelul. Astfel :
• daca tabelul este aliniat stanga ( <table align="left"> ), atu nci textul care
urmeaza dupa punctul de inserare al tabelului va fi dispus in p artea dreapta a
tabelului.
• daca tabelul este aliniat dreapta ( <table align="right"> ), a tunci textul care
urmeaza dupa punctul de inserare al tabelului va fi dispus in p artea stanga a
tabelului.
• daca tabelul este aliniat pe centru ( <table align="center"> ) , atunci textul care
urmeaza dupa punctul de inserare al tabelului va fi afisat pe t oata latimea
paginii, imediat sub tabel.
Culoarea de fond se stabileste cu ajutorul atributului bgcolor, care poate fi atasat
intregului tabel prin eticheta <table>, unei linii prin etichet a <tr> sau celule de date prin
eticheta <td>. Valorile pe care le poate primi bgcolor sunt cel e cunoscute pentru o culoare.
Daca in tabel sunt definite mai multe atribute bgcolor, atunci prioritatea este urmatoarea:
<td>, <tr>, <table> ( cu prioritate cea mai mica ).

<html>
<head>
<title> tabel </title>
</head>
<body>
<h1 align=center> Un tabel simplu colorat </h1>
<hr>
<table border="3" bgcolor="green">
<tr>
<td> verde 11 </td>
<td bgcolor="red"> rosu 11 </td>
</tr>
<tr bgcolor="blue">
<td> albastru 21 </td>
<td bgcolor="yellow"> galben 22 </td>
</tr>
<tr bgcolor="cyan">
<td> c31</td>
<td> c32</td>
</tr>
<tr>
<td> c41</td>
<td bgcolor="white"> c42</td>
</tr>
</table>

64 Programare Web (suport de curs)
</body>
</html>

Culoarea textului din fiecare celula se pote stabili cu ajutoru l expresiei:
<font color="valoare">…</font>.
Distanta dintre doua celule vecine se defineste cu ajutorul atr ibutului cellspacing al
etichetei <table>.Valorile acestui atribut pot fi numere intreg i pozitive, inclusiv 0, si reprezinta
distanta in pixeli dintre doua celule vecine. Valorea prestabil ita a atributului cellspacing este
2.
Distanta dintre marginea unei celule si continutul ei poate fi definita cu ajutorul
atributului cellpadding al etichetei <table>.Valorile acestui a tribut pot fi numere intregi
pozitive, si reprezinta distanta in pixeli dintre celule si con tinutul ei. Valorea prestabilita a
atributului cellpadding este 1.
Dimensiunile unui tabel – latimea si inaltimea – pot fi stabili te exact prin intermediul a
doua atribute, width si height, ale etichetei <table>.Valorile acestor atribute pot fi:
• numere intregi pozitive reprezentand latimea respectiv inaltim ea in pixeli a
tabelului;
• numere intregi intre 1 si 100, urmate de semnul %, reprezentan d fractiunea
din latimea si inaltimea totala a paginii.

<html>
<head>
<title> tabel </title>
</head>
<body>
<h1 align=center> Text</h1>
<table width="100%" height="100%">
<tr>
<td align="center">
<h2> Text centrat. </h2>
</td>
</tr>
</table>
</body>
</html>

Un tabel poate avea celule cu semnificatia de cap de tabel. Ace ste celule sunt
introduse de eticheta <th> ( de la " tabel header " = cap de ta bel ) in loc de <td>. Toate
atribute care pot fi atasate etichetei <td> pot fi de asemenea atasate etichetei <th>.
Continutul celulelor definite cu <th> este scris cu caractere a ldine si centrat.
Alinierea pe orizontala a continutului unei celule se face cu a jutorul atributului align
care poate lua valorile:
• left ( la stanga );
• center ( centrat , valoarea prestabilita );
• right ( la dreapta );
• char ( alinierea se face fata de un caracter ).
Alinierea pe verticala a continutului unei celule se face cu aj utorul atributului valign
care poate lua valorile:
• baseline ( la baza );
• bottom ( jos );
• middle ( la mijloc, valoarea prestabilita );
• top ( sus ).
Aceste atribute pot fi atasate atat etichetei <tr> pentru a def ini tuturor elementelor
celulelor unui rand, cat si etichetelor <td> si <th> pentru a s tabili alinierea textului într-o
singura celula.

Programarea client – side 65
Un tabel trebuie privit ca o retea dreptunghiulara de celule.Cu ajutorul a doua atribute
ale etichetelor <td> si <th>, o celula se poate extinde peste c elule vecine.
Astfel:
• extinderea unei celule peste celulele din dreapta ei se face c u ajutorul
atributului colspan, a carui valoare determina numarul de celul e care se
unifica.
• extinderea unei celule peste celulele dedesubt se face cu ajut orul atributului
rowspan, a carui valoare determina numarul de celule care se un ifica.
Sunt posibile extinderi simultane ale unei celule pe orizontala si pe verticala. In acest
caz , in etichetele <td> si <th> vor fi prezente ambele atribut e
colspan si rowspan .

<html>
<head>
<title> table </title>
</head>
<body>
<h1 align=center> Un tabel simplu cu chenar </h1>
<hr>
<table border="0">
<tr> <td rowspan="3"> c11</td>
<br> c21<br>c31 </td>
<td> c12</td>
<td colspan="2" rowspan="3"> c13 , c4 </td>
<br> c23, c24 <br>c33, c34 </td>
</tr>
<tr>
<td> c22</td>
</tr>
<tr>
<td> c32</td>
</tr>
<tr>
<td> c41</td>
<td colspan="3"> c42, c43, c44 </td>
</tr>
</table>
</body>
</html>

Daca un tabel are celule vide, atunci aceste celule vor aparea in tabel fara un chenar
de delimitare.
In scopul de a afisa un chenar pentru celule vide se utilizeaza &nbsp în interiorul unei
celule:
• dupa <td> se pune &nbsp;;
• dupa <td> se pune <br>.
Caracterul &nbsp; ( no breakable space ) este de fapt caracteru l spatiu.Un spatiu
introdus prin intermediul acestui caracter nu va fi ignorat de browser.
3.1.2. Frames (cadre) în HTML

Ferestrele sau (cadrele) ne permit să definim in fereastra brow serului subferestre in
care să fie incarcate documente HTML diferite.Ferestrele sunt d efinite într-un fisier HTML
special , in care blocul <body>…</body> este inlocuit de bloc ul <frameset>…</frameset>. In
interiorul acestui bloc, fiecare cadru este introdus prin etich eta <frame>.

66 Programare Web (suport de curs)
Un atribut obligatoriu al etichetei <frame> este src, care prim este ca valoare adresa
URL a documentului HTML care va fi incarcat in acel frame. Defi nirea cadrelor se face prin
impartirea ferstrelor (si a subferestrelor) in linii si coloane :
• impartirea unei ferstre într-un numar de subferestre de tip co loana se face cu
ajutorul atributului cols al etichetei <frameset> ce descrie ac ea fereastra;
• impartirae unei ferestre într-un numar de subferestre de tip l inie se face cu
ajutorul atributului rows al etichetei <frameset> ce descrie ac ea fereastra;
• valoare atributelor cols si rows este o lista de elmente separ ate prin virgula ,
care descriu modul in care se face impartirea.
Elementele listei pot fi:
• un numar intreg de pixeli;
• procente din dimensiunea ferestrei (numar intre 1 si 99 termin at cu %);
• n* care inseamna n parti din spatiul ramas;
Exemplu 1: cols=200,*,50%,* inseamna o impartire in 4 subfer estre, dintre care prima are
200 pixeli, a treia ocupa jumatate din spatiul total disponibil , iar a doua si a patra ocupa in
mod egal restul de spatiu ramas disponibil. Exemplu 2: cols=200,1*,50%,2* inseamna o impartire in 4 subf erestre , dintre care prima
are 200 pixeli , a treia ocupa jumatate din spatiul total dispo nibil iar a doua si a patra ocupa
in mod egal restul de spatiu ramas disponibil, care se imparte in trei parti egale , a doua
fereastra ocupand o parte , iar a patra ocupand 2 parti. Observatii:
• daca mai multe elemente din lista sunt configurate cu * , atun ci spatiul
disponibil ramas pentru ele se va imparti in mod egal.
• o subfereastra poate fi un cadru (folosind <frame>)in care se va incarca un
document HTML sau poate fi impartita la randul ei la alte subfe reste (folosind
<frameset>).

<html>
<head>
<title> frames </title>
</head>
<frameset cols="*,*">
<frame src="f1.html">
<frame src="f2.html">
</frameset>
</html>

In exemplul urmator este creata o pagina Web cu trei cadre mixt e.Pentru a o crea se
procedeaza din aproape in aproape. Mai intai, pagina este impar tita in doua subferestre de
tip coloana, dupa care a doua subfereastra este impartita in do ua subferestre de tip linie.

<html>
<head>
<title> frames </title>
</head>
<frameset cols="20%,*">
<frame src="p1.html">
<frameset rows="*,*">
<frame src="p2.html">
<frame src="p3.html">
</frameset>
</frameset>
</html>

Pentru a stabili culoarea chenarului unui cadru se utilizeaza a tributul bordercolor.
Acest atribut primeste ca valoare un nume de culoare sau o culo are definita in conformitate

Programarea client – side 67
cu modelul de culoare RGB.Atributul bordercolor poate fi atasat atat etichetei <frameset>
pentru a stabili culoarea tuturor chenarelor cadrelor incluse,c at si etichetei <frame> pentru a
stabili culoarea chenarului pentru un cadru individual.
Atributul border al etichetei <frameset> permite configurarea l atimii chenarelor tuturor
cadrelor la un numar dorit de pixeli. Valoarea prestabilita a a tributului border este de 5 pixeli.
O valoare de 0 pixeli va defini un cadru fara chenar.
<html>
<head><title> frames </title></head>
<frameset cols="20%,*" bordercolor="green" border="15">
<frame src="p1.html">
<frameset rows="*,*">
<frame src="p2.html" bordercolo r="blue"> <frame src="p3.htm l">
</frameset>
</html>
Pentru a obtine cadre fara chenar se utilizeaza border="0". In mod prestabilit,
chenarul unui cadru este afisat si are aspect tridimensional. A fisarea chenarului unui cadru
se poate dezactivata daca se utilizeaza atributul frameborder c u valoare "no". Acest atribut
poate fi atasat atat etichetei <frameset> (dezactivarea fiind v alabila pentru toate cadrele
incluse) cat si etichetei <frame> (dezactivarea fiind valabila numai pentru un singur cadru).
Valorile posibile ale atributului frameborder sunt: "yes" -echivalent cu 1; "no" –
echivalent cu 0;

<html>
<head><title> frames </title></head>
<frameset cols="20%,*" border="0">
<frame src="p1.html">
<frameset rows="*,*">
<frame src="p2.html"> <frame src="p3.html">
</frameset>
</html>

Atributul scrolling al etichetei <frame> este utilizat pentru a adauga unui cadru o bara
de derulare care permite navigarea in interiorul documentului a fisat in interiorul cadrului.
Valorile posibile sunt:
• yes – barele de derulare sunt adaugate intotdeauna;
• no – barele de derulare nu sunt utilizabile;
• auto – barele de derulare sunt vizibile atunci cand este neces ar

<html>
<head><title> frames </title></head>
<frameset cols="*,*,*">
<frame src="p.html" sc rolling="yes" noresize>
<frame src="p.html" sc rolling="no" noresize>
<frame src="p.html" scro lling="auto" noresize>
</frameset>
</html>

Atributul noresize al etichetei <frame> (fara nici o valoare su plimentara) daca este
prezent, inhiba posibilitatea prestabilita a utilizatorului de a redimensiona cadrul cu ajutorul
mouse-ului.
Un cadru intern este specificat prin intermediul blocului <ifra me>…</iframe>. Un
cadru intern se insereaza într-o pagina Web in mod asemanator c u o imagine sau in modul
in care se specifica marcajul <frame>, asa cum rezulta din urma torul exemplu: <iframe
src="iframes_ex.html" height =40% width=50%> </iframe>
In acest caz fereastra de cadru intern care are 40%din inaltime a si 50% din latimea
paginii curente.

68 Programare Web (suport de curs)
Atributele aceptate de eticheta <iframe> sunt in parte preluate de la etichetele
<frame> si <frameset>, cum ar
fi:src,border,frameborder,bordercolor,marginheight,marginwidth, scrolling,name,noresize; sau
de la eticheta <img> vspace,hspace,align,width,height;
In mod prestabilit, la efectuarea unui clic pe o legatura noua pagina (catre care indica
legatura) o inlocuieste pe cea curenta in aceeasi fereastra (ac elasi cadru). Acest
comportament se poate schimba in doua moduri:
• prin plasarea in blocul <head>…</head> a unui element <base> c a r e
precizeaza,prin atributul target numele ferestrei (cadrului) in care se vor
incarca toate paginile noi referite de legaturile din pagina cu renta conform
sintaxei: <base target="nume_ferastra/frame_de_baza">
• prin plasarea in eticheta <a> a atributului target, care preci zeaza numele
ferestrei (cadrului) in care se va incarca pagina nou referita de legatura,
conform sintaxei: <a href="legatura" target="nume_fereastra/fra me">…</a>
Daca este prezent atat un atribut target in <base> cat si un at ribut target in <a>,
atunci cele precizate de atributul target din <a> sunt priorita re.
Numele unui cadru este stabilit prin atributul name al etichete i <frame> conform
sintaxei: <farme name="nume_frame">
In exemplul urmator este prezentata o pagina Web cu doua cadre. Toate legaturile
din cadrul 1 incarca paginile in cadrul 2.

<html>
<head><title> frames </title></head>
<frameset cols="20%,*">
<frame src="left.html" name="left">
<frame src="p.html" name="main">
</frameset>
</html>
<html>
<head><title> frame_left </title> </head>
<body>
<a href="p1.html" target="main">
Fisierul1 </a><br> <a href="p2.html" target="main">
Fisierul2 </a><br> <a href="p3.html" target="main">
Fisierul3 </a><br><br> <a href="p1.html" target="_blank">
Fis1 într-o fereastra noua </a><br><br> <a href="p1. html" target="_self">
Fis1 in fereastra curenta </a><br><br> <a href="p.html" target="main">
Home </a><br>
</body>
</html>

Atributul target al etichetei<frame> accepta anumite valori :
• "_self" (incarcarea noii pagini are loc in cadrul curent);
• "_blank" (incarcarea noii pagini are loc într-o fereastra noua anonima);
• "_parent" (incarcarea noii pagini are loc in cadrul parinte al cadrului curent
daca acesta exista, altfel are loc in fereastra browserului cur ent);
• "_top" (incarcarea noii pagini are loc in fereastra browserulu i ce contine cadrul
curent);
3.1.3. Formulare

Un formular este un ansamblu de zone active alcatuit din butoan e, casete de
selectie, campuri de editare etc. Formularele asigura construir ea unor pagini Web care
permit utilizatorilor să introduca informatii si să le transmit a serverului. Formularele pot varia
de la o simpla caseta de text , pentru introducerea unui sir de caractere pe post de cheie de

Programarea client – side 69
cautare, pana la o structura complexa, cu multiple sectiuni, ca re ofera facilitati puternice de
transmisie a datelor.
Un formular este definit într-un bloc delimitat de etichetele c orespondente
<form> si </form> .
Exista doua atribute importante ale elementului <form>.
1. Atributul action precizeaza ce se va intampla cu datele formu larului odata ce
acestea ajung la destinatie. De regula , valoarea atributului a ction este adresa URL a unui
script aflat pe un server WWW care primeste datele formularului , efectueaza o prelucrare a
lor si expedieaza catre utilizator un raspuns.
<form action="http://www.yahoo.com/cgi-bin/nume_fis.cgi">.
Script-urile pot fi scrise in limbajele Perl, C, PHP, Unix shel l. etc
2. Atributul method precizeaza metoda utilizata de browser pentru expedierea datelor
formularului. Sunt posibile urmatoarele valori:
• get (valoarea implicita). In acest caz , datele din formular sunt adaugate la adresa
URL precizata de atributul action ; (nu sunt permise cantitati mari de date – maxim 1
Kb )
• post In acest caz datele sunt expediate separat. Sunt permise canti tati mari de date
(ordinul MB)
Majoritatea elementelor unui formular sunt definite cu ajutorul etichetei <input>.
Pentru a preciza tipul elementului se foloseste atributul type al etichetei <input>. Pentru un
camp de editare, acest atribut primeste valoarea "text". Alte a tribute pentru un element
<input> sunt:
• atributul name ,permite atasarea unui nume fiecarui element al formularului.
• atributul value ,care permite atribuirea unei valori initiale unui element al
formularului.
Un buton de expediere al unui formular se introduce cu ajutorul etichetei <input>, in
care atributul type este configurat la valoarea "submit".Acest element poate primi un nume
prin atributul name. Pe buton apare scris "Submit Query" sau va loarea atributului value , daca
aceasta valoare a fost stabilita.

<form method="post" action="mailto:youremail@youremail.com" > First:<input type="text" name="First" size="12 maxlength="12" / >
Last:<input type="text" name="Las t" size="24" maxlength="24" />
<input type="submit" value="Send Email" />
</form>
Pentru elementul <input> de tipul camp de editare (type = "text ") , alte doua atribute
pot fi utile:
• atributul size specifica latimea campului de editare depaseste aceasta latime,
atunci se executa automat o derulare acestui camp;
• atributul maxlength specifica numarul maxim de caractere pe ca re le poate
primi un camp de editare; caracterele tastate peste numarul max im sunt
ignorate.
Daca se utilizeaza eticheta <input> avand atributul type config urat la valoarea
"password" , atunci in formular se introduce un element asemana tor cu un camp de
editare obisnuit (introdus prin type="text"). Toate atributele unui camp de editare
raman valabile. Singura deosebire consta in faptul ca acest cam p de editare nu
afiseaza caracterele in clar, ci numai caractere *, care ascund de privirile altui
utilizator aflat in apropiere val oarea introdusa într-un asemen ea camp. La expedierea
formularului insa, valoarea tastata într-un camp de tip "passwo rd" se transmite in
clar.

70 Programare Web (suport de curs)

<html>
<head><title> forms </title></head>
<body><h1> Un formular cu un buton reset </h1>
<hr>
<form action= mailto:test @yahoo.com" method="post">
Nume: <input type="text" name="nume" value="Numele"><br>
Prenume: <input type="text" name="prenu me" value="Prenumele"><br>
Password: <input type="password" name="parola" ><br>
<input type="reset" value="sterg e"> <input type="submit" value= "trimite"> </form></body>
</html>

Butoanele radio permit alegerea , la un moment dat , a unei sin gure variante
din mai multe posibil e. Butoanele radio se i ntroduc prin etiche ta <input> cu atributul
type avand valoarea "radio".

Italian: <input type="radio" name="food" />
Greek: <input type="radio" name="food" />
Chinese: <input type="radio" name="food" />

O caseta de validare (checkbox) permite selectarea sau deselect area unei
optiuni. Pentru inserarea unei c asete de validare se utilizeaza eticheta <input> cu
atributul type configurat l a valoarea "checkbox".
Fiecare caseta poate avea un nume definit prin atributul name.f iecare caseta poate
avea valoarea prestabilita "select at" definita prin atributul checked .

<p>Please select every sport that you play.</p> Soccer: <input type="checkbox" checked="yes" name="sports" valu e="soccer" />
<br />
Football: <input type="checkbox" name="sports" value="football" />
<br /> Baseball: <input type="checkbox" name="sports" value="baseball" />
<br />
Basketball: <input type="checkbox" checked="yes" name="sports" value="basketball"
/>

Intr-o pereche "name = value" a unui formular se poate folosi i ntregul continut
al unui fisier pe post de valoare. Pentru aceasta se insereaza un element <input>
într-un formular , cu atributul type avand valoarea "file" (fis ier). Atributele pentru un
element de tip case ta de fisiere:
• atributul name permite atasarea unui nume
• atributul value primeste ca valoare adresa URL a fisierului care va fi expedia t o
data cu formularul. Aceasta valoare poate fi atribuita direct a tributului value , se
poate fi tastata într-un camp de editare ce apare o data cu for mularul sau poate fi
selectata prin intermediul unei casete de tip File Upload sau C hoose File care
apare la apasarea butonului Browse… din formular;
• atributul enctype precizeaza metoda utilizata la criptarea fisierului de
expediat.Valoarea acestui atribut este "multipart/form-data".
O lista de selectie permite u tilizatorului să aleaga unul sau m ai multe elemente
dîntr-o lista finita. Lista de selectie este inclusa in formula r cu ajutorul etichetelor
corespondente <select>si </select>. O lista de selectie poate av ea urmatoarele atribute:

Programarea client – side 71
• atributul name, care ataseaza listei un nume (utilizat in pere chile "name=value"
expediat serverului);
• atributul size, care precizeaza (prîntr-un numar intreg poziti v , valoarea
prestabilita fiind 1) cate elemente din lista sunt vizibile la un moment dat pe ecran
(celelalte devenind vizibile prin actionarea barei de derulare atasate automat
listei).
Elementele unei liste de selectie sunt incluse in lista cu ajut orul etichetei
<option>.
Doua atribute ale etichetei option se dovedesc utile:
• atributul value primeste ca valore un text care va fi expediat serverului in
perechea "name=value"; daca acest atribut lipseste , atunci cat re server va fi
expediat textul ce urmeaza dupa <option>;
• atributul selected (fara alte valori) permite selectarea prest abilita a unui elemment
al listei.
<select> <option>Bucuresti – B</option>
<option>Craiova – DJ</option>
<option selected="yes">Iasi – IS</option> </select>
O lista de selectie ce permite selectii multiple se creeaza int ocmai ca o lista de
selectie obisnuita. In plus, eticheta <select> are un atribut m ultiple (fara alte valori).
Cand formularul este expediat catre server pentru fiecare eleme nt selectat al listei
care este se insereaza cate o pereche "name=value" unde name es te numele listei.

<select multiple=”yes” size=”3” name=”orase”>
<option>Bucuresti – B</option>
<option>Craiova – DJ</option> <option selected="yes">Iasi – IS</option> </select>
Intr-un formular campuri de edita re multilinie pot fi incluse c u ajutorul etichetei
<textarea>. Eticheta are urmatoarele atribute:
• atributul cols, care specifica numarul de caractere afisate în tr-o linie;
• atributul rows, care specifica numarul de linii afisate simult an;
• atributul name, care permite atasarea unui nume campului de ed itare multilinie;
• atributul wrap, (de la "word wrap"=trecerea cuvintelor pe rand ul urmator0, care
determina comportamentul campului de editare fata de sfarsitul de linie.
Acest atribut poate primi urmatoarele valori:
a) " off "; in acest caz:
• intreruperea cuvintelor la marginea dreapta a editorului se pr oduce numai cand
doreste utilizatorul;
• caracterul de sfarsit de linie este inclus in textul transmis serverului o data cu
formularul;
b) " hard "; in acest caz:
• se produce intreruperea cuvintelor la marginea dreapta a edito rului ;
• caracterul de sfarsit de linie este inclus in textul transmis serverului o data cu
formularul;
c) " soft "; in acest caz:
• se produce intreruperea cuvintelor la marginea dreapta a edito rului ;
• nu se include caracterul de sfarsit de linie in textul transmi s serverului o data cu
formularul;

72 Programare Web (suport de curs)

<textarea cols="20" rows="5" wrap="hard">
As you can see many times word wrapping is often the desired l ook for your textareas.
Since it makes everything nice and easy to read.
</textarea> <textarea cols="20" rows="5" wrap="hard" readonly="yes"> As you can see many times word wrapping is often the desired lo ok for your text areas.
Since it makes everything nice and easy to read.
</textarea>
Intr-un formular pot fi afisate butoane.Cand utilizatorul apasa un buton, se lanseaza in
executie o functie de tratare a acestui eveniment. Limbajul HTM L nu permite scrierea unor
astfel de functii (acest lucru este posibil daca se utilizeaza limbajele Javascript sau Java).
Pentru a insera un buton într-un formular, se utilizeaza etiche ta <input> avand atributul type
configurat la valoarea "button".Alte doua atribute ale elementu lui "button" sunt:
• atributul name, care permite atasarea unui nume butonului
• atributul
value , care primeste ca valoare textul ce va fi afisat pe buton.
Toate elementele cuprinse într-un formular pot avea un atribut disabled care permite
dezactivarea respectivului element si un atribut readonly care interzice modificarea
continutului acestor elemente.
3.2. XML
Xml (eXtensible Markup Language) este un limbaj care permite defini rea
documentelor ce contin informatii într-un mod structurat. Infor matia structurata dintr-un
document xml are atat continut (cuvinte, imagini, etc.), cat si o indicatie despre rolul pe care il
are acel continut (de exemplu continutul din sectiunea header a re alt rol fata de cel din
footer, care la randul lui e diferit de continutul dintr-un tab el al unei baze de date). Toate
documentele au o anumita structura. Aceste structuri se constru iesc utilizand marcatori.
W3.org se ocupa de standardizarea XML-ului, si specificatiile c omplete ale acestui limbaj se
afla la adresa http://www.w3.org/TR/WD-xml .
In HTML, atat multimea de tag-uri (marcatori), cat si semantica asociata fiecarui tag
sunt predefinite. Spre exemplu <H1> va reprezenta intotdeauna u n header de nivel 1, iar tag-
ul <documentHTML> nu are nici un sens (nu are asociata nici o v aloare semantica).
Standardul XML nu specifica nici semantica si nici multimea de tag-uri ale limbajului. De fapt
XML este un metalimbaj pentru definirea limbajelor bazate pe ma rcatori (markup language).
Cu alte cuvinte XML permite definirea de tag-uri precum si rela tia dintre acestea. Deoarece
nu exista o multime de tag-uri predefinita, nu exista nici o se mantica asociata cu acestea.
Definirea semantica documentelor XML este o sarcina a aplicatii lor care folosesc
documentelor respective sau a foilor de stiluri
Avantaje XML:
• XML descrie continutul si modul de afisare al continutului;
• informatia este mai usor de gasit si manipulat daca este in fo rmat XML;
• XML ofera facilitati multiple si imbunatatite de prezentare (d e exemplu folosind
browserele)
Structura unui document X ML este arborescentă:
<book>
<title>My First XML</title> <prod id="33-657" media="paper"></prod> <chapter>Introduction to XML <para>What is HTML</para> <para>What is XML</para>
</chapter>
<chapter>XML Syntax <para>Elements must have a closing tag</para> <para>Elements must be properly nested</para> </chapter>
</book>

Programarea client – side 73
<book> este elementul rădăcină (root), title, prod și chapter s unt frați (siblings) și sunt copii
(child) lui book.
3.3. CSS – Cascading Style Sheets (foi de stil in cascada)
Stilurile pun la dispozitia creatorilor de site-uri noi posibil itati de personalizare
a paginilor Web. Un stil reprezinta un mod de a scrie un bloc d e text ( adica anumite
valori pentru font, marime culoare, aliniere, distante fata de margini etc). Exista doua
modalitati de a defini un stil:
• sintaxa CSS (Cascading Style Sheets);
• sintaxa Javascript.
O foaie este construită din reguli de stil care spun unui brows er cum să arate
un document. Regulile de stil sunt formate după cum urmează: se lector { property:
value }
Declarațiile de stil multiple pentru un singur selector pot fi despărțite de punct
și virgulă:
selector { property1: v alue1; property2: value2 }
Ca exemplu, următorul segment de cod definește proprietățile cu loare (color)
și mărime-font (font-size) pentru elementele H1 și H2:
<head> <title>exemplu css</title> <style> h1 { font-size: x-large; color: red } h2 { font-size: large; color: blue } </style>
</head>
Orice element HTML este un posibi l selector CSS1. Selectorul es te elementul
care este legatla un stil particu lar. De exemplu, selectorul în declarația CSS: P { text-
indent: 3em }, este P.
Declarațiile CSS pot fi introdus e într-o pagina HTML în 3 modur i: inline, intern
și extern.
1) Declarația inline se realizez ă cu ajutorul tag-ului style. D e exemplu:
<p style="background: blue; color : white;">A new background and font color
with inline CSS</p>
La modul general declarația este de forma: <htmltag style="cssproperty1: value; cssproperty2: value;"> </h tmltag>
O eroare des întâlnită este folo sirea „” în interiorul declaraț iei de mai sus:
<p style="background: url("yellow_rock.gif");">Greșit</p>
<p style="background: url(yellow_rock.gif);">Corect</p>

2) Declarația internă se realizează cu ajutorul tag-ului <style> … </style>
<html> <head> <style type="text/css">
p {color: white; }
body {background-color: black; }
</style> </head> <body> <p>White text on a black background!</p>
</body>
</html>

74 Programare Web (suport de curs)
3) Declarația externă. Atunci când se folosește CSS este de pre ferat să se separe
codul HTML de cosdul CSS. De aceea, declarațiile CSS se pun de obicei într-un fișier
separat, cu extensia .css . Avantajele unei asemenea abordari s unt:
• separarea conținutului paginii de design, crescând lizibilitat ea codului html
• modificarea ușoară a design-ului unui site prin modificarea în tr-un singur fișier
css decât in mai multe pagini html
• reutilizarea ușoară a codului css
Declarația externă se realizează prin intermediul tag-ului <lin k></link>:

<html> <head>
<link rel="stylesheet" type="text/css" href="test.css" />
</head>
<body>
<h3> A White Header </h3> <p> This paragraph has a blue font. The background color of th is page is gray
because we changed it with CSS! </p>
</body>
</html>

Fișierul test.css trebuie să se af le în același director cu pag ina html.
În CSS se pot defini așa numitele clase. Un simplu selector poa te avea diferite
clase, astfel permițându-i acelui ași element să aibă diferite s tiluri. Toate tagurile din
pagina HTML cu aceeași clas ă vor fi forma tate identic.
p.html { color: #191970 } p.css { color: #4b0082 } Exemplul de mai sus a creat două clase, css și html pentru folo sirea cu tag-ul
P al HTML. Caracteristica CLASS (clasă) este folosită în HTML p entru a indica clasa
unui element, ca de exemplu,
<P CLASS = html>Doar o clasă est e permisă pentru un selector. < /P>
<P CLASS = css> De exemplu, p.html.css este invalid.</P>
<P CLASS = html>Acest rând are ac eeași culoare cu primul. </P>

Clasele pot fi declarate fără un element asociat:
.note { font-size: small }
În acest caz, clasa note poate fi folosită cu orice element.

Selectorii ID sunt sunt desemnați cu scopul de a defini element e în mod
individual și nu mai multe elem ente o dată ca în cazul claselor . Un selector ID este
desemnat folosind indicatorul "#" care precede un nume. De exem plu, un selector ID
ar putea fi desemnat astfel:
#text3M { text-indent: 3em } La acest selector se va face ref erință în HTML folosind caracte ristica ID:
<P ID=text3M>Textul are în față un spațiu de mărimea a trei lit ere `m`</P>

O proprietate este desemnată unui selector pentru a-i manipula stilul. Exemplele de
proprietăți includ color, margin, și font.

Programarea client – side 75
Pentru a descrie formatările repetate într-o foaie de stil, gru parea selectorilor și a
declarațiilor este permisă. De exemplu, toate titlurile dintr-u n document ar putea primi
declarații identice prîntr-o grupare:
H1, H2, H3, H4, H5, H6 {color: red; font-family: sans-serif } Toți selectorii care sunt interpuși în cadrul altor selectori v or moșteni valorile
proprietăților selectorilor în cadrul cărora sunt interpuși, da că nu se specifică altfel. De
exemplu, o culoare definită pentru BODY va fi aplicată și textu lui dintr-un paragraf.
Există și cazuri în care selectorul conținut nu moștenește valo rile selectorului care îl
conține, dar acestea ar trebui să se evidențieze în mod logic. De exemplu, proprietatea
margin-top nu este moștenită; în mod intuitiv, un paragraf nu v a avea aceeași margine de
sus cum o va avea tot documentul (prin selectorul body).
O listă completă a selectorilor CSS puteți găsi la
http://www.w3schools.com/css/default.asp

76 Programare Web (suport de curs)
4. Programarea server – side cu ASP.NET
4.1. Serverul IIS
Microsoft Internet Information Services (IIS) este serverul de aplicatii web al Microsoft. El este o
componenta a Windows XP: Add/Remo ve Programs -> Add/Remove Wind ows Components.

4.2. Caracteristici ale ASP si ASP .NET
ASP (Active Server Pages) reprezintă o tehnologie creată de Microso ft pentru a crea
pagini web dinamice, ce are la bază stocarea si execuția script urilor pe serverul Web.
Serverele Web care suporta tehnologia ASP sunt în număr de două :
• PWS – Personal Web Server (Windows 98, Me) si
• IIS – Internet Information Server (Windows NT, 2000 si ulterior).
Principalele caracteristici ale tehnologiei ASP sunt:
• Permite accesarea si actualizarea usoară a bazelor de date;
• Viteză mare de execuție;
• Securitate ridicată, datorită faptului că scriptul nu poate fi vizualizat în
browser;
• Generarea dinamică a răspunsurilor către clienții WEB, etc.

Microsoft .NET este o platforma de dezvoltare software, care ar e menirea de a oferi
programatorilor un mediu in care sunt puse la dispozitie divers e servicii cum sunt:
managementul firelor de executie, managementul duratei de viata a obiectelor (Garbage
Collection), tratarea exceptiilor, etc; si care determina o vit eza mult mai mare a dezvoltarii
aplicatiilor decât direct pe platforma Win32, adica direct pe s istemul de operare Windows.
Inovația adusă de Microsoft, constă în dezvoltarea unei platfor me comune pentru mai
multe limbaje de programare, platformă care permite dezvoltarea unei aplicații în orice limbaj
doreste programatorul. Acest lucru este posibil prin dezvoltare a unui interpretor – Comon
Language Runtime – care transformă codul de program dintr-un li mbaj oarecare, compatibil
cu platforma .NET, în limbajul Microsoft Intermediate Language . Codul rezultat în limbajul
Microsoft Intermediate Language, se poate apoi compila pentru o rice sistem de operare care
are instalat .NET Framework. Paginile web dinamice create cu aj utorul ASP pot îngloba mai
multe tipuri de tehnologii Web existente. De asemenea, scriptur ile din fisierele ASP pot fi si
ele de mai multe tipuri :vbscript, javascript, active server)

Caracteristicile principale ale platformei .NET, sunt:
• Permite integrarea usoară a aplicațiilor Windows cu cele de WE B;

Programarea server – side cu ASP.NET 77
• Facilitează interoperabilitatea între aplicații, indiferent de platforma pentru
care sunt create;
• Asigură serializarea/deserializarea obiectelor;
• Asigură un mediu stabil de programare obiectuală;
• Instalare simplificată, fără conflicte între versiuni;
• Execuția securizată a codurilor;
• Utilizează standardele existente pentru comunicare;
• Înlocuirea mediului script cu cel compilat, în cazul aplicații lor ASP
• Codul de program al unei aplicații, scris într-un anumit limba j de programare,
poate fi integrat fără probleme în altă aplicație, scrisă în al t limbaj de
programare, etc.;

Printre limbajele care suportă .NET , în primul rând trebuie amintite cele dezvoltate de
Microsoft – VB .NET, C# .NET, Visual C++ .NET , cât si limbaje dezvoltate de alte firme:
Borland C#, Cobol, Eiffel, Perl, Phython, Smalltalk, Pascal, Fo rtran, etc.
Limbajele de programare dezvoltate de Microsoft , desi au toate la bază aceeasi
platformă, pot fi clasificate în funcŃie de gradul de complexit ate:
• VB .NET , este cel mai accesibil, fiind o evoluție a mediului Visual Basic 6.0 ;
• C# .NET , este un limbaj „hibrid” între complexitatea limbajului C++ si
accesibilitatea oferită de limbajul VB .NET ;
• VC ++ .NET – este cel mai complex, fiind o evoluție a mediului VC++ 6.0 .
ASP .NET reprezintă o evoluție a ASP bazată pe o nouă tehnologie dezvolt ată de
Microsoft, si anume platforma: .NET Framework. Tehnologia ASP . NET, aduce îmbunătățiri
semnificative față de ASP, cele mai evidente fiind următoarele:
• Execuția este mai rapidă;
• Este independent de programul de navigare pe Internet;
• Codul aplicației este compilat si executat de server; acesta, în cazul ASP,
este interpretat pe măsura parcurgerii scripturilor;
• Utilizează noțiunea de code behind, adică separă partea de pre zentare de
partea de execuție a unei aplicații WEB;
• Favorizează reutilizarea codului, ceea ce în cazul ASP simplu, e r a o
problemă, singura „reutilizare” care se făcea în ASP, fiind ace ea de copiere a
codului;
• Serializarea/deserializarea cu usurință a obiectelor;
• Asigură interoperabilitatea între aplicații WEB, între aplicaț ii WEB si alte
categorii de aplicații;
• Securitate crescută;
Datorită platformei .NET, pot fi înglobate cu usurință în apli cațiile WEB toate
componentele care erau până acum caracteristice doar mediului W indows.
Microsoft ASP .NET este următoarea generație a tehnologiei de d ezvoltare a
aplicațiilor Web. Ea preia tot ce este mai bun de la Active Ser ver Pages (ASP) la fel ca si
serviciile bogate si facilitățile oferite de Common Language Runtime (CLR) si multe alte
facilități noi. Rezultatul este o nouă modalitate de dezvoltare web rapidă, scalabilă si robustă
care permite o mare flexibilitate cu foarte puține linii de cod scrise. Web Forms reprezintă
partea centrală pe care se bazează ASP .NET. Acestea reprezintă elementele de interfață cu
utilizatorul care dau aplicațiilor web aspectul si comportament ul dorit. Formularele Web sunt
similare formularelor Windows prin faptul că oferă proprietăți, metode si evenimente
controalelor plasate pe ele. Totusi, aceste elemente de interfa ță sunt afisate prin intermediul
limbajului HTML, iar în cazul utilizării Microsoft Visual Studi o .NET poate fi folosită interfața
familiară de tip drag-and-drop pentru crearea aspectului formul arelor Web. Formularele Web
sunt constituite din două componente: partea vizuală (fisierul .ASPX) si codul din spatele
formularului, care este stocat în fisiere separate.

78 Programare Web (suport de curs)
4.3. Crearea de aplicații WEB folosind ASP.NET
Pentru a crea aplicații web cu ASP.NET avem nevoie de următoare le instrumente
software:
Microsoft Internet Information Services (IIS) este serverul de aplicatii web al
Microsoft. El este o componenta a Windows XP: Add/Remove Progra ms -> Add/Remove
Windows Components.
Visual WebDeveloper 2005 Express Edition – este un mediu integrat de dezvoltare,
care cuprinde inclusiv unelte de design al Form-urilor web, une lte de debug si deployment.
Colectia de namespaces System.Web . Acestea sunt parte integranta a .NET
Framework si include clase predefinite care se ocupa de chestiu ni specifice aplicatiilor web.
Controalele HTML si server sunt componente ale interfetei cu utilizatorul care sunt
folosite pentru a afisa respectiv colecta informatii catre / di nspre utilizatori.
Limbajul de programare C# .
ADO.NET – sunt clase predefinite care se ocupa de managementul datelor – accesul
la date in baze de date ODBC si Microsoft SQL Server.
4.3.1. Configurarea masinii de lucru pentru proiecte ASP.NET
Va trebui să aveti instalate IIS si Visual WebDeveloper 2005 E xpress Edition, care
instaleaza automat si .NET Framework si inregistreaza ASP.NET i n IIS.
Atentie: daca ati instalat IIS dupa .NET Framework, nu veti putea rula aplicatii
ASP.NET. Pentru a face totusi asta, trebuie să rulati din linia de comanda fisierul
aspnet_regiis.exe cu optiunea –i, din directorul
C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322.
4.3.2. Proiectele ASP.NET in Visual Studio .NET cu C#
Un proiect ASP.NET poate fi creat cu ajutorul Visual WebDevelo per 2005 Express
Edition: File -> New Web Site -> ASP.NET Web Site. Se alege la opțiunea Language limbajul
C#. Se creaza automat de catre IDE urmatoarele fisiere:
• Un Form care este de fapt un fisier Default.aspx , care poate fi vizualizat
in doua moduri: Design si HTML. Acesta contine cod HTML si aici pot fi
asezate prin design contoalele care ruleaza la nivel de server.
• Fiecare fisier .aspx are asociat unul de tip .cs, unde este codul din spatele
Form-ului, adica codul care este executat la nivel de server. S e poate
ajunge la acel fisier cu click dreapta pe Form si View Code. Ac est fisier
are atasate automat cateva namespaces (folosind cuvantul cheie din
limbajul C# using ) , p r i n t r e c a r e s e p o t o b s e r v a s i c e l e d i n f a m i l i a
System.Web.
• Web.config – acesta este un fisier XML in care se pot seta mai multe
informatii de configurare a aplicatiei web. In general, el este folosit pentru
securitate (autentificare), dar si pentru stocarea unor informa tii gen
constante care să poata fi regasite din codul executabil. Avant ajele stocatii
unor astfel de constante in web.config sunt: modificarile in ac est fiser nu
atrag dupa sine necesitatea de recompilare a aplicatiei, respec tiv
informatiile sunt într-un singur loc si pot fi modificate cu us urinta. (În
fereastra soluțion explorer, click dreapta pe website1, add exi sting item și
apoi web.config)
In general, se recomanda ca designul aplicatiilor (din punct d e vedere al ingineriei
software si nu vizual) să respecte anumite criterii. Astfel, da ca ne gandim la modelul
arhitectural pe mai multe nivele:
• User Interface Layer – Form-uri web, in care se fac afisari si de unde se
preiau informatii de la utilizator.
• Business Layer – clase in care se efectueaza operatiile specif ice aplicatiei.

Programarea server – side cu ASP.NET 79
• Data Access Layer – clase care se ocupa cu accesul la baza de date si
trimiterea informatiilor in nivelele superioare.
ASP.NET vine cu cateva controale predefinite, in plus fata de c ele HTML, numite si
controale server, numite asa deoarece tratarea evenimentelor la care acestea raspund se
executa pe server. Visual Studio .NET 2005 are o interfată care permite manipularea facila a
acestora din Toolbox.
ASP.NET 2.0 vine cu peste 50 de noi astfel de controale. Toolbo x-ul este alcatuit din
tab-urile Standard, Data, Validation, Navigation, Login, WebPar ts, HTML si General. Fiecare
tab contine controale specifice.
In ASP.NET 2.0, majoritatea controalelor dispun de Smart Tasks (sau Common
Tasks). Acestea, in functie de controlul in cauza, permit forma tarea controalelor cu stiluri
predefinite, atasarea de date, setarea modului de vizualizare e tc.
Observati ca atunci cand introduceti controale într-un Form web , in codul "din spatele
acestuia", adica in fisierul .cs asociat, se produc niste modif icari: se creaza un nou obiect, in
functie de ce anume ati adaugat, ca instanta al uneia dintre cl asele din spatiul de nume
System.Web.UI.WebControls.
Exista controale folosite la afisare de date: Labels, TextBoxes ; dar in mod curent se
folosesc si unele pentru afisarea unor colectii de informatii, cum ar fi: ListBoxes,
DropDownLists si GridViews. Acestea din urma se folosesc foarte mult in aplicatii de
management al informatiilor, cum ar fi de exemplu una de biblio teca, unde se poate dori
afisarea tuturor cartilor dintr-un anumit domeniu, etc.
Controalele sunt caracterizate prin:
• Proprietati (ID-ul controlului, Text, Font, Activare etc.)
• Evenimente predefinite la care stiu să raspunda (de exemplu, b utoanele au
Click, textbox-urile au TextChanged, etc.)
In momentul in care doriti să tratati un eveniment, să spunem a pasarea unui buton de
catre utilizator, trebuie să asociati un handler evenimentului predefinit Click al butonului
respectiv. Un handler nu este altceva decât o functie, iar asoc ierea respectiva se poate face
foarte usor din Visual Studio.
Pentru cazul anterior, este suficient dublu-click pe buton, pen tru ca să se creeze
automat o metoda de tipul
protected void ButtonX_Click( object sender, EventArgs e){}
4.3.3. Formula re în ASP.NET
Pentru a prezenta informatii in navigatorul clientului folosim formularele Web
ASP.NET care ofera o abstractizare in modelul de programare, un model orientat obiect si
bazat pe evenimente. Acest mediu de lucru beneficiaza de toate facilitatile oferite de
platforma .NET (siguranta tipurilor, mediu de executie controla t, mostenire) si reprezinta o
inlocuire a clasicelor formulare HTML
Componenta vizuala este reprezentata de un fisier cu extensia .aspx-actionand ca
un container pentru HTML, text static si controale server care pot fi afisate in browser, iar
logica aplicatiei este reprezentata de un fisier cu extensia .c s (pentru limbajul Visual C#) sau
.vb (pentru Visual Basic.NET). Fisierele .aspx mai sunt referit e ca pagini ASP.NET. Aceasta
tehnica de separare a codului de partea de prezentare este numi ta"code-behind
programming"
Formularele Web si ASP .NET au fost create pentru a depăsi cât eva dintre limitările
ASP. Principalele facilități noi sunt redate în continuare:
• Separarea interfeței HTML de logica aplicației
• Un set bogat de controale pentru server ce detectează tipul br owserului si
generează limbaj HTML corespunzător acestuia
• Mai puțin cod de scris din cauza modului în care sunt construi te noile
controale server
• Model de programare bazat pe evenimente

80 Programare Web (suport de curs)
• Cod compilat si suport pentru mai multe limbaje de programare, fată de ASP
care era interpretat ori ca VBScript ori ca Jscript
• Permite crearea de controale de către terți care să aducă noi f uncționalități.
Logica aplicatiei reprezinta in fapt o clasa care extinde func tionalitatea clasei
System.Web.UI.Page. Aceasta clasa contine metode care trateaza diferite evenimente ce
apar in timpul executiei formularului Web la server (de exemplu , daca metoda Page_Load
este conectata la evenimentul Load al clasei de baza Page, atun ci aceasta este apelata la
fiecare acces al unui formular Web), proprietati (de exemplu, p rin proprietatea IsPostBack
putem afla daca o pagina Web este la primul acces sau la accesa ri ulterioare), atribute
corespunzatoare unor controale din pagina WebForms si alte date membre necesare
implementarii aplicatiei.
O pagina WebForms, la procesarea pe serverul Web, poate fi priv ita ca un program
executabil pentru care iesirea standard o reprezinta browserul sau dispozitivul client. In acest
model, pagina trece prîntr-o serie de stagii de procesare: init ializare, procesare si eliberare.
In ordinea aparitiei, acestea sunt:
• Init, eveniment care initializeaza pagina si in care proprieta tile controalelor
sunt actualizate. Aici este corect să initializam controale car e se adauga dinamic la pagina
sau variabile necesare inainte de initializarea paginii;
• Load poate fi numit locul in care utilizatorul isi initializea za codul. Evenimentul
este generat de fiecare data cand pagina este incarcata dupa ce controalele au fost
initializate la pasul anterior;
• Tratarea evenimentelor utilizator, reprezinta stagiul in care sunt tratate
evenimentele generate de client cum ar fi: schimbarea unui text într-un control, apasarea
unui buton etc. Trebuie retinut ca aceste evenimente nu sunt tr atate într-o anumita ordine pe
server, iar tratarea lor are loc dupa aparitia unui eveniment C lick care trimite formularul la
server (a unui submit);
• PreRender, eveniment care poate fi folosit pentru a face ultim ile actualizari
asupra paginii Web inainte ca aceasta să fie generata la client ;
• Render, eveniment care genereaza la client reprezentarea HTML a paginii
Web ASP.NET incarcata la server;
• Unload este ultimul eveniment care se executa inainte ca pagin a să fie
eliberata. Evenimentul este util de folosit atunci cand dorim s ă efectuam ultimele operatii de
eliberare a resurselor: inchiderea fisierelor, a conexiunilor l a baza de date si eliberarea
obiectelor din memorie.

4.3.4. Controale în ASP.NET

Exista doua tipuri de baza in care pot fi impartite controalele :
• HTML Controls, reprezinta elemente HTML care pot fi programate la nivelul
serverului si expun un model obiectual restrictionat la capabil itatile
elementelor HTML pe care le afiseaza;
• Web Controls, aduc facilitati superioare controalelor HTML inc luzand
controale mult mai complexe, cum ar fi controlul calendar, iar modelul obiect
nu reflecta neaparat sintaxa HTML.
Controalele HTML sunt asemenea elementelor HTML folosite cu aju torul Frontpage
sau al oricărui alt editor HTML. Pot fi folosite si elementele standard HTML într-un Formular
Web, de exemplu pentru a crea o casetă de text: <input type="te xt" id=txtFirstName
size=25>
Orice element poate fi însă marcat să ruleze ca si un control H TML atunci când
formularul este procesat de server prin adăugarea textului "run at=server" în interiorul tagului.
<input type="text" id=txtFirstName size=25 runat=server>

Programarea server – side cu ASP.NET 81
În cazul folosirii Visual Studio .NET, adăugarea acestui text c e permite procesarea
controlului de către server se poate face foarte simplu dând cl ic dreapta pe elemental HTML
în Design View si selectând Run as Server Control din meniul co ntextual.
Controalele HTML permit de asemenea tratarea evenimentelor asoc iate cu tagul
HTML (clic pe un buton, de exemplu) si manipularea în mod progr amatic a tagului prin codul
din Formularul Web. In momentul în care controlul este afisat î n browser, tagul este afisat
exact asa cum a fost salvat ca si cum a fost salvat pe Formular ul Web, mai puŃin textul
„runat=server”, ceea ce oferă un control foarte precis a ceea c e va fi trimis către browser.
ASP.NET defineste un al doilea tip de controale – Web Controls. Numite si controale
inteligente, ele pot fi caracterizate prin:
• ofera un bogat si consistent model obiectual de programare;
• detecteaza automat tipul navigatorului, iar afisarea la client va fi optimizata in
functie de capabilitatile acestuia;
• pentru unele controale se pot defini sabloane (template-uri) d e afisare;
• posibilitatea de a controla generarea evenimentelor pe server;
• posibilitatea de a trimite ev enimente unui container din inter iorul acestuia (de
exemplu, un control de tip buton in interiorul unui tabel);
• legarea la surse de date a tuturor proprietatilor controalelor pentru a influenta
afisarea la executie.
Sunt definite in spatiul de nume System.Web.UI.WebControls si m ostenesc, direct
sau indirect, clasa de baza WebControl.

4.3.5. Pastrarea informatiilor
Avand in vedere ca ne referim la aplicatii ASP.NET, trebuie să tinem cont de faptul ca
fiecare Form se executa pe server si la fiecare incarcare a sa, obiectele pe care le contine
acesta, si pe care noi dorim să le folosim, nu isi pastreaza va loarea, adica sunt setate pe
null. Deci la navigarea într-un Form nou si incarcarea acestuia , in mod normal nu se retin
obiectele folosite in cel anterior.
Mai trebuie observat faptul ca fiecare Form se reincarca (se ex ecuta Page_Load) la
fiecare raspuns al serverului pentru un eveniment (cum ar fi ap asarea unui buton).
Se impune deci să pastram starea obiectelor pe care dorim să le folosim, chiar daca
nu parasim Form-ul curent.
Exista urmatoarele modalitati de a pastra informatii utile: Que ry Strings, Cookies,
View State, Session State, Application State.
Session State: Variabilele din Session pot fi create in timpul executiei, iar acesta
poate fi imaginat ca un cos in care depunem obiecte pe care dor im să le pastram pe durata
intregii executii a aplicatiei de catre utilizatorul curent. As tfel ar arata crearea unui nou obiect
in Session:
Session["Feedback"] = objFeedback; Iar “luarea” lui din Session: objFeedback = (Feedback)Session["Feedback"]; Se observa ca s-a facut o conversie de tip. În Session, toate v ariabilele sunt de tip
object, iar atribuirea se face unui obiect de tip Feedback (o c lasa definită de utilizator).

4.3.6. Navigarea intre Forms cu pastrarea informatiilor
Exista mai multe posibilitati de a naviga intre Form-urile unei aplicatii ASP.NET.
Controlul Hyperlink si metoda Response.Redirect() fac acelasi l ucru, diferența fiind ca
primul este un control care rezida in .aspx, iar metoda se apel eaza din cod (.aspx.cs).
Medoda Server.Transfer(), face acelasi lucru doar ca asa se pot retine informatii din
Form-ul sursa si folosite in cel destinatie. Daca setam paramet rul preserveForm al metodei la
valoarea true, atunci QueryString si ViewState din sursa vor fi vizibile in destinatie. Totusi,
pentru a le folosi, va trebui să setam atributul EnableViewStat eMac din directiva Page

82 Programare Web (suport de curs)
(fisierul .aspx) pe valoarea false. Deoarece in mod normal info rmatia din ViewState este
hash-uita, iar asa nu va mai fi, deci se va putea citi la nevoie

4.3.7. Securitatea în ASP.NET
Exista mai multe moduri de a securiza o aplicatie ASP.NET. In g eneral, se poate face
acest lucru atat din IIS Management Console (click dreapta pe u n director virtual din IIS,
Properties, Directory Security, Edit) – unde se pot alege mai m ulte tipuri de autentificare
{Anonymous, Windows Integrated, Digest for Windows domain serve rs, Basic}.
Pe de alta parte, securizarea aplicatiei se poate face din ASP. NET. Pentru asta se
foloseste fisierul de configurare web.config, dupa cum se vede mai jos. Forms poate fi
inlocuit cu Windows sau Passport.
<authentication mode="Forms">
In primul rand, trebuie totusi să vorbim de aplicatii publice care nu necesita nici un fel
de autentificare. Trebuie să fiti atenti, acesta este modul imp licit in care este creata o noua
aplicatie ASP.NET. Atunci cand se creează un proiect ASP.NET cu Visual Studio, se creaza
o aplicatie web accesibila anonim.
In momentul in care in IIS se activează Anonymous Access pe un director virtual
(adica pe o aplicatie web), atunci cand un utilizator acceseaza aplicatia, el ia automat contul
IUSR_<numele_masinii>, care in mod normal se afla in grupul de utilizatori Guest pe orice
masina. Acest cont trebuie să aibă dreptul de a citi fisierele care sunt necesare aplicatiei. De
exemplu, daca aplicatia foloseste la un moment dat Form-ul “Stu dent.aspx”, atunci
IUSR_<numele_masinii> trebuie să aibă dreptul de a citi fisieru l de pe hard-disk
corespunzator, să spunem “c:\Inetpub\wwwroot\library\student.as px”.
Pentru o aplicatie securizata, avem mai multe posibilitati de a utentificare, cele mai
des intalnite fiind sintetizate in tabelul de pe slide. Impleme ntarea politicii de securitate se
poate face atat din IIS cat si din aplicatia ASP.NET.

Tipul
aplicatiei Modul
de autentificareDescriere
Aplicatie web
publica pe Internet. Anonim Nu avem nevoie de
securizare.
Aplicatie web
pentru Intranet. Windows
Integrated Acest mod autentifca
utilizatorii folosind lista de useri
de pe server (Domain
Controller). Drepturile userilor
in aplicatia web este dat de
nivelul de privilegii al contului
respectiv.
Aplicatie web
disponibila pe
Internet, dar cu
acces privat. Windows
Integrated Utilizatorii companiei
pot accesa aplicatia din afara
Intranetului, folosind conturi din
lista serverului (Domain
Controller).
Aplicatii web
comerciale. Forms
Authentication Aplicatii care au nevoie
de informatii confidentiale si
eventual in care sunt mai multe
tipuri de utilizatori.

Programarea server – side cu ASP.NET 83
4.3.7.1.1 Windows Authentication
În acest mod de autentificare, aplicația ASP .NET are încorpora te procedurile de
autentificare, dar se bazează pe sistemul de operare Windows pe ntru autentificarea
utilizatorului.
1. Utilizatorul solicită o pagină securizată de la aplicația We b.
2. Cererea ajunge la Serverul Web IIS care compară datele de au tentificare ale
utilizatorului cu cele ale aplicației (sau ale domeniului)
3. Dacă acestea două nu corespund, IIS refuză cererea utilizato rului.
4. Calculatorul clientului generează o fereastră de autentifica re,
5. Clientul introduce datele de autentificare, după care retrim ite cererea către IIS
6. IIS verifică datele de autentificare, si în cazul în care su nt corecte, direcționează
cererea către aplicația Web.
7. Pagina securizată este returnată utilizatorului.
4.3.7.1.2 Forms-Based Authentication
Atunci când se utilizează autentificarea bazată pe formulare, I IS nu realizează
autentificarea, deci este necesar ca în setările acestuia să fi e permis accesul anonim.
1. În momentul în care un utilizator solicită o pagină securiza tă, IIS autentifică clientul
ca fiind un utilizator anonim, după care trimite cererea către ASP.NET.
2. Acesta verifică pe calculatorul clientului prezența unui anu mit cookie1
3. Dacă cookie-ul nu este prezent sau este invalid, ASP .NET re fuză cererea
clientului si returnează o pagină de autentificare (Login.aspx) .
4. Clientul completează informațiile cerute în pagina de autent ificare si apoi trimite
informațiile
5. Din nou, IIS autentifică clientul ca fiind un utilizator ano nim si trimite cererea către
ASP .NET
6. ASP .NET autentifică clientul pe baza informațiilor furnizat e. De asemenea
generează si un cookie.
Cookie reprezintă un mic fisier text ce păstrează diverse infor mații despre utilizatorul
respectiv, informații folosite la următoarea vizită a să pe sit e-ul respectiv, la autentificare, sau
în diverse alte scopuri.
7. Pagina securizată cerută si noul cookie sunt returnate clien tului. Atâta timp cât
acest cookie rămâne valid, clientul poate solicita si vizualiza orice pagină securizată ce
utilizează aceleasi informații de autentificare.
4.3.7.1.3 Passport Authentication
La utilizarea Serviciului Web Microsoft Passport, nici IIS nici aplicația Web nu se
ocupă de autentificarea clientului. Atunci când utilizatorul ce re o pagină securizată, cererea
este trimisă mai întâi serverului IIS.
1. IIS autentifică clientul ca utilizator anonim si trimite cer erea către ASP .NET.
2. Acesta verifică prezența unui anumit cookie pe calculatorul clientului.
3. Dacă cookie-ul nu există, cererea este refuzată si clientul este direcționat către
site-ul Web Passport.com pentru autentificare.
4. Site-ul Passport.com generează un formular de Login pe care îl trimite utilizatorului
5. Utilizatorul completează cu datele corespunzătoare si le tri mite înapoi către
Passport.com. 6. Dacă informațiile introduse se potrivesc cu cele din baza de date Passport.com, clientul
este autentificat si primeste un cookie corespunzător informați ilor introduse.

4.4. ADO.NET
ADO.NET este componenta din .NET Framework care se ocupa cu acc esul la baze
de date ; este standardizata in sensul ca se pot folosi aceleas i obiecte pentru accesarea

84 Programare Web (suport de curs)
diferitelor tipuri de baze de date : Access, MS SQL Server, Ora cle, etc. Sunt necesare la
referinte doua namespaces : System.Data si System.Data.SqlClien t pentru MS SQL sau
System.Data.OleDb pentru Access.
Mecanismul accesarii bazelor de date in ADO.NET este urmatorul: un obiect
Connection stabileste o conexiune intre aplicatie si baza de da te. Aceasta conexiune poate fi
accesata direct de un obiect Command sau de un obiect DataAdapt er. Obiectul Command
executa o comanda asupra bazei de date. Daca se returneaza valo ri multiple, se utilizeaza
un obiect DataReader care va contine datele returnate. Aceste d ate pot fi procesate direct de
de aplicatie. Alternativ, se poate utiliza un DataAdapter pentr u a popula un obiect DataSet.
Modificarile asupra bazei de date se pot efectua prin intermedi ul unui obiect Command sau
unui obiect DataAdapter.
Connection reprezinta conexiunea curenta la baza de date.
Tipuri de conexiuni:
• SqlConnection – pentru conectarea la SQL Server 7 sau versiuni ulterioare
• OleDbConnection – conexiuni la diverse tipuri de baze de date
• ODBCConnection
• OracleConnection
Un obiect Connection contine toate informatiile necesare deschi derii unui canal de
comunicatie cu baza de date in cadrul proprietatii ConnectionSt ring. Sunt incorporate, de
asemenea, metode pentru facilitarea tranzactiiilor.
Command este reprezentat de doua clase: SqlCommand si OleDbComm and Utilizat
pentru a efectua apeluri de proceduri stocate sau de comenzi SQ L asupra bazei de date sau
pentru a returna tabele.
Metode:
• ExecuteNonQuery – executa comenzi care nu returneaza inregistr ari –
INSERT, UPDATE, DELETE
• ExecuteScalar – returneaza o singura valoare dîntr-o interogar e
• ExecuteReader – returneaza o multime rezultat, sub forma unui obiect
DataReader
DataReader
• contine un recordset bazat pe conexiune, forward-only, read-on ly
• obiectele DataReader nu pot fi instantiate direct, sunt return ate ca rezultat al
metodei ExecuteReader a unui obiect Command (SqlCommand –
SqlDataReader etc)
• o singura linie din recordset este in memorie la un moment dat , deci se
foloseste un minim de resurse, dar este necesara mentinerea act iva a unui
obiect Connection pe durata de viata a obiectului DataReader
DataAdapter este clasa din nucleul tehnologiei ADO.NET, bazata pe mecanismul
non-conexiune.
• faciliteaza comunicarea intre baza de date si DataSet
• populeaza obiectele DataTable sau DataSet ori de cate ori se a peleaza
metoda Fill
• metoda Update inregistreaza modificarile, efectuate local, in baza de date
La apelul metodei Update, se copie modificarile din DataSet in baza de date,
executandu-se una din comenzile reprezentate de InsertCommand, DeleteCommand sau
UpdateCommand.
Exista controale folosite la afisare de date: Labels , TextBoxes – informatii unicate;
dar in mod curent se folosesc si unele pentru afisarea unor col ectii de informatii, cum ar fi:
ListBoxes , DropDownLists s i GridViews . Acestea din urma se folosesc foarte mult in
aplicatii de management al informatiilor, cum ar fi de exemplu una de biblioteca, unde se
poate dori afisarea tuturor cartilor dintr-un anumit domeniu, e tc.

Programarea server – side cu ASP.NET 85

4.4.1. Obiectele ADO.Net 4.4.1.1.1 SqlConnection
Un obiect SqlConnection este la fel ca orice alt obiec t C#. de cele mai multe ori
declararea si instantierea se face in acelasi timp:
SqlConnection sqlConn = new SqlConnection( "Data Source=(local) ;Initial
Catalog=Northwind;Integrated Security=SSPI");
SqlConnection sqlConn1 = new SqlConnection("Data Source=Databas eServer;Initial
Catalog=Northwind;User ID=YourUserID;Password=YourPassword");
OleDbConnection oleDbConn = new
OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=M yDatabase.mdb");

Obiectul SqlConnection de mai sus este instantiat folosind un c onstructor care
primeste ca parametru un string. Acest argument este stringul d e conectare.
Scopul instantierii unui obiect de tip SqlConnection este ca al te obiecte ADO.Net să
poata lucra cu baza de date. Alte obiecte, cum ar fi SqlDataAda pter si SqlCommand, au
constructori care primesc obiectul conexiune ca parametru. Atun ci cand se lucreaza cu o
baza de date trebuie urmati pasii:
1. Instantierea unui obiect SqlConnection; 2. Deschiderea conexiunii;
3. Trimiterea conexiunii ca parametru altor obiecte ADO.Net;
4. Realizarea operatiunilor asupra bazei de date; 5. Inchiderea conexiunii.

4.4.1.1.2 SqlCommand
Obiectele de tipul SqlCommand permit specificare tipului de act iune asupra bazei de
date. De exemplu se poate face o interogare, inserare, modifica re sau stergere.
Atunci cand se realizează o interogare in baza de date, se obți ne un tabel rezultat
care trebuie să poata fi vizualizat. Pentru a obtine acest lucr u folosind obiecte SqlCommand
este folosita metoda ExecuteReader care intoarce un obiect de t ipul SqlDataReader.
Exemplul de mai jos arata modul de obtinere a unei instante SqlDataReader .
SqlCommand cmd = new SqlCommand ("SELECT CategoryName FROM Cate gories",
conn);
SqlDataReader rdr = cmd.ExecuteReader();
Pentru a insera valori într-o baza de date trebuie apelata func tia ExecuteNonQuery
pe un obiect SqlCommand. Exemplul urmator arata modul de insera re într-o baza de date.

string insertString = @"INSERT INTO Categories (CategoryName, D escription)
VALUES ('Miscellaneous', 'Whatever doesn''t fit elsewhere')" ;
SqlCommand cmd = new SqlCommand (insertString, conn);
cmd.ExecuteNonQuery();
Modificarea si stergerea datelor dîntr-o baza de date se face l a fel ca si inserarea,
dar ca punem primul parametru al constructorului SqlCommand pe valoarea
corespunzatoare.
Uneori avem nevoie dîntr-o baza de date doar de o singura valoa re, care poate fi
suma, media, etc. inregistrarilor dintr-un tabel. Apeland Execu teReader si apoi calculand
acea valoare in program nu este cea mai eficienta metoda de a a junge la rezultat. Cea mai
buna metoda este să lasam baa de date să faca ceea ce este nece sar si să intoarca o
singura valoare. Acest lucru il face metoda ExecuteScalar:

SqlCommand cmd = new SqlCommand ("SELECT count(*) FROM Categori es", conn);

86 Programare Web (suport de curs)
int count = (int) cmd.ExecuteScalar();

4.4.1.1.3 SqlDataReader
Tipul SqlDataReader este folosit pentru a citi date in cea mai eficienta metoda
posibila. NU poate fi folosit pentru scriere. O data citita o i nformatie nu mai poate fi citita inca
o data. SqlDataReader citeste secvential date.
Datprita faptului ca citeste doar inainte (forward-only) permit e acestui tip de date să
fie foarte rapid in citire. Overhead-ul asociat este foarte mic (overhead generat cu
inspectarea rezultatului si a scrierii in baza de date). Daca î ntr-o aplicatie este nevoie doar
de informatii care vor fi citite o singura data, sau rezultatul unei interogari este prea mare ca
să fie retinut in memorie (caching) SqlDataReader este solutia cea mai buna.
Obtinerea unei instante de tipul SqlDataReader este putin difer ita de instantierea
normala – trebuie apelata metoda ExecuteDataReader. Daca pentru instantiere este folosit
operatorul new veti obtine un obiect cu care nu puteti face nim ic pentru ca nu are o
conexiune si o comanda atasate.
SqlDataReader obtine datele într-un stream secvential. Pentru a citi aceste informatii
trebuie apelata metoda Read; aceasta citeste un singur rand din tabelul rezultat. Metoda
clasica de a citi informatia dintr-un SqlDataReader este de a i tera într-o bucla while asa cum
se vede in figura 4 la liniile 32-35.
Metoda Read intoarce true cat timp mai este ceva de citit din s tream.

4.4.1.1.4
4.4.1.1.5 Instalarea unei aplicaț ii web pe serverul IIS

Evident ca dupa dezvoltarea unei aplicatii, ea trebuie livrata beneficiarului. Pentru ca
ea să mearga, este nevoie să fie “depusa” pe serverul acestuia de web. In primul rand,
fisierele trebuie copiate undeva pe hard-disk-ul serverului web (nu neaparat in calea
predefinita …\Inetpub\wwwroot\). Dupa aceea, in IIS-ul server-u lui web, trebuie creat un nou
director virtual, care să indice catre calea directorului fizic unde se afla de fapt aplicatia.
Deci, dupa ce ati depus proiectul ASP.NET pe serverul web (ast a se face prin simpla
copiere), mergeti in IIS, click dreapta pe Default Web Site, Ne w -> Virtual Directory, alegeti
un Alias (acesta va fi de fapt numele aplicatiei asa cum va fi ea vazuta din afara), navigati la
calea directorului propriu-zis si … gata. Acum, aplicatia va pu tea fi referita din exterior cu
numele: http://<nume_server>/<alias> ; unde <nume_server> este de fapt situl principal
expus de serverul web, iar <alias> este ce ati ales voi la crea rea directorului virtual in IIS.
Evident, trebuie neaparat să aveti grija de securizarea aplica tiei daca este cazul,
dupa cum se vede si in paragraful precedent.
4.4.2. Configurare, mentenanta
Avantajele folosirii unui fisier web.config. In primul si in pr imul rand, să ne imaginam o
aplicatie de E-Commerce care lucreaza cu un server de baze de d ate si să ne imaginam ca
noi facem aplicatia si o dam la mai multi clienti.
In mod evident, serverul de baze de date se va numi in mod dif erit la fiecare client.
Cum facem deci să putem livra aplicatia clientilor, fara a reco mpila codul la fiecare ? Cum
facem conexiunea la baza de date pentru fiecare client ? Ei bin e, folosim web.config :

<appSettings>
<add key="Database" value="Data Source=MISHU\MISHUSQL;Initial
Catalog=elearning;User Id=***;Password=***" />
</appSettings>

Dupa cum se poate vedea aici, am pus o inregistrare care contin e chiar un string de
conexiune la baza de date. Cum fac conexiunea in aplicatia mea ? Caut in web.config o
cheie cu numele « Database ». Iata:

Programarea server – side cu ASP.NET 87

public static SqlConnection ConnectToDB() { string strParameters; System.Configuration.AppSettingsReader apsr = new
System.Configuration.AppSettingsReader();
strParameters = (string)apsr.GetValue("Database",typeof(string ));
SqlConnection sqlConn = new SqlConnection(strParameters);
return sqlConn;
}

88 Programare Web (suport de curs)
5. Referinte

http://www.sei.cmu.edu/str/descr iptions/clientserver_body.html
http://en.wikipedia.org/wiki/Multitier_architecture
http://en.wikipedia.org/wiki/Service-oriented_architecture
http://en.wikipedia.org/wiki/Model-view-controller
http://en.wikipedia.org/wiki/OSI_Model
http://en.wikipedia.org/wiki/Internet_protocol_suite
http://www.w3schools.com/web/web_scripting.asp http://en.wikipedia.org/wiki/HTTP

http://www.w3.org/TR/html401/
http://www.w3schools.com/html/default.asp
http://www.w3.org/Style/CSS/
http://www.w3schools.com/css/default.asp http://en.wikipedia.org/wiki/.NET_Framework http://www.charlespetzold.com/dotnet/

Proiectarea,
organizarea
și evaluarea
activitãților didactice

MiniGhid Metodologic Informatică & TIC
91

Cuprins

I.Programa școlară reper obligat oriu pentru un demers flexibil… ………………93
II.Aplicarea programelor școlare…………………………. ………………………………………9 4
III.Proiectarea demersului didactic………………………. ……………………………………..95
III.1. Lectura personalizată a programelor școlare
III.2. Planificarea calendaristică III.3. Proiectarea unei unități de învățare
III.4. Proiectarea activității de evaluare
III.4.1. Tipuri de itemi III.4.2. Metode complementare de evaluare

IV. Proiectul unității de învăț are – Proiectu l de lecție ?… …………….. …………….107
V. Anexe ……………… …………………………………………………………108
1. Planificări calendaristice și P roiecte de unităț i de învățare

MiniGhid Metodologic Informatică & TIC
93

I.Programa școlară reper obligat oriu pentru un demers flexibil

Programa școlară este parte a Curriculumului na tional. Termenul de curriculum d erivă din limba latină
unde, printre altele înseamna drum către .
Programa școlară descrie oferta educațională a unei anumite discipline pentru u n parcurs școlar determinat
Filosofia contemporană a educației a evidențiat diferența dintr e o educație bazată pe curriculum , adică
având ca element central la toate etajele sale activiatea de proiectare ș i programa analitică , care are în
centrul activității didactice ideea de programare a traseului elevului către un țel cunoscut și impus doar de
către adulți.
Conceptual, programele școlare actuale , se diferențiază de ,,program ele analitice" prin accentul pe c are îl
pun pe interiorizarea unui mod de gândire specific fiecărui dom eniu transpus în școală prin intermediul unui
obiect de studiu, nu pe succesiunea conținuturilor și pe număru l de ore alocat lor.
Actualele programe școlare subliniază importanța rolului regla tor al achizițiilor elevilor în plan formativ .
Centrarea pe competențe reprezintă modalitatea care face ca sin tagma centrarea pe elev să nu rămână o
lozincă fără conținut.

Proiectarea curriculumului p e competențe vine în întâmpinarea cercetărilor din psihologia cognitivă,
conform cărora prin competență se realizează în mod exemplar tr anferul și mobilizarea cunoștințelor și a
depriderilor în situații/contexte noi și dinamice.
Modelul de proiectare curriculară centrat pe competențe simplif ică structura curriculumului și asigură o mai
mare eficiență a proceselor de predare/învățare și evaluare. Ac esta permite operarea la toate nivelurile cu
aceeași unitate: competența, în măsură să orienteze demersurile agenților implicați în procesul de educație:
• conceptorii de curriculum; • inspectorii;
• specialiștii în evaluare; • elevii;
• profesorii; • părinții .
Fără a intra în detalii conceptu ale, formulăm câteva definiții de lucru necesare pentru explicarea manierei în
care au fost concepute programele școlare.
Definim competențele ca fiind ansambluri structurate de cunoștințe și deprinderi do bândite prin învățare;
acestea permit identificarea și r ezolvarea în contexte diverse a unor probleme caracteristice unui anumit
domeniu.
Structura programei școlare cuprinde: o notă de prezentare, competențe generale, competențe specifice și
conținuturi, valori și atitudini, sugestii metodologice.
9 Competențele generale se definesc pe obiect de studiu și se formează pe durata învăț ământului liceal.
Ele au un grad ridicat de generalitate și complexitate și au ro lul de a orienta demersul didactic către
achizițiile finale ale elevului.
9 Competențele specifice se definesc pe obiect de studiu și se formează pe parcursul un ui an școlar. Ele
sunt derivate din competențele generale, fiind etape în dobândi rea acestora. Competențelor specifice li se
asociază prin programă unități de conținut.
Componenta fundamentală a program ei este cea referitoare la com petențe specifice și conținuturi.
Pentru a asigura o marjă cât mai largă de acoperire a obiectelo r de studiu, s-a pornit de la o diferențiere cât
mai fină a etapelor unui proces de învățare . Acestora le corespund categorii de competențe organizate în
jurul câtorva verbe definitorii , ce exprimă complexe de operații mentale:
1. Receptarea – concretizată prin următoa rele concepte operaționale:
-identificarea de termeni, relații, procese;
– observarea unor fenomene, procese;
– perceperea unor relații, conexiuni; – nominalizarea unor concepte;
– culegerea de date din surse variate;
– definirea unor concepte.
2. Prelucrarea primară (a datelor) – concretizată prin următoarele concepte operațio nale:
– compararea unor date, stabilirea unor relații;
– calcularea unor rezultate parțiale;
– clasificarea datelor;
– reprezentarea unor date; – sortarea-discriminarea;
– investigarea, descoperirea, explorarea;
– experimentarea.
3.Algoritmizarea – concretizată prin urmatoarele concepte operaționale:
-reducerea la o schemă sau model; -anticiparea unor rezultate;

MiniGhid Metodologic Informatică & TIC
94 -remarcarea unor invarianți;
-reprezentarea datelor -rezolvarea de probleme prin modelare si
algoritmizare.
4.Exprimarea – concretizata prin urmatoare le concepte operaționale:
-descrierea unor stări, sisteme, procese, fenomene;
-generarea de idei; -argumentarea unor enunțuri;
-demonstrarea.
5.Prelucrarea secundară (a rezultatelor) – concretizată pr in urmatoarele concepte opera ționale:
-compararea unor rezultate, date de ieșire, concluzii;
-calcularea, evaluarea unor rezultate;
-interpretarea rezultatelor;
-analiza de situații; -elaborarea de strategii;
-relaționări între diferite tipuri de reprezentări,
între reprezentare și obiect.
6.Transferul, care poate fi concretizat prin urmatoarele concepte operațional e:
-aplicarea în alte domenii;
-generalizarea și particularizarea;
-integrarea unor domenii;
-verificarea unor rezultate;
-optimizarea unor rezultate; i: -transpunerea într-o altă sferă;
-negocierea;
-realizarea de conexiuni între rezultate;
-adaptarea și adecvarea la context.

Competențele generale ce se urmăresc a fi formate la elevi pe p arcursul treptei liceale de școlarizare
precum și competențele specifice fiecărui an de studiu, derivat e din acestea, se stabil esc pornind de la modelul
de generare prin gruparea categoriilor de concepte operaționale in funcție de dominan tele avute in vedere.

9 Valorile și atitudinile apar în mod explicit sub forma unei liste separate in programa fiecărui obiect
d e s t u d i u . E l e a c o p e r ă î n t r e g p a rcursul învățăma ntului liceal ș i orientează dimensiunile axioiogică si
afectiv-atitudinală aferente formării personalitaiii din perspective fiecărei discipline. Realizarea lor
concretă derivă din activitatea didactică permanentă a profesor ului, constituind un implicit al acesteia.
Valorile si atitudinile au o impor tanță egală în reglarea proce sului educativ ca și competențele – care
acoperă dimensiunea cognitiva a personalității – dar se supun a ltor criterii de organizare didactico-
metodică și de evaluare.

9 Sugestiile metodologice cuprind recomandări generale privind metodologia de aplicare a programei.
Aceste recomandari se pot referi la:
– desfasurarea efectivă a procesul ui de predare/învățare, centrat pe formarea de competențe:
– identificarea celor mai adecvate metode și activități de învăța re;
– dotări/materiale necesare pentru aplicarea în condiții optime a programei;
– evaluarea continuă.

Dincolo de structura unitară a p rogramelor școlare, curriculumu l național actual propune o ofertă flexibilă ,
ce permite profesorului adaptarea cadrului formal la personalitatea sa și la specificul clasei de elevi cu care
lucrează. Elementele care asigură acest reglaj sunt:
– posibilitatea intervenției profeso rului în succesiunea elemente lor de conținut, cu condiția asigurării
coerenței tematice și a respectăr ii logicii interne a domeniulu i;
– lipsa prescrierii de la centru a intervalului de timp alocat el ementelor de conținut;
– posibilitatea modificării, a completării sau a înlocuirii activ ităților de învățare, astfel încât acestea să
permită un demers didactic personalizat.

II.Aplicarea programelor școlare

Existența unor programe centra te pe achizițiile elevilor determ ină un anumit sens al schimbării în didactica
fiecărei discipline. Tabelul de mai jos prezintă în antiteză ca racteristici ale procesului de predare-învățare din
didactica tradiționala și didactica actuală.

Criterii Strategii didactice
Orientare tradițională Orientare modernă
Rolul elevului Urmărește prelegerea, expunerea, explicația
profesorului. Exprimă puncte de vedere proprii.
Încearcă sa rețină și sa reproducă ideile auzite Realizează un schimb de idei cu ceilalți.
Acceptă în mod pasiv ideile transmise. Argumentează; pune și î și pune întrebări cu sco-
pul de a înțelege, de a realiza sensul unor idei

MiniGhid Metodologic Informatică & TIC
95 Lucrează izolat. Cooperează în rezolvarea problemelor și a
sarcinilor de lucru.
Rolul
profesorului Expune, ține prelegeri. Facilit ează și moderează învățarea.
Impune puncte de vedere. Ajută elevii să înțeleagă și să expli ce punctele
de vedere proprii.
Se consideră și se manifestă în permanență
„ca un părinte"'. Este partener în învățare.
Modul de
realizare a
învățării Învățarea are loc predominant prin memorare
și reproducere de cunoștințe, prin apel doar la
exemple „clasice", validate. Învățarea are loc predom inant prin formare de
competențe și deprinderi practice.
Învățarea conduce la competiție între elevi,
cu scopul de ierarhizare Învățarea se realizează prin cooperare.
Evaluarea Vizează măsurarea și aprecierea cunoștin țelor
(ce știe elevul). Vizează măsurarea și aprecierea competențelor
(ce poate să facă elevul cu ceea ce știe).
Pune accent pe aspectul cantitativ (cât de
multă informație deține elevul). Pune accent pe elementele de ordin calitativ
(valori, atitudini).
Vizează clasificarea „statică" a elevilor, Vizează progresul î n învățare pentru fiecare
elev.

De fapt, diferența dintre didactica tradițională și cea actuală constă în modul de concepere și
organizare a situațiilor de învățare (riguros dirijate în primul caz și având autonomie de diferite grade, în
cel de-al doilea). Altfel spus, o strategie este legitimă sau i legitimă nu în general, ci potrivit unor
circumstanțe concrete; profesorul eficient este acela care știe:
o să selecționeze
o să combine
o să varieze diferite metode
o să aleagă strategii adecvate .

III.Proiectarea demersului didactic

Predarea reprezintă activitatea profesorului de organizare și conducer e a ofertelor de învățare care are
drept scop facilitarea și stimularea învățării eficiente la ele vi.
Proiectarea demersului didactic este acea activitate desfășura tă de profesor care constă în anticiparea
etapelor și a acțiunilor concrete de realizare a predării. Pro iectarea demersului didactic presupune:
– lectura personalizată a programelor școlare;
– planificarea calendaristică;
– proiectarea secvențială (a unităților de învățare).

III.1. Lectura personalizată a programelor școlare
În contextul noului curriculum, conceptul central al proiectări i didactice este demersul didactic personalizat,
iar instrumentul acestuia este unitatea de învățare . Demersul personalizat exprimă dreptul profesorului – ca
și al autorului de manual – de a lua decizii asupra modalitățil or pe care le consideră optime în creșterea
calității procesului de învatamant, respectiv, răspunderea personală pentru a asigura elevilor un parcurs școlar
individualizat, în funcție de condiții și cerințe concrete.

LECTURAREA PROGRAMEI se realizează “pe orizontală” în succesiun ea următoare:

Competente Competente Conținuturi Activități
Generale → Specifice → → de învățare

III.2.Planificarea calendaristică

În contextul noului curriculum, planificarea calendaristică este un document administrativ care asociază
elemente ale programei cu alocar ea de timp consid erată optimă d e către profesor pe parcursul unui an școlar.
În elaborarea planificărilor ca lendaristice recomandăm parcurge rea următoarelor etape:
1. Realizarea asocierilor dintre competențele specifice și conținuturi.
2. Împărțirea în unități de învățare.
3. Stabilirea succesiunii de parcu rgere a unităților de învățare.

MiniGhid Metodologic Informatică & TIC
96 4. Alocarea timpului considerat necesar pentru fiecare unitate de învățare, în concordanță cu competențele
specifice și conți nuturile vizate.
Planificările pot fi intocmite pornind de la următoarea rubrica ție

Unitatea școlară…………………
Disciplina……………………….. Profesor…………………………..
Clasa/Nr. ore pe săpt./ …………..

Planificare calendaristică
Anul școlar…………..
Unități de
învățare Competențe
specifice Conținuturi Nr. de ore
alocate Săptămâna Observatii

In acest tabel:
• Unitățile de învățare se indică prin titluri (teme) stabilite d e către profesor.
• In rubrica Competențe specifice s e trec simboluril e competențel or specifice din p rograma școlară.
• Continuturile selectate sunt cele extrase din lista de continut uri ale programei.
• Numarul de ore alocate se stabileste de catre profesor in funcț ie de experiența acestuia și de nivelul de achiziții
ale elevilor clasei.
Întregul cuprins al planificării are valoare orientativă, eventualele modificări determinate de aplicarea
efectivă la clasă putând fi consemnate în rubrica Observații.
O planificare anuală corect înto cmită trebuie să acopere integr al programa școlară la nivel de competențe
specifice și conținuturi.

III.3. Proiectarea unei unități de învățare

Elementul generator al planifică rii calendaristice este unitate a de învățare.
O unitate de învățare reprezintă o structură didactică deschis ă și flexibilă,care are următoarele caracteristici:
– determină formarea la elevi a unui comportament specific, gen erat prin integrarea unor competențe specifice;
– este unitară din punct de vedere tematic;
– se desfășoară în mod sistematic și continuu pe o perioadă de timp;
– se finalizează prin evaluare.
Detaliem în continuare elementele esențiale ale proiectării une i unități de învățare.
Se recomandă utilizarea următorului format.

Unitatea școlară…………………
Disciplina……………………….. Profesor…………………………..
Clasa/Nr. ore pe săpt./ …………..

Proiectul unității de învățare…………………………………..
Nr. de ore alocate………………..

Conținuturi Competențe
specificeActivități de învățare Resurse Evaluare Observatii

• Conținuturi: apar inclusiv detalieri de conținut necesare în ex plicitarea anumitor parcursuri, respectiv în
cuplarea lor la baza proprie de cunoastere a elevilor.
• In rubrica Competențe specifice s e trec simboluril e competențel or specifice din programa școlară
• Activitățile de învățare pot fi cele din programa școlară, comp letate, modificate sau chiar înlocuite de
altele, pe care profesorul le consideră adecvate pentru atinger ea obiectivelor propuse.
• Rubrica Resurse cuprinde specificări de timp, de loc, forme de organizare a clasei,
material didactic folosit etc.
• în rubrica Evaluare se menționează instrumentele s au modalitați le de evaluare aplicate la clasă.
Finalul fiecărei unități de învățare presupune Evaluare sumativă.

MiniGhid Metodologic Informatică & TIC
97 Desi denumirea si alocarea de ti mp pentru unitățile de învățare se stabilesc la începutul anului școlar prin
planificare, este recomandabil ca proiectele unitaților de înva țare să se completeze ritmic pe parcursul anului,
având în avans un interval de timp optim pentru ca acestea să r eflecte cât mai bine realitatea.
In completarea rubricației, se urmarește corelarea elementelor celor cinci coloane. Practic pe baza indicațiilor
din planificare se fac detalierile pe orizontală, ordonând acti vitațile în succeesiunea derulării, raportandu-le la
competențe și specificând resu rsele necesare bunei desfășurări a procesului didactic.
Proiectarea unității de învățare – ca si a lecției – începe pri n parcurgerea schemei urmatoare:

În ce scop voi face? Ce voi face? Cu ce voi face? Cum voi face? Cât s-a realizat?

Identificarea
competențelor
Selectarea conținuturilor

Analiza resurselor
Determinarea activităților de învățare

Stabilirea instrumentelor de evaluare

ConceptuI de unitate de învățare are rolul să materializeze con ceptul de demers didactic personalizat,
flexibilizâd proiectarea didacti că și definind în acest sens pe ntru practica didactică premise mai bine
fundamentate din punct de vedere pedagogic.
Identificarea unei unității de învățare se face prin tema acest eia. Stabilirea temei de catre profesor pe baza
lecturii programei, utilizând surse diverse, este primul pas în identificarea unităților de învățare în care va fi
imparțită materia anului școlar, respectiv, în organizarea unu demers didactic personalizat. Temele sunt
enunțuri complexe legate de analiza scopurilor învațării, formu lări fie originale, fie preluate din lista de
conținuturi a programei, sau din manual formulări care reflectă din partea profesorului o întelegere profundă
a scopurilor activitații sale, talen t pedagogic, inspirație, cr eativitate.
Activitățile de învățare se consruiesc prin corelarea competențelor cu conținuturile și presupun orientarea
către un anumit scop, redat prin tema activității. In momentul propunerii lor spre rezolvare elevilor,
activitățile de învățare vor fi tr anspuse într-o anumită formă de comunicare inteligibilă nivelului de vârstă.
Intr-o abordare pragmatică, resursele cuprind acele elemente care asigură cadrul necesar pentru buna
desfașurare a activitaților de învățare. Astfel, profesorul va menționa în această rubrică forme de organizare a
clasei (tipuri de interacțiuni ale resurselor umane), mijloace de învățamant, alocarea de timp, precum și orice
alte elemente pe care le conside ră utile în derularea scenariul ui didactic.
In condițiile noului curriculum, lectura programei și a manuale lor nu mai este în mod obligatoriu liniară.
Programa trebuie parcursă în mod necesar de către toți , dar ea , ca și manualele se pliază unei citiri personale
și adaptate. Asupra conținuturilor programei profesorul poate interveni prin regruparea lor sub temele
unităților de învățare pe care le-a stabilit.
III.4. Proiectarea activității de evaluare se realizează concomitent cu proiectarea demersului de
predare/învățare și în deplină concordanță cu acesta. Câteva în trebări utile în proiectarea instrumentelor de
evaluare sunt urmatoarele:
• Care sunt competențel e din programa școlară, pe care trebuie să le dobândească elevii?
• Care sunt performanțele minime, medii și superioare pe care le pot atinge elevii, pentru a demonstra
că au atins aceste competențe?
• Care este specificu colectivului de elevi pentru care îmi propu n evaluarea?
• Când și în ce scop evaluez?
• Pentru ce tipuri de evaluare optez?
• Cu ce instrumente voi realiza evaluarea?
• C um voi pr oc e da pe ntr u ca fi eca re e le v sa fi e e va l uat pr i n t i pu ri de probe cât mai variate astfel încât
evaluarea să fie cât mai obiectivă?
• Cum voi folosi datele oferite de instrumentele de evaluare admi nistrate, pentru a e limina eventualele
blocaje constatate în formarea elevilor și pentru a asigura pro gresul scolar al fiecaruia dintre ei?
PREDICTIVĂ (INIȚIALĂ)
FORMATIVĂ (CONTINUĂ)
SUMATIVĂ (FINALĂ) TIPURI
DE
EVALUARE

MiniGhid Metodologic Informatică & TIC
98

Adeseori, evaluarea formativă est e înlocuită cu evaluarea curen tă, în accepțiunea tradițională de “notare
ritmică”, constând în probe stereotipe precum dictări, calcule, compuneri, diverse tipuri de exerciții etc., care
sunt apreciate prin note în mod aproximativ, fără interes în ce ea ce privește nivelul cognitiv, afectiv,
psihomotor, relațional. O astfel de evaluare are în vedere doar unele tipuri de comportamente, de obicei
nerelevante pentru personalitat ea elevului și neglijează aspect e importante ca: gândirea, imaginația,
atitudinea de responsabilitate, adoptarea unor metode proprii d e lucru, competența de comunicare și de
relaționare etc.
Ceea ce este generalizat în evaluarea curentă din școli este st ocarea în memorie a abstracțiilor și
promptitudinea reproducerii acestora. Multe cunoștințe și capac ități care necesită evaluare sunt ignorate, deși
sunt, în egală măsură, variabile importante ale învățării, cum ar fi: atitudinea elevului față de învățare, față de
disciplina de studiu, față de educator și față de interrelațiil e din interiorul colectivului de elevi, modul în care
elevul învață (sistematic sau s poradic), modul cum abordează cu noștințele pentru a rezolva probleme
practice, specifice vieții cotidiene etc.
Focalizată pe unitatea de învățare, evaluarea ar trebui să asig ure evidențierea progresului înregistrat de
elev în raport cu sine însuși, pe drumul atingerii competențelo r prevăzute în programă. Este important să fie
evaluată nu numai cantitatea de i nformație de care dispune elev ul, ci, mai ales, ceea ce poate el să facă
utilizând ceea ce știe sau ceea ce intuiește.
In acest sens, câteva aspect e pot fi avute în vedere:
– modificarea raportului dintre evaluarea sumativă, care inventariază, selectează și ierarhizează prin notă și
evaluarea formativă, ce are drept scop valorificarea pot ențialului de care dispun el evii și conduce la
perfecționarea continuă a stilului și a metodelor proprii de în vățare;
– realizarea unui echilibru dinamic între evaluarea scrisă ș i evaluarea orală: aceasta din urmă, deși
presupune un volum mare de timp pentru aprec ierea tuturor elevi lor și blocaje datorate emoției sau timidității,
prezintă avantaje deosebite, ca: realizarea interacțiunii elev- profesor, demonstrarea comportamentului
comunicativ și de inte r-relaționare a elevului.
– folosirea cu mai mare frecvență a metodelor de autoevaluareși evaluare prin consultare în grupuri mici.
În raport cu momentele realizării evaluării, în proiectul unității de învățare apar specificații: evaluare
inițială , formativă sau sumativă.
Fiecare activitate de evaluare a rezultatelor școlare trebuie î nsoțită în mod sistematic de o autoevaluare a
procesului pe care profesorul l-a desfășurat cu toți elevii și cu fiecare elev. Numai astfel pot fi stabilite
modalitățile prin care poate fi reg lată, de la o etapă la alta, activitatea de învățare / f ormare a elevilor în mod
diferențiat.
III.4.1. Tipuri de itemi
Item = <întrebare> + <formatul acesteia> + <răspunsul așteptat>

Teoria și practica evaluării evidențiază mai multe citerii pe b aza cărora pot fi clasificați itemii. Unul dintre
criteriile cel mai des utilizate este acela al gradului de obiectivitate oferit în corectare . În funcție de acest
criteriu, itemii pot fi clasificați în trei mari categorii: COMPLEMENTARETRADIȚIONALE
METODE ȘI
INSTRUME NTE
DE
EVALUARE • Probe scrise
• Probe orale
• Probe practice
• Observarea sistematică a elevilor
• Investigația
• Proiectul
• Portofoliul
• Tema pentru acasă
• Tema de lucru în clasă
• Autoevaluarea

MiniGhid Metodologic Informatică & TIC
99 a. Itemii obiectivi asigură un grad de obiectivitate ridicat în măsurarea rezultate lor școlare și testează un
număr mare de elemente de conținut într-un interval de timp rel ativ scurt. Răspunsul așteptat este bine
determinat, ca și modalitatea de notare a acestuia.
b. Itemii semiobiectivi permit ca răspunsul așteptat să nu fie totdeauna unic determin at, modalitatea de
corectare și notare inducând uneori mici diferențe de la un cor ector la altul. Aceștia testează o gamă mai
variată de capacități intelectuale, oferind în același timp pos ibilitatea de a utiliza și materiale auxiliare în
rezolvarea sarcinilor de lucru propuse.
c. Itemii subiectivi (cu răspuns deschis) solicită un răspuns amplu, permițând valorificarea capacitățil or
creative ale elevilor. Aceștia sunt relativ ușor de construit, principala problemă constituind-o modul de
elaborare a schemei de notare astfel încât să se poată obține u nitate și uniformitate la nivelul corectării.
a. Itemi obiectivi
Fie că este vorba de activități de proiectare și programare (In formatică), fie că este vorba de activități de
utilizare și combinare a instrumentelor informatice (Tehnologia Informației), lucrul cu calculatorul implică
formulări standardizate, lipsite de echivoc, itemii obiectivi ș i cei semiobiectivi repezentând instrumente de
evaluare fracvent aplicat e la aceste discipline.
Itemii obiectivi sunt caracterizați prin:
¾ structurarea sarcinilor propuse și standardizarea formatului lo r de prezentare;
¾ corelarea strictă a sarcinilo r cu obiectivele de evaluării;
¾ capacitatea de a testa un număr mare de elemente de conținut în tr-un timp relativ scurt;
¾ obiectivitate privind aprecierea răspunsului;
¾ posibilitatea asocierii cu un sistem de notare extrem de simplu : punctajul aferent se acordă integral, se
acordă parțial conform unei reguli (formule) de calcul sau nu s e acordă deloc (în funcție de răspunsul
așteptat);
¾ rolul secundar pe care îl au de a obișnui elevul cu formulări s tandard, științifice, elemente utile în
construirea răspunsurilor pentru itemii semiobiectivi și subiec tivi.
a.1. Itemi cu alegere duală
Alegerea duală presupune formula rea unei cerințe cu două varian te complementare de răspuns
(Adevărat /Fals, Da/Nu, Corect /Incorect etc.).
Se pot verifica prin intermedi ul itemilor cu alegere duală:
– cunoștințele legate de corectitudinea sintac tică a unor expresi i (comenzi, instrucțiuni, notații etc.);
– înțelegerea semnificației unor noțiuni din terminologia de spec ialitate (denumiri, instrumente de
prelucrare, metode de rezolvare, proprietăți etc.)
– recunoașterea unor explicații, definiții, sau imagini.
Itemii de acest tip se prezintă sub forma unor întrebări sau en unțuri, efortul elevului reducându-se la
identificarea unui răspuns din două posibile. Achizițiile evalu ate prin itemii cu alegere duală sunt de regulă
rudimentare. Fac excepție enunțurile care pun în evidență justi ficări ale unor proprietăți, operații sau reguli,
justificări care necesită achiziții cognitive superioare. Tot î n categoria itemilor cu alegere duală se pot realiza
cerințe care necesită din partea elevului operații de anticipar e a efectului unei operații prin aplicarea unui
sistem riguros de cunoștințe înt r-un context nou. Aceștia sunt itemii cu cel mai înalt grad de dificultate.
Atragem atenția asupra faptului că lipsa “firului roșu“ care pu ne în evidență elementele sistematice întâlnite
în utilizarea unui produs soft (chiar și în cazul unui soft de bază) conduc la un experimentalism accentuat
care împiedică formarea capacității elevului de a se adapta sit uațiilor noi, neexersate.
Factorul de discriminare fiind în să extrem de mic, elevul va pu tea obține un rezultat acceptabil la un test format
numai din astfel de itemi alegâ nd la întâmplare un răspuns dint re cele două admise pentru fiecare item în parte.
De obicei, itemii cu alegere duală sunt formulați în combinație cu itemi subiectivi de tipul “Justificați…”,
“Scrieți varianta corectă…”, “Explicați în ce constă eroarea. ..“ etc. În aceste cazuri, o parte din punctaj este
alocată justificării.
Pentru proiectarea corectă a itemilor cu alegere duală este nec esară respectarea următoarelor cerințe:
¾ formularea clară a enunțului, fără ambiguități sau formulări in complete;
¾ dacă se solicită aprecierea cu ADEVĂRAT/FALS, se vor evita enun țurile foarte generale;
¾ selectarea unor enunțuri relevante pentru domeniul de cunoașter e sau categoria de competențe testată
(uneori, efortul de a realiza enunțuri fără echivoc duce la ela borarea de itemi nesemnificativi din
punct de vedere educațional sau științific);
¾ se va evita utilizarea unor enunțuri negative, acestea conducân d la raționamente ce folosesc dubla
negație, inducând un grad înalt de ambiguitate;

MiniGhid Metodologic Informatică & TIC
100 ¾ se vor evita enunțurile lungi și complexe, prin eliminarea ele mentelor redundante inutile în raport cu
ideea enunțului și cerința itemului; nu se va folosi un limbaj academic, o terminologie foarte
specializată sau o construcție lingvistică stufoasă și greoaie;
¾ se va evita introducerea a două idei într-un singur enunț, cu e xcepția cazului în care se dorește
evidențierea relației dintre acestea;
¾ enunțurile vor fi aproxim ativ egale ca lungime;
¾ enunțurile adevărate sau false să fie aproximativ egale ca numă r, dar nu exact egale, deoarece acesta
ar putea constitui un indiciu după care elevul încearcă să ghic ească răspunsul corect.
a.2. Itemi de tip pereche
Itemii de tip pereche solicită stabilirea unor corespondențe în tre informațiile distribuite pe două coloane.
Prima coloană conține informații de tip enunț ( premise ), cea de-a doua coloană conținând informații de tip
răspuns. Elevului i se solicită să asocieze fiecare enunț cu un unic răspuns.
Cele două coloane sunt precedate de instrucțiuni de asociere în care i se explică elevului tehnica de
formare a perechilor (să unească printr-o linie, să rescrie per echile asociate sau doar elementele lor de
identificare etc.) și se precizează dacă un răspuns poate fi fo losit la mai mult de un enunț (dacă funcția de
asociere este injectivă sau nu), eventual dacă există răspunsur i care nu vor fi folosite n iciodată (dacă funcția de
asociere este surjectivă sau nu).
Se verifică prin intermediul ite milor de tip pereche capacitate a elevului de a stabili corelații între:
– funcții și instrumente;
– simboluri și concepte;
– termeni și definiții;
– probleme și metode de rezolvare.
Itemii de acest tip permit abordarea unui volum mare de informa ție într-un interval de timp relativ redus.
Factorul de discriminare este ceva mai mare decât în cazul item ilor cu alegere duală, strategia de asociere “la
întâmplare” neconducând decât în situații foarte rare la un rez ultat acceptabil privind rezultatul testului.
Pentru proiectarea corectă a ite milor de tip de pereche este ne cesară respectarea următoarelor cerințe:
¾ utilizarea unui material omogen , dintr-o sferă relativ restrâns ă;
¾ utilizarea unui număr inegal de p remise și răspunsuri, astfel î ncât, dacă elevul asociază corect n-1
enunțuri dintre cele n date, să nu rezulte automat răspunsul pe ntru cel de-al n-lea enunț;
¾ aranjarea listei de răspunsuri (m ai ales dacă sunt multe) într- o ordine logică, astfel încât căutarea
răspunsului în listă să se realizeze cât mai comod;
¾ aranjarea enunțurilor în listă astfel încât să nu se poată intu i o regulă de asociere (referințele să fie
“încrucișate”);
¾ aranjarea coloanelor astfel încât acestea să încapă în întregim e pe aceeași pagină.
a.3. Itemi cu alegere multiplă
Itemii cu alegere multiplă sunt cele mai utilizate tipuri de it emi, în special în testele standardizate
(bacalaureat, admitere etc.)
Un item cu alegere multiplă este format dintr-un enunț numit premisă sau bază și un număr de opțiuni din
care elevul trebuie să aleagă un singur răspuns numit cheie . Celelalte răspunsuri, nec onforme cu cerința, dar
plauzibile poartă numele de distractori .
Se verifică prin intermediul ite milor de tip pereche capacitate a elevului de a identifica:
– definiții și notații;
– instrumentul adecvat unei prelucrări;
– secvențe de program care realizează o anumită prelucrare;
– expresii cu o valoare dată;
– termeni și expresii de specialitate;
– metode de rezolvare și tehnici de implementare.
Itemii de acest tip permit abordarea unui volum mare de informa ție într-un interval de timp relativ redus,
oferind posibilitatea evaluării unor achiziții cognitive comple xe, deși nu pot măsura capacitatea elevului de
a-și organiza și exprima ideile. Sunt forme de testare cu un gr ad mare de fidelitate, iar factorul de
discriminare este mai mare decât în cazul celorlalți itemi obie ctivi. Abilitatea profesorului de a elabora
distractori cât mai plauzibili, care să construiască toate alte rnativele posibile de a greși, contribuie la reușita
aplicării testelor cu alegere multiplă. Erorile comise de elevi oferă profesorului informații suplimentare
necesare în autoreglarea procesului de învățământ.
O categorie de itemi cu alegere multiplă solicită răspunsul cor ect, celelalte variante fiind greșite, în timp ce
alți itemi solicită cel mai bun răspuns, pe baza unei discrimin ări complexe. În aceste cazuri trebuie

MiniGhid Metodologic Informatică & TIC
101 manifestată grijă la formularea cerinței astfel încât criteriul de discriminare a “celui mai bun răspuns” să
reiasă clar din enunț.
Pentru proiectarea corectă a ite milor cu alegere multiplă este necesară respectarea următoarelor cerințe:
¾ stabilirea clară a cerinței, în c oncordanță cu obiectivul de ev aluare;
¾ furnizarea tuturor informațiilo r necesare în premisă, eliminând u-se materialul irelevant;
¾ formularea premisei folosind a firmații sau întrebări pozitive;
¾ construirea unor alternative pl auzibile, aflate în concordanță cu premisa;
¾ construirea itemului astfel încât să existe o singură alternati vă “corectă” sau “cea mai bună”;
¾ construirea unor alternative astfel încât distractorii să fie î n mod cert “greșiți” sau “mai puțin buni”, iar
varianta cheie să fie în mod cert “corectă” sau “cea mai bună”;
¾ aranjarea listei de răspunsuri în tr-o ordine logică, astfel înc ât căutarea răspunsului în listă să se
realizeze cât mai comod;
¾ construirea ansamblurilor de itemi cu alegere multiplă astfel î ncât răspunsurile să oc upe poziții diferite
în lista de variante (să nu fie în mod constant al doilea răspu ns, de exemplu)
b. Itemi semiobiectivi
Itemii semiobiectivi formează o categorie de instrumente de eva luare ce solicită construirea parțială sau
totală a unui răspuns pe b aza unei sarci ni definite.
Itemii semiobiectivi sunt caracterizați prin:
¾ posibilitatea de a testa o gamă mai largă de capacități intelec tuale și rezultate ale învățării;
¾ crearea unor situații cognitive de nivel mai ridicat prin solic itarea de elaborare a răspunsului și nu de
alegere a lui dintr-o mulțime prestabilită, ca în cazul itemilo r obiectivi;
¾ raportarea parțial subiectivă a profesorului în raport cu răspu nsul formulat (răspunsul poate fi scris
ordonat sau dezordonat, formularea poate fi mai clară sau mai n eclară, termenii folosiți se pot încadra în
niște standarde științifice sau pot fi variante particulare ale acestora etc.)
¾ posibilitatea asocierii unui sistem de notare în care pot să in tervină situații neprevăzute (răspunsuri
neașteptate, care comportă raportări noi la barem).
b.1. Itemi cu răspuns scurt / de completare
Itemii cu răspuns scurt solicită ca elevul să formuleze un răspuns scurt sau să compl eteze o
afirmație astfel încât aceasta să capete sens sau să aibă valoa re de adevăr.
Se pot verifica prin intermediul itemilor cu răspuns scurt și d e completare:
– cunoașterea unor noțiuni, expres ii de specialitate, simboluri, notații etc.;
– recunoașterea și nominalizarea unor elemente vizuale specifice unui anumit mediu de lucru;
– capacitatea de integrare a unor elemente necesare din punct de vedere sintactic sau semantic într-un
context dat;
– schimbarea unor elemente dintr-un context dat astfel încât să s e realizeze o finalitate precizată.
Itemii cu răspuns scurt se prezintă cel mai des sub forma unor întrebări. Ei solicită un răspuns sub o formă
restrânsă (un număr, un simbol, un cuvânt, o expresie, o propoz iție sau frază concisă).
Itemii de completarea se prezintă sub forma unui enunț, unei afirmații incomplete. E i solicită găsirea
cuvîntului sau sintagmei care completează și dă sens enunțului respectiv.
Pentru proiectarea corectă a ite milor cu răspuns scurt / de com pletare este necesară respectarea
următoarelor cerințe:
¾ formularea enunțului astfel încât să admită un răspus scurt, ex primat cu precizie;
¾ formularea enunțului astfel încâ t acesta să admită un singur ră spuns corect, pe cât posibil;
¾ rezervarea unor spații pentru răspuns care să sugereze numărul de cuvinte așteptate (dacă acest lucru nu
reprezintă un indiciu), nu și dimensiunea lor;
¾ vizarea unui răspuns care să reprezinte o sinteză de cunoștințe sau un rezultat al înțelegerii unei situații
și mai puțin o reproducere a unor informații.
b.2. Întrebări structurate
Întrebările structurate solicită, printr-un sistem de subîntreb ări relative la o temă comună, răspunsuri de tip
obiectiv, răspunsuri scurte sau de completare prin care se pot evalua cunoștințele complexe referitoare la
tema respectivă fără a solicita elaborarea unui răspuns deschis (eseu).
Se pot verifica prin intermediul întrebărilor structurate:
– capacitatea de a urmări, recunoaște, adapta și construi un algo ritm pe o temă dată sau un program într-un
limbaj de programare;

MiniGhid Metodologic Informatică & TIC
102– capacitatea de a realiza din apro ape în aproape o prelucrare co mplexă utilizând un mediu de lucru informatic.
O întrebare structurată poate să conțină materiale suport și in formații suplimentare ce se adaugă treptat,
conferind procesului de evaluare varietate, complexitate și gra dualitate. Se pot verifica totodată cunoștințe,
dar și priceperi și deprinderi sporind gradul de obiectivitate în raport cu itemii cu răspuns deschis.
Subîntrebările ce formează itemul permit creșterea progresivă a dificultății cerințelor, dar este recomandat ca
subîntrebările să fie independente, adică răspunsul la o întreb are să nu depindă de răspunsul la întrebările
precedente. Proiectarea lor neces ită atenție, pricepere și timp .
Pentru proiectarea corectă a în trebărilor strucutrate este nece sară respectarea următoarelor cerințe:
¾ redactarea subîntrebărilor astfel încât acestea să solicite răs punsuri simple la început crescând pe
parcurs dificultatea acestora;
¾ formularea unor subîntrebări autoconținute (al căror răspuns co rect să nu depindă de răspunsul corect
la una dintre întrebările precedente;realizarea concordanței di ntre enunțul general (tema întrebării) și
subîntrebările formulate.
c. Itemi subiectivi (cu răspuns deschis)
Itemii subiectivi formează o categorie de instrumente de evalua re ce vizează creativitatea elevului,
originalitatea și caracterul per sonal al răspunsului. Deși sunt ușor de formulat, itemii subiectivi ridică
probleme privind obiectivitatea evaluării.
Itemii subiectivi sunt caracterizați prin:
¾ abordare globală a unei sarcini asociate unui obiectiv ce nu po ate fi evaluat prin intermediul itemilor obiectivi;
¾ crearea unor situații cognitive de nivel foarte ridicat prin so licitarea de a realiza interacțiuni reale și
complexe între cunoștințe, abilități și deprinderi;
¾ raportarea subiectivă a profesorului în raport cu răspunsul for mulat;
¾ necesitatea predefinirii unor criterii privind baremul de corec tare și notare, criterii clare, judicioase și
puternic anticipative;
¾ posibilitatea, în cazul în care b aremul nu a prevăzut toate sit uațiile de interpretare și construire a
răspunsului, a unor elemente noi ( răspunsuri neașt eptate) care comportă reanalizarea baremului.
În cazul informaticii și tehnologiei informației se pot elabora itemi subiectivi de tip eseu (structurat sau liber)
și itemi de tip problemă (care necesită proiectare, redactare ș i uneori implementare a rezolvării).
c.1. Itemi de tip eseu
Itemii de tip eseu pot fi structurați sau liberi. Itemii struct urați sunt construiți astfel încât răspunsul așteptat să
fie “orientat” cu ajutorul unor elemente din enunț (indicii pri vind ordinea de tratare, numărul de linii,
formularea răspunsului, ideile care trebuie să fie atinse etc.) . Un eseu liber nu furnizează în enunț nici un fel
de indicații sau constrângeri, elevul având libertatea să-și st rucutreze cum consideră și cum poate materialul
pe care-l solicită enunțul. Acest tip de eseu comportă operații de maximă complexitate (analiză, sinteză,
sistematizare și restructurare) lăsând frâu liber fanteziei și capacităților creative ale elevului.
Deoarece la informatică elementele de creativitate se manifestă mai ales prin rezolvări de probleme și
proiecte, iar în cazul tehnologiei informației prin teme practi ce și proiecte, itemii de tip eseu preferați sunt cei
structurați, un eseu liber nefiind necesar decât rar, pentru an umite teme cu un volum mai mare de elemente
“informative” în raport cu achizițiile “operaționale”.
Se pot verifica prin intermediul itemilor de tip eseu:
– cunoștințele globale legate de stuctura sistemelor de calcul, s isteme de operare, evoluția istorică a
sitemelor hard și soft, principiile de utilizare a unei anumite aplicații, etapele conceptuale ale proiectării
unei aplicații etc.
– capacitățile de sistema tizare a unor elemente prin construirea unor scheme sau reprezentări grafice.
Itemii de tip eseu se prezintă sub forma unor cerințe generale însoțite eventual (pentru eseurile structurate)
de indicii privind tratarea ceri nței. Se pot adăuga restricții privind întinderea în timp sau spațiu (număr
rânduri, pagini, paragrafe etc.) sau privind forma de prezentar e a răspunsului.
c.2. Itemi de tip problemă
Rezolvarea unei probleme presupune soluționarea unei situații c onflictuale generată de neconcordanțe ivite
între sistemul de achiziții și situațiile concrete descrise de un enunț. Aceste neconcordanțe sunt generate
uneori de nepotrivirea între contextul general al cunoștințelor și situațiile particulare în care acestea trebuie
să fie aplicate. Alteori achizițiile sunt dobândite prin experi mente (situații particulare) și, pentru a fi aplicate
în cu totul alte situații, acestea trebuie să fie ridicate la u n înalt nivel de abstractizare și generalizare.

MiniGhid Metodologic Informatică & TIC
103 Rezolvarea de probleme este o activitate specifică și des utili zată la disciplina “Informatică”,
elementele gândirii algoritmice, metodele de rezolvare și tehni cile de implementare fiind supuse unui “tir”
sistematic de probleme prin care acestea să formeze competențe reale de programare.
Capacitățile cognitive superioare l egate de aplicare creativă, gândire divergentă, descoperirea condițiilor
interne, alegerea modelului adecvat etc. sunt verificate prin i temi de acest tip. Obiectivele urmărite prin
utilizarea rezolvării de probleme sunt:
– obținerea informațiilor nece sare rezolvării problemei;
-formularea și testarea ipotezelor;
-descrierea metodei de rezolvare a problemei;
-elaborarea unui raport despre rezultatele obținute;
-posibilitatea de generalizare și transfer a tehnicilor
de rezolvare.

MiniGhid Metodologic Informatică & TIC
104 Cerințe suplimentare asociate une i probleme pot pune în evidenț ă capacitatea elevului de a estima eficiența unei
rezolvări, de a construi un al goritm conform unor criterii (lim ita de memorie, număr de instrucțiuni etc.).
Se pot formula probleme în care se furnizează algoritmul și se cere un enunț de problemă care se rezolvă prin
intermediul algoritmului respectiv. Acest tip de item impune o analiză atentă a algoritmului și asocierea lui
cu una dintre problemele sau prelucrările numerice întâlnite la matematică, fizică sau în alte domenii, o
formulare a enunțului care să se caracter izeze prin coerență.
Enunțurile pot fi formulate abstract, “la obiect” sau pot crea un “context” care trebui e modelat pentru a
se ajunge la rezolvarea propriu-z isă. “Povestea” în spatele căr eia se ascunde problema are de cele mai multe
ori conotații practice, descriind situații concrete de prelucra re, amintind că rolul programatorului este acela
de a “ordona” inițial informația și operațiile specifice unui a numit context și abia după aceea de a elabora
algoritmul, de a implementa și verifica programul corespunzător .
Aspecte de aceeași natură se întâ lnesc și în domeniul utilizări i calculatorului, la Tehnologia
informației, când beneficiarul formulează un enunț și utilizato rul trebuie să-și aleagă programul de aplicație
adecvat, din cadrul programului să-și aleagă obiectele și instr umentele potrivite, să proiecteze, pe pași,
prelucrarea astfel încât “produsul” (documentul, prezentarea, r aportul etc.) să răspundă cerințelor și să fie
realizat în timp record. Aspectele reale de concepție, de creat ivitate și gândire divergentă intervin la
realizarea machetelor, a prezentărilor etc.
Evaluarea prin rezolvare de probleme la informatică ridică uneo ri probleme din punctul de vedere al
întocmirii baremului de corectare. Unele tendințe exagerate tin d să impună o corectare pe principiul:
problemă =program funcțional corect (pornind de la premisa că “un program care aproape merge e ca un
avion care aproape zboară”). Se recomandă totuși ca baremul de corectare să cuprindă fracțiuni din punctaj
pentru diferitele aspecte pe care le comportă rezolvarea unei p robleme la informatică: corectitudinea
sintactică, structurarea datelor și declararea variabilelor, st ructurarea programului, corectitudinea
algoritmului, eficiența algoritmului, tratarea unor situații li mită, eventual explicarea metodei aplicate (chiar
daca a fost aplicată greșit) etc.
Se pot verifica prin intermediul itemilor de rezolvare de probl eme:
– concepția unor algoritmi de rezolvare a problemelor elementare;
– asimilarea unui algoritm general p rin adaptarea lui astfel încâ t să rezolve o problemă particulară;
– capacitatea de a alege structurile de program și de date adecva te rezolvării unei probleme;
– abilitatea de a implementa programul, de a-l depana, de a-l tes ta și, în funcție de erorile apărute, de a
reconsidera elementele de sintaxă ale programului, strategiile de structurare a datelor sau însuși
algoritmul de rezolvare (în partea practică a probei);
– capacitatea de a organiza volume mari de date cu ajutorul bazel or de date;
– discernământul în a alege un algoritm mai eficient (conform unu ia dintre din criteriile studiate: număr
operații, spațiu de memorie utilizat)
III.4.2. Metode complementare de evaluare
Metodele complementare de evaluare reprezintă instrumente supli mentare, nestandardizate, de evaluare
dispunând de forme specifice cum ar fi: investigația , referatul , portofoliul , proiectul , observarea
sistematică a activității elevului și autoevaluarea .
Metodele complementare realizează actul evaluării în strînsă le gătură cu procesul educativ, prin
întrepătrundere cu etapele acestuia, urmărind în special capaci tățile cognitive superio are, motivațiile și
atitudinea elevului în demersul educațional.
Metodele alternative de evaluare se caracterizează prin următoa rele:
¾ capacitatea de a transforma rela ția profesor-elev inducând un c limat de colaborare și parteneriat;
¾ posibilitatea transformării procesului de evaluare prin înlocui rea tendinței de a corecta și sancționa prin
aceea de a soluționa erorile semnalate;
¾ posibilitatea de a deprinde elevul cu mecanismele de aurocorect are și autoeducare necesare și în procesul
de integrare socială;
¾ utilizarea mai amplă a tehnicilor și mijloacelor didactice;
¾ caracterul sumativ, realizat prin evaluarea cunoștințelor, capa cităților și atitudinilor pe o periadă mai
lungă de timp și dintr-o arie mai largă;
¾ caracterul formativ, realizat pri n valorificarea atitudinii ele vului în raport cu propria sa evaluare;
¾ capacitatea de a realiza o evaluare individualizată (observare sistematică);
¾ capacitatea de a educa spiritul de echipă prin activități de gr up (investigații, proiecte);

MiniGhid Metodologic Informatică & TIC
105 ¾ caracterul profund integrator realizat prin interdisciplinarita te, educare și instruire mutilaterală.
1.Investigația
Investigația este o metodă de evaluare și învățare utilizată fo arte des la disciplina Tehnologie informației și
numai ocazional la disciplina Informatică.
Organizarea unei activități de eva luare și învățare prin metoda investigației presupune:
– valorificarea metodei de învățare prin descoperire;
– studiul unor documentații complementare, experimentarea unor in strumente de prelucrare
nestandard, compararea și genera lizarea unor tehnici și metode utilizate în tehnologie prin cercetarea
altor izvoare sau prin utilizarea altor instrumente echivalente ;
– extrapolarea cunoștințelor dobândi te și verificare a ipotezelor formulate;
– solicitarea unor cunoștințe sau deprinderi dobândite la alte di cipline prin adaptarea creatoare a
acestora la cerințele temei de investigație.
În cele mai multe dintre cazuri investigația trebuie să fie org anizată ca muncă independentă depusă de elev,
dirijată și sprijinită de profesor. Tehnologia informației, cu multitudinea de aplicații software din domenii
atât de variate, este un teren ideal pentru desfășurarea invest igațiilor. Elevul cercetează “posibilitățile” unei
aplicații (de exemplu, aplicația românească de tip agendă MyCount difuzată pe Internet): citește explicațiile
asociate butoanelor, opțiunile din meniuri, informațiile din He lp, experimentează operațiile propuse de
aplicație imaginând utilitatea practică a acestora și formuleaz ă concluzii generale referitoare la acel soft
(utilitate, spațiul ocupat pe disc sau în memorie, spațiul ocup at de produsele construite cu ajutorul lui,
calitatea grafică și funcțională a interfeței). Investigații ma i rafinate pot realiza elevii inițiați în programare și
în sisteme de operare care disting mult mai multe aspecte “în s patele“ produsului soft investigat (eficiență,
posibilitate de dezvoltare, confi gurare, conflicte cu alte prog rame etc.).
Pentru organizarea activitățilo r de investigație, profesorul va urmări:
¾ formularea generală a temei;
¾ asigurarea surselor bibliografice sau tehnice necesare;
¾ formularea unor indicații care să direcționeze activitatea elev ilor;
¾ urmărirea activității elevului în sensul utilizării eficiente ș i creatoare a materialului de investigat;
¾ sprijinirea elevilor sau grupurilor de elevi care întâmpină dif icultăți în înțelegerea temei sau a metodelor
specifice de studiu;
¾ încurajarea și evidențierea ac tivităților creatoare desfășurate de elevi, a descoperirilor neașteptate.

2. Referatul și proiectul

Referatul reprezintă o formă de îmbinare a studiului individual cu activ itate de prezentare și argumentare.
Tema referatului, însoțită de bibliografie și alte surse de doc umentare (Internet, vizite etc.), este tratată în
mod independent de către elev și susținută apoi în fața colegil or sau altui auditoriu mai larg. Varietatea
universului informatic (a limbajelor și tehnicilor de programar e, a aplicațiilor din domeniul TIC, a noutăților
hardware etc.) justifică utilizarea acestei forme de studiu și evaluare la clasă, atât la Tehnologia informației
cât și la Informatică. Dacă studiul aferent și rezultatul studi ului prezintă interes și din punct de vedre practic,
rezultatul fiind un program (o aplicație) sau un produs TI comp lex (rezultatul aplicării creatoare a
instrumentelor informatice), dacă bibliografia propusă este mai bogată și etapele de p roiectare (concepție),
implementare și testare necesită un timp mai îndelungat, lucrar ea poartă numele de proiect .
Organizarea unei activități de eva luare și învățare prin interm ediul referatelor și proiectelor presupune:
– valorificarea metodei de învățare prin descoperire;
– studiul unor materiale suplimentare și izvoare de informare div erse în scopul îmbogățirii și activizării
cunoștințelor din domeniul studi at sau domenii conexe, prin com pletări de conținut ale programei sau
prin aducerea în atenție a unei problematici complet noi;
– structurarea informației corespunzătoare unui referat într-un m aterial ce poate fi scris, ilustrat sau
prezentat pe calculator; activită țile de concepere, organizare, experimentare, reproiectare (dacă este
cazul), dezvoltare și elaborare a documentației aferente necesi tă planificarea unor etape de elaborare și
o strategie de lucru, în cazul proiectului;
– prezentarea referatului sau proiectului de către elevul sau ele vii care l-au elaborat, acesta (sau un
reprezentant al grupului) trebuind să-l susțină, să fie capabil să dea explicații suplimentare, să
răspundă la întrebări etc.
Referatul este de regulă o lucrarea de mai mică amploare, dar m ai structurată și mai bogată în
informații decât o temă de muncă independentă aferentă lecției curente. Proiectul este o lucrare mai amplă a

MiniGhid Metodologic Informatică & TIC
106 cărei temă este comunicată sau aleasă din timp, elaborarea unui proiect putând să dureze de la 1-2 săptămîni
până la 2-3 luni sau chiar un semestru. Proiectul poate fi elab orat în grup, cu o distribuire judicioasă a
sarcinilor între membrii grupului.
Referatul poate fi utilizat la Informatică și în egală măsură l a Tehnologia informației temele referatelor
vizând cel mai des domenii de actualitate în producția sofware sau în domeniul TIC.
Pentru a realiza o evaluare pe bază de referate, profesorul:
¾ va formula teme clare, de complexitate medie, precizînd pe cât posibil amploarea lucrării (câte pagini,
durata maximă necesară prezentării etc.)
¾ va recomanda sau asigura sursele bibliografice și de informare necesare;
¾ își va rezerva suficient timp (î n perioada de evaluare sau la s fârșitul unor unități d e învățare) pentru ca
elevii însărcinați cu elaborarea referatelor să-și poată prezen ta referatul;
¾ va supraveghea discuțiile purtate cu elevii asupra conținutului referatului.
Pentru a realiza o evaluare pe bază de proiecte, profesorul:
¾ va formula teme practice, de complexitate sporită, lăsând celor care elaborează proiectul multă libertate
în a improviza, adapta și interpreta cerința într-un mod person al;
¾ va stabili un termen final și, î n funcție de modul de evaluare, termene intermediare de raportare;
¾ va recomanda sau asigura sursele bibliografice și de informare necesare;
¾ își va rezerva suficient timp (în perioada de evaluare sau la s fîrșitul unor unități de învățare) pentru ca
elevii însărcinați cu elaborarea proiectelor să-și poată prezen ta rezultatul proiectării;
¾ va supraveghea discuțiile purtate cu elevii asupra proiectului.

3. Portofoliul
Portofoliul reprezintă o metodă complexă de evaluare în care un rezultat al evaluării este elaborat pe baza
aplicării unui ansamblu variat de probe și instrumente de evalu are.
Prin multitudinea de forme și momente în care se desfășoară tes tarea elevului, rezultatul final “converge”
către valoarea reală a acestuia, sesizând elementele de progres sau regres, ilustrând preocuparea pentru
lămurirea neclarităților, oferind o imagine de ansamblu asupra nivelului cunoștințelor, gradului de formare a
abilităților și gradului de raportare atitudinală pe care acest a o are față de tema evaluată. Portofoliul este
realizat pe o periadă mai înde lungată, de la un semestru, un an , până la un ciclu de învățământ.
Conținutul unui portofoliu este reprezentat de rezultatele la: lucrări scrise sau practice, teme pentru
acasă, investigații, referate și proiecte, observarea sistemati că la clasă, autoevaluarea elevului, chestionare de
atitudini etc. La Tehnologia informației portofoliul se poate c onstitui dintr-o colecție de lucrări practice
realizate pe calculator, fiecare vizând anumite aspecte de util izare.
Alegerea elementelor ce formează portofoliul este realizată de către profesor (astfel încât acestea să ofere
informații concludente privind pregătirea, evoluția, atitudinea elevului) sau chiar de către elev (pe
considerente de performanță, preferințe etc.)
Structurarea evaluării sub forma de portofoliu se dovedește deo sebit de utilă, atât pentru profesor, cât și
pentru elev sau părinții acestuia.
Pentru a realiza o evaluare pe bază de potofoliu, profesorul:
¾ va comunica elevilor intenția de a realiza un portofoliu, adapt ând instrumentele de evaluare ce constituie
“centrul de greutate” ale portofo liului la specificul disciplin ei;
¾ va alege componentele ce formeaz ă portofoliul, dând și elevului posibilitatea de a adăuga piese pe care le
consideră relevante pentru activitatea sa;
¾ va evalua separat fiecare piesă a portofoliului în momentul rea lizării ei, dar va asigura și un sistem de
criterii pe baza cărora să realize ze evaluarea globală și final ă a portofoliului;
¾ va pune în evidență evoluția e levului, particularitățile de exp rimare și de ra portare a acestuia la aria vizată;
¾ va integra rezultatul evaluării portofoliului în sistemul gener al de notare.

4. Observarea sistematică a activităț ii și comportamentului elevil or
Fișa de observare a activității și comportamentului elevului înregistrează informații legate de
particularitățile personalității el evului manifestate în proces ul didactic, de achizițiile evaluate spontan
(răspunsuri sporadice, atitudini semnificative etc.), de progre sul înregistrat de acesta. Profesorul construiește
această fișă în vederea indivi dualizării procesului sumativ de evaluare, dar și a celui de învățare.
Pe baza fișei de evaluare se poate realiza și orientarea școlar ă și profesională a elevului. Informațiile din fișa
personală au caracter parțial secret, parte dintre ele fiind co municate elevului și părinților acestuia.

MiniGhid Metodologic Informatică & TIC
107 Un model orientativ de fișă de observare conține:
¾ Date generale despre elev (nume, prenume, vârstă, climat educat iv, condiții materiale, particularități
socio-comportamentale);
¾ Particularități ale proceselor intelectuale (gîndire, limbaj, i maginație, memorie, atenție, spirit de
observație etc.);
¾ Aptitudini și interese manifestate;
¾ Particularități afectiv-motivaționale;
¾ Trăsături de temperament;
¾ Atitudini și relaționare (cu sine însuși, cu materia studiată, cu colegii)
¾ Considerații privind evoluția a ptitudinilor, atitudinilor, inte reselor și nivelului de integrare.
Prin stabilirea copmpetențelor g enerale ale disciplinei și achi zițiile cognitive și comportamentale vizate
de aceasta, fișa de observare poate să conțină și considerente legate de atingerea și formarea competențelor
specifice. Completarea fișei se realizează în timp într-un ritm adecvat specificului activităților de la disciplina,
din anul și de la clasa respectivă, dar și în funcție de implic area și de ritmul indi vidual al elevului.

IV. . Proiectul unității de învățare – Proiectul de lecție ?
Față de proiectarea tradițională centrată pe lecție (ora de cur s) – proiectarea unității de învățare are urmatoarele
avantaje:
• creează un mediu de învățare coerent în care așteptările elevil o r d e v i n c l a r e p e t e r m e n
mediu și lung;
• implică elevii în ,,proiecte de î nvatare personale" pe termen m ediu si lung – rezolvare de
probleme complexe, luare de decizii complexe, cu accent pe exp lorare și reflecție;
• implică profesorul într-un ,,pro iect didactic" pe termen mediu și lung, cu accent pe
ritmurile de învățare proprii ale elevilor;
• dă perspectiva lecțiilor, conferin d acestora o structură specif ică, în funcție de secvența
unității de învățare în care se află.
Proiectul de lecție – conceput ca document separat – este recun oscut ca o formalitate consumatoare de timp
și energie. Proiectul unei unități de învățare conține suficien te elemente pentru a oferi o imagine asupra fiecărei
ore. Ca urmare, în tabelul care sintetizeaza proiectarea unitat ii de învățare se pot delimita prin linii orizontale
(punctate) spatiile cor espunzatoare unei ore de curs. Astfel, p entru fiecare lecție, proiectul unității de învățare
oferă date referitoare la elementele de conținut și competențel e vizate, la care se raportează anumite activități
de învățare; totodată, sunt indica te resurse materiale, forme d e organizare a clasei etc., pentru fiecare activitate
precum și instrumente de evaluar e necesare la nivelul lecției ( orei). In consecință, dacă proiectul unității de
învățare este bi ne construit, nu mai este necesară detalierea l a nivelul proiectului de lecție.
Lecția este înțeleasă ca o componentă operațională ( Cum? ) pe termen scurt a unității de învățare. Dacă
unitatea de învățare oferă întelegerea procesului din perspecti vă strategică, lecția oferă înțelegerea procesului
din perspectiva operati vă, tactică. Proiectul unității de învăț are trebuie să ofere o der ivare simplă a lecțiilor
componente. Ca urmare, trecerea d e la unitatea de învățare – o entitate supraordonată – la o lecție componentă
trebuie să permită o ,,replicare" în același timp functională ( De ce? ), structurală ( Cu ce?) și operațională
(Cum? ) a unitații de învățare, la o scară temporală mai mică și într -un mod subordonat.
Acest mod de tratare orientată către scopuri precise caracteri zează organizarea atât a unității de învățare cât și a
lecției.

Introducer e în Pr ogramar ea .Net Framework
Nãvodari, 20-30 august 2007
www .micr osoft.com/r omania/educatie
http://msdn2.micr osoft.com/en-us/expr ess/default.asp x